# 1.自媒体环境详情



![image.png](/static/img/c5787cc2ae2ec722940e252fddaceebd.image.webp)

# 2.图片上传功能

![image.png](/static/img/93e94ad31af226b7fe69c843961486a7.image.webp)

实现在网关中将userId存入请求头中,在网关中添加


```java
            // 获取用户信息
            Object userId = claimsBody.get("id");

            // 存储到header中
            ServerHttpRequest serverHttpRequest = request.mutate().headers(httpHeaders ->
                    httpHeaders.add("userId",userId+"")).build();

            // 重置请求
            exchange.mutate().request(serverHttpRequest);
```

在wmedia中添加自定义拦截器并将userId存入ThreadLocal中


```java
package com.heima.wemedia.interceptor;

import com.heima.model.wemedia.pojos.WmUser;
import com.heima.utils.thread.WmThreadLocalUtil;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Enumeration;

public class WmTokenInterceptor implements HandlerInterceptor {
    /**
     * 得到header中的用户信息并且存入到当前线程中
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String userId = request.getHeader("userId");
        if (userId != null){
            WmUser wmUser = new WmUser();
            wmUser.setId(Integer.valueOf(userId));
            WmThreadLocalUtil.setWmUser(wmUser);
        }
        return true;
    }

    /**
     * 清理线程中的数据
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        WmThreadLocalUtil.clear();
    }
}

```

编写图片上传的业务代码


```java
package com.heima.wemedia.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.heima.file.service.FileStorageService;
import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.common.enums.AppHttpCodeEnum;
import com.heima.model.wemedia.pojos.WmMaterial;
import com.heima.utils.thread.WmThreadLocalUtil;
import com.heima.wemedia.mapper.WmMaterialMapper;
import com.heima.wemedia.service.WmMaterialService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.Date;
import java.util.UUID;


@Slf4j
@Service
@Transactional
public class WmMaterialServiceImpl extends ServiceImpl<WmMaterialMapper, WmMaterial> implements WmMaterialService {


    @Autowired
    private FileStorageService fileStorageService;


    /**
     * 图片上传实现类
     * @param multipartFile
     * @return
     */
    @Override
    public ResponseResult uploadPicture(MultipartFile multipartFile) {
        // 1.检查参数
        if (multipartFile == null || multipartFile.getSize() == 0) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        // 2.上传图片到MinIO
        String fileId = null;
        String fileName = UUID.randomUUID().toString().replace("-","");
        String originalFilename = multipartFile.getOriginalFilename();
        String postfix = originalFilename.substring(originalFilename.lastIndexOf("."));
        try {
            fileId = fileStorageService.uploadImgFile("",fileName+postfix,multipartFile.getInputStream());
            log.info("上传图片到MinIo中{}",fileId);
        } catch (IOException e) {
            e.printStackTrace();
            log.error("WmMaterialServiceImpl上传文件失败");
        }
        // 3.将图片存储到数据库中
        WmMaterial wmMaterial = new WmMaterial();
        wmMaterial.setUserId(WmThreadLocalUtil.getWmUser().getId());
        wmMaterial.setUrl(fileId);
        wmMaterial.setIsCollection((short)0);
        wmMaterial.setType((short)0);
        wmMaterial.setCreatedTime(new Date());
        save(wmMaterial);
        // 4.返回结果
        return ResponseResult.okResult(wmMaterial);
    }
}

```
# 3.发布文章功能

![image.png](/static/img/3fc1b903daccec6ceb43cdb6305648a0.image.webp)

实现流程

![image.png](/static/img/6f3e05461a8c0ac6b58c652b18eea968.image.webp)

参数详情

![image.png](/static/img/e92469343d5ce28f7de43d2806eff644.image.webp)

返回参数说明

![image.png](/static/img/cb7fa0510f615574a661a40c4d99db87.image.webp)

发布文章业务层代码

```java
package com.heima.wemedia.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.heima.common.constants.WemediaConstants;
import com.heima.common.exception.CustomException;
import com.heima.model.common.dtos.PageResponseResult;
import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.common.enums.AppHttpCodeEnum;
import com.heima.model.wemedia.dtos.WmNewsDto;
import com.heima.model.wemedia.dtos.WmNewsPageReqDto;
import com.heima.model.wemedia.pojos.WmMaterial;
import com.heima.model.wemedia.pojos.WmNews;
import com.heima.model.wemedia.pojos.WmNewsMaterial;
import com.heima.model.wemedia.pojos.WmUser;
import com.heima.utils.thread.WmThreadLocalUtil;
import com.heima.wemedia.mapper.WmMaterialMapper;
import com.heima.wemedia.mapper.WmNewsMapper;
import com.heima.wemedia.mapper.WmNewsMaterialMapper;
import com.heima.wemedia.service.WmNewsService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.servlet.View;

import java.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
@Transactional
public class WmNewsServiceImpl  extends ServiceImpl<WmNewsMapper, WmNews> implements WmNewsService {


    private final View error;

    public WmNewsServiceImpl(View error) {
        this.error = error;
    }


    @Autowired
    private WmNewsMaterialMapper wmNewsMaterialMapper;


    @Autowired
    private WmMaterialMapper wmMaterialMapper;

    /**
     * 媒体端文章查询接口
     * @param dto
     * @return
     */
    @Override
    public ResponseResult findAll(WmNewsPageReqDto dto) {
        // 参数检查
        dto.checkParam();

        // 分页条件查询
        IPage page = new Page<>(dto.getPage(),dto.getSize());
        LambdaQueryWrapper<WmNews> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        // 状态精确查询
        if (dto.getStatus() !=null){
            lambdaQueryWrapper.eq(WmNews::getStatus,dto.getStatus());
        }
        // 频道精确查询
        if (dto.getChannelId() !=null){
            lambdaQueryWrapper.eq(WmNews::getChannelId,dto.getChannelId());
        }
        // 根据时间查询
        if (dto.getBeginPubDate() !=null&& dto.getEndPubDate()!=null){
            lambdaQueryWrapper.between(WmNews::getPublishTime,dto.getBeginPubDate(),dto.getEndPubDate());
        }
        // 关键字模糊查询
        if (StringUtils.isNotBlank(dto.getKeyword())){
            lambdaQueryWrapper.like(WmNews::getTitle,dto.getKeyword());
        }
        WmUser user =  WmThreadLocalUtil.getWmUser();
        // 当前登录人检索
        lambdaQueryWrapper.eq(WmNews::getUserId,user.getId());
        // 按照发布时间倒序排序
        lambdaQueryWrapper.orderByDesc(WmNews::getPublishTime);

        page = page(page, lambdaQueryWrapper);

        ResponseResult responseResult = new PageResponseResult(dto.getPage(),dto.getSize(),(int)page.getTotal());

        responseResult.setData(page.getRecords());

        return responseResult;
    }

    /**
     * 文章保存修改或存为草稿实现方法
     * @param dto
     * @return
     */
    @Override
    public ResponseResult submitNews(WmNewsDto dto) {
        // 条件判断
        if (dto == null || dto.getContent() == null){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }

        // 保存或修改文章
        WmNews wmNews = new WmNews();

        // 属性名称和类型相同能够拷贝  拷贝属性到文章类中
        BeanUtils.copyProperties(dto,wmNews);
        if (dto.getImages() !=null){
            // 将images列表转换成字符串s
            String imageStr = org.apache.commons.lang.StringUtils.join(dto.getImages(),",");
            wmNews.setImages(imageStr);
        }

        // 封面类型为-1
        if (dto.getType().equals(WemediaConstants.WM_NEWS_TYPE_AUTO)){
            wmNews.setType(null);
        }

        saveOrUpdateWmNews(wmNews);
        // 判断是否为草稿,如果为草稿结束当前方法
        if (dto.getStatus().equals(WmNews.Status.NORMAL.getCode())){
            return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
        }
        // 提取图片url信息
        List<String> materials =  extractUrlInfo(dto.getContent());

        // 提取封面url信息

        // 保存文章内容图片与素材的关系
        saveRelativeInfoForContent(materials,wmNews.getId());
        // 保存文章封面图片与素材的关系 如果设置为自动则自动匹配封面
        saveRelativeInfoForCover(dto,wmNews,materials);
        return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
    }

    /**
     * 保存文章封面图片与素材的关系 如果设置为自动则自动匹配封面
     *  1.如果内容图片大于1小于3则设置单图 type 1
     *  2.如果内容图片大于等于3则设置3图 type 3
     *  3.如果内容图片没有则不设置图片 type 0
     *  保存封面与文章的关系
     * @param dto
     * @param wmNews
     * @param materials
     */
    private void saveRelativeInfoForCover(WmNewsDto dto, WmNews wmNews, List<String> materials) {
        List<String> images = dto.getImages();
        if (dto.getType() == WemediaConstants.WM_NEWS_TYPE_AUTO){
            // 多图
            if (materials.size() >=3){
                wmNews.setType(WemediaConstants.WM_NEWS_MANY_IMAGE);
                images = materials.stream().limit(3).collect(Collectors.toList());
                // 单图

            } else if (materials.size()>=1) {
                wmNews.setType(WemediaConstants.WM_NEWS_SINGLE_IMAGE);
                images = materials.stream().limit(1).collect(Collectors.toList());
                // 无图

            } else{
                wmNews.setType(WemediaConstants.WM_NEWS_NONE_IMAGE);
            }
            // 修改文章
            if (images != null && images.size() > 0){
                wmNews.setImages(org.apache.commons.lang.StringUtils.join(images,","));
            }
            updateById(wmNews);
            if (images != null && images.size() > 0){
                saveRelativeInfo(images,wmNews.getId(),WemediaConstants.WM_COVER_REFERENCE);
            }


        }
    }


    /**
     * 提取文章内容分中的图片信息
     * @param content
     * @return
     */
    private List<String> extractUrlInfo(String content) {
        List<Map> maps = JSON.parseArray(content,Map.class);
        List<String> materials = new ArrayList<>();
        for (Map map : maps) {
            if (map.get("type") .equals( "image")){
                String imageUrl= (String) map.get("value");
                materials.add(imageUrl);
            }
        }
        return materials;
    }


    /**
     * 保存图片与内容的关系
     * @param materials
     */
    private void saveRelativeInfoForContent(List<String> materials,Integer newsId) {
        saveRelativeInfo(materials,newsId,WemediaConstants.WM_CONTENT_REFERENCE);
    }


    /**
     * 保存文章与图片的关系到数据库中
     * @param materials
     * @param newsId
     * @param wmContentReference
     */
    private void saveRelativeInfo(List<String> materials, Integer newsId, Short wmContentReference) {
        // 根据图片的url查询图片id
        List<WmMaterial> wmMaterials= wmMaterialMapper.selectList(Wrappers.<WmMaterial>lambdaQuery().in(WmMaterial::getUrl, materials));
        // 判断素材是否有效
        if (wmMaterials == null ||wmMaterials.size()==0){
            throw new CustomException(AppHttpCodeEnum.MATERIALS_REFERENCE_FAIL);
        }
        // 判断数据库查询的数据和url的数据是否
        if (wmMaterials.size() != materials.size()){
            throw new CustomException(AppHttpCodeEnum.MATERIALS_REFERENCE_FAIL);
        }
        List<Integer> idList = wmMaterials.stream().map(WmMaterial::getId).collect(Collectors.toList());
        wmNewsMaterialMapper.saveRelations(idList,newsId,wmContentReference);
    }


    private void saveOrUpdateWmNews(WmNews wmNews) {
        wmNews.setUserId(WmThreadLocalUtil.getWmUser().getId());
        wmNews.setCreatedTime(new Date());
        wmNews.setSubmitedTime(new Date());
        wmNews.setEnable((short) 1); // 默认上架

        if (wmNews.getId() == null){
            // 保存
            save(wmNews);
        }else {
            // 修改 删除文章图片已关联的关系
            wmNewsMaterialMapper.delete(Wrappers.<WmNewsMaterial>lambdaQuery().eq(WmNewsMaterial::getNewsId,wmNews.getId()));
            updateById(wmNews);
        }
    }
}

```

# 4.自媒体文章自动审核

![image.png](/static/img/e74f661dc90373c3a11b16b4219f1cb1.image.webp)

业务流程

![image.png](/static/img/a2bfe1c657f4ce06f9360de4a832b20d.image.webp)

黑马头条(2)

黑马头条（1）

# 1，jvm进程缓存



传统缓存的问题

![image.png](/static/img/7739a2f579196d0c2668980dd9ad0324.image.webp)

多级缓存方案

![image.png](/static/img/4e9b8e81b4b767b4393eac632ab70a56.image.webp)

多级缓存

# 1.Redis持久化



![image.png](/static/img/15fcababaf222915ece91c539644cf65.image.webp)

RDB

![image.png](/static/img/a491304458af13a58f011e84f0f4ef8c.image.webp)

安装redis

官网下载redis安装包

![image.png](/static/img/58d34b4a50cb1817e81ebc7fe0c0a407.image.webp)

解压缩

![image.png](/static/img/ad00a81fb140c6abc8a1c2aeda304071.image.webp)

进入redis文件夹编译

![image.png](/static/img/8da649764571f6df16ba8a23ff291607.image.webp)

修改基础配置

![image.png](/static/img/5653ce1fafc2ca9ecc8b9b46265a7690.image.webp)

启动和停止

![image.png](/static/img/12daa581d61e1c241f1d7aa473227598.image.webp)

RDB会在redis关闭时执行，默认将数据存储在运行redis的目录

RDB相关配置

![image.png](/static/img/24ec7ada65c8794d7418663fe23938fd.image.webp)

RDB底层实现

![image.png](/static/img/c9c374b35391b5112f5600c02516d0e9.image.webp)

# AOF持久化

![image.png](/static/img/7df5293ba92008e2b444f52bbe9d51a8.image.webp)

AOF默认关闭

![image.png](/static/img/44a7f733764f663c8e12d9029e8201d8.image.webp)

AOF缺点解决

![image.png](/static/img/d49c703304c5f631adc49263157af841.image.webp)

配置自动触发BGREWRITEAOF

![image.png](/static/img/f659385a0810f739ecd69b0125f7ddb1.image.webp)

持久化方案对比

![image.png](/static/img/7c238ac9d0fe87b4c379f57f0e965735.image.webp)

# 3.Redis主从搭建

![image.png](/static/img/830c6f34a128cebce001d7b5163570fa.image.webp)

创建3个文件夹，分别拷贝配置文件

![image.png](/static/img/ce8d956455e892d2d89bbbf008de0599.image.webp)

分别修改配置文件

```SHELL
sed -i -e 's/6379/7001/g' -e 's/dir .\//dir \/tmp\/7001\//g' 7001/redis.conf
sed -i -e 's/6379/7002/g' -e 's/dir .\//dir \/tmp\/7002\//g' 7002/redis.conf
sed -i -e 's/6379/7003/g' -e 's/dir .\//dir \/tmp\/7003\//g' 7003/redis.conf
```

```SHELL
sed -i '1a replica-announce-ip 192.168.42.10' 7001/redis.conf
sed -i '1a replica-announce-ip 192.168.42.10' 7002/redis.conf
sed -i '1a replica-announce-ip 192.168.42.10' 7003/redis.conf
```
启动集群

```shell
# 第1个
redis-server 7001/redis.conf
# 第2个
redis-server 7002/redis.conf
# 第3个
redis-server 7003/redis.conf
```
从节点连接主节点

```shell
slaveof 192.168.42.10 7001

```
执行命令临时的主从关系

![image.png](/static/img/c50aed958a5558a8f4149574bfda8ea4.image.webp)

查看主从关系

```shell
[root@localhost tmp]# redis-cli -p 7001
127.0.0.1:7001> INFO replication
# Replication
role:master
connected_slaves:2
slave0:ip=192.168.42.10,port=7002,state=online,offset=84,lag=1
slave1:ip=192.168.42.10,port=7003,state=online,offset=84,lag=1

```

数据同步原理

第一次同步（全量同步）

![image.png](/static/img/67031721c3c7cb8b1120e25f7d94691a.image.webp)

![image.png](/static/img/043d9e65e0a62e390204f7dd21b15674.image.webp)

![image.png](/static/img/6f5b560768409fac9ed8ee1b35d61361.image.webp)

优化集群

![image.png](/static/img/098926137a91279b4b53cebb4f18c521.image.webp)

# 4.Redis哨兵

![image.png](/static/img/44754682b83a517cb23fffdab933314f.image.webp)

服务器状态监控

![image.png](/static/img/a2ff4ae9b20da725b448a6433c55bee4.image.webp)

流程

![image.png](/static/img/36d6944a038b6c37962f117944c24616.image.webp)

搭建哨兵集群

创建s1 s2 s3 并添加sentinel.conf文件

![image.png](/static/img/0e7368fd78eeb1fb58273c35ccd23f62.image.webp)

```config
# 端口
port 27001
sentinel announce-ip 192.168.42.10
# 声明集群 2 是超过 2各判断master下线
sentinel monitor mymaster 192.168.42.10 7001 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
# 工作目录
dir "/tmp/s1"

```

启动redis的sentinel

```shell
redis-sentinel ./s2/sentinel.conf 
```

RedisTemplate哨兵模式

![image.png](/static/img/c354329996ac62f5069701ad93cda942.image.webp)

读写分离

![image.png](/static/img/c53560f1e623e181c76bda0650b9f43e.image.webp)

# 5.Redis分片集群

![image.png](/static/img/a5e690729690187c5a377d0573587550.image.webp)

搭建分片集群

创建目录存放redis.conf的配置文件

![image.png](/static/img/e5e642167ea4c249c5966a3523920146.image.webp)

![image.png](/static/img/4a94ce38509d220b5a1b78b81258df73.image.webp)

一键启动

![image.png](/static/img/e56cafa0ddbd528d35c245fe25452f15.image.webp)

关闭命令

![image.png](/static/img/cb0a0ce786e00a5c8e5801f0067cc0c6.image.webp)

创建集群

![image.png](/static/img/46dccb75cf82ffc9fe7dfb46bc8b50bf.image.webp)

查看集群状态

![image.png](/static/img/4968720b68fcafa4b73943f03da746a9.image.webp)

散列插槽（判断key在哪一个插槽上）

![image.png](/static/img/d3b815286426f5cb2a8350f301cd9ca6.image.webp)

控制同类数据放在同一节点

![image.png](/static/img/00d3ef3033175037b4040e0493daf09d.image.webp)

集群伸缩

添加节点进入集群

![image.png](/static/img/cc957bc3a2b699c281094f7429c16c48.image.webp)

Redis分布式缓存

# 1.ACID原则



![image.png](/static/img/04a3f1208fe89608e7b0585366522eac.image.webp)

![image.png](/static/img/73adf4a53cd0ecb93f0a0f828b63dae8.image.webp)

# 2.解决分布式事务

cap定理

![image.png](/static/img/f1b7e4bd7253e9748c42f57da3e26d2b.image.webp)

base理论

![image.png](/static/img/ff54d31f75d8bd91509b8152d01fbfc9.image.webp)

# 3.初识seata

![image.png](/static/img/a253691bce007d771ddcac229c877be0.image.webp)

# 4.seata部署

官网下载seata

https://seata.apache.org/release-history/seata-server

配置register.conf

![image.png](/static/img/de5a4bf7c5c6c8cfd7dee772abe4af0e.image.webp)

修改为nacos相关配置

![image.png](/static/img/d1f124b1d452b730ab51fd421f8aa565.image.webp)

在nacos添加seata的配置


```config
# 数据存储方式，db代表数据库
store.mode=db
store.db.datasource=druid
store.db.dbType=mysql
## mysql 5.xx
store.db.driverClassName = "com.mysql.jdbc.Driver"
## mysql 8.0
#store.db.driverClassName=com.mysql.cj.jdbc.Driver
# 对应导入的数据库
store.db.url=jdbc:mysql://127.0.0.1:3306/seata?useUnicode=true&rewriteBatchedStatements=true&useSSL=false
store.db.user=root
store.db.password=qpj@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.distributedLockTable=distributed_lock
​
# 对应 ${spring.application.name}-group，指定需要分布式事务的模块
service.vgroupMapping.seata-validate-demo-group=default
service.vgroupMapping.default=default
      
store.db.maxWait=5000
# 事务、日志等配置
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
server.undo.logSaveDays=7
server.undo.logDeletePeriod=86400000
​
# 客户端与服务端传输方式
transport.serialization=seata
transport.compressor=none
# 关闭metrics功能，提高性能
metrics.enabled=false
metrics.registryType=compact
metrics.exporterList=prometheus
metrics.exporterPrometheusPort=9898

```

在mysql中建表

创建数据库


```sql
CREATE DATABASE `seata` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
```


```sql
-- -------------------------------- 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_status_gmt_modified` (`status` , `gmt_modified`),
    KEY `idx_transaction_id` (`transaction_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;
​
-- 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 = utf8mb4;
​
-- the table to store lock data
CREATE TABLE IF NOT EXISTS `lock_table`
(
    `row_key`        VARCHAR(128) NOT NULL,
    `xid`            VARCHAR(128),
    `transaction_id` BIGINT,
    `branch_id`      BIGINT       NOT NULL,
    `resource_id`    VARCHAR(256),
    `table_name`     VARCHAR(32),
    `pk`             VARCHAR(36),
    `status`         TINYINT      NOT NULL DEFAULT '0' COMMENT '0:locked ,1:rollbacking',
    `gmt_create`     DATETIME,
    `gmt_modified`   DATETIME,
    PRIMARY KEY (`row_key`),
    KEY `idx_status` (`status`),
    KEY `idx_branch_id` (`branch_id`),
    KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;
​
CREATE TABLE IF NOT EXISTS `distributed_lock`
(
    `lock_key`       CHAR(20) NOT NULL,
    `lock_value`     VARCHAR(20) NOT NULL,
    `expire`         BIGINT,
    primary key (`lock_key`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;
​
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('AsyncCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryRollbacking', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('TxTimeoutCheck', ' ', 0);

```

项目中引入seata依赖

![image.png](/static/img/d6fd74b37daf61195cc1f0614558861a.image.webp)

微服务继承seata

![image.png](/static/img/324fc8c89490b6ed1ca66874bf18e47a.image.webp)

XA模式原理

![image.png](/static/img/25f98f014c2926f13f5430b4e7d2bb53.image.webp)

先执行操作但是不提交，在全部服务成功之后最后提交，一旦有操作失败就回滚操作

seata中的XA

![image.png](/static/img/fe41c89a0ff4d3699a4b66a38d6c0600.image.webp)

实现XA模式

![image.png](/static/img/fdf8f806035632394291d1354062cb26.image.webp)

AT模式

AT模式会直接提交，会记录前后更新的快照

![image.png](/static/img/467de18c3581a118c1e9a243462176fd.image.webp)

启用AT模式

导入seata数据库

```sql
-- seata_demo.undo_log definition
​
CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `context` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  `ext` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=63 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;

```

配置中修改为AT模式重启服务

TCC模式

![image.png](/static/img/05741f50abe5e893da9d100c4136da85.image.webp)

![image.png](/static/img/6f94080e0caf34bcea44c3cf693da3cb.image.webp)

![image.png](/static/img/6c2e9acde53da2445287771beac47eae.image.webp)

saga模式

![image.png](/static/img/20351b871cc8921c7b14c08beabe3799.image.webp)

模式对比

![image.png](/static/img/f1157f47bc9cf55c3b4fcc259b0cedf5.image.webp)

# 5.高可用

TC异地多机房容灾架构

![image.png](/static/img/f4532c98ac1a315bc0e036c354aa559b.image.webp)