Welcome to My Blog!

这里记录着我的java后端学习之路

(MK)zookeeper分布式与dubbo微服务

2020-09-06

百味皆苦

zookeeper

zookeeper MK

java api
- 会话连接与恢复

java api

会话连接与恢复

连接
连接

/**
 * @Title: ZKConnectDemo.java
 * @Package com.imooc.zk.demo
 * @Description: zookeeper 连接demo演示
 */
public class ZKConnect implements Watcher {
         
    final static Logger log = LoggerFactory.getLogger(ZKConnect.class);
 
    public static final String zkServerPath = "192.168.1.110:2181";
// public static final String zkServerPath = "192.168.1.111:2181,192.168.1.111:2182,192.168.1.111:2183";
    public static final Integer timeout = 5000;
    
    public static void main(String[] args) throws Exception {
         /**
          * 客户端和zk服务端链接是一个异步的过程
          * 当连接成功后后，客户端会收的一个watch通知
          * 
          * 参数：
          * connectString：连接服务器的ip字符串，
          *      比如: "192.168.1.1:2181,192.168.1.2:2181,192.168.1.3:2181"
          *      可以是一个ip，也可以是多个ip，一个ip代表单机，多个ip代表集群
          *      也可以在ip后加路径
          * sessionTimeout：超时时间，心跳收不到了，那就超时
          * watcher：通知事件，如果有对应的事件触发，则会收到一个通知；如果不需要，那就设置为null
          * canBeReadOnly：可读，当这个物理机节点断开后，还是可以读到数据的，只是不能写，
          *                          此时数据被读取到的可能是旧数据，此处建议设置为false，不推荐使用
          * sessionId：会话的id
          * sessionPasswd：会话密码 当会话丢失后，可以依据 sessionId 和 sessionPasswd 重新获取会话
          */
         ZooKeeper zk = new ZooKeeper(zkServerPath, timeout, new ZKConnect());
         
         log.warn("客户端开始连接zookeeper服务器...");
         log.warn("连接状态：{}", zk.getState());
         
         new Thread().sleep(2000);
         
         log.warn("连接状态：{}", zk.getState());
    }
 
    @Override
    public void process(WatchedEvent event) {
         log.warn("接受到watch通知：{}", event);
    }
}

重连

/**
 * 
 * @Title: ZKConnectDemo.java
 * @Description: zookeeper 恢复之前的会话连接demo演示
 */
public class ZKConnectSessionWatcher implements Watcher {
    
    final static Logger log = LoggerFactory.getLogger(ZKConnectSessionWatcher.class);
 
    public static final String zkServerPath = "192.168.1.110:2181";
    public static final Integer timeout = 5000;
    
    public static void main(String[] args) throws Exception {
         
         ZooKeeper zk = new ZooKeeper(zkServerPath, timeout, new ZKConnectSessionWatcher());
         
         long sessionId = zk.getSessionId();
         String ssid = "0x" + Long.toHexString(sessionId);
         System.out.println(ssid);
         byte[] sessionPassword = zk.getSessionPasswd();
         
         log.warn("客户端开始连接zookeeper服务器...");
         log.warn("连接状态：{}", zk.getState());
         new Thread().sleep(1000);
         log.warn("连接状态：{}", zk.getState());
         
         new Thread().sleep(200);
         
         // 开始会话重连
         log.warn("开始会话重连...");
         
         ZooKeeper zkSession = new ZooKeeper(zkServerPath, 
                                                timeout, 
                                                new ZKConnectSessionWatcher(), 
                                                sessionId, 
                                                sessionPassword);
         log.warn("重新连接状态zkSession：{}", zkSession.getState());
         new Thread().sleep(1000);
         log.warn("重新连接状态zkSession：{}", zkSession.getState());
    }
    
    @Override
    public void process(WatchedEvent event) {
         log.warn("接受到watch通知：{}", event);
    }
}

Read All

尚zookeeper

2020-09-06

百味皆苦

zookeeper

zookeeper
- 入门
  - 概述
入门

概述
- Zookeeper是一个开源的分布式的，为分布式应用提供协调服务的Apache项目。
- 工作机制：Zookeeper从设计模式角度来理解：是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper就将负责通知已经在Zookeeper上注册的那些观察者做出相应的反应，从而实现集群中类似Master/Slave管理模式
Read All

数据加解密工具类

2020-08-28

百味皆苦

工具类

数据安全

BASE64

BASE64

Base64是一种根据ASCII码来进行加密的可逆算法，这类算法简单来说，就等于将每个字符对应一个特定的字符（常常是根据进制进行匹配），一一对应，特别像电台密码本，因为每个字符都必须要加密，加密比较笨重。
加密
- 获取字符串中每个字符的ASCII码
- 按照每3个8bit的字符为一组来分组，即每组24bit
- 将这24bit划分成4个6bit的4个单位，每个单位前面添加2个0，得到4个8bit的单位
- 将每个8bit的单位转换成十进制数字，对照Base64编码表找到对应的字符进行拼接，得到最终的加密后的字符串
解密
- 读入4个字符，对照Base64编码表找到字符对应的索引，生成4个6为的值
- 将这4个6为的值拼接起来，形成一个24为的值
- 将这个24位的值按照8位一组截断成3个8位的值
- 对照ASCII表找到这三个8位的值对应的字符，即解码后的字符

/** 工具类实现代码  **/
public class BASE64Util {
    private static final Map<Integer, Character> base64CharMap = new HashMap<>();
    private static final String base64CharString = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   
    private static BASE64Util instance;
   
    private BASE64Util() {
        for (int i = 0; i < base64CharString.length(); i++) {
            char c = base64CharString.charAt(i);
            base64CharMap.put(new Integer(i), new Character(c));
        }
    }
   
    public static BASE64Util getInstance() {
        if (instance == null) {
            synchronized (BASE64Util.class) {
                if (instance == null) {
                    instance = new BASE64Util();
                }
            }
        }
        return instance;
    }
   
    /**
     * This method is used to encode a normal string to base64 string @param
     * origin The String to be encoded @return The String after encoded.
     */
    public String encode(String origin) {
        if (origin == null) {
            return null;
        }
        if (origin.length() == 0) {
            return "";
        }
        int length = origin.length();
        String binaryString = "";
        // to binary String
        for (int i = 0; i < length; i++) {
            int ascii = origin.charAt(i);
            String binaryCharString = Integer.toBinaryString(ascii);
            while (binaryCharString.length() < 8) {
                binaryCharString = "0" + binaryCharString;
            }
            binaryString += binaryCharString;
        }
   
        // to base64 index
        int beginIndex = 0;
        int endIndex = beginIndex + 6;
        String base64BinaryString = "";
        String charString = "";
        while ((base64BinaryString = binaryString.substring(beginIndex, endIndex)).length() > 0) {
            // if length is less than 6, add "0".
            while (base64BinaryString.length() < 6) {
                base64BinaryString += "0";
            }
            int index = Integer.parseInt(base64BinaryString, 2);
            char base64Char = base64CharMap.get(index);
            charString = charString + base64Char;
            beginIndex += 6;
            endIndex += 6;
            if (endIndex >= binaryString.length()) {
                endIndex = binaryString.length();
            }
            if (endIndex < beginIndex) {
                break;
            }
        }
        if (length % 3 == 2) {
            charString += "=";
        }
        if (length % 3 == 1) {
            charString += "==";
        }
        return charString;
    }
   
    public String decode(String encodedString) {
        if (encodedString == null) {
            return null;
        }
        if (encodedString.length() == 0) {
            return "";
        }
        // get origin base64 String
        String origin = encodedString.substring(0, encodedString.indexOf("="));
        String equals = encodedString.substring(encodedString.indexOf("="));
   
        String binaryString = "";
        // convert base64 string to binary string
        for (int i = 0; i < origin.length(); i++) {
            char c = origin.charAt(i);
            int ascii = base64CharString.indexOf(c);
            String binaryCharString = Integer.toBinaryString(ascii);
            while (binaryCharString.length() < 6) {
                binaryCharString = "0" + binaryCharString;
            }
            binaryString += binaryCharString;
        }
        // the encoded string has 1 "=", means that the binary string has append
        // 2 "0"
        if (equals.length() == 1) {
            binaryString = binaryString.substring(0, binaryString.length() - 2);
        }
        // the encoded string has 2 "=", means that the binary string has append
        // 4 "0"
        if (equals.length() == 2) {
            binaryString = binaryString.substring(0, binaryString.length() - 4);
        }
   
        // convert to String
        String charString = "";
        String resultString = "";
        int beginIndex = 0;
        int endIndex = beginIndex + 8;
        while ((charString = binaryString.substring(beginIndex, endIndex)).length() == 8) {
            int ascii = Integer.parseInt(charString, 2);
            resultString += (char) ascii;
            beginIndex += 8;
            endIndex += 8;
            if (endIndex > binaryString.length()) {
                break;
            }
        }
        return resultString;
    }
}

Read All

11/59

Welcome to My Blog!

(MK)zookeeper分布式与dubbo微服务

java api

会话连接与恢复

尚zookeeper

入门

概述

数据加解密工具类

BASE64