实验1 远程过程调用

实验目的

利用RMI技术构建远程会话：2个客户端发送消息到服务器端，服务器端把相应的消息中转发送给对应的客户，进行远程对话。
使用Dubbo框架实现此功能。

RMI实现

1.定义此服务的接口

public interface Message extends java.rmi.Remote{
    public List<String> getMessageById(int id) throws RemoteException;
    public void sendMessageById(String mess,int sourse,int destination) throws RemoteException;
}

2.定义服务器端的接口实现

public class MessageImpl implements Message,Serializable{
    
    //用一个hash表存取用户的信息，key即用户的id
    Map<Integer, List<String>> message=new HashMap<>();
    
    //获取指定用户的信息
    public List<String> getMessageById(int id) throws RemoteException
    {
        return message.get(id);
    }
    
    //某用户给指定用户发送消息
    public void sendMessageById(String mess,int sourse,int destination) throws RemoteException
    {
        if(message.get(destination)!=null)
        {
            List<String> old=message.get(destination);
            old.add(mess);
        } 
        else
        {
            List<String> messageList=new ArrayList<>();
            messageList.add(mess);
            message.put(destination, messageList);
        }
    }
}

3.构建服务器：将服务绑定到指定端口（也可随机）并发布，同时开一个注册表的端口，将服务添加到注册表中。
疑问：为啥服务端口可以和注册端口一样而不报错？

public class Server {
    
    
    public static void main(String[] args) throws RemoteException, AlreadyBoundException {
        
        
        MessageImpl message=new MessageImpl();
        Message stub=(Message) UnicastRemoteObject.exportObject(message, 3333);//将服务绑定到端口3333上
        Registry registry=LocateRegistry.createRegistry(3333);//用端口3333开一个注册表

        registry.bind("Message", stub);//将服务添加到注册表
        System.out.println("bind success! listen on port 3333....");
        
        
        //查看注册表中的服务
        for(int i=0;i<registry.list().length;i++)
        {
            System.out.println(registry.list()[i]);
        }   
        
    }
}

UnicastRemoteObject.exportObject(message, 3333)这个步骤很关键，它将此服务发布到3333端口上。只有通过这一步，才会生成远程对象的存根，如果省去这一步直接把MessageImpl对象绑定到注册表上，当客户端调用此服务时得到的将不会是服务器端对象的存根，二是根据传来的类信息在客户端本地创建一个MessageImpl对象.如：
客户端代码:

String url="rmi://localhost:3333/Message";
        Message stub=(Message) Naming.lookup(url);
        System.out.println(stub.getClass());

服务器端不省去UnicastRemoteObject.exportObject(message, 3333)时，客户端输出:

class com.sun.proxy.$Proxy0

$Proxy0即为存根对象的类型

服务器端改写成

MessageImpl message=new MessageImpl();
//Message stub=(Message) UnicastRemoteObject.exportObject(message, 3333);//将服务绑定到端口3333上
Registry registry=LocateRegistry.createRegistry(3333);//用端口3333开一个注册表
registry.bind("Message", message);//将服务添加到注册表

客户端输出:

4.编写客户端程序：定义两个客户，id为1,2，分别隔1s,2s给对方发消息并查看自己的新消息。
（只贴出client1的代码）

public class Client1 {
    public static void main(String[] args) throws MalformedURLException, RemoteException, NotBoundException {
        int index=0;
        String url="rmi://localhost:3333/Message";
        Message stub=(Message) Naming.lookup(url);
        while(true)
        {
            List<String> messageList=stub.getMessageById(1);
            if(messageList!=null)
            {
                while(index<messageList.size())
                {
                    System.out.println(messageList.get(index));
                    index++;
                }
            }
            stub.sendMessageById("hello,client2!", 1, 2);
            try{
                Thread.sleep(1000);
            }
            catch(Exception e){
                System.exit(0);//退出程序
            }
        }
    }
}

5.运行服务器后，同时运行客户端1,2

server.png

client1.png

client2.png

注意:
服务端需要实现远程接口，因为服务端需要具体的远程对象绑定相应的服务。但是服务所提供的功能可以在客户端实现，而对于服务器却是透明的。具体如下：

服务器提供功能的模板接口TFunction，并将其作为远程对象方法Compute的参数，Compute进行TFunction方法的调用。
客户端用相应的类Function实现接口TFunction，同时实现Serializable接口。
基于对象串行化技术，客户端将实例Function1作为参数传入，调用远程对象的方法Compute。

这样就使得客户端将计算的类传给服务器端，让服务端调用，实现了简单的云计算服务。
（参考oracle官网实例：https://docs.oracle.com/javase/tutorial/rmi/client.html）。

Dubbo框架实现

Dubbo架构

dubbo框架.png

Dubbo注册中心

对于服务提供方，它需要发布服务，而且由于应用系统的复杂性，服务的数量、类型也不断膨胀；
对于服务消费方，它最关心如何获取到它所需要的服务，而面对复杂的应用系统，需要管理大量的服务调用。
而且，对于服务提供方和服务消费方来说，他们还有可能兼具这两种角色，即既需要提供服务，有需要消费服务。

通过将服务统一管理起来，可以有效地优化内部应用对服务发布/使用的流程和管理。服务注册中心可以通过特定协议来完成服务对外的统一

Dubbo提供的注册中心有如下几种类型可供选择：

Multicast注册中心
Zookeeper注册中心
Redis注册中心
Simple注册中心

本例采用Zookeeper注册中心,为什么采用Zookeeper?

Zookeeper是一个分布式的服务框架，是树型的目录服务的数据存储，能做到集群管理数据，这里能很好的作为Dubbo服务的注册中心。
Dubbo能与Zookeeper做到集群部署，当提供者出现断电等异常停机时，Zookeeper注册中心能自动删除提供者信息，当提供者重启时，能自动恢复注册数据，以及订阅请求

安装完成后，进入到bin目录，并且启动zkServer.cmd，这个脚本中会启动一个java进程：
(注：需要先启动zookeeper后，后续dubbo demo代码运行才能使用zookeeper注册中心的功能)

zookeeper.png

Dubbo优势

透明化的远程方法调用
像调用本地方法一样调用远程方法；只需简单配置，没有任何API侵入。
软负载均衡及容错机制
可在内网替代nginx lvs等硬件负载均衡器。
服务注册中心自动注册 & 配置管理
不需要写死服务提供者地址，注册中心基于接口名自动查询提供者ip。
使用类似zookeeper等分布式协调服务作为服务注册中心，可以将绝大部分项目配置移入zookeeper集群。
服务接口监控与治理

实现流程

1.创建dubbo-api的MAVEN项目(有独立的pom.xml，用来打包供提供者消费者使用)。

public interface DemoService {
    List<String> getMessageById(int id);
    void sendMessageById(String mess,int sourse,int destination);
}

2.创建dubbo-provider的MAVEN项目(有独立的pom.xml，用来打包供消费者使用)。
实现服务接口

public class DemoServiceImpl implements DemoService {
    Map<Integer, List<String>> message=new HashMap<>();

    public List<String> getMessageById(int id)
    {
        return message.get(id);
    }

    public void sendMessageById(String mess,int sourse,int destination)
    {
        if(message.get(destination)!=null)
        {
            List<String> old=message.get(destination);
            old.add(mess);
        }
        else
        {
            List<String> messageList=new ArrayList<>();
            messageList.add(mess);
            message.put(destination, messageList);
        }
    }
}

配置声明暴露服务，将服务注册到Zookeeper上

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://code.alibabatech.com/schema/dubbo
       http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <!--定义了提供方应用信息，用于计算依赖关系；在 dubbo-admin 或 dubbo-monitor 会显示这个名字，方便辨识-->
    <dubbo:application name="demotest-provider" owner="programmer" organization="dubbox"/>
    <!--使用 zookeeper 注册中心暴露服务，注意要先开启 zookeeper-->
    <dubbo:registry address="zookeeper://localhost:2181"/>
    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20880" />
    <!--使用 dubbo 协议实现定义好的 api.PermissionService 接口-->
    <dubbo:service interface="com.alibaba.dubbo.demo.DemoService" ref="demoService" protocol="dubbo" />
    <!--具体实现该接口的 bean-->
    <bean id="demoService" class="com.alibaba.dubbo.demo.impl.DemoServiceImpl"/>
</beans>

provider开启服务

public class Provider {
        public static void main(String[] args) throws IOException {
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("provider.xml");
            System.out.println(context.getDisplayName() + ": here");
            context.start();
            System.out.println("服务已经启动...");
            System.in.read();
        }
    }

server.png

3.创建dubbo-consumer的MAVEN项目
通过Spring配置引用远程服务

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <dubbo:application name="demotest-consumer" owner="programmer" organization="dubbox"/>
    <!--向 zookeeper 订阅 provider 的地址，由 zookeeper 定时推送-->
    <dubbo:registry address="zookeeper://localhost:2181"/>
    <dubbo:reference id="messageService" interface="com.alibaba.dubbo.demo.DemoService"/>
</beans>

启动Consumer,调用远程服务

public class Consumer {
    public static void main(String[] args) {
        //测试常规服务
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("consumer.xml");
        context.start();
        System.out.println("consumer start");
        DemoService demoService = context.getBean(DemoService.class);
        System.out.println("consumer");
        int index=0;
        while(true)
        {
            List<String> messageList=demoService.getMessageById(1);
            if(messageList!=null)
            {
                while(index<messageList.size())
                {
                    System.out.println(messageList.get(index));
                    index++;
                }
            }
            demoService.sendMessageById("hello,client2!", 1, 2);
            try{
                Thread.sleep(1000);
            }
            catch(Exception e){
                System.exit(0);//退出程序
            }
        }
    }
}

4.同时运行consumer1,consumer2

consumer1.png

consumer2.png

参考博文https://blog.csdn.net/noaman_wgs/article/details/70214612