运用前边写的RPC demo，结合zookeeper实现服务注册与发现、负载均衡(轮询)

运用前边写的RPC demo，结合zookeeper实现服务注册与发现、负载均衡(轮询)

本例模拟了user，order，good三个服务，每个服务有2~3个地址，数据只存放在java容器中未和数据库交互，未使用任何成熟框架（后面会用spring cloud实现真实些的项目），配置未实现热加载，后续可能会写关于热加载的东西。。过程中尽量实现基于配置的自动化，避免写死一些东西。

本人电脑很辣鸡内存只有2G，虚拟机卡爆，只能在Windows下操作，且只有这一台电脑，只能用不同端口模拟不同的主机，所以ip都是本地，本例未用到分布式锁，因为用了也测不出效果，后续会基于zookeeper写个简单的。代码较多，只贴出重点。

• 服务注册代码

public static void regServer(String serverAddressKey) {
//LoadConfig为读取文件的配置文件工具类
        String rigCenterAddress = LoadConfig.getConfigValue("server_rigister_center");
        String[] rigCenterPathArr = rigCenterAddress.split(":");
        if(rigCenterPathArr.length != 2
                || rigCenterPathArr[0] == null || rigCenterPathArr[1] == null){
            throw new RuntimeException("获取的注册中心地址有误");
        }
        ZkClient zkClient = new ZkClient(rigCenterAddress, 5000, 2000);
        //若不存在根节点先创建根节点,持久节点
        String rootPath = ExposeAll.rootPath;
        if (!zkClient.exists(rootPath)) {
            zkClient.createPersistent(rootPath,rigCenterAddress);
        }
        //若不存在相应服务父节点，则先创建，持久节点
        String serverType = serverAddressKey.substring(0, serverAddressKey.indexOf("_"));
        String serverPath = rootPath + LoadConfig.getConfigValue(serverType + "_server_name");
        System.out.println("serverPath:"+serverPath);
        if (!zkClient.exists(serverPath)) {
                //其子节点才携带具体地址
                zkClient.createPersistent(serverPath);
         }
        String serverAddress = LoadConfig.getConfigValue(serverAddressKey);
        String[] addressArr = serverAddress.split(":");
        if(addressArr.length != 2
                || addressArr[0] == null || addressArr[1] == null){
            throw new RuntimeException("获取" + serverAddress + "地址有误");
        }

        //若不存在相应服务节点，则先删除再创建，临时节点
        String nodePath = serverPath + "/" + serverAddressKey;
        if (zkClient.exists(nodePath)) {
            zkClient.delete(nodePath);
         }
        zkClient.createEphemeral(nodePath, serverAddress);
        System.out.println(nodePath + "服务注册成功");
    }

• 服务发现与负载均衡（轮询）

package testZookeeper.testZKServer;

import org.junit.Test;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.Socket;
import java.util.*;

public class ServiceProxyFactory {

    //private static Class consumer;

    public static Object getService(Class serviceClazz){
        return Proxy.newProxyInstance(serviceClazz.getClassLoader(), new Class[]{serviceClazz},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        Object back = null;
                        String[] path = getPath(serviceClazz);
                        if(null == path || path.length != 2
                                || path[0] == null || path[1] == null){
                            throw new RuntimeException("获取的地址有误");
                        }
                        System.out.println((Arrays.asList(path)));
                        String ip = path[0];
                        int port;
                        try {
                            port = Integer.parseInt(path[1]);
                        } catch (NumberFormatException e) {
                            throw new RuntimeException("获取的端口有误");
                        }
                        ObjectOutputStream objOutStream = null;
                        Socket client;
                        try {
                            client = new Socket(ip,port);
                            objOutStream = new ObjectOutputStream(client.getOutputStream());
                            objOutStream.writeUTF(method.getName());
                            objOutStream.writeObject(method.getParameterTypes());
                            objOutStream.writeObject(args);

                            try (ObjectInputStream objInStream = new ObjectInputStream(client.getInputStream())) {
                                back = objInStream.readObject();
                            } catch (ClassNotFoundException e) {
                                e.printStackTrace();
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        finally {
                            try {
                                if(null != objOutStream)
                                    objOutStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        return back;
                    }
                });
    }

    /**
     * 根据配置去注册中心查找服务地址
     * @return ip和端口
     */
    private static String[] getPath(Class consumer){
        try {
            //用负载均衡算法获取具体服务地址
            String ipAndPort = getServerAddress(consumer);
            //为简化，假设ip和端口格式合法，暂不做格式校验
            System.out.println("具体服务地址为:" + ipAndPort);
            return ipAndPort.split(":");
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    // 服务调用次数
    private static int count = 1;

	//客户端实现轮询
    private static String getServerAddress(Class consumer) {
        //serversMap;
        System.out.println("App.serversMap=" + App.serversMap);
        List<String> serverList = App.serversMap.get(getFatherServerNode(consumer));
        String balancingAlgorithms = LoadConfig.getConfigValue("load_balancing_algorithms");
        //轮询算法
        if("polling".equals(balancingAlgorithms)){

            String serverAddress = serverList.get(count % serverList.size());
            count++;
            return serverAddress;
        }
        //其他情况,取首
        return serverList.get(0);
    }

    @Test
    public void test(){
        System.out.println(App.serversMap.get(getFatherServerNode(GoodService.class)));
    }

    private static String getFatherServerNode(Class consumerClazz) {
        String clazzName = consumerClazz.getName();
        String serverName = clazzName.substring(clazzName.lastIndexOf(".")+1);
        String serverKey = serverName.substring(0,serverName.indexOf("Service")).toLowerCase() + "_server_name";
        return LoadConfig.getConfigValue(serverKey).replace("/","");
    }
}

• 配置文件

#注册中心根路径
root_node_name=/rigister_center
#注册中心地址
server_rigister_center=127.0.0.1:2181
#user服务父节点路径
user_server_name=/user_server_address
#user服务主机地址1
user_server_address_1=127.0.0.1:6060
#user服务主机地址2
user_server_address_2=127.0.0.1:6061
#user服务主机地址3
user_server_address_3=127.0.0.1:6062

#order服务父节点路径（相对根节点）
order_server_name=/order_server_address
#order服务主机地址1
order_server_address_1=127.0.0.1:7070
#order服务主机地址2
order_server_address_2=127.0.0.1:7071

#good服务父节点路径（相对根节点）
good_server_name=/good_server_address
#good服务主机地址1
good_server_address_1=127.0.0.1:9090
#good服务主机地址2
good_server_address_2=127.0.0.1:9091

#负载均衡算法类型，本例只实现了一中
load_balancing_algorithms=polling

• zokeeper节点结构

• 所有代码截图，没有模块化，时间有限请谅解