java缓存框架zookepper_Zookeeper分布式开源框架

Zookeeper分布式开源框架

一、zookeeper简介

zookeeper中文动物园管理员,作为其他分布式组件的协调调度，本身也是分布式，支持集群，在集群当中有选举机制，主从复制，以及读写分离等等比较重点的概念

zk支持统一命名服务，以及统一资源管理等

Zookeeper集群机制：本身zk支持单节点，但是主要特性还是在集群环境当中凸显，在集群中有一个Leader(领导者)和多个Follower(跟随者)

当Leader节点挂掉之后会重新选举Leader当做领导者，同时可以做到数据同步

Zookeeper集群机制数据结构：

zk中默认有一个根节点，根节点下可以创建子节点以及数据，子节点分为临时节点和持久节点

二、zookeeper环境搭建

1、安装一台虚拟机，配置好网卡，设置静态IP

2、克隆虚拟机，更改网卡

2.1 编辑网卡文件，使用命令

vi /etc/sysconfig/network-scripts/ifcfg-eno167xxxxxxxxxxxxx

按i，将IPADDR内容修改为静态IP地址，比如192.168.7.77

修改完毕，按esc，使用:wq!保存并且推出

重启网卡服务 service network restart

重启完毕，通过命令：ip addr命令查看当前虚拟机IP

2.2 使用Xshell连接

1.关闭防火墙

关闭：systemctl stop firewalld.service

禁用：systemctl disable firewalld.service

2.使用Xshell新建一个会话，会话名称自定义，主机写虚拟机地址

输入用户名和密码然后点击确定，点击连接，点击接受并保存

3、搭建ZK环境

3.1 搭建之前保证虚拟机有JDK环境，ZK运行需要依赖于JDK

卸载自带JDK，先通过命令：

rpm -qa|grep java查找当前是否安装JDK

卸载命令：rpm -e --nodeps java-oepnxxxxxxxxxx

安装JDK：

上传jdk安装包：

通过XFTP上传，切换到/usr/local目录，新建一个文件夹为java，进入到java文件夹然后上传

切换到/usr/local/java目录

解压JDK压缩包

tar -zxvf xxxxxxxxxxxxxxxx

解压完成JDK后配置环境变量：

vi /etc/profile 切换到最后一行，粘贴对应环境变量：

export JAVA_HOME=/usr/local/java/jdk1.8.0_121

export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

export PATH=$PATH:$JAVA_HOME/bin

source /etc/profile 重新加载该文件

java -version查看

搭建ZK集群：

1.将Zookeeper的tar包上传到对应/usr/local/zookeeper当中

2.切换到cd /usr/local/zookeeper

3.tar -zxvf zookeeper.xxx.tar.gz

4.vi /etc/profile文件配置环境变量

export JAVA_HOME=/usr/local/java/jdk1.8.0_121

export ZOOKEEPER_HOME=/usr/local/zookeeper/zookeeper-3.4.10

export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

export PATH=$JAVA_HOME/bin:$ZOOKEEPER_HOME/bin:$PATH

5.切换到zookeeper解压目录的conf文件夹下面

cd /usr/local/zookeeper/zookeeper-3.4.10/conf

mv zoo_sample.cfg zoo.cfg

6.修改zoo.cfg文件

vi /usr/local/zookeeper/zookeeper-3.4.10/conf/zoo.cfg

将dataDir修改为自己的目录：dataDir=/usr/local/zookeeper/zookeeper-3.4.10/data

在文件末尾加入如下内容：

server.0=192.168.7.66:2888:3888

server.1=192.168.7.77:2888:3888

server.2=192.168.7.88:2888:3888

7.在/usr/local/zookeeper/zookeeper-3.4.10/data下面创建一个myid文件，文件内容为机器标识，第一台机器就是0

8.将zookeeper内容复制到本地，从本地再次上传到另外两台服务器的对应文件夹

9.重复第4个步骤以及第7个步骤

10.切换到zookeeper解压目录的bin文件夹下，然后通过./zkServer.sh start命令启动zk服务

如果权限不够则使用chmod 777 ./*.sh赋权

11.查看zk启动状态命令：zkServer.sh status停止zk使用命令：./zkServer.sh stop

4、zookeeper具体步骤

1.为什么要做数据同步？

防止单台机器节点宕机后，数据丢失或者访问不到

2.当Leader宕机后，会发生什么？

其余的Follwer机器会根据特定的规则选择出一个Leader，当集群机器节点存在于半数以上则能继续对外提供服务

3.搭建ZK集群环境

注意：配置任何文件都要找到对应目录查看当前目录地址：pwd

3.1 搭建zk集群之前，保证每一台机器都要JDK环境，并且机器数量不能小于3台

第一台：192.168.7.66

第二台：192.168.7.77

第三台：192.168.7.88

如果安装完系统后默认存在JDK应该如何操作：

1.查找当前系统当中存在的jdk

npm -qa |grep java

2.使用rmp -e --nodeps jdk-openxxxxxxxxx

如何配置JDK：

1.在/usr/local下新建了一个文件夹java，将JDK的tar包上传到Linux系统对应目录当中

2.切换到对应目录，找到刚刚上传的tar包

cd /usr/local/java 可以通过ll命令查看当前目录下的所有文件

3.解压jdk安装包

tar -zxvf jdk-1.8xxxxxx.tar.gz

4.配置jdk环境变量，更改环境变量文件

vi /etc/profile

5.切换到该文件的最后一行，然后编辑(按i)，将对应内容复制或者手写到该文件当中

如有疑问请搜索：Linux配置JDK环境变量，将对应配置目录改为自己目录即可

3.2 配置ZK集群

3.2.1 首先在/usr/local下创建一个文件夹zookeeper，将本地windows计算机当中的zookeeper-3.6.10.tar.gz包上传到Linux系统对应目录当中

3.2.2 切换到/usr/local/zookeeper目录当中

3.2.3 使用tar -zxvf zookeeper-3.4.10.tar.gz解压到当前文件夹

3.2.4 编辑系统环境变量，加入zk环境变量

vi /etc/profile

文件末尾加入如下内容(路径根据自身情况进行书写)

export JAVA_HOME=/opt/jdk1.8.0_71

export ZOOKEEPER_HOME=/usr/local/zookeeper

export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

export PATH=$JAVA_HOME/bin:$ZOOKEEPER_HOME/bin:$PATH

3.2.5 将zookkeeper解压目录的conf文件夹下的zoo_sample.cfg改名为zoo.cfg

mv zoo_sample.cfg zoo.cfg

3.2.6 修改对应的zoo.cfg

3.2.6.1 修改dataDir内容指向到自定义地址，建议在zookeeper解压目录下新建一个data文件夹，然后指向到该文件夹

dataDir是数据文件存放地址

3.2.6.2 在zoo.cfg文件末尾加入集群机器配置关系

server.myid(zk机器标识)=IP地址：2888:3888

server.0=192.168.7.66:2888:3888

server.1=192.168.7.77:2888:3888

server.2=192.168.7.88:2888:3888

3.2.6.3 esc，:wq!保存并退出

3.2.7 创建对应服务器标识

要知道当前在那一台服务器，然后创建对应myid标识

cd /usr/local/zookeeper/zookeeper-3.4.10/data

创建myid文件 vi myid

编辑myid文件加入对应服务器标识

3.3 注意问题

我们可以在一台机器上配置完JDK以及zk和环境变量后，将当前机器关闭，右键克隆

克隆完成需要改对应IP地址和Myid文件配置：

IP地址更改：

vi /etc/sysconfig/network-scripts/ifcfg-eno167xxxxxxxxxxxxx

将IPADDR内容修改为静态IP地址，比如192.168.7.77

Myid文件改为对应服务器标识即可

集群环境各个机器节点需要通信

集群机器需要关闭防火墙

conentos7关闭防火墙：

systemctl stop firewalld.service

systemctl disable firewalld.service

3.4 启动zk服务

切换到对应bin目录：

cd /usr/local/zookeeper/zookeeper-3.4.10/bin

启动zk服务：./zkServer.sh start

停止zk服务：./zkServer.sh stop

重启zk服务：./zkServer.sh restart

5、监控zk

5.1 在linux当中，可以通过再bin目录下使用./zkServer.sh status查看当前服务器的角色以及状态

6、 windows如何操作zk

6.1 找到zk压缩包，将压缩包解压到当前文件夹

6.2 将conf文件夹下的zoo_sample.cfg文件改为zoo.cfg

6.3 在解压目录下创建一个data文件夹，修改zoo.cfg中dataDir数据目录路径(不是必须)

6.4 启动zk，找到bin目录下有一个zkServer.cmd(启动前保证有JDK环境变量)

6.5操作zk

操作工具：ZooInspector

找到对应目录：E:\学习文档\Zookeeper\ZooInspector\build

双击启动jar文件：zookeeper-dev-ZooInspector.jar

7、介绍zoo.cfg文件内容

tickTime代表心跳时间，一般情况下来讲，每一台服务器会定时发送心跳，如果超过该时间没有发送心跳则代表当前服务器宕机，最小超时时间为两个心跳时间

initLimit：多少个心跳时间内，允许其他server连接并初始化数据，如果ZooKeeper管理的数据较大，则应相应增大这个值

clientPort：服务的监听端口，默认为2181

dataDir：用于存放内存数据库快照的文件夹，同时用于集群的myid文件也存在这个文件夹里(注意：一个配置文件只能包含一个dataDir字样，即使它被注释掉了。)

syncLimit：多少个tickTime内，允许follower同步，如果follower落后太多，则会被丢弃。

server.A=B：C：D：

A是一个数字,表示这个是第几号服务器,B是这个服务器的ip地址

C第一个端口用来集群成员的信息交换,表示的是这个服务器与集群中的Leader服务器交换信息的端口

D是在leader挂掉时专门用来进行选举leader所用

8、利用zk原生客户端操作zk服务器

在上面案例中利用到了ZooInterceptor工具操作了zk服务器，那么就相当于利用客户端进行操作

8.1 查看当前zk服务器的目录结构

8.2 创建节点：不能跳目录创建

create 目录节点值

示例：

在根目录下创建一个节点，值为空

create /znode ''

在根目录的zookeeper目录下创建一个节点znodeChild，值为znodeValue

create /zookeeper/znodeChild znodeValue

节点分类型：节点分为临时和持久

默认情况下创建的节点为持久节点

创建临时节点如下：(临时节点创建后不能有子节点)

create -e 目录节点值[权限]

示例：

create -e /zNodeEphemearl EphemearlValue

8.3 获取节点

get 节点

8.4 修改节点

set 节点节点值

8.5 删除节点

delete 节点只能一层一层删除

rmr 节点递归删除

三、JavaAPI操作zk

步骤一：导入zk依赖

org.apache.zookeeper

zookeeper

3.4.6

JavaAPI操作zk步骤：

1、连接到zookeeper

//zk连接地址private static final String CONNECT_ADDR="192.168.7.66:2181,192.168.7.77:2181,192.168.7.88:2181";

private static final String CONNECT_ADDR="127.0.0.1:2181";

//zk连接超时时间，如果超过时间没有建立连接则不进行连接

private static final Integer SESSION_TIME_OUT=2000;

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

/**

* 步骤一：连接到zookeeper

* 参数一：String path代表连接zk的地址

* 参数二：Integer SessionTimeOut连接超时时间

* 参数三：Watcher代表监听，可以监听连接，添加节点，修改节点等等操作

ZooKeeper zooKeeper=new ZooKeeper(CONNECT_ADDR, SESSION_TIME_OUT, new Watcher() {

//代表监听回调方法，如果不需要监听则方法内部可以没有任何实现代码

//如果需要监听，则需要根据状态和类别进行监听

//event代表操作事件

@Override

public void process(WatchedEvent event) {

}

});

System.out.println("zk连接成功~");

//关闭zk

zooKeeper.close();

}

2、创建一个节点

/**

* 创建节点

* 参数一:节点路径地址

* 参数二：节点存放的值

* 参数三：权限

* 参数四：代表节点类型(持久/瞬时)

* 返回值：创建节点的实际路径

String zNode = zooKeeper.create("/zNode", "zNodeValue".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

System.out.println("创建节点返回值："+zNode);

3、修改节点

/**

* 修改节点

* 参数一：修改节点路径

* 参数二:修改节点的值

* 参数三：代表版本号

Stat stat = zooKeeper.setData("/zNode", "zNodeNewValue".getBytes(), -1);

System.out.println(stat.toString());

4、删除节点

/**

* 删除节点

* delete 需要一层一层删除

* 参数一：代表删除节点路径

* 参数二：代表版本，不知道为-1

zooKeeper.delete("/zNode/zNodeChild",-1);

System.out.println("删除成功~");

5、获取节点

/**

* 获取子集节点

List children = zooKeeper.getChildren("/", false);

for (String node:children) {

System.out.println(node);

}

//获取节点值

byte[] data = zooKeeper.getData("/zookeeper/quota", false, new Stat());

System.out.println(new String(data));

四、Watcher监听基础

1、创建监听

public class ZookeeperDemo {

//zk连接地址private static final String CONNECT_ADDR="192.168.7.66:2181,192.168.7.77:2181,192.168.7.88:2181";

private static final String CONNECT_ADDR="192.168.7.66:2181,192.168.7.77:2181,192.168.7.88:2181";

//zk连接超时时间，如果超过时间没有建立连接则不进行连接

private static final Integer SESSION_TIME_OUT=2000;

//计数器，在JUC包下的java.util.concurrent代表并发包，并发包中工具类可以控制并发线程访问以及资源

//对一个线程进行监控，Watcher监听时会启动一个线程，当线程执行完毕后，将计数器-1

private static CountDownLatch countDownLatch=new CountDownLatch(1);

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

/**

* 步骤一：连接到zookeeper

* 参数一：String path代表连接zk的地址

* 参数二：Integer SessionTimeOut连接超时时间

* 参数三：Watcher代表监听，可以监听连接，添加节点，修改节点等等操作

ZooKeeper zooKeeper=new ZooKeeper(CONNECT_ADDR, SESSION_TIME_OUT, new Watcher() {

//代表监听回调方法，如果不需要监听则方法内部可以没有任何实现代码

//如果需要监听，则需要根据状态和类别进行监听

//event代表操作事件

@Override

public void process(WatchedEvent event) {

//获取zk状态

Event.KeeperState state = event.getState();

//已经建立连接状态下

if(state== Event.KeeperState.SyncConnected){

//监听事件，监听连接还是增删改

Event.EventType type = event.getType();

if(type== Event.EventType.None){

System.out.println("客户端与服务器建立了连接");

//计数器-1，代表有一个线程执行结束

countDownLatch.countDown();

}

});

//线程等待,阻塞,等待计数器为0则放行

countDownLatch.await();

System.out.println("建立连接后，后续操作~");

//关闭zk

zooKeeper.close();

}

2、事件监听

public class MyWatcher implements Watcher {

//zk连接地址private static final String CONNECT_ADDR="192.168.7.66:2181,192.168.7.77:2181,192.168.7.88:2181";

private static final String CONNECT_ADDR="192.168.7.66:2181,192.168.7.77:2181,192.168.7.88:2181";

//zk连接超时时间，如果超过时间没有建立连接则不进行连接

private static final Integer SESSION_TIME_OUT=2000;

private ZooKeeper zooKeeper = null;

//对一个线程进行监控，Watcher监听时会启动一个线程，当线程执行完毕后，将计数器-1

private static CountDownLatch countDownLatch=new CountDownLatch(1);

//只要事件发生该表都会执行该回调方法

@Override

public void process(WatchedEvent event) {

//获取事件类型和状态

Event.EventType type = event.getType();

Event.KeeperState state = event.getState();

String path = event.getPath();

System.out.println("zk状态："+state+"\tzk类型:"+type+"\t操作地址："+path);

if(state == Event.KeeperState.SyncConnected){

/**

* 监听连接状态

if(type == Event.EventType.None){

System.out.println("~~~~~~~~~~~~~~~~zk成功建立连接~~~~~~~~~~~~");

countDownLatch.countDown();

}else if(type == Event.EventType.NodeCreated){

System.out.println("~~~~~~~~~~~~~~~~zk成功创建节点~~~~~~~~~~~~");

}else if(type == Event.EventType.NodeDataChanged){

System.out.println("~~~~~~~~~~~~~~~~zk成功修改节点数据~~~~~~~~~~~~");

}else if(type == Event.EventType.NodeDeleted){

System.out.println("~~~~~~~~~~~~~~~~zk成功删除节点数据~~~~~~~~~~~~");

}else if(type == Event.EventType.NodeChildrenChanged){

System.out.println("~~~~~~~~~~~~~~~~zk成功修改子节点数据~~~~~~~~~~~~");

}

/**

* 创建ZK连接方法

public void createZkConnection(String connect_Addr,Integer session_Time_Out){

try {

zooKeeper = new ZooKeeper(connect_Addr, session_Time_Out, this);

} catch (IOException e) {

e.printStackTrace();

}

/**

* 关闭zk连接

* @throws InterruptedException

public void closeZkConnection(){

if(zooKeeper!=null){

try {

zooKeeper.close();

} catch (InterruptedException e) {

e.printStackTrace();

}

public MyWatcher() {

createZkConnection(CONNECT_ADDR,SESSION_TIME_OUT);

}

/**

* 创建节点

* @throws InterruptedException

public String createNode(String path,String value) throws KeeperException, InterruptedException {

//创建节点需要开启监听

zooKeeper.exists(path,true);

String node = zooKeeper.create(path, value.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);

return node;

}

/**

* 修改节点

* @param

* @throws InterruptedException

* @throws KeeperException

public Stat setNodeData(String path,String value) throws KeeperException, InterruptedException {

zooKeeper.exists(path,true);

Stat stat = zooKeeper.setData(path, value.getBytes(), -1);

return stat;

}

/**

* 删除节点

* @param path

* @throws KeeperException

* @throws InterruptedException

public void deleteNode(String path) throws KeeperException, InterruptedException {

zooKeeper.exists(path,true);

zooKeeper.delete(path,-1);

}

public static void main(String[] args) throws InterruptedException, KeeperException {

MyWatcher myWatcher=new MyWatcher();

countDownLatch.await();

myWatcher.createNode("/zNode/zNodeChild02", "zNodeValue");

//System.out.println("创建节点返回结果："+zNodeValue);

//myWatcher.setNodeData("/zNode/zNodeChild","zValue");

//myWatcher.deleteNode("/znode02");

myWatcher.closeZkConnection();

}

五、Leader选举机制

1、三个角色

Leader角色：领导者，协调调度，分配任务....

Follwer角色：跟随者

OBServer角色：观察者，不参与选举

2、Leader选举机制的过程

根据myid和事务的id进行比较选取

默认启动过程：

假设第一台机器A启动的时候，不进行选举，因为当前集群中只有当前一台节点

当第二个机器B启动的时候，机器A,B都进入选举状态Looking，双方互换对应内容，机器A将当前生成的[myid,事务id]交给机器B，机器B将当前生成的[myid,事务id]交给机器A

交换完成后进行数据对比，首先对比事务ID，谁大推举谁当领导者，因为事务ID越大代表机器的数据越新，如果事务ID相等则进行myid的比较，谁大推举谁当领导者，当有半数以上节点

同意同一个机器作为领导者时，那么该机器就是领导者，其他机器就是跟随者

当Leader宕机后，选举过程：

当Leader挂掉后，其余的follwer进入选举状态，进行选举，然后多个机器进行数据的互换，然后通过事务进行对比，如果相等则进行myid对比，直到每一台机器都推荐以为领导者后

半数以上机器同一同一台机器作为领导者，那么该机器就是领导者，其他机器就是跟随者

当数据交换时，如果数据之前已经进行交换，那么同一台节点的数据再次交换时，会根据时间戳判断，留下最新数据

六、zookeeper解决分布式锁的问题

1、分布式锁

单节点环境下，多个线程之间抢占资源可以用锁解决问题

多个节点下，需要用到分布式锁的思想来解决对应问题

2、分布式锁解决方案

1.数据库解决分布式锁

效率低，无阻塞的，并不能完全解决分布式锁的问题，并且无事件监听

2.缓存：Redis

无事件监听

3.zookeeper

zk节点是唯一的，并且支持临时节点，而且附带事件监听

当有线程或者Tomcat访问到zk时，创建一个临时节点作为标识，如果节点能够成功创建则代表可以生成订单，如果不能创建代表节点正在被使用，那么就等待，等待其他线程什么时候将节点删除了，那其他线程再资源进行订单生成，利用到zk事件监听，可以监听到节点什么时机删除

案例：

/**

* 生成订单的类

public class OrderNumGenerator {

//序号

private static Integer number=0;

//生成订单号的方法

public String getOrderNumber(){

SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");

return simpleDateFormat.format(new Date())+"-"+ ++number;

}

/**

* 订单业务逻辑类

public class OrderService {

private OrderNumGenerator orderNumGenerator=new OrderNumGenerator();

private Lock lock=new ZkAbstractLock();

/**

* 获取订单

public synchronized void getNumber() throws InterruptedException {

//获取锁

lock.getLock();

//生成订单

System.out.println(orderNumGenerator.getOrderNumber());

//释放锁

lock.unLock();

}

public static void main(String[] args) {

for (int i = 0; i < 10; i++) {

new Thread(new Runnable() {

@Override

public void run() {

OrderService orderService = new OrderService();

try {

orderService.getNumber();

} catch (InterruptedException e) {

e.printStackTrace();

}

}).start();

}

/**

* 锁接口

public interface Lock {

//获取锁

public void getLock() throws InterruptedException;

//释放锁

public void unLock();

}

public class ZkAbstractLock implements Lock{

//连接的服务器地址

private static final String CONNECT_ADDR="127.0.0.1:2181";

//创建zk连接对象

protected ZkClient zkClient=new ZkClient(CONNECT_ADDR);

//zk临时节点

private final String PATH="/orderNode";

//计数器

private CountDownLatch countDownLatch=new CountDownLatch(1);

@Override

public void getLock() throws InterruptedException {

//创建节点，获取结果

if(!tryLock()){

//等待

waitLock();

//等待完成后再次创建该节点

getLock();

}

//创建节点

private boolean tryLock(){

try {

zkClient.createEphemeral(PATH);

return true;

}catch (Exception e){

return false;

}

//等待

private void waitLock() throws InterruptedException {

//创建监听对象

IZkDataListener iZkDataListener=new IZkDataListener() {

@Override

public void handleDataChange(String s, Object o) throws Exception {

}

//数据删除

@Override

public void handleDataDeleted(String s) throws Exception {

countDownLatch.countDown();

}

};

//启动监听

zkClient.subscribeDataChanges(PATH,iZkDataListener);

//如果节点存在则一直等待

if(zkClient.exists(PATH)){

countDownLatch=new CountDownLatch(1);

countDownLatch.await();

}

//删除事件通知

zkClient.unsubscribeDataChanges(PATH,iZkDataListener);

}

@Override

public void unLock() {

if(zkClient!=null){

zkClient.close();

}

七、Dubbo实现生产者和消费者案例

1、步骤一：导入对应依赖，Dubbo依赖(依赖于String)以及zk依赖

生产者对应代码：生产者负责生产业务接口(与之前SSM整合相同)，将接口通过Dubbo发布到zk当中

示例：

步骤一：创建一个业务接口

/**

* 业务接口

public interface DoSomeService {

//业务方法

public String doSome();

}

2、步骤二：创建业务接口的实现类，并完成业务员实现

public class DoSomeServiceImpl implements DoSomeService {

@Override

public String doSome() {

System.out.println("接口中业务方法被调用");

return "doSome()";

}

3、步骤三：将业务接口发布到zk

配置Spring大配置文件(服务提供方，注册中心，Dubbo协议端口，业务接口发布)

4、采用注解方式

业务员接口实现类：

@Service("userInfoService")

public class UserInfoServiceImpl implements UserInfoService {

@Override

public Object getUser() {

System.out.println("用户业务方法");

return "user";

}

配置文件：

5、消费者：负责调用接口

步骤一：配置文件中指定注册中心信息，通过接口调用方式拿到接口对象

测试：

public static void main(String[] args) {

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

DoSomeService doSomeService = (DoSomeService)applicationContext.getBean("doSomeService");

System.out.println(doSomeService.doSome());

}

八、DubboAdmin平台

1、配置方式

DubboAdmin监控Dubbo情况，以及配置服务的负载均衡机制

1.找到Tomcat解压目录的webapps下,将DubboAdmin解压包放到该目录当中，修改该项目下WEB-INF下有一个dubbo.properties配置文件修改为自己的zk地址

2.启动Tomcat，浏览器通过地址/dubbo-admin访问该平台输入用户名和密码

2、集群，负载均衡，容错机制

集群：Dubbo集群，服务的集群，通过修改端口号，产生相同的服务就算作集群

负载均衡：建立集群之上

负载均衡机制：

随机权重比例：调整权重加大服务的访问几率

默认：轮训：轮训调用集群中的服务

最小连接

容错机制：

Failover Cluster：失败自动切换，当出现失败，重试其它服务器。

通常用于读操作，但重试会带来更长延迟。可通过 retries="2" 来设置重试次数(不含第一次)。

集群配置如下：

或

Failfast Cluster：快速失败，只发起一次调用，失败立即报错。

通常用于非幂等性的写操作，比如新增记录。

或

Failsafe Cluster：失败安全，出现异常时，直接忽略。

通常用于写入审计日志等操作。

或

Failback Cluster：失败自动恢复，后台记录失败请求，定时重发。

通常用于消息通知操作。

或

Forking Cluster：并行调用多个服务器，只要一个成功即返回。

通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过 forks="2" 来设置最大并行数。

或

3、Dubbox分布式架构

3.1 从github上下载对应当当的dubbox

3.2 将Dubbox下载的压缩包解压，然后通过cmd命令行窗口先对dubbox进行编译

切换到dubbox解压目录：cd C:\Users\FLC\Desktop\授课内容\DubboX\dubbox-master

通过 mvn install -Dmaven.test.skip=true 编译

将Dubbox编译到本地Maven库中：

mvn install:install-file -Dfile=C:\Users\FLC\Desktop\授课内容\DubboX\dubbox-master\dubbo\target\dubbo-2.8.4.jar -DgroupId=com.alibaba -DartifactId=dubbo -Dversion=2.8.4 -Dpackaging=jar -DgeneratePom=true

导入依赖~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

4、创建公共模块

@Path("/dubbox")

public interface DubboxProviderService {

@Path("/doDubboxService/{userName}") //访问地址

@GET

@Consumes({MediaType.APPLICATION_JSON}) //指定格式

public String doDubboxService(@PathParam("userName") String userName);

}

5、编写Dubbox生产者

3.4.1 引入公共模块的依赖

3.4.2 书写对应业务的实现类

@Service("dubboxProviderService")

public class DubboxPorviderServiceImpl implements DubboxProviderService {

@Override

public String doDubboxService(String userName) {

System.out.println("当前Dubbox生产者对应的业务方法被访问："+userName);

return "dubbox";

}

3.4.3 通过dubbox将业务接口发布出去

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"

xmlns:context="http://www.springframework.org/schema/context"

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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

6、消费者实现

配置文件：

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans

测试类：

public static void main(String[] args) {

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

DubboxProviderService dubboxProviderService = (DubboxProviderService)applicationContext.getBean("dubboxProviderService");

System.out.println(dubboxProviderService.doDubboxService("柴英杰"));

}

7、dubbo注解应用

生产者和消费者双方采用注解方式进行服务的发布和调用需开启dubbo注解支持：

生产者发布服务时，在服务的实现类上加入@Service注解即可

消费者调用时直接使用@Reference即可

java缓存框架zookepper_Zookeeper分布式开源框架相关推荐

阿里巴巴有哪些好玩的分布式开源框架？
前言开源项目起初由国外一些工程师发起,最著名的开源社区及私有软件项目的托管平台GitHub,由国外Chris Wanstrath创办从一个开发者社区变成了一个免费开源代码托管平台:国内越来越多的公司 ...
七个实用的分布式开源框架
分布式系统是由一组通过网络进行通信.为了完成共同的任务而协调工作的计算机节点组成的系统,广泛应用在互联网企业项目生产研发中.近几年 "大数据" 概念的兴起,让复杂而宽泛的分布式系统 ...
iBase4J-JAVA分布式开源框架
java分布式开源架构:SpringMVC,Mybatis,Redis数据和session缓存,分布式,单点登录,shiro权限管理,dubbo扩展,Rest等等, 地址:点击打开链接系统主要功能如 ...
开源框架_跨平台开源框架对比介绍
知识库夕阳下你的背影轻轻嗅探你诱人的气息幻想远方的你就在身边这的空气也已不再污浊若隐若现知识库主要记录生活,工作不断归纳总结的经验,能时刻指导我不断清空自我,处于空杯状态去面对未来和过去 ...
Java基础之《分布式事务（4）—分布式开源框架使用》
一.hmily框架 1.到github拉取最新的源码 idea:File - New - Project form Version Control 2.切换release版本此时拉下来的是maste ...
java rpc框架 hsf_分布式服务框架HSF学习
转载:http://googi.iteye.com/blog/1884754 HSF提供的是分布式服务开发框架,taobao内部使用较多,总体来说其提供的功能及一些实现基础: 1.标准Service方 ...
java 分布式rpc框架_分布式RPC框架Apache Dubbo(一)
4 Dubbo快速入门 Dubbo作为一个RPC框架,其最核心的功能就是要实现跨网络的远程调用.本小节就是要创建两个应用,一个作为服务的提供方,一个作为服务的消费方.通过Dubbo来实现服务消费方远程 ...
java iot框架_物联网开源框架Thingsboard使用总结
总架构文档:https://thingsboard.io/docs/reference/architecture/ 并发模型: Actor模型akka 集群协作:zookeeper 支持协议:mqt ...
grpc框架_分布式RPC框架dubbo、motan、rpcx、gRPC、thrift简介与性能比较
Dubbo Dubbo 是阿里巴巴公司开源的一个Java高性能优秀的服务框架,使得应用可通过高性能的 RPC 实现服务的输出和输入功能,可以和 Spring框架无缝集成.曾有一段时间放弃维护,不过当前 ...

java缓存框架zookepper_Zookeeper分布式开源框架

java缓存框架zookepper_Zookeeper分布式开源框架相关推荐

最新文章

热门文章