zookeeper系列（三）实战数据发布订阅

时间 2019-11-09

原文原文链接

zookeeper系列（一）zookeeper必知
zookeeper系列（二）实战master选举
zookeeper系列（三）实战数据发布订阅
zookeeper系列（四）实战负载均衡
zookeeper系列（五）实战分布式锁
zookeeper系列（六）实战分布式队列
zookeeper系列（七）实战分布式命名服务
zookeeper系列（八）zookeeper运维java

数据发布订阅

多个订阅者对象同时监听同一主题对象，主题对象状态变化时通知全部订阅者对象更新自身状态。发布方和订阅方独立封装、独立改变，当一个对象的改变须要同时改变其余对象，而且它不知道有多少个对象须要改变时，可使用发布订阅模式。mysql

在分布式系统中的顶级应用有配置管理和服务发现。sql

配置管理：指集群中的机器拥有某些配置，而且这些配置信息须要动态地改变，那么咱们就可使用发布订阅模式把配置作统一的管理，让这些机器订阅配置信息的改变，可是配置改变时这些机器获得通知并更新本身的配置。segmentfault

服务发现：指对集群中的服务上下线作统一管理，每一个工做服务器均可以做为数据的发布方，向集群注册本身的基本信息，而让某些监控服务器做为订阅方，订阅工做服务器的基本信息。当工做服务器的基本信息改变时，如服务上下线、服务器的角色或服务范围变动，那么监控服务器能够获得通知并响应这些变化。服务器

架构图

左边表明Zookeeper集群，右侧表明服务器集群。其中前3个为工做服务器Work Server，绿色为管理服务器Manage Server，最下面的是控制服务器Control Server。架构

config节点，用于配置管理。Manage Server经过config节点下发配置信息，Work Server能够经过订阅config节点的改变来更新本身的配置。负载均衡

Servers节点，用于服务发现，每一个Work Server在启动时都会在Servers节点下建立一个临时节点，Manage Server充当monitor，经过监听Servers节点的子节点列表的变化来更新本身内存中工做服务器列表的信息。运维

经过Control Server由Command节点做为中介，向Manage Server发送控制指令。Control Server向command节点写入命令信息，Manage Server订阅command节点的数据改变来监听并执行命令。分布式

流程图

Manage Server程序主体流程ide

核心类图

WorkServer对应架构图的Work Server；
ManageServer对应架构图的Manage Server；
ServerConfig用于记录Work Server的配置信息；
ServerData用于记录Work Server的基本信息；
SubscribeZkClient做为示例程序入口服务站启动Work Server和Manage Server

实现代码

/**
 * 配置信息
 */
public class ServerConfig {
    
    private String dbUrl;
    private String dbPwd;
    private String dbUser;
    public String getDbUrl() {
        return dbUrl;
    }
    public void setDbUrl(String dbUrl) {
        this.dbUrl = dbUrl;
    }
    public String getDbPwd() {
        return dbPwd;
    }
    public void setDbPwd(String dbPwd) {
        this.dbPwd = dbPwd;
    }
    public String getDbUser() {
        return dbUser;
    }
    public void setDbUser(String dbUser) {
        this.dbUser = dbUser;
    }
    
    @Override
    public String toString() {
        return "ServerConfig [dbUrl=" + dbUrl + ", dbPwd=" + dbPwd
                + ", dbUser=" + dbUser + "]";
    }

}

/**
 * 服务器基本信息
 */
public class ServerData {
    
    private String address;
    private Integer id;
    private String name;

    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "ServerData [address=" + address + ", id=" + id + ", name="
                + name + "]";
    }

}

/**
 * 表明工做服务器
 */
public class WorkServer {

    private ZkClient zkClient;
    // ZooKeeper
    private String configPath;
    // ZooKeeper集群中servers节点的路径
    private String serversPath;
    // 当前工做服务器的基本信息
    private ServerData serverData;
    // 当前工做服务器的配置信息
    private ServerConfig serverConfig;
    private IZkDataListener dataListener;

    public WorkServer(String configPath, String serversPath,
            ServerData serverData, ZkClient zkClient, ServerConfig initConfig) {
        this.zkClient = zkClient;
        this.serversPath = serversPath;
        this.configPath = configPath;
        this.serverConfig = initConfig;
        this.serverData = serverData;

        this.dataListener = new IZkDataListener() {

            public void handleDataDeleted(String dataPath) throws Exception {

            }

            public void handleDataChange(String dataPath, Object data)
                    throws Exception {
                String retJson = new String((byte[])data);
                ServerConfig serverConfigLocal = (ServerConfig)JSON.parseObject(retJson,ServerConfig.class);
                updateConfig(serverConfigLocal);
                System.out.println("new Work server config is:"+serverConfig.toString());
                
            }
        };

    }

    // 启动服务器
    public void start() {
        System.out.println("work server start...");
        initRunning();
    }

    // 中止服务器
    public void stop() {
        System.out.println("work server stop...");
        zkClient.unsubscribeDataChanges(configPath, dataListener); // 取消监听config节点
    }

    // 服务器初始化
    private void initRunning() {
        registMe(); // 注册本身
        zkClient.subscribeDataChanges(configPath, dataListener); // 订阅config节点的改变事件
    }

    // 启动时向zookeeper注册本身的注册函数
    private void registMe() {
        String mePath = serversPath.concat("/").concat(serverData.getAddress());

        try {
            zkClient.createEphemeral(mePath, JSON.toJSONString(serverData)
                    .getBytes());
        } catch (ZkNoNodeException e) {
            zkClient.createPersistent(serversPath, true);
            registMe();
        }
    }

    // 更新本身的配置信息
    private void updateConfig(ServerConfig serverConfig) {
        this.serverConfig = serverConfig;
    }

}

public class ManageServer {

    // zookeeper的servers节点路径
    private String serversPath;
    // zookeeper的command节点路径
    private String commandPath;
    // zookeeper的config节点路径
    private String configPath;
    private ZkClient zkClient;
    private ServerConfig config;
    // 用于监听servers节点的子节点列表的变化
    private IZkChildListener childListener;
    // 用于监听command节点数据内容的变化
    private IZkDataListener dataListener;
    // 工做服务器的列表
    private List<String> workServerList;

    public ManageServer(String serversPath, String commandPath,
            String configPath, ZkClient zkClient, ServerConfig config) {
        this.serversPath = serversPath;
        this.commandPath = commandPath;
        this.zkClient = zkClient;
        this.config = config;
        this.configPath = configPath;
        this.childListener = new IZkChildListener() {

            public void handleChildChange(String parentPath,
                    List<String> currentChilds) throws Exception {
                // TODO Auto-generated method stub
                workServerList = currentChilds; // 更新内存中工做服务器列表
                
                System.out.println("work server list changed, new list is ");
                execList();

            }
        };
        this.dataListener = new IZkDataListener() {

            public void handleDataDeleted(String dataPath) throws Exception {
                // TODO Auto-generated method stub
                // ignore;
            }

            public void handleDataChange(String dataPath, Object data)
                    throws Exception {
                // TODO Auto-generated method stub
                String cmd = new String((byte[]) data);
                System.out.println("cmd:"+cmd);
                exeCmd(cmd); // 执行命令

            }
        };

    }

    private void initRunning() {
        zkClient.subscribeDataChanges(commandPath, dataListener);
        zkClient.subscribeChildChanges(serversPath, childListener);
    }

    /*
     * 1: list 2: create 3: modify
     */
    private void exeCmd(String cmdType) {
        if ("list".equals(cmdType)) {
            execList();

        } else if ("create".equals(cmdType)) {
            execCreate();
        } else if ("modify".equals(cmdType)) {
            execModify();
        } else {
            System.out.println("error command!" + cmdType);
        }

    }

    // 列出工做服务器列表
    private void execList() {
        System.out.println(workServerList.toString());
    }

    // 建立config节点
    private void execCreate() {
        if (!zkClient.exists(configPath)) {
            try {
                zkClient.createPersistent(configPath, JSON.toJSONString(config)
                        .getBytes());
            } catch (ZkNodeExistsException e) {
                zkClient.writeData(configPath, JSON.toJSONString(config)
                        .getBytes()); // config节点已经存在，则写入内容就能够了
            } catch (ZkNoNodeException e) {
                String parentDir = configPath.substring(0,
                        configPath.lastIndexOf('/'));
                zkClient.createPersistent(parentDir, true);
                execCreate();
            }
        }
    }

    // 修改config节点内容
    private void execModify() {
        // 咱们随意修改config的一个属性就能够了
        config.setDbUser(config.getDbUser() + "_modify");

        try {
            zkClient.writeData(configPath, JSON.toJSONString(config).getBytes());
        } catch (ZkNoNodeException e) {
            execCreate(); // 写入时config节点还未存在，则建立它
        }
    }

    // 启动工做服务器
    public void start() {
        initRunning();
    }

    // 中止工做服务器
    public void stop() {
        zkClient.unsubscribeChildChanges(serversPath, childListener);
        zkClient.unsubscribeDataChanges(commandPath, dataListener);
    }

}

/**
 * 调度类
 */
public class SubscribeZkClient {
    
       private static final int  CLIENT_QTY = 5; // Work Server数量

        private static final String  ZOOKEEPER_SERVER = "192.168.1.105:2181";
        
        private static final String  CONFIG_PATH = "/config";
        private static final String  COMMAND_PATH = "/command";
        private static final String  SERVERS_PATH = "/servers";
           
        public static void main(String[] args) throws Exception {

            List<ZkClient>  clients = new ArrayList<ZkClient>();
            List<WorkServer>  workServers = new ArrayList<WorkServer>();
            ManageServer manageServer = null;

            try {

                // 建立一个默认的配置
                ServerConfig initConfig = new ServerConfig();
                initConfig.setDbPwd("123456");
                initConfig.setDbUrl("jdbc:mysql://localhost:3306/mydb");
                initConfig.setDbUser("root");

                // 实例化一个Manage Server
                ZkClient clientManage = new ZkClient(ZOOKEEPER_SERVER, 5000, 5000, new BytesPushThroughSerializer());
                manageServer = new ManageServer(SERVERS_PATH, COMMAND_PATH,CONFIG_PATH,clientManage,initConfig);
                manageServer.start(); // 启动Manage Server

                // 建立指定个数的工做服务器
                for ( int i = 0; i < CLIENT_QTY; ++i ) {
                    ZkClient client = new ZkClient(ZOOKEEPER_SERVER, 5000, 5000, new BytesPushThroughSerializer());
                    clients.add(client);
                    ServerData serverData = new ServerData();
                    serverData.setId(i);
                    serverData.setName("WorkServer#"+i);
                    serverData.setAddress("192.168.1."+i);

                    WorkServer  workServer = new WorkServer(CONFIG_PATH, SERVERS_PATH, serverData, client, initConfig);
                    workServers.add(workServer);
                    workServer.start();    // 启动工做服务器
                    
                }

                System.out.println("敲回车键退出！\n");
                new BufferedReader(new InputStreamReader(System.in)).readLine();
                
            } finally {
                System.out.println("Shutting down...");

                for ( WorkServer workServer : workServers ) {
                    try {
                        workServer.stop();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }               
                }

                for ( ZkClient client : clients ) {
                    try {
                        client.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    
                }
            }
        }    

}

咱们用zookeeper的命令行客户端向Manage Server下达指令。
执行zkCli命令：

create /command list

java控制台输出：

cmd:list
[192.168.1.1, 192.168.1.0, 192.168.1.3, 192.168.1.2, 192.168.1.4]

执行zkCli命令：

set /command create

java控制台输出：

cmd:create
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456, dbUser=root]
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456, dbUser=root]
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456, dbUser=root]
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456, dbUser=root]
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456, dbUser=root]

执行zkCli命令：

set /command modify

java控制台输出：

cmd:modify
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456_modify, dbUser=root]
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456_modify, dbUser=root]
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456_modify, dbUser=root]
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456_modify, dbUser=root]
new Work server config is: ServerConfig [dbUrl=jdbc:mysql://localhost:3306/mydb, dbPwd=123456_modify, dbUser=root]