Zookeeper

1. Zookeeper 概述

1.1 概述

ZooKeeper 是一个用于分布式应用的高性能协调服务。它在一个简单的接口中公开了常见的服务 —— 如命名、配置管理、同步和组服务，因此您不必从头开始编写它们。你可以用它来实现共识、组管理、组长选举和存在协议。您还可以根据自己的特定需求对其进行构建。

总结：Zookeeper 是一个开源的分布式（多台服务器干一件事）的，为分布式应用提供协调服务的 Apache 项目。美团，饿了么，淘宝，58同城等等应用都是Zookeeper的现实生活版。

1.2 工作机制

Zookeeper 从设计模式角度来理解：是一个基于观察者模式（一个人干活，有人盯着他）设计的分布式服务管理框架。

它负责存储和管理大家都关心的数据

• 然后接受观察者的注册，一旦这些数据的发生变化

• Zookeeper 就将负责通知已经注册的那些观察者做出相应的反应

• 从而实现集群中类似 Master/Slave 管理模式

Zookeeper = 文件系统 + 通知机制。

1.3 特点

1.3.1 分布式和集群的区别

无论分布式和集群，都是很多人在做事情。具体区别如下：

例如：我有一个饭店，越来越火爆，我得多招聘一些工作人员。

• 分布式：招聘 1 个厨师，1 个服务员，1 个前台，三个人负责的工作不一样，但是最终目的都是为饭店工作。
• 集群：招聘 3 个服务员，三个人的工作一样。

1.3.2 特点概括

1. 是一个 leader 和多个 follower 来组成的集群（狮群中，一头雄狮，N头母狮）
2. 集群中只要有半数以上的节点存活，Zookeeper 就能正常工作（5 台服务器挂 2 台，没问题；4 台服务器挂 2 台，就停止）
3. 全局数据一致性，每台服务器都保存一份相同的数据副本，无论 client 连接哪台 server，数据都是一致的
4. 数据更新原子性，一次数据要么成功，要么失败
5. 实时性，在一定时间范围内，client 能读取到最新数据
6. 更新的请求按照顺序执行，会按照发送过来的顺序，逐一执行（发来 123，执行 123，而不是 321 或者别的）

1.4 数据结构

• ZooKeeper 数据模型的结构与 linux 文件系统很类似，整体上可以看作是一棵树，每个节点称做一个 ZNode（ZookeeperNode）。
• 每一个 ZNode 默认能够存储 1MB 的数据（元数据），每个 ZNode 的路径都是唯一的。
  • 元数据（Metadata），又称中介数据、中继数据，为描述数据的数据（data about data），主要是描述数据属性（property）的信息，用来支持如指示存储位置、历史数据、资源查找、文件记录等功能。

1.5 应用场景

提供的服务包括：统一命名服务、统一配置管理、统一集群管理、服务器节点动态上下线、软负载均衡等。

统一命名服务

• 在分布式环境下，通常需要对应用或服务进行统一的命名，便于识别

• 例如：服务器的 IP 地址不容易记，但域名相比之下却是很容易记住

统一配置管理

• 分布式环境下，配置文件做同步是必经之路

• 1000 台服务器，如果配置文件作出修改，那一台一台的修改，运维人员肯定会疯，如何做到修改一处就快速同步到每台服务器上

• 将配置管理交给 Zookeeper

  • 将配置信息写入到 Zookeeper 的某个节点上

  • 每个客户端都监听这个节点

  • 一旦节点中的数据文件被修改，Zookeeper 这个话匣子就会通知每台客户端服务器

    

服务器节点动态上下线

• 客户端能实时获取服务器上下线的变化
• 例如：在美团 APP上实时可以看到商家是否正在营业或打样

软负载均衡

• Zookeeper 会记录每台服务器的访问数，让访问数最少的服务器去处理最新的客户请求（雨露均沾）

2. Zookeeper本地模式安装

镜像库地址：http://archive.apache.org/dist/zookeeper/

2.1 本地模式安装

2.1.1 安装前准备

1. 安装 jdk
2. 拷贝 apache-zookeeper-3.6.0-bin.tar.gz 到 opt 目录
3. 解压安装包 tar -zxvf apache-zookeeper-3.6.0-bin.tar.gz
4. 重命名 mv apache-zookeeper-3.6.0-bin zookeeper

2.1.2 配置修改

1. 在 /opt/zookeeper/ 这个目录上创建 zkData 和 zkLog 目录

   mkdir zkData mkdir zkLog

2. 进入 /opt/zookeeper/conf 这个路径，复制一份 zoo_sample.cfg 文件并命名为 zoo.cfg

   cp zoo_sample.cfg zoo.cfg

3. 编辑 zoo.cfg 文件，修改 dataDir 路径

   dataDir=/opt/zookeeper/zkData

   dataLogDir=/opt/zookeeper/zkLog

2.1.3 操作 Zookeeper

1. 启动 Zookeeper：./zkServer.sh start

2. 查看进程是否启动：jps

   QuorumPeerMain：是zookeeper集群的启动入口类，是用来加载配置启动QuorumPeer线程的

3. 查看状态：./zkServer.sh status

   Zookeeper启动失败：Error contacting service. It is probably not running.

4. 启动客户端：./zkCli.sh

5. 退出客户端：quit

2.2 配置参数解读

Zookeeper 中的配置文件 zoo.cfg 中参数含义解读如下：

• tickTime = 2000：通信心跳数，Zookeeper 服务器与客户端心跳时间，单位毫秒
  • Zookeeper 使用的基本时间，服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个 tickTime 时间就会发送一个心跳，时间单位为毫秒。
• initLimit = 10：LF 初始通信时限
  • 集群中的 Follower 跟随者服务器与 Leader 领导者服务器之间，启动时能容忍的最多心跳数。
  • 10 * 2000（10个心跳时间）如果领导和跟随者没有发出心跳通信，就视为失效的连接，领导和跟随者彻底断开。
• syncLimit = 5：LF 同步通信时限
  • 集群启动后，Leader 与 Follower 之间的最大响应时间单位，假如响应超过 syncLimit * tickTime ->10 秒，Leader 就认为 Follwer 已经死掉，会将Follwer 从服务器列表中删除。
• dataDir：数据文件目录 + 数据持久化路径
  • 主要用于保存 Zookeeper 中的数据。
• dataLogDir：日志文件目录
• clientPort = 2181：客户端连接端口
  • 监听客户端连接的端口。

3. Zookeeper 内部原理

3.1 选举机制（面试重点）

半数机制：集群中半数以上机器存活，集群可用。所以 Zookeeper 适合安装奇数台服务器。

虽然在配置文件中并没有指定 Master 和 Slave。但是，Zookeeper工作时，是有一个节点为 Leader，其他则为 Follower，Leader 是通过内部的选举机制临时产生的。

1. Server1 先投票，投给自己，自己为 1 票，没有超过半数，根本无法成为 leader，顺水推舟将票数投给了 id 比自己大的 Server2
2. Server2 也把自己的票数投给了自己，再加上 Server1 给的票数，总票数为 2 票，没有超过半数，也无法成为 leader，也学习 Server1，顺水推舟，将自己所有的票数给了 id 比自己大的 Server3
3. Server3 得到了 Server1 和 Server2 的两票，再加上自己投给自己的一票，3 票超过半数，顺利成为 leader
4. Server4 和 Server5 都投给自己，但是无法改变 Server3 的票数，只好听天由命，承认 Server3 是leader

3.2 节点类型

• 持久型（persistent）：
  • 持久化目录节点（persistent）：客户端与 zookeeper 断开连接后，该节点依旧存在。
  • 持久化顺序编号目录节点（persistent_sequential）：客户端与 zookeeper 断开连接后，该节点依旧存在，创建 znode 时设置顺序标识，znode 名称后会附加一个值，顺序号是一个单调递增的计数器，由父节点维护，例如：Znode001，Znode002…
• 短暂型（ephemeral）：
  • 临时目录节点（ephemeral）：客户端和服务器端断开连接后，创建的节点自动删除。
  • 临时顺序编号目录节点（ephemeral_sequential）：客户端与 zookeeper 断开连接后，该节点被删除，创建 znode 时设置顺序标识，znode名称后会附加一个值，顺序号是一个单调递增的计数器，由父节点维护，例如：Znode001，Znode002…

注意：序号是相当于 i++，和数据库中的自增长类似

3.3 监听器原理（面试重点）

1. 在 main 方法中创建 Zookeeper 客户端的同时会创建两个线程，一个负责网络连接通信，一个负责监听
2. 监听事件就会通过网络通信发送给 zookeeper
3. zookeeper 获得注册的监听事件后，立刻将监听事件添加到监听列表里
4. zookeeper 监听到 数据变化 或 路径变化，就会将这个消息发送给监听线程
   • 常见的监听
     1. 监听节点数据的变化：get path [watch]
     2. 监听子节点增减的变化：ls path [watch]
5. 监听线程就会在内部调用 process 方法（需要我们实现 process 方法内容）

3.4 写数据流程

1. Client 想向 ZooKeeper 的 Server1 上写数据，必须的先发送一个写的请求。
2. 如果 Server1 不是 Leader，那么 Server1 会把接收到的请求进一步转发给 Leader。
3. 这个 Leader 会将写请求广播给各个 Server，各个 Server 写成功后就会通知 Leader。
4. 当 Leader 收到半数以上的 Server 数据写成功了，那么就说明数据写成功了。
5. 随后，Leader 会告诉 Server1 数据写成功了。
6. Server1 会反馈通知 Client 数据写成功了，整个流程结束。

4. Zookeeper 实战

4.1 分布式安装部署

集群思路：先搞定一台服务器，再克隆出两台，形成集群！

4.1.1 配置服务器编号

• 在 /opt/zookeeper/zkData 创建 myid 文件

[root@localhost zkData]# vim myid

• 在文件中添加与 server 对应的编号：1
• 其余两台服务器分别对应 2 和 3

4.1.2 配置 zoo.cfg 文件

• 打开 zoo.cfg 文件，增加如下配置

#######################cluster##########################
server.1=192.168.61.1:2888:3888
server.2=192.168.61.1:2888:3888
server.3=192.168.61.1:2888:3888

• 配置参数解读

  server.A= B : C : D

  • A：一个数字，表示第几号服务器；集群模式下配置的 /opt/zookeeper/zkData/myid 文件里面的数据就是 A 的值
  • B：服务器的 ip 地址
  • C：与集群中 Leader 服务器交换信息的端口
  • D：选举时专用端口，万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的 Leader，而这个端口就是用来执行选举时服务器相互通信的端口

4.1.3 配置其余两台服务器

1. 在虚拟机数据目录 vms 下，创建 zk02
2. 将本台服务器数据目录下的 .vmx 文件和所有的 .vmdk 文件分别拷贝 zk02 下
3. 虚拟机->文件->打开 （选择 zk02 下的.vmx 文件）
4. 开启此虚拟机，弹出对话框，选择“我已复制该虚拟机”
5. 进入系统后，修改 linux 中的 ip，修改 /opt/zookeeper/zkData/myid 中的数值为 2

4.1.4 集群操作

1. 每台服务器的防火墙必须关闭：systemctl stop firewalld.service
2. 启动第 1 台：./zkServer.sh start
3. 查看状态：./zkServer.sh status
   • 注意：因为没有超过半数以上的服务器，所以集群失败 （防火墙没有关闭也会导致失败）
4. 当启动第 2 台服务器时
   • 查看第 1 台的状态：Mode: follower
   • 查看第 2 台的状态：Mode: leader

4.2 客户端命令行操作

• 启动客户端：./zkCli.sh

• 显示所有操作命令：help

• 查看当前 znode 中所包含的内容：ls /

• 查看当前节点详细数据：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：子节点数

• 分别创建 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

  • 如果原来没有序号节点，序号从 0 开始递增。

  • 如果原节点下已有 2 个节点，则再排序时从 2 开始，以此类推

  • create -s /ru/city   # 执行三次
    ls /ru
    [city0000000000, city0000000001, city0000000002]
    

• 修改节点数据值

  • 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

• 删除节点

  • 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 客户端

public class TestZK {
    
	// zookeeper集群的ip和端口
    private String connectString = "192.168.61.1:2181,192.168.61.1:2181,192.168.61.1:2181";
    
    /*
    session超时时间 60s: 时间不宜设置太小，因为zookeeper和加载集群环境会因为性能等原因而延迟略高，
    如果时间太少，还没有创建好客户端，就开始操作节点，会报错的（心急吃不了热豆腐）
     */
    private int sessionTimeout = 60 * 1000;

    //zookeeper客户端对象
    private ZooKeeper zkClient;

    @Before
    public void init() throws Exception {
        zkClient = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            public void process(WatchedEvent watchedEvent) {
                System.out.println("得到监听反馈，再进行的业务处理代码！");
                System.out.println(watchedEvent.getType());
            }
        });
    }
}

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：创建者才有全部权限

@Before
public void init()  throws IOException{
    // 省略...
}

//创建节点
@Test
public void createNode() throws Exception {
    String str = zkClient.create("/lagou", "laosun".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    // 参数1：要创建的节点的路径
	// 参数2：节点数据
	// 参数3：节点权限
	// 参数4：节点的类型
    System.out.println("已创建节点: " + str);
}

4.3.4 查询节点的值

@Test
public void getNodeData() throws Exception {
    byte[] bytes = zkClient.getData("/lagou", false, new Stat()); // 路径不存在时会报错
    String str = new String(bytes);
    System.out.println("/lagou节点的数据：" + str);
}

4.3.5 修改节点的值

@Test
public void update()throws Exception{
    Stat stat = zkClient.setData("/lagou", "laosunA".getBytes(), 0); //先查看节点详情，获得dataVersion = 0
    System.out.println(stat);
}

4.3.6 删除节点

@Test
public void delete() throws Exception {
    zkClient.delete("/lagou", 1);  // 先查看节点详情，获得dataVersion = 1
    System.out.println("删除成功！");
}

4.3.7 获取子节点

@Test
public void getChildren() throws Exception {
    List<String> children = zkClient.getChildren("/",false); // false:不监听
    for (String child : children) {
        System.out.println(child);
    }
}

4.3.8 监听子节点的变化

@Test
public void getChildren() throws Exception {
    List<String> children = zkClient.getChildren("/", true); // true：注册监听
    for (String child : children) {
        System.out.println(child);
    }
    // 让线程不停止，等待监听的响应
    System.in.read();
}

• 程序在运行的过程中，我们在 linux 下创建一个节点
• IDEA 的控制台就会做出响应：NodeChildrenChanged–/

4.3.9 判断 Znode 是否存在

@Test
public void exist() throws Exception {
    Stat stat = zkClient.exists("/lagou", false);
    System.out.println(stat == null ? "不存在" : "存在");
}

先在main方法中写出业务流程，再创建用到的方法。

4.4 案例——分布式锁——商品秒杀

锁：我们在多线程中接触过，作用就是让当前的资源不会被其他线程访问！

在 zookeeper 中使用传统的锁引发的 “羊群效应” ：1000 个人创建节点，只有一个人能成功，999人 需要等待！

羊群是一种很散乱的组织，平时在一起也是盲目地左冲右撞，但一旦有一只头羊动起来，其他的羊也会不假思索地一哄而上，全然不顾旁边可能有的狼和不远处更好的草。羊群效应就是比喻人都有一种从众心理，从众心理很容易导致盲从，而盲从往往会陷入骗局或遭到失败。

避免“羊群效应”，zookeeper 采用分布式锁。

• 羊群效应：所有人都盯着同一个资源
• 分布式锁：对前面小我一级的节点进行监听

1. 所有请求进来，在 /lock 下创建临时顺序节点 ，zookeeper 会帮你编号排序
2. 判断自己是不是 /lock 下最小的节点
   1. 是，获得锁（创建节点）
   2. 否，对前面小我一级的节点进行监听
3. 获得锁请求，处理完业务逻辑，释放锁（删除节点），后一个节点得到通知
4. 重复步骤 2

4.4.1 初始化数据库

在Linux环境下（SQLyog连接CentOS7）创建数据库 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  -- 用户编号
)

4.4.2 搭建工程

搭建 ssm 框架，对库存表 -1，对订单表 +1

1）pom.xml

<packaging>war</packaging>
<properties>
    <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>

2）mybatis.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>

3）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:mvc="http://www.springframework.org/schema/mvc"
       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">
    <!-- 1.扫描包下的注解 -->
    <context:component-scan base-package="controller,service,mapper"/>
    <!-- 2.创建数据连接池对象 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="url" value="jdbc:mysql://192.168.204.131:3306/zkproduct?serverTimezone=GMT" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="username" value="root" />        
        <property name="password" value="123123" />
        <property name="maxActive" value="10" />
        <property name="minIdle" value="5" />
    </bean>
    <!-- 3.创建SqlSessionFactory，并引入数据源对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>
    </bean>
    <!-- 4.告诉spring容器，数据库语句代码在哪个文件中-->
    <!-- mapper.xDao接口对应resources/mapper/xDao.xml-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="mapper"></property>
    </bean>
    <!-- 5.将数据源关联到事务 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 6.开启事务 -->
    <tx:annotation-driven/>
    <!-- 7.扫描 mapper 注解 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.linuaa.mapper"/>
    </bean>
</beans>

4）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>

5）Mapper

@Mapper
@Component
public interface OrderMapper {
    // 生成订单
    @Insert("insert into `order` (id,pid,userid) values (#{id},#{pid},#{userid})")
    int insert(Order order);
}
@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);
}

6）service 实现类

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    ProductMapper productMapper;
    @Autowired
    OrderMapper orderMapper;
    @Override
    public void reduceStock(int id) throws Exception {
        // 1.获取库存
        Product product = productMapper.getProduct(id);
        // 模拟网络延迟
        Thread.sleep(1000);
        if(product.getStock() <= 0)
            throw  new RuntimeException("已抢光！");
        // 2.减库存
        int i = productMapper.reduceStock(id);
        if(i == 1){
            Order order = new Order();
            order.setId(UUID.randomUUID().toString());
            order.setPid(id);
            order.setUserid(101);
            orderMapper.insert(order);
        }else
            throw new RuntimeException("减库存失败，请重试！");
    }
}

7）Controller

@Controller
public class ProductAction {
    @Autowired
    private ProductService productService;
    @GetMapping("/product/reduce")
    @ResponseBody
    public Object reduceStock(int id) throws Exception{
        productService.reduceStock(id);
        return "ok";
    }
}

4.4.3 启动测试

1. 启动两次工程，端口号分别 8001 和 8002

2. 使用 nginx 做负载均衡

   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 请求

   

4. 查看测试结果，10 次请求全部成功

5. 查看数据库，stock 库存变成 -5 （并发导致的数据结果错误）

4.4.4 apahce 提供的 zookeeper 客户端

基于 zookeeper 原生态的客户端类实现分布式是非常麻烦的，我们使用 apahce 提供的一个 zookeeper客户端来实现。

Curator：http://curator.apache.org/

pom.xml

<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>4.2.0</version>
</dependency>

recipes 是 curator 族谱大全，里面包含 zookeeper 和 framework

4.4.5 在控制层中加入分布式锁的逻辑代码

@Controller
public class ProductAction {
    @Autowired
    private ProductService productService;
    private static String connectString = "192.168.131.128:2181,192.168.131.129:2181,192.168.131.130:2181";
    
    @GetMapping("/product/reduce")
    @ResponseBody
    public Object reduce( int id) throws Exception {
        // 重试策略 （1000毫秒试1次，最多试3次）
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        //1.创建curator工具对象
        CuratorFramework client = CuratorFrameworkFactory.newClient(connectString, retryPolicy);
        client.start();
        //2.根据工具对象创建“内部互斥锁”
        InterProcessMutex lock = new InterProcessMutex(client, "/product_"+id);
        try {
            //3.加锁
            lock.acquire();
            productService.reduceStock(id);
        }catch(Exception e){
            if(e instanceof RuntimeException){
                throw e;
            }
        }finally{
            //4.释放锁
            lock.release();
        }
        return "ok";
    }
}

4.4.6 再次测试，并发问题解决！