Zookeeper注册中心实现简易手写RPC框架

主要内容

1. 使用zookeeper原生 API 实现分布式锁
2. 分析Curator实现分布式锁的原理
3. 实现带注册中心的RPC框架

使用zookeeper原生 API 实现分布式锁

Synchronized或者Lock

zookeeper 、redis、数据库

在使用ZooKeeper进行分布式锁的实现过程中，如何有效的避免“羊群效应( herd effect)”的出现。

有序临时节点

数据库写入log实现分布式锁

​ 缺点：1.若当前线程挂掉容易出现死锁

​ 　　    2.容易出现单点故障

redis实现分布式锁

​ 缺点 ：容易出现短期死锁，当前线程挂掉，但是由于redis的过期机制，所以可能多时间内死锁

zookeeper实现分布式锁

总结：相对来说zookeeper 更适合实现分布式锁，实现相对简单,可靠性相对比较高，性能比较好。

zookeeper如何实现分布式锁解决羊群效应

什么是惊群效应

zk的客户端可以在znode上添加一个watch，用来监听znode相关事件并被通知

惊群效应就是 一个特定的znode 改变的时候ZooKeper 触发了所有watches 的事件。

举个例子，如果有1000个客户端watch 一个znode的exists调用，当这个节点被创建的时候，将会有1000个通知被发送。这种由于一个被watch的znode变化，导致大量的通知需要被发送，将会导致在这个通知期间的其他操作提交的延迟。因此，只要可能，我们都强烈建议不要这么使用watch。仅仅有很少的客户端同时去watch一个znode比较好，理想的情况是只有1个。

案例分析

举个例子，有n 个clients 需要去拿到一个全局的lock.

一种简单的实现就是所有的client 去create 一个/lock znode.如果znode 已经存在，只是简单的watch 该znode 被删除。当该znode 被删除的时候，client收到通知并试图create /lock。这种策略下，就会存在上文所说的问题，每次变化都会通知所有的客户端。（惊群效应）

另外一种策略就是每个client去创建一个顺序的znode /lock/lock-.ZooKeeper 会自动添加顺序号/lock/lock-xxx.我们可以通过/lock getChildren 去拿到最小的顺序号。如果client不是最小的序列号，就再比自己小一点的znode上添加watch.

分布式锁实现

维基百科：分布式锁，是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，在这种情况下，便需要使用到分布式锁。

锁代码简单设计

基于ZooKeeper实现锁，一般都是创建EPHEMERAL_SEQUENTIAL子节点并比较序号实现的。参照Redis的分布式锁实现，也可以使用EPHEMERAL节点实现。

/**
 * zk分布式实现
 */
public class DistributedLock implements Lock, Watcher {
    /**
     * 定义zookeeper的连接
     */
    private ZooKeeper zk = null;
    /**
     * 定义一个根节点
     */
    private String ROOT_LOCK = "/locks";
    /**
     * 等待前一个锁
     */
    private String WAIT_LOCK;
    /**
     * 表示当前锁
     */
    private String CURRENT_LOCK;


    private CountDownLatch countDownLatch;

    public DistributedLock() {
        try {
            this.zk = new ZooKeeper("192.168.1.101:2181", 4000, this);
            // 判断根节点是否存在
            Stat stat = zk.exists(ROOT_LOCK, false);
            if (null == stat) {
                zk.create(ROOT_LOCK, "0".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void lock() {
        // 如果获得锁成功
        if (this.tryLock()) {
            System.out.println(Thread.currentThread().getName() + "->" + CURRENT_LOCK + "-> 获得锁成功!");
            return;
        }
        try {
            waitForLock(WAIT_LOCK); // 没有获得锁，则继续等待获得锁
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private boolean waitForLock(String prev) throws KeeperException, InterruptedException {
        // 监听当前节点的上一个节点
        Stat stat = zk.exists(prev, true);
        if (null != stat) {
            System.out.println(Thread.currentThread().getName() + "->等待" + ROOT_LOCK + "/" + prev + "释放");
            countDownLatch = new CountDownLatch(1);
            countDownLatch.await();
            System.out.println(Thread.currentThread().getName() + "->获得锁成功");
        }
        return true;
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
    }

    @Override
    public boolean tryLock() {
        try {
            // 创建临时有序节点
            CURRENT_LOCK = zk.create(ROOT_LOCK + "/", "0".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            System.out.println(Thread.currentThread().getName() + "->" +
                    CURRENT_LOCK + "尝试竞争锁");
            // 获取根节点下的所有子节点
            List<String> childrens = zk.getChildren(ROOT_LOCK, false);
            // 定义一个集合对节点进行排序
            SortedSet<String> sortedSet = new TreeSet<>();
            for (String children : childrens) {
                sortedSet.add(ROOT_LOCK + "/" + children);
            }
            // 获取当前所有子节点中最小的值
            String firstNode = sortedSet.first();
            SortedSet<String> lessThenMe = ((TreeSet<String>) sortedSet).headSet(CURRENT_LOCK);
            // 通过当前节点和子节点中最小的节点进行比较，如果相等，表示获得锁成功
            if (CURRENT_LOCK.equals(firstNode)) {
                return true;
            }
            if (!lessThenMe.isEmpty()) {
                // 获得比当前节点更小的最后一个节点，设置给WAIT_LOCK
                WAIT_LOCK = lessThenMe.last();
            }
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public void unlock() {
        System.out.println(Thread.currentThread().getName() + "->释放锁" + CURRENT_LOCK);
        try {
            zk.delete(CURRENT_LOCK, -1);
            CURRENT_LOCK = null;
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Condition newCondition() {
        return null;
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        if (this.countDownLatch != null) {
            this.countDownLatch.countDown();
        }
    }
}

public static void main(String[] args) throws IOException {
    final CountDownLatch countDownLatch = new CountDownLatch(10);
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            try {
                countDownLatch.await();
                DistributedLock distributedLock = new DistributedLock();
                // 获得锁
                distributedLock.lock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "Thread-" + i).start();
        countDownLatch.countDown();
    }
    System.in.read();
}

1 阻塞锁和非阻塞锁

根据业务特点，普通分布式锁有两种需求：阻塞锁和非阻塞锁。

阻塞锁：多个系统同时调用同一个资源，所有请求被排队处理。已经得到分布式锁的系统，进入运行状态完成业务操作；没有得到分布式锁的线程进入阻塞状态等待，当获得相应的信号并获得分布式锁后，进入运行状态完成业务操作。

非阻塞锁：多个系统同时调用同一个资源，当某一个系统最先获取到锁，进入运行状态完成业务操作；其他没有得到分布式锁的系统，就直接返回，不做任何业务逻辑，可以给用户提示进行其他操作。

 

基于Zookeeper注册中心实现简易手写RPC框架

一，环境准备

1. Zookepper单点或集群环境，演示使用集群环境
2. Zookeeper的Curator客户端工具
3. 使用Maven进行项目构建

二，代码实现

服务端

1，jar包依赖

<dependency>
  <groupId>org.apache.zookeeper</groupId>
  <artifactId>zookeeper</artifactId>
  <version>3.4.8</version>
</dependency>
<dependency>
  <groupId>org.apache.curator</groupId>
  <artifactId>curator-framework</artifactId>
  <version>4.0.1</version>
</dependency>

2、请求rpc时需要的参数

/**
 * @Description:    请求rpc时需要的参数
 * @Author:         cong zhi
 * @CreateDate:     2021/1/16 17:52
 * @UpdateUser:     cong zhi
 * @UpdateDate:     2021/1/16 17:52
 * @UpdateRemark:   修改内容
 * @Version:        1.0
 */
public class RpcRequest implements Serializable {

    private static final long serialVersionUID = 4186108850712886052L;
    /**
     * 类
     */
    private String className;
    /**
     * 方法名
     */
    private String methodName;
    /**
     * 参数
     */
    private Object[] parameters;

    private String version;

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Object[] getParameters() {
        return parameters;
    }

    public void setParameters(Object[] parameters) {
        this.parameters = parameters;
    }
}

服务地址

/**
 * zk 连接配置服务地址
 * @Author:         cong zhi
 * @CreateDate:     2021/2/4 16:25
 * @UpdateUser:     cong zhi
 * @UpdateDate:     2021/2/4 16:25
 * @UpdateRemark:   修改内容
 * @Version:        1.0
 */
public class ZkConfig {

    public final static String CONNECTION_STR ="192.168.1.101:2181";

    public final static String ZK_REGISTER_PATH = "/registrys";
}

自定义注解

/**
 * 自定义注解
 * @Author:         cong zhi
 * @CreateDate:     2021/2/7 10:51
 * @UpdateUser:     cong zhi
 * @UpdateDate:     2021/2/7 10:51
 * @UpdateRemark:   修改内容
 * @Version:        1.0
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface RpcAnnotation {

    /**
     * 对外发布的服务接口地址
     * @author      cong zhi
     * @date        2021/2/7 10:50
     */
    Class<?> value();

    /**
     * 版本
     */
    String version() default "";
}

3、注册服务接口

* 注册服务

​ -- 注册服务名称为根节点下的持久化节点

​ -- 注册服务对应的服务器地址为服务名称节点下的临时节点

​ -- 每次服务重启时会清空临时节点（服务的分布式服务器），并重新注册临时节点

public class RegisterCenterImpl implements RegisterCenter {

    private CuratorFramework curatorFramework;
    // 通过静态块初始化Curator
    {
        curatorFramework = CuratorFrameworkFactory.builder()
                .connectString(ZkConfig.CONNECTION_STR)
                .sessionTimeoutMs(4000)
                .retryPolicy(new ExponentialBackoffRetry(1000, 10))
                .build();
        curatorFramework.start();
    }
    
    @Override
    public void register(String serviceName, String serviceAddress) {
        // 注册服务
        String servicePath = ZkConfig.ZK_REGISTER_PATH + "/" + serviceName;
        try {
            // 判断 /registrys/product-service是否存在，不存在则创建
            if (curatorFramework.checkExists().forPath(servicePath) == null) {
                curatorFramework.create().creatingParentsIfNeeded()
                        .withMode(CreateMode.PERSISTENT).forPath(servicePath, "0".getBytes());
            }
            // 获取完整路径
            String addressPath = servicePath + "/" + serviceAddress;
            // 创建临时节点
            String rsNode = curatorFramework.create().withMode(CreateMode.EPHEMERAL)
                    .forPath(addressPath, "0".getBytes());
            System.out.println("服务注册成功" + rsNode);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4、绑定服务

* 通过构造初始化构造中心，服务发布地址已经服务绑定集合（Map）

 * 远程调用的服务端入口，使用socket监听
 *
 * @Author: cong zhi
 * @CreateDate: 2021/1/17 11:29
 * @UpdateUser: cong zhi
 * @UpdateDate: 2021/1/17 11:29
 * @UpdateRemark: 修改内容
 * @Version: 1.0
 */
public class RpcService {
    /**
     * 定义个线程池
     */
    private static final ExecutorService executorService = Executors.newCachedThreadPool();

    /**
     * 注册中心
     */
    private RegisterCenter registerCenter;
    /**
     * 服务发布地址
     */
    private String serviceAddress;

    /**
     * 存放服务名称和对象之间的关系
     */
    Map<String, Object> handleMap = Maps.newHashMap();

    public RpcService(RegisterCenter registerCenter, String serviceAddress) {
        this.registerCenter = registerCenter;
        this.serviceAddress = serviceAddress;
    }

* 对外服务接口

@RpcAnnotation(IUserService.class)
public class UserServiceImpl implements IUserService {
    @Override
    public String sayHello(String msg) {
        return "Hello ,"+msg;
    }
}

* 根据注解信息获取服务名称，服务版本号并绑定服务

/**
 * 绑定服务名称和服务对象
 * @author cong zhi
 * @params * @param null
 * @date 2021/2/7 10:45
 */
public void bind(Object... services) {
    for (Object service : services) {
        RpcAnnotation annotation = service.getClass().getAnnotation(RpcAnnotation.class);
        String serviceName = annotation.value().getName();
        String version = annotation.version();
        if (null != version && !version.equals("")) {
            serviceName = serviceName + "-" + version;
        }
        // 绑定接口名称对应的服务名
        handleMap.put(serviceName, service);
    }
}

5，发布服务端服务

​ * 根据服务地址启动服务，并注册服务到注册中心

/**
 * 注册服务实例，服务注册后，其他客户端通过接口调用就可以调用服务端的实现
 *
 * @return
 * @throws
 * @author cong zhi
 * @date 2021/1/17 12:14
 */
public void publisher() {

    ServerSocket serverSocket = null;
    try {
        String[] addrs = serviceAddress.split(":");

        // 启动一个服务监听
        serverSocket = new ServerSocket(Integer.parseInt(addrs[1]));
        for (String interfaceName : handleMap.keySet()) {
            registerCenter.register(interfaceName, serviceAddress);
            System.out.println("注册服务成功: " + interfaceName + "->" + serviceAddress);
        }
        while (true) {
            // 监听端口，是个阻塞的方法
            Socket socket = serverSocket.accept();
            // 处理rpc请求，这里使用线程池来处理
            executorService.execute(new ProcessorHandler(socket, handleMap));
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (serverSocket != null) {
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

* main方法启动服务，通过启动两个服务实现模拟分布式，并验证负载均衡

public class ServiceDemo {

    public static void main(String[] args) throws IOException {

        IUserService userService = new UserServiceImpl();
        IUserService userService2 = new UserServiceImpl2();
        RegisterCenter register = new RegisterCenterImpl();
        // 初始化注册中心和服务端口信息
        RpcService service = new RpcService(register,   "127.0.0.1:8080");
        // 绑定服务
        service.bind(userService,userService2);
        // 发布并注册服务
        service.publisher();
        System.in.read();
    }
}

*  服务启动执行结果

* zookeeper查询节点

客户端

1、jar包依赖

<dependency>
  <groupId>org.apache.zookeeper</groupId>
  <artifactId>zookeeper</artifactId>
  <version>3.4.8</version>
</dependency>
<dependency>
  <groupId>org.apache.curator</groupId>
  <artifactId>curator-framework</artifactId>
  <version>4.0.1</version>
</dependency>
<dependency>
  <groupId>org.apache.curator</groupId>
  <artifactId>curator-recipes</artifactId>
  <version>4.0.1</version>
</dependency>

2，通过Zookeeper获取注册服务

* 通过构造方法初始化Curator客户端

/**
 * 实现类
 *
 * @Author: cong zhi
 * @CreateDate: 2021/2/7 11:44
 * @UpdateUser: cong zhi
 * @UpdateDate: 2021/2/7 11:44
 * @UpdateRemark: 修改内容
 * @Version: 1.0
 */
public class ServiceDiscoveryImpl implements ServiceDiscovery {

    List<String> repos = Lists.newArrayList();

    private String address;

    private CuratorFramework curatorFramework;

    public ServiceDiscoveryImpl(String address) {
        this.address = address;
        curatorFramework = CuratorFrameworkFactory.builder()
                .connectString(address)
                .sessionTimeoutMs(4000)
                .retryPolicy(new ExponentialBackoffRetry(1000, 10))
                .build();
        curatorFramework.start();
    }
    
    //  * 通过serviceName获取服务节点
    @Override
    public String discovery(String serviceName) {
        String path = ZkConfig.ZK_REGISTER_PATH + "/" + serviceName;
        try {
            repos = curatorFramework.getChildren().forPath(path);
        } catch (Exception e) {
            throw new RuntimeException("获取子节点异常");
        }
        // 动态发现服务节点变化
        registerWatcher(path);
        // 负载均衡机制
        LoadBanalce loadBanalce = new RandomLoadBanalce();
        // 返回调用服务地址
        return loadBanalce.selectHost(repos);
    }
    
    //   * 服务监听代码
    /**
     * 监听服务节点
     *
     * @param path
     */
    private void registerWatcher(final String path) {

        PathChildrenCache pathChildrenCache = new PathChildrenCache(curatorFramework, path, true);
        PathChildrenCacheListener pathChildrenCacheListener = new PathChildrenCacheListener() {

            @Override
            public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
                repos = curatorFramework.getChildren().forPath(path);
            }
        };
        // 将当前事件添加到当前节点上
        pathChildrenCache.getListenable().addListener(pathChildrenCacheListener);
        try {
            pathChildrenCache.start();
        } catch (Exception e) {
            throw new RuntimeException("注册PatchChild Watcher 异常:" + e);
        }
    }

* 通过随机数实现简易负载均衡代码

/**
 * 负载均衡
 * @Author:         cong zhi
 * @CreateDate:     2021/2/7 12:05
 * @UpdateUser:     cong zhi
 * @UpdateDate:     2021/2/7 12:05
 * @UpdateRemark:   修改内容
 * @Version:        1.0
 */
public interface LoadBanalce {

    String selectHost(List<String> repos);
}

* 抽象类构造模板方法

public abstract class AbstractLoadBanalce implements LoadBanalce {

    protected abstract String doSelect(List<String> repos);

    @Override
    public String selectHost(List<String> repos) {
        if (repos == null || repos.size() == 0) {
            return null;
        }
        if (repos.size() == 1) {
            return repos.get(0);
        }
        return doSelect(repos);
    }
}

随机负载均衡

/**
 * 随机负载均衡
 * @Author:         cong zhi
 * @CreateDate:     2021/2/7 12:16
 * @UpdateUser:     cong zhi
 * @UpdateDate:     2021/2/7 12:16
 * @UpdateRemark:   修改内容
 * @Version:        1.0
 */
public class RandomLoadBanalce extends AbstractLoadBanalce {

    @Override
    protected String doSelect(List<String> repos) {
        int len = repos.size();
        Random random =new Random();
        
        return repos.get(random.nextInt(len));
    }
}

3，构建动态代理，发起服务请求

* 构建动态代理对象

/**
 * @Description: 创建代理对象
 * @Author: li cong zhi
 * @CreateDate: 2021/1/16 17:52
 * @UpdateUser: li cong zhi
 * @UpdateDate: 2021/1/16 17:52
 * @UpdateRemark: 修改内容
 * @Version: 1.0
 */
public class RpcClientProxy {

    private ServiceDiscovery serviceDiscovery;


    public RpcClientProxy(ServiceDiscovery serviceDiscovery) {
        this.serviceDiscovery = serviceDiscovery;
    }

    /*public <T> T clientProxy(final Class<T> interfaceCls,
                             final String host, final int port) {
        // 使用动态代理
        return (T) Proxy.newProxyInstance(interfaceCls.getClassLoader(), new Class[]{
                interfaceCls}, new RemoteInvokeHandler(host, port));
    }*/

    public <T> T clientProxy(final Class<T> interfaceCls, String version) {
        // 使用动态代理
        return (T) Proxy.newProxyInstance(interfaceCls.getClassLoader(), new Class[]{
                interfaceCls}, new RemoteInvokeHandler(serviceDiscovery, version));
    }
}

4，发送服务请求到客户端

* 通过负载均衡获取的服务地址构建套接字

/**
 * @Description: socket传输
 * @Author:     cong zhi
 * @CreateDate: 2021/1/16 18:09
 * @UpdateUser: cong zhi
 * @UpdateDate: 2021/1/16 18:09
 * @UpdateRemark: 修改内容
 * @Version: 1.0
 */
public class TcpTransport {

    private String serviceAddress;


    public TcpTransport(String serviceAddress) {
        this.serviceAddress = serviceAddress;
    }

    public Socket newSocket() {
        System.out.println("准备创建Socket连接");
        Socket socket;
        try {
            String[] arrs = serviceAddress.split(":");
            socket = new Socket(arrs[0], Integer.parseInt(arrs[1]));
            return socket;
        } catch (IOException e) {
            throw new RuntimeException("Socket连接建立失败！");
        }
    }
    
   // * 通过套接字输出流构建对象输出流
   // * 通过对象输出流写出服务请求参数
    public Object send(RpcRequest request) {
        Socket socket = null;
        try {
            socket = newSocket();
            ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
            // 通过 ObjectOutputStream 将当前request传给服务端
            outputStream.writeObject(request);
            outputStream.flush();

            ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
            Object result = inputStream.readObject();
            inputStream.close();
            outputStream.close();
            return result;
        } catch (Exception e) {
            throw new RuntimeException("发起远程调用异常");
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
    }
}

5，InvocationHandler实现

* 通过构造方法初始化注册中心对象和版本号

public class RemoteInvokeHandler implements InvocationHandler {

    private ServiceDiscovery serviceDiscovery;

    private String version;

    public RemoteInvokeHandler(ServiceDiscovery serviceDiscovery, String version) {
        this.serviceDiscovery = serviceDiscovery;
        this.version = version;
    }

    /**
     * 增强的InvocationHandler,接口调用方法的时候实际是调用socket进行传输
     * 动态代理实现方法调用并提交服务请求发送
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 将远程调用需要的接口类、方法名、参数信息封装成RPCRequest
        RpcRequest request = new RpcRequest();
        request.setClassName(method.getDeclaringClass().getName());
        request.setMethodName(method.getName());
        request.setParameters(args);
        request.setVersion(version);

        // 通过socket发送RPCRequest给服务端并获取结果返回 00:42
        // 根据接口名称得到对应的服务地址
        String serviceAddress = serviceDiscovery.discovery(request.getClassName());

        TcpTransport tcpTransport = new TcpTransport(serviceAddress);

        return tcpTransport.send(request);
    }
}

客户端接收响应

1，根据套接字输入流构建对象输入流（class RPCTransPort）

public Object send(RpcRequest request) {
    Socket socket = null;
    try {
        socket = newSocket();
        ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
        // 通过 ObjectOutputStream 将当前request传给服务端
        outputStream.writeObject(request);
        outputStream.flush();

        ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
        Object result = inputStream.readObject();
        inputStream.close();
        outputStream.close();
        return result;
    } catch (Exception e) {
        throw new RuntimeException("发起远程调用异常");
    } finally {
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
        }
    }
}

4，请求结果

​ * 从下图可以看到，8081和8082端口各有出现；这是因为服务端在注册服务时模拟分布式注册多个服务节点，客户端在处理服务节 点时进行了简易的基于随机数的负载均衡，main方法中循环调用

 * 请求main方法分十次进行服务获取，每一次都会随机获取8080或者8081端口服务，并进行调用

public class ClientDemo {

    public static void main(String[] args) throws RemoteException, NotBoundException, MalformedURLException, InterruptedException {

        ServiceDiscovery serviceDiscovery = new ServiceDiscoveryImpl(ZkConfig.CONNECTION_STR);
        RpcClientProxy proxy = new RpcClientProxy(serviceDiscovery);
        for (int i = 0; i < 10; i++) {
            IUserService service = proxy.clientProxy(IUserService.class,null);
            System.out.println(service.sayHello("lisa"));
            Thread.sleep(1000);
        }

    }
}

输出结果

三、实现多版本服务

1，服务端暴露服务自定义注解上添加version属性

@RpcAnnotation(value = IUserService.class,version = "1.0")
public class UserServiceImpl implements IUserService {
    @Override
    public String sayHello(String msg) {
        return "[I'M 8080] node : "+msg;
    }
}

@RpcAnnotation(value = IUserService.class,version = "2.0")
public class UserServiceImpl2 implements IUserService {
    @Override
    public String sayHello(String msg) {
        return "[I'M 8081] node : "+msg;
    }
}

2，服务绑定根据版本号分别绑定两个服务并注册到注册中心

  * 修改main方法

public class ServiceDemo {
    public static void main(String[] args) {
        IUserService userService = new UserServiceImpl();
        IUserService helloService2 = new UserServiceImpl2();
        RegisterCenter registerService = new RegisterCenterImpl();
        // 初始化注册中心和服务端口信息
        RPCServer server = new RPCServer(register, "127.0.0.1:8080");
        // 绑定服务
        server.bind(helloService, helloService2);
        // 发布服务
        server.publishServer();
        System.out.println("服务发布成功");
        System.in.read();
    }
}

zookeeper节点查询

GitHub 地址：https://github.com/lwx57280/Distributed-topics