接上一章，我们已经完成了基础框架搭建及mybatis plus+nacos集成，本章我们要开始集成open feign 及 seata

        首先把上一章没有操作的日志管理模块弄好。要做的事情是，当我们对用户模块进行操作，对应去生成日志信息

 贴一下日志的xml，sql就对照着弄吧，这只是个示例，真正项目的日志肯定也不会用这个

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.andy.log.dao.LogginInfoDao">

    <resultMap id="user" type="com.andy.log.entity.LogginInfo">
        <id column="id" property="id" />
        <result column="loggin_type" property="logginType" />
        <result column="loggin_url" property="logginUrl" />
        <result column="loggin_model" property="logginModel" />
        <result column="loggin_result" property="logginResult" />
        <result column="loggin_time" property="logginTime" />

    </resultMap>

    <insert id="save" parameterType="com.andy.log.entity.LogginInfo">
        insert into loggin_info(loggin_type,loggin_url,loggin_model,loggin_result,loggin_time)
        values(#{logginType},#{logginUrl},#{logginModel},#{logginResult},#{logginTime});
    </insert>

    <update id="update" parameterType="com.andy.log.entity.LogginInfo">
        update loggin_info set
        loggin_type = #{logginType},loggin_url = #{logginUrl},
        loggin_model = #{logginModel},loggin_result=#{logginResult},
        loggin_time = #{logginTime}) where id = #{id}
    </update>

    <delete id="delete" parameterType="com.andy.log.entity.LogginInfo">
        delete loggin_info where id = #{id}
    </delete>

    <select id="queryAll" resultMap="user">
        select * from loggin_info
    </select>

</mapper>

现在的问题就是，如何让用户模块去调用日志模块。这里我们就使用open feign,它是什么我就不介绍了，直接贴如何使用：

1. 上一章的父pom其实我已经把open feign的依赖写出来了，这儿把关于open feign的再贴出来一下，是open feign和nacos的依赖，一个是父类公共引用，所以具体实现不需要再去依赖，还有一个就是如果版本低些，把排除ribbon和引入spring-cloud-loadbalance的内容删除

        hutool工具包是一个比较好用的各种工具api,现在主要使用他的json工具，他还有日期，http请求等等工具，可以自行百度用法，比较多，不详讲

    <!--openfeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <!--nacos-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--hutool工具包-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.5.9</version>
        </dependency>

2. 我们现在是user 调用 loggin,首先需要在用户模块启动类中加入注解

        @EnableFeignClients

3. 在feign包下面新建接口调用 

        @FeignClient 声明需要调用的服务名称（对应loggin项目yml中的

        spring:

         application:

           name: log-service），及地址（controller的RequestMapping）

LogginFeign.java

package com.andy.user.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.List;

@FeignClient(name = "log-service",path = "/loggin")
public interface LogginFeign {

    @RequestMapping("/save")
    String save(@RequestParam("logginInfo") String logginInfo);

}

我这儿写了两个接口，对应的就是loggin 服务中的接口，方法名称，参数都一致

LogginController.java

package com.andy.log.controller;

import cn.hutool.json.JSONUtil;
import com.andy.log.entity.LogginInfo;
import com.andy.log.service.LogginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/loggin")
public class LogginController {
    @Autowired
    LogginService LogginService;

    @RequestMapping("/save")
    public String save(@RequestParam("logginInfo") String logginInfo){
        LogginInfo info = JSONUtil.toBean(logginInfo, LogginInfo.class);
        LogginService.save(info);
        return "新增成功";
    }
    @RequestMapping("/update")
    public String update(LogginInfo logginInfo){

        LogginService.update(logginInfo);
        return "修改成功";
    }
    @RequestMapping("/delete")
    public String delete(LogginInfo logginInfo){

        LogginService.delete(logginInfo);
        return "删除成功";
    }
    @RequestMapping("/queryAll")
    public List<LogginInfo> queryAll(){

        return LogginService.queryAll();

    }
}

4.接下来就是UserController.java中调用这个接口

 

5.启动项目测试

 

以上就实现了我们微服务之间的接口调用， 但是这个有一个比较大的问题，我们微服务是为了更好的各司其职做自己的事情，比如上面两个模块，一个用户，一个日志，但是现在两个系统之间有了关联，当用户新增成功了，才会去新增日志。思考一些问题：

        1.如果用户新增失败需要添加操作日志吗？明显是需要的，但是现在的代码不可用

        2.如果用户新增成功，但是日志添加失败合理吗？

 我们想要的结果是不是应该是他们两个都能够同时成功，保证原子性（不用考虑日志是不是必须的，只是一个场景例子，可以理解为用户下单，订单和减库存这个就有强一致，我们这儿也认为他俩需要强一致），以前我们单项目想要保证原子操作，一般就是加事务，两个操作同时完成就一同成功，我们这儿就使用seata来保证分布式事务，本文只讲实现，具体底层就自行了解了

集成seata

1. 首先需要部署Seata的Server端 下载地址：Releases · seata/seata · GitHub 

        对应一下版本版本说明 · alibaba/spring-cloud-alibaba Wiki · GitHub

        我这儿就对应1.3.0

2. 解压后，打开 conf 文件夹，我们需对其中的一些配置做出修改。

  本文使用nacos,为了节省篇幅，把除了nacos的其他内容删除了，可以留着，对应一下nacos的信息，账号密码地址啥的

registry {
  # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  type = "nacos"

  nacos {
    application = "seata-server"
    serverAddr = "127.0.0.1:8848"
    group = "SEATA_GROUP"
    namespace = "public"
    cluster = "default"
    username = "nacos"
    password = "nacos"
  }
}

config {
  # file、nacos 、apollo、zk、consul、etcd3
  type = "nacos"

  nacos {
    serverAddr = "127.0.0.1:8848"
    namespace = "public"
    group = "SEATA_GROUP"
    username = "nacos"
    password = "nacos"
  }
  
}

3.创建一个数据库my-seata ，需要执行的脚本可以在seata官网找到，我直接贴出来使用了

-- -------------------------------- The script used when storeMode is 'db' --------------------------------
-- the table to store GlobalSession data
CREATE TABLE IF NOT EXISTS `global_table`
(
    `xid`                       VARCHAR(128) NOT NULL,
    `transaction_id`            BIGINT,
    `status`                    TINYINT      NOT NULL,
    `application_id`            VARCHAR(32),
    `transaction_service_group` VARCHAR(32),
    `transaction_name`          VARCHAR(128),
    `timeout`                   INT,
    `begin_time`                BIGINT,
    `application_data`          VARCHAR(2000),
    `gmt_create`                DATETIME,
    `gmt_modified`              DATETIME,
    PRIMARY KEY (`xid`),
    KEY `idx_gmt_modified_status` (`gmt_modified`, `status`),
    KEY `idx_transaction_id` (`transaction_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;

-- the table to store BranchSession data
CREATE TABLE IF NOT EXISTS `branch_table`
(
    `branch_id`         BIGINT       NOT NULL,
    `xid`               VARCHAR(128) NOT NULL,
    `transaction_id`    BIGINT,
    `resource_group_id` VARCHAR(32),
    `resource_id`       VARCHAR(256),
    `branch_type`       VARCHAR(8),
    `status`            TINYINT,
    `client_id`         VARCHAR(64),
    `application_data`  VARCHAR(2000),
    `gmt_create`        DATETIME(6),
    `gmt_modified`      DATETIME(6),
    PRIMARY KEY (`branch_id`),
    KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;

-- the table to store lock data
CREATE TABLE IF NOT EXISTS `lock_table`
(
    `row_key`        VARCHAR(128) NOT NULL,
    `xid`            VARCHAR(96),
    `transaction_id` BIGINT,
    `branch_id`      BIGINT       NOT NULL,
    `resource_id`    VARCHAR(256),
    `table_name`     VARCHAR(32),
    `pk`             VARCHAR(36),
    `gmt_create`     DATETIME,
    `gmt_modified`   DATETIME,
    PRIMARY KEY (`row_key`),
    KEY `idx_branch_id` (`branch_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;

4. 因为我们是使用的Nacos作为配置中心，所以这里需要先执行脚本来初始化Nacos的相关配置  GitHub - seata/seata: Seata is an easy-to-use, high-performance, open source distributed transaction solution.

打开官网找到 script 下载下来 放到刚才解压的seata里面

（很多博客需要改file.conf,如果使用nacos作为配置，所以可以不必要修改）

 

然后打开 script>config-center>config.txt修改

transport.type=TCP
transport.server=NIO
transport.heartbeat=true
transport.enableClientBatchSendRequest=false
transport.threadFactory.bossThreadPrefix=NettyBoss
transport.threadFactory.workerThreadPrefix=NettyServerNIOWorker
transport.threadFactory.serverExecutorThreadPrefix=NettyServerBizHandler
transport.threadFactory.shareBossWorker=false
transport.threadFactory.clientSelectorThreadPrefix=NettyClientSelector
transport.threadFactory.clientSelectorThreadSize=1
transport.threadFactory.clientWorkerThreadPrefix=NettyClientWorkerThread
transport.threadFactory.bossThreadSize=1
transport.threadFactory.workerThreadSize=default
transport.shutdown.wait=3
#事务组 重点
service.vgroupMapping.my_test_tx_group=default
#服务地址
service.default.grouplist=127.0.0.1:8091
service.enableDegrade=false
service.disableGlobalTransaction=false
client.rm.asyncCommitBufferLimit=10000
client.rm.lock.retryInterval=10
client.rm.lock.retryTimes=30
client.rm.lock.retryPolicyBranchRollbackOnConflict=true
client.rm.reportRetryCount=5
client.rm.tableMetaCheckEnable=false
client.rm.sqlParserType=druid
client.rm.reportSuccessEnable=false
client.rm.sagaBranchRegisterEnable=false
client.tm.commitRetryCount=5
client.tm.rollbackRetryCount=5
client.tm.degradeCheck=false
client.tm.degradeCheckAllowTimes=10
client.tm.degradeCheckPeriod=2000
#存储方式 要改成db
store.mode=db
store.file.dir=file_store/data
store.file.maxBranchSessionSize=16384
store.file.maxGlobalSessionSize=512
store.file.fileWriteBufferCacheSize=16384
store.file.flushDiskMode=async
store.file.sessionReloadReadSize=100
store.db.datasource=druid
#数据库相关信息自行调整
store.db.dbType=mysql
store.db.driverClassName=com.mysql.jdbc.Driver
jdbc:mysql://127.0.0.1:3306/my-seata?useUnicode=true&serverTimezone=Asia/Shanghai
store.db.user=root
store.db.password=123456
store.db.minConn=5
store.db.maxConn=30
store.db.globalTable=global_table
store.db.branchTable=branch_table
store.db.queryLimit=100
store.db.lockTable=lock_table
store.db.maxWait=5000
store.redis.host=127.0.0.1
store.redis.port=6379
store.redis.maxConn=10
store.redis.minConn=1
store.redis.database=0
store.redis.password=null
store.redis.queryLimit=100
server.recovery.committingRetryPeriod=1000
server.recovery.asynCommittingRetryPeriod=1000
server.recovery.rollbackingRetryPeriod=1000
server.recovery.timeoutRetryPeriod=1000
server.maxCommitRetryTimeout=-1
server.maxRollbackRetryTimeout=-1
server.rollbackRetryTimeoutUnlockEnable=false
client.undo.dataValidation=true
#jackson改为kryo 解决数据库Datetime类型问题
client.undo.logSerialization=kryo
client.undo.onlyCareUpdateColumns=true
server.undo.logSaveDays=7
server.undo.logDeletePeriod=86400000
client.undo.logTable=undo_log
client.log.exceptionRate=100
transport.serialization=seata
transport.compressor=none
metrics.enabled=false
metrics.registryType=compact
metrics.exporterList=prometheus
metrics.exporterPrometheusPort=9898

5.修改完了以后，再打开script>config-center>nacos

        前提：先要启动上一章的nacos,不赘述了

        双击运行 nacos-config.sh（前提要安装过git）

        运行成功后，打开nacos查看

        如果不成功，检查一下nacos是否启动，配置nacos地址是否有问题等等

 6. 启动 seata\bin\seata-server.bat     seata服务，至此seate服务已经配置完成，接下来就是代码中使用

    ps:启动seata服务如果错误根据错误提示自行查找哪些配置有问题，或者复制我的配置进行修改

客户端实际使用

        1. 在所有的参与事务的数据库中需要加入一个undo_log  表，我这儿只用了一个myaliababa数据库，所以只需要在这个库中新增该表

CREATE TABLE `undo_log`
(
    `id`            bigint(20) NOT NULL AUTO_INCREMENT,
    `branch_id`     bigint(20) NOT NULL,
    `xid`           varchar(100) NOT NULL,
    `context`       varchar(128) NOT NULL,
    `rollback_info` longblob     NOT NULL,
    `log_status`    int(11) NOT NULL,
    `log_created`   datetime     NOT NULL,
    `log_modified`  datetime     NOT NULL,
    PRIMARY KEY (`id`),
    UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

2. 在所有参与事务的pom中加入seata依赖

<!-- seata与序列化依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
        </dependency>
        <dependency>
            <groupId>io.seata</groupId>
            <artifactId>seata-serializer-kryo</artifactId>
            <version>1.3.0</version>
        </dependency>

      

 3. 修改对应的yml文件，application-id 自己改一下，自定义的名称，不同项目不一样

#Seata配置
seata:
  enabled: true
  application-id: user-service
  #对应nacos配置 service.vgroupMapping.my_test_tx_group
  tx-service-group: my_test_tx_group
#  service:
#    vgroup-mapping:
#      #对应nacos配置 service.vgroupMapping.my_test_tx_group 的值 default
#      my_test_tx_group: 'default'
  registry:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      group: SEATA_GROUP
      username: "nacos"
      password: "nacos"
  config:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      group: SEATA_GROUP
      username: "nacos"
      password: "nacos"
      #namespace没有改就不要写，不然报错

4. 在UserController.java 中只需要加入一个注解：@GlobalTransactional

@RequestMapping("/save")
    @GlobalTransactional(name = "add_user_save_logging",rollbackFor = Exception.class)
    public String saveUser(UserInfo userInfo){

        //新增日志
        LogginInfo log = new LogginInfo("新增","user/save","成功");

        if(!userService.saveUser(userInfo)){
            log.setLogginResult("失败");
        }
        //添加日志
        logginFeign.save(JSONUtil.toJsonStr(log));
        //int i = 1/0;
        return "新增成功";
    }

这个标记一个主事务（事务开始的地方），name事务名称，rollbackFor 异常情况回滚

 在LogginController.java 中只需要加入一个@Transactional

@RequestMapping("/save")
    @Transactional
    public String save(@RequestParam("logginInfo") String logginInfo){
        LogginInfo info = JSONUtil.toBean(logginInfo, LogginInfo.class);
        LogginService.save(info);
        return "新增成功";
    }

这就搞定了，重启两个项目进行测试，当然可以把 int i = 1/0放开，这时执行，user和log都会进行回滚，那么分布式事务就集成成功。

        贴出这一部分源码：阿里云盘分享

        这里面还有一些问题，因为篇幅和尽量不偏离主题，那么我们留到下一章解决