4. Zookeeper实战(开发重点)
4.1 分布式安装部署
集群思路:先搞定一台服务器,再克隆出两台,形成集群!
4.1.1 安装zookeeper
请参考 https://blog.csdn.net/dear_zx/article/details/113809479 文中 2.1
4.1.2 配置服务器编号
- 在/opt/zookeeper/zkData创建myid文件
- 在文件中添加与server对应的编号:1
- 其余两台服务器分别对应2和3
4.1.3 配置zoo.cfg文件
打开zoo.cfg文件,增加如下配置
#######################cluster##########################
server.1=192.168.204.141:2888:3888
server.2=192.168.204.142:2888:3888
server.3=192.168.204.143:2888:3888
- 配置参数解读 server.A=B:C:D
- A:一个数字,表示第几号服务器
- 集群模式下配置的/opt/zookeeper/zkData/myid文件里面的数据就是A的值
- B:服务器的ip地址
- C:与集群中Leader服务器交换信息的端口
- D:选举时专用端口,万一集群中的Leader服务器挂了,需要一个端口来重新进行选举,选出一个新的Leader,而这个端口就是用来执行选举时服务器相互通信的端口。
- A:一个数字,表示第几号服务器
4.1.4 配置其余两台服务器
- 1. 在虚拟机数据目录vms下,创建zk02
- 2. 将本台服务器数据目录下的.vmx文件和所有的.vmdk文件分别拷贝zk02下
- 3. 虚拟机->文件->打开 (选择zk02下的.vmx文件)
- 4. 开启此虚拟机,弹出对话框,选择“我已复制该虚拟机”
- 5. 进入系统后,修改linux中的ip,修改/opt/zookeeper/zkData/myid中的数值为2
第三台服务器zk03,重复上面的步骤
4.1.5 集群操作
- 1. 每台服务器的防火墙必须关闭
[root@localhost bin]# systemctl stop firewalld.service
- 2. 启动第1台
[root@localhost bin]# ./zkServer.sh start
- 3. 查看状态
[root@localhost bin]# ./zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost.
Error contacting service. It is probably not running.
注意:因为没有超过半数以上的服务器,所以集群失败 (防火墙没有关闭也会导致失败)
- 4. 当启动第2台服务器时
- 查看第1台的状态:Mode: follower
- 查看第2台的状态:Mode: leader
4.2 客户端命令行操作
- 启动客户端
[root@localhost bin]# ./zkCli.sh
- 显示所有操作命令
help
- 查看当前znode中所包含的内容
ls /
- 查看当前节点详细数据
- zookeeper老版本使用 ls2 / ,现在已经被新命令替代
- ls -s /
- cZxid:创建节点的事务
- 每次修改ZooKeeper状态都会收到一个zxid形式的时间戳,也就是ZooKeeper事务ID。
- 事务ID是ZooKeeper中所有修改总的次序。
- 每个修改都有唯一的zxid,如果zxid1小于zxid2,那么zxid1在zxid2之前发生。
- ctime:被创建的毫秒数(从1970年开始)
- mZxid:最后更新的事务zxid
- mtime:最后修改的毫秒数(从1970年开始)
- pZxid:最后更新的子节点zxid
- cversion:创建版本号,子节点修改次数
- dataVersion:数据变化版本号
- aclVersion:权限版本号
- ephemeralOwner:如果是临时节点,这个是znode拥有者的session id。如果不是临时节点则是0。
- dataLength:数据长度
- numChildren:子节点数
- zookeeper老版本使用 ls2 / ,现在已经被新命令替代
- 分别创建2个普通节点
- 在根目录下,创建中国和美国两个节点
- create /china
- create /usa
- 在根目录下,创建俄罗斯节点,并保存“普京”数据到节点上
- create /ru "pujing"
- 多级创建节点
- 在日本下,创建东京 “热”
- japan必须提前创建好,否则报错 “节点不存在”
- 创建好节点后执行:create /japan/Tokyo "hot"
- 获得节点的值
- get /japan/Tokyo
- 创建短暂节点:创建成功之后,quit退出客户端,重新连接,短暂的节点消失
- create -e /uk
- ls /
- quit
- ls /
- 创建带序号的节点
- 在俄罗斯ru下,创建3个city
- create -s /ru/city # 执行三次
- ls /ru
- [city0000000000, city0000000001, city0000000002]
- 如果原来没有序号节点,序号从0开始递增。
- 如果原节点下已有2个节点,则再排序时从2开始,以此类推
- 修改节点数据值
- set /japan/Tokyo "too hot"
- 监听 节点的值变化 或 子节点变化(路径变化)
- 1. 在server3主机上注册监听/usa节点的数据变化
- addWatch /usa
- 2. 在Server1主机上修改/usa的数据
- set /usa "telangpu"
- 3. Server3会立刻响应
- WatchedEvent state:SyncConnected type:NodeDataChanged path:/usa
- 4. 如果在Server1的/usa下面创建子节点NewYork
- create /usa/NewYork
- 5. Server3会立刻响应
- WatchedEvent state:SyncConnected type:NodeCreatedpath:/usa/NewYork
- 1. 在server3主机上注册监听/usa节点的数据变化
- 删除节点
-
delete /usa/NewYork
-
- 递归删除节点 (非空节点,节点下有子节点)
-
deleteall /ru
-
不仅删除/ru,而且/ru下的所有子节点也随之删除
-
- 在根目录下,创建中国和美国两个节点
4.3 API应用
4.3.1 IDEA环境搭建
1. 创建一个Maven工程
2. 添加pom文件
<dependencies>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.8.2</version>
</dependency>
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.6.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
3. 在resources下创建log4j.properties
log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/zk.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n
4.3.2 创建ZooKeeper客户端
4.3.3 创建节点
- 一个ACL对象就是一个Id和permission对
- 表示哪个/哪些范围的Id(Who)在通过了怎样的鉴权(How)之后,就允许进行那些操作(What):Who How What;
- permission(What)就是一个int表示的位码,每一位代表一个对应操作的允许状态。
- 类似linux的文件权限,不同的是共有5种操作:CREATE、READ、WRITE、DELETE、ADMIN(对应更改ACL的权限)
- OPEN_ACL_UNSAFE:创建开放节点,允许任意操作 (用的最少,其余的权限用的很少)
- READ_ACL_UNSAFE:创建只读节点
- CREATOR_ALL_ACL:创建者才有全部权限
4.3.4 查询节点的值
4.3.5 修改节点的值
4.3.6 删除节点
4.3.7 获取子节点
4.3.8 监听子节点的变化
- 程序在运行的过程中,我们在linux下创建一个节点
- IDEA的控制台就会做出响应:NodeChildrenChanged--/
4.3.9 判断Znode是否存在
以下代码为4.3.4 ~ 4.3.9的演示代码
package test;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.junit.Before;
import org.junit.Test;
import java.util.List;
/**
* zookeeperAPI
*/
public class testZK {
// zookeeper集群的ip和端口
private String connString = "192.168.58.222:2181,192.168.58.223:2181,192.168.58.224:2181";
// session超时时间:时间不宜设置太小,因为zookeeper和加载集群环境会因为性能等原因而延迟略高
// 如果时间太少,还没有创建好客户端,就开始操作节点。会报错
private int sessionTimeout = 60*1000;
// zookeeper客户端对象
private ZooKeeper zkClient;
@Before
public void init() throws Exception{
zkClient = new ZooKeeper(connString, sessionTimeout, new Watcher() {
public void process(WatchedEvent watchedEvent) {
System.out.println("得到的监听反馈,在进行的业务处理!");
System.out.println(watchedEvent.getType());
}
});
}
/*
* 创建节点
* */
@Test
public void createNode() throws Exception{
String str = zkClient.create("/lagou", "mzj".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
System.out.println("已创建节点"+str);
}
/*
* 获取节点上的值
* */
@Test
public void getNodeData() throws Exception{
byte[] data = zkClient.getData("/lagou", false, new Stat());
String str = new String(data);
System.out.println("/lagou节点的数据"+str);
}
/*
* 修改节点
* */
@Test
public void updateData() throws Exception{
Stat data = zkClient.setData("/lagou", "mzjA".getBytes(), 0);
System.out.println("修改后的数据"+data);
}
/*
* 删除节点
* */
@Test
public void deleteData() throws Exception{
zkClient.delete("/lagou",1);
}
/*
* 获取子节点
* */
@Test
public void getChildren() throws Exception{
List<String> list = zkClient.getChildren("/china", false);
for (String s : list) {
System.out.println(s);
}
}
/*
* 监听根节点
* */
@Test
public void watchNode() throws Exception{
List<String> children = zkClient.getChildren("/", true);
for (String child : children) {
System.out.println(child);
}
// 让线程无限的等待下去
System.in.read();
}
/*
* 判断节点是否存在
* */
@Test
public void exists() throws Exception{
Stat exists = zkClient.exists("/lagou", false);
if (exists == null){
System.out.println("不存在");
} else{
System.out.println("存在");
}
}
}
4.4 案例-模拟美团商家上下线
4.4.1 需求
- 模拟美团服务平台,商家营业通知,商家打烊通知
- 提前在根节点下,创建好 /meituan 节点
4.4.2 商家服务类
package meituan;
import org.apache.zookeeper.*;
import java.io.IOException;
public class ShopServer {
private String connString = "192.168.58.222:2181,192.168.58.223:2181,192.168.58.224:2181";
private int sessionTimeout = 60*1000;
private ZooKeeper zkClient;
// 创建客户端 连接zookeeper
public void conntect() throws Exception{
zkClient = new ZooKeeper(connString, sessionTimeout, new Watcher() {
@Override
public void process(WatchedEvent watchedEvent) {
}
});
}
// 注册到zookeeper
public void register(String shopName) throws Exception{
// 一定要创建EPHEMERAL_SEQUENTIAL 临时有序的节点
// 可以自动编号
// 断开时,节点自动删除
String s = zkClient.create("/meituan/shop", shopName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
System.out.println("["+shopName+"]开始营业了!"+s);
}
public static void main(String[] args) throws Exception {
// 开一个饭店
ShopServer shopServer = new ShopServer();
// 连接zookeeper集群
shopServer.conntect();
// 将服务节点注册到zookeeper(入驻美团)
shopServer.register(args[0]);
// 业务逻辑处理
shopServer.business(args[0]);
}
// 做买卖
private void business(String shopName) throws Exception {
System.out.println("【"+shopName+"】正在火爆营业中");
System.in.read();
}
}
4.4.3 客户类
package meituan;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class Customers {
private String connString = "192.168.58.222:2181,192.168.58.223:2181,192.168.58.224:2181";
private int sessionTimeout = 60*1000;
private ZooKeeper zkClient;
// 创建客户端 连接zookeeper
public void connect() throws Exception{
zkClient = new ZooKeeper(connString, sessionTimeout, new Watcher() {
@Override
public void process(WatchedEvent watchedEvent) {
// 重新获取商家列表
try {
getShopList();
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
public static void main(String[] args) throws Exception {
Customers customers = new Customers();
// 获得zookeeper连接(用户打开app)
customers.connect();
// 获取meituan下的所有子节点列表(获取商家列表)
customers.getShopList();
// 业务逻辑处理(对比商家,下单)
customers.business();
}
// 获取子节点列表
private void getShopList() throws KeeperException, InterruptedException {
// 获取服务器的子节点信息,并且对父节点进行监听
List<String> shops = zkClient.getChildren("/meituan", true);
// 声明存储服务器信息的集合
ArrayList<String> shopList = new ArrayList<>();
for (String shop : shops) {
byte[] bytes = zkClient.getData("/meituan/" + shop, false, new Stat());
shopList.add(new String(bytes));
}
System.out.println("目前正在营业的商家:"+shopList);
}
private void business() throws IOException {
System.out.println("用户正在浏览商家");
System.in.read();
}
}
1. 运行客户类,就会得到商家列表
2. 首先在linux中添加一个商家,然后观察客户端的控制台输出(商家列表会立刻更新出最新商家),多添加几个,也会实时输出商家列表
create /meituan/KFC "KFC"
create /meituan/BKC "BurgerKing"
create /meituan/baozi "baozi"
3. 在linux中删除商家,在客户端的控制台也会实时看到商家移除后的最新商家列表
delete /meituan/baozi
4. 运行商家服务类(以main方法带参数的形式运行)
4.5 案例-分布式锁-商品秒杀
- 锁:我们在多线程中接触过,作用就是让当前的资源不会被其他线程访问!
- 我的日记本,不可以被别人看到。所以要锁在保险柜中
- 当我打开锁,将日记本拿走了,别人才能使用这个保险柜
- 在zookeeper中使用传统的锁引发的 “羊群效应” :1000个人创建节点,只有一个人能成功,999人需要等待!
- 羊群是一种很散乱的组织,平时在一起也是盲目地左冲右撞,但一旦有一只头羊动起来,其他的羊也会不假思索地一哄而上,全然不顾旁边可能有的狼和不远处更好的草。羊群效应就是比喻人都有一种从众心理,从众心理很容易导致盲从,而盲从往往会陷入骗局或遭到失败。
- 避免“羊群效应”,zookeeper采用分布式锁
- 1. 所有请求进来,在/lock下创建 临时顺序节点 ,放心,zookeeper会帮你编号排序
- 2. 判断自己是不是/lock下最小的节点
- 1. 是,获得锁(创建节点)
- 2. 否,对前面小我一级的节点进行监听
- 3. 获得锁请求,处理完业务逻辑,释放锁(删除节点),后一个节点得到通知(比你年轻的死了,你成为最嫩的了)
- 4. 重复步骤2
实现步骤
1. 初始化数据库
创建数据库zkproduct,使用默认的字符集utf8
CREATE TABLE product(
id INT PRIMARY KEY AUTO_INCREMENT, -- 商品编号
product_name VARCHAR(20) NOT NULL, -- 商品名称
stock INT NOT NULL, -- 库存
VERSION INT NOT NULL -- 版本
)
INSERT INTO product (product_name,stock,VERSION)
VALUES('锦鲤-清空购物车-大奖',5,0)
-- 订单表
CREATE TABLE `order`(
id VARCHAR(100) PRIMARY KEY, -- 订单编号
pid INT NOT NULL, -- 商品编号
userid INT NOT NULL -- 用户编号
)
2. 搭建工程
搭建ssm框架,对库存表-1,对订单表+1
pom.xml:
<packaging>war</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>11</java.version>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<spring.version>5.2.7.RELEASE</spring.version>
</properties>
<dependencies>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- Mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.5</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.5</version>
</dependency>
<!-- 连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>
<!-- 数据库 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.20</version>
</dependency>
<!-- junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!-- maven内嵌的tomcat插件 -->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<!-- 目前apache只提供了tomcat6和tomcat7两个插件 -->
<artifactId>tomcat7-maven-plugin</artifactId>
<configuration>
<port>8001</port>
<path>/</path>
</configuration>
<executions>
<execution>
<!-- 打包完成后,运行服务 -->
<phase>package</phase>
<goals>
<goal>run</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 后台的日志输出:针对开发者-->
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
</configuration>
spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
">
<!--扫描包注解-->
<context:component-scan base-package="controller,service,mapper" />
<!--配置数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="url" value="jdbc:mysql://192.168.58.222:3306/zkproduct?serverTimezone=GMT" />
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="username" value="root" />
<property name="password" value="Za@123456" />
<property name="maxActive" value="10" />
<property name="minIdle" value="5" />
</bean>
<!--sqlsessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>
</bean>
<!--事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<!--开启事务-->
<tx:annotation-driven />
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="mapper"/>
</bean>
</beans>
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
version="3.1">
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/spring.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
<async-supported>true</async-supported>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
OrderMapper
package mapper;
import models.Order;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Component;
/*
* 订单操作类
* */
@Mapper
@Component
public interface OrderMapper {
/*
* 生成订单
* */
@Insert("insert into `order` (id,pid,userid) values(#{id},#{pid},#{userid})")
int insert (Order order);
}
ProductMapper
package mapper;
import models.Product;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import org.springframework.stereotype.Component;
/*
* 订单操作类
* */
@Mapper
@Component
public interface ProductMapper {
/*
* 查询商品(目的查询库存)
* */
@Select("select * from product where id = #{id}")
Product getProduct(@Param("id") int id);
/*
* 减库存
* */
@Update("update product set stock = stock - 1 where id = #{id}")
int reduceStock(@Param("id") int id);
}
ProductService
package service;
/*
* 商品服务
* */
public interface ProductService {
/*
* 减库存
* */
void reduceStock(int id) throws Exception;
}
ProductServiceImpl
package service.impl;
import mapper.OrderMapper;
import mapper.ProductMapper;
import models.Order;
import models.Product;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import service.ProductService;
import java.util.UUID;
/*
* 服务实现类
* */
@Service
public class ProductServiceImpl implements ProductService {
@Autowired
private ProductMapper productMapper;
@Autowired
private OrderMapper orderMapper;
public void reduceStock(int id) throws Exception {
// 获取库存(查询商品)
Product product = productMapper.getProduct(id);
if (product.getStock() <= 0){
throw new RuntimeException("已抢光!");
}
// 减库存
int i = productMapper.reduceStock(id);
if (i == 1){
// 生成订单
Order order = new Order();
order.setId(UUID.randomUUID().toString());// 使用uuid工具生成一个订单号
order.setPid(id);
order.setUserid(101);
orderMapper.insert(order);
} else {
throw new RuntimeException("减库存失败!");
}
}
}
ProductAction
/*
* 控制层
* */
@Controller
public class ProductAction {
@Autowired
private ProductService productService;
@GetMapping("/product/reduce")
@ResponseBody
public Object reduce(int id) throws Exception {
productService.reduceStock(id);
return "ok";
}
}
3. 启动测试
1. 启动两次工程,端口号分别8001和8002
2. 使用nginx做负载均衡(nginx.conf)
upstream sga{
server 192.168.204.1:8001;
server 192.168.204.1:8002;
}
server {
listen 80;
server_name localhost;
#charset koi8-r;
#access_log logs/host.access.log main;
location / {
proxy_pass http://sga;
root html; index index.html index.htm;
}
}
3. 使用 JMeter 模拟1秒内发出10个http请求
- 下载地址:http://jmeter.apache.org/download_jmeter.cgi
- 1. 查看测试结果,10次请求全部成功
- 2. 查看数据库,stock库存变成 -5 (并发导致的数据结果错误)
4. apahce提供的zookeeper客户端
基于zookeeper原生态的客户端类实现分布式是非常麻烦的,我们使用apahce提供了一个zookeeper客户端来实现
Curator:http://curator.apache.org/
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>4.2.0</version>
<!-- 网友投票最牛逼版本 -->
</dependency>
recipes是curator族谱大全,里面包含zookeeper和framework
5. 在控制层中加入分布式锁的逻辑代码
package controller;
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import service.ProductService;
/*
* 控制层
* */
@Controller
public class ProductAction {
private String connString = "192.168.58.222:2181,192.168.58.223:2181,192.168.58.224:2181";
@Autowired
private ProductService productService;
@GetMapping("/product/reduce")
@ResponseBody
public Object reduce(int id) throws Exception {
// 重试策略(1000毫秒试一次,最多试3次)
RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000,3);
// 创建curator工具对象
CuratorFramework client = CuratorFrameworkFactory.newClient(connString,retryPolicy);
client.start();
// 根据工具对象创建“内部互斥锁”
InterProcessMutex lock = new InterProcessMutex(client,"/product_"+id);
// 加锁
try {
lock.acquire();
productService.reduceStock(id);
}catch (Exception e){
if (e instanceof RuntimeException){
throw e;
}
}
finally {
// 释放锁
lock.release();
}
return "ok";
}
}
6. 再次测试,并发问题解决!