java分布式事务用什么插件

转载

架构领航博主 2024-09-24 07:50:49

文章标签 java分布式事务用什么插件 zookeeper apache 服务器 文章分类 Java 后端开发

4. Zookeeper实战（开发重点）

4.1 分布式安装部署

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

4.1.1 安装zookeeper

请参考文中 2.1

4.1.2 配置服务器编号

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

[root@localhost zkData] # vim 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，而这个端口就是用来执行选举时服务器相互通信的端口。

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：子节点数

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

删除节点

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方法带参数的形式运行）

java分布式事务用什么插件_java分布式事务用什么插件

4.5 案例-分布式锁-商品秒杀

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

我的日记本，不可以被别人看到。所以要锁在保险柜中
当我打开锁，将日记本拿走了，别人才能使用这个保险柜

在zookeeper中使用传统的锁引发的 “羊群效应” ：1000个人创建节点，只有一个人能成功，999人需要等待！
羊群是一种很散乱的组织，平时在一起也是盲目地左冲右撞，但一旦有一只头羊动起来，其他的羊也会不假思索地一哄而上，全然不顾旁边可能有的狼和不远处更好的草。羊群效应就是比喻人都有一种从众心理，从众心理很容易导致盲从，而盲从往往会陷入骗局或遭到失败。

java分布式事务用什么插件_服务器_02

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

java分布式事务用什么插件_服务器_03

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

java分布式事务用什么插件_apache_04

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

java分布式事务用什么插件_服务器_05

下载地址：http://jmeter.apache.org/download_jmeter.cgi

java分布式事务用什么插件_zookeeper_06

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. 再次测试，并发问题解决！

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。