生产中出现了 `org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only` 异常，结合源码分析下原因




# Spring 事务源码分析

## 示例

代码之间的调用如下

```java
    @Transactional(rollbackFor = Exception.class)
    public void test() {
        // 测试出现 "Transaction rolled back because it has been marked as rollback-only"
        try {
            logService.testRockBack();
        } catch (Exception e) {
            System.out.println("try catch Exception : " + e.getMessage());
        }
    }
    
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void testRockBack() {
        int i = 0;
        System.out.println(1/i);
    }
```

接口调用后，出现以下异常

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


### 问题原因

在多个方法都有 `@Transactional`注解，A调用B，且把B的调用进行了try-catch


### 分析

从源码中开始分析，在 `AbstractPlatformTransactionManager #processRollback` 中，设置 `unexpectedRollback` 为 true 时，才会抛出此异常

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


继续查看源码的调用栈，找到其 `processRollback(defStatus, true)` 方法处调用，入参为 true，那正常应该为不会调用到此方法，为什么此处会调用到呢？

我们接着分析下 `!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()` 这个判断条件


```java
    /**
     * This implementation of commit handles participating in existing
     * transactions and programmatic rollback requests.
     * Delegates to {@code isRollbackOnly}, {@code doCommit}
     * and {@code rollback}.
     * @see org.springframework.transaction.TransactionStatus#isRollbackOnly()
     * @see #doCommit
     * @see #rollback
     */
    @Override
    public final void commit(TransactionStatus status) throws TransactionException {
        if (status.isCompleted()) {
            throw new IllegalTransactionStateException(
                            "Transaction is already completed - do not call commit or rollback more than once per transaction");
        }

        DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
        if (defStatus.isLocalRollbackOnly()) {
            if (defStatus.isDebug()) {
                    logger.debug("Transactional code has requested rollback");
            }
            processRollback(defStatus, false);
            return;
        }

        if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
            if (defStatus.isDebug()) {
                    logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
            }
            processRollback(defStatus, true);
            return;
        }

        processCommit(defStatus);
    }

```


查看方法源码 `shouldCommitOnGlobalRollbackOnly()` 的实现底层，发现默认返回 false，那么此判断条件中一定为 true, 不会影响判断结果，核心的问题还是出现在 `defStatus.isGlobalRollbackOnly()` 的校验上，我们继续分析此方法

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


通过断点，可以确认此处判断调用到 `DataSourceTransactionManager #isRollbackOnly` 方法，其核心的 `rollbackOnly` 参数为 true，所以上述的逻辑判断中才会执行进程回滚的动作


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

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


上述已然了解参数的定义，接下来查找下源码中如何设置成 true，从源码中发现如下代码设置为true

```java
    /**
     * Mark the resource transaction as rollback-only.
     */
    public void setRollbackOnly() {
        this.rollbackOnly = true;
    }
```

查看代码的引用，发现一个熟悉的调用 `DataSourceTransactionManager #setRollbackOnly`

```java
    public void setRollbackOnly() {
        getConnectionHolder().setRollbackOnly();
    }  
```

![image.png](https://blog.liushigong.cn/static/img/f2944cb53c962c8811e475cf331973bf.image.webp)


从堆栈中查看调用信息，发现又回到了老朋友 `#processRollback` 方法上，

![image.png](https://blog.liushigong.cn/static/img/953f7915fa750dcc56443dcee5e8bc0a.image.webp)

此处有个判断 `status.hasTransaction()` 结果为 true，表示存在事务，在这做个事务源码的延伸，这部分为多个事务之间嵌套的处理，源码处理的位置如下

![image.png](https://blog.liushigong.cn/static/img/4cc1892cba6a84c9e747e836a2a154e6.image.webp)


继续查找堆栈信息，可以找到 `completeTransactionAfterThrowing` 方法

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

继续往上，就看到这是 `try catch` 部分，我们都知道事务底层实现就是aop，由于此问题出现的原因是嵌套事务，且嵌套中的事务抛出异常，当异常抛出后，就会被捕获，且将底层 `rollbackOnly` 设置为 true，此时接下来回归到到主线上调用 `commitTransactionAfterReturning` 方法进行提交

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


其实走到这就很明朗了，此处代码已经是文章开头追溯的那部分源码

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


## 总结

梳理下源码的流程，当嵌套内事务抛出异常时，会将**全局仅回滚标记** `rollbackOnly = true` 设置为 true, 从源码的正常流程来说会把异常继续 throw，但是当我们外层事务 `try catch` 后，就导致异常无法抛出，最外层事务在执行后续 `commit` 时，会校验是否为**全局回滚参数**，抛出 `throw new UnexpectedRollbackException("Transaction rolled back because it has been marked as rollback-only")`;

![image.png](https://blog.liushigong.cn/static/img/5f37493125d6c6c73ecf6f57406591ea.image.webp)

Spring 多重事务嵌套产生的异常

在开发的过程中，使用事务与锁是解决一些问题最常用的方式，但是当这俩个结合起来你真的会用吗？在高并发的场景下会出现哪些问题？要如何避免这些问题？接下来，带你了解事务与锁之间真正的打开方式。



# 示例

开发过程中，扣减库存是最经典的场景之一，接下来以此场景模拟扣减库存的代码实现


## 场景模拟

```java
// 实体
@Data
public class MaterialStock {

    /**
     * 物料库存id
     */
    private Long id;

    /**
     * 物料名称
     */
    private String name;

    /**
     * 库存数量
     */
    private Long stockNum;
}
```

```java
// 加锁 - 此处等同于分布式锁
ReentrantLock lock = new ReentrantLock();

// 实现方法
@SneakyThrows
@Override
@Transactional
public void updateById(Long id) {
    lock.lock();

    try {
        // 查询物料库存，扣减，然后更新库存
        MaterialStock materialStock = materialStockMapper.selectById(id);
        Long stockNum = materialStock.getStockNum();
        if (materialStock.getStockNum() <= 0) {
            log.info("库存不足");
            return;
        }
        materialStock.setStockNum(stockNum - 1);
        materialStockMapper.updateById(materialStock.getId(), materialStock.getStockNum());
        log.info("当前库存数量:{}\t，更新后库存数量:{}", stockNum, materialStock.getStockNum());

        // 其他处理，耗时 500ms
        TimeUnit.MILLISECONDS.sleep(500);
    }finally {
        // 释放锁
        lock.unlock();
    }
}

```

```java
// 单元测试
public void test3(){
    for (int i = 0; i < 30; i++) {
        new Thread(() -> customExecutorService.updateById(1L)).start();
    }
}
```

接下来，模仿并发下的场景，设置20个库存，使用30个线程同步进行扣减，查看库存扣减的情况

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

可以发现，库存中出现了少扣的情况，按照我们预想的执行，流程上应该是【加锁 -> 查询库存 -> 扣减库存 -> 更新库存 -> 释放锁】，数据上【线程数 30 - 库存数 20 = 剩余库存数 10】

现在看来，锁应该是失效了，那这是怎么回事呢？

## 代码分析

首先分析，一定是在【查询库存】的环节异常，将上次扣减的库存查询出来，那出现这种情况只有两种可能性，一种是【加锁】环节没有生效，一种就是【更新库存】没有执行成功，目前代码上加锁逻辑没有任何问题，那么出现问题的就只能是【更新库存】了，通过对更新库存的操作进行断点，我们查看库存的扣减情况，下面过程中发现当【更新库存 -> 释放锁】的步骤执行完，数据库中的数据并没有更新，事务并没有提交。


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

上面场景中，上一次线程库存数量已更新为18个，但是当前线程读取到的还是19个，且对此库存进行扣减，初步分析为上一个事务没有提交，当前线程就已经读取库存了。

说到这，了解事务实现原理的童鞋可能已经分析出来了，**<span style='color:red'>事务底层是通过aop实现，aop底层又是动态代理对象实现</span>，此时上一个线程update方法执行结束，锁已经释放了，但是整个service方法还没有执行结束，后置处理中的事务还没有提交，其他线程此时开始加锁读取库存数量，就导致了此问题的产生**。


## 解决方式

解决方式就比较多了，根据不同业务复杂度，可做不同的处理

1、业务场景简单的情况，将锁直接提到上层，调用带事务的service即可

```java
    public void test3(){
        // 加锁
        ReentrantLock lock = new ReentrantLock();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                lock.lock();
                try {
                    customExecutorService.updateById(1L);
                }finally {
                    // 释放锁
                    lock.unlock();
                }
            }).start();
        }
    }
```

查看数据，发现正常扣减了


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

2、业务场景复杂的情况，要考虑锁的力度，根据业务逻辑拆分接口，可将逻辑校验都提到代码最前方，将库存校验留到校验的最后，且与更新库存进行绑定，进行加锁处理，流程如下

```java

    // 加锁 - 此处等同于分布式锁
    ReentrantLock lock = new ReentrantLock();
    
    @Override
    public void updateById(Long id) {
        try {
            // 其他逻辑处理...
            
            lock.lock();
            // 处理事务
            stockNum(id);
        }finally {
            // 释放锁
            lock.unlock();
        }
    }

    @SneakyThrows
    @Transactional
    void stockNum(Long id) {
        // 查询物料库存，扣减，然后更新库存
        MaterialStock materialStock = materialStockMapper.selectById(id);
        Long stockNum = materialStock.getStockNum();
        if (materialStock.getStockNum() <= 0) {
            log.info("库存不足");
            return;
        }
        materialStock.setStockNum(stockNum - 1);
        materialStockMapper.updateById(materialStock.getId(), materialStock.getStockNum());
        log.info("当前库存数量:{}\t，更新后库存数量:{}", stockNum, materialStock.getStockNum());

        // 其他IO处理，耗时 500ms
        TimeUnit.MILLISECONDS.sleep(500);
    }

```

## 总结

解决这个问题的本质，**就是不要将锁，放到被事务方法中**，同时也要思考如果是其他aop切面或者自定义代理了方法会不会有影响。

往往开发的过程中使用的技术体系与底层的实现原理息息相关，掌握原理带动大脑思考

基于 Spring 声明式事务下锁失效的场景分析

对于Java新手来说，日志查询是公司实际开发中必备技能，对于老手来说，怎么更快捷的查询日志定位问题才是关键。我整理了工作中日志查询常用的命令与技巧，以及一些生产日志定位问题的实战经验，欢迎各位小伙伴留言补充命令用法与场景描述。



# 日志查询

## 命令
使用的命令无非就是[tail](https://www.runoob.com/linux/linux-comm-tail.html)、
[cat](https://www.runoob.com/linux/linux-comm-cat.html)、[grep](https://www.runoob.com/linux/linux-comm-grep.html)、
[head](https://www.runoob.com/linux/linux-comm-head.html)、[sed](https://www.runoob.com/linux/linux-comm-sed.html)等，这些命令都是linux系统自带的，不需要安装。


## 玩法

在玩之前，先了解以上命令的基础用法，不然直接上手，也是一脸懵。

### 实时输出日志

```shell
# 实时输出日志
tail -f catalina.out

# 实时输出日志文件中所有模糊匹配到'Exception'的行
tail -f catalina.out | grep 'Exception'

# --line-buffered 是一行的缓冲区，只要这一行的缓冲区满了就会打印出来，添加此命令可用于实时监控日志
tail -f catalina.out | grep --line-buffered 'Exception'

# -200f 表示输出最后200行日志内出现过'Exception'的行，且继续实时输出出现过'Exception'的行
tail -200f catalina.out | grep 'Exception'
```

:::warning{title="警告"}
`tail -n +200 catalina.out` 从第200行开始输出日志，不会停止，需要手动停止<kbd>Ctrl</kbd>+<kbd>C</kbd>，除非紧跟grep搜索，要不然日志输出刹不住车啊
:::

### 非实时查询日志
```shell
# -n 200 表示输出最后200行出现'Exception'的行日志，不会实时输出日志
tail -n 200 catalina.out | grep 'Exception'

# 输出最后200行日志，且分页显示
tail -n 200 catalina.out | more 

# 从第200行开始输出日志
tail -n +200 catalina.out 

# 查询200行以后日志，并查找关键字'Exception'
tail -n +200 catalina.out | grep 'Exception'

# 显示全部日志信息，从头开始输出
cat catalina.out

# 查看日志文件中所有出现过'Exception'信息，-n是带行号输出
cat -n catalina.out | grep 'Exception'

# 查看日志中所有出现过'Exception'信息，-n是带行号输出，输出到文件Exception.txt
cat -n catalina.out | grep 'Exception' > Exception.txt

# 查询日志文件中所有出现过'Exception'信息，且显示前后100行（-A 查询之后的、-B 查询之前的、-C 查询前后的）
cat catalina.out | grep 'Exception' -C 100

# 查询200行以后的日志，且只显示10行，也就是查看200到210行之间的日志
cat -n catalina.out | tail -n +200 | head -n 10

# 查询5到10行日志
sed -n '5,10p' catalina.out

# 查询日志文件中的前200行日志(与 tail -n 正好相反)
head -n 200 catalina.out 

# 查询日志前200行，出现过'Exception'的行
head -n 200 catalina.out | grep 'Exception'

# 查看日志中出现过'Exception'的行数
grep 'Exception' catalina.out | wc -l

# 查询日志中出现123或者abc的行
grep -E '123|abc' catalina.out

# 查找当前目录下所有扩展名为.log的文件，并找出包含'Exception'的行
find . -name '*.log' | xargs grep 'Exception'

# 查询多个日志文件中出现过'Exception'的行
grep 'Exception' 2023-05-10.log 2023-05-09.log

```

:::warning{title="警告"}
`cat catalina.out` 查看文件会从头开始输出，不会停止，需要手动停止<kbd>Ctrl</kbd>+<kbd>C</kbd>，除非紧跟grep搜索，要不然日志输出刹不住车啊
:::

## 实战

### 查询某个'Exception'的行号，然后查询其行号往下10行的日志
```shell
# 查询所有出现过 'Exception' 的行号
cat -n catalina.out | grep 'Exception'

# 根据行号80021查询附近日志，且只显示10行
cat -n catalina.out | tail -n +80021 | head -n 10
```

### 查询时间范围内，某个线程的所有日志
```shell
# 首先要进行范围时间段内日志查询先查看是否在当前日之内存在，也就是说 11-07 18:29:20 必须在日志中存在这个时间点（如果日期时间已确认，可直接执行sed命令）
grep '11-07 18:29:20' catalina.out
grep '11-07 18:31:11' catalina.out

# 或者根据grep搜索到的日志确认日期行号（查询后确认日期真实存在，比如，确实存在 2023-04-10 17:39:03.883 的日志，可直接执行sed命令）
cat -n catalina.out | grep 717892

# 时间范围内的查询，以4-10 17:39:03.883为起点，到4-10 17:39:05所有毫秒的日志
sed -n '/4-10 17:39:03.883/,/4-10 17:39:05.*/p' catalina.out
 
 # 时间范围内的查询，以11-07 18:29分为起点，到11-07 18:31分之间的所有日志
sed -n '/11-07 18:29:/,/11-07 18:31:/p' catalina.out | grep 'http-nio-8084-exec-6'
```

日志快速查询的命令与技巧

此文章主要介绍 阿里云短信服务 的使用，可根据实际业务需求自行编写代码




## 云服务
想实现 阿里云短信服务，必须的有阿里云的账号，此处文章前的你们是不是有备而来？点击下方注册 OR 登录到阿里云

[阿里云短信服务](https://www.aliyun.com/product/sms?spm=5176.12825654.h2v3icoap.84.7b652c4aqS05Yt&aly_as=678uM2qJ)

[短信服务官方帮助文档](https://help.aliyun.com/product/44282.html?spm=5176.12226203.0.0.3dcc1cbeTbz6xA)

## 控制台配置

登录成功后，进入到短信服务的控制台，可看到如下界面，具体菜单功能我就 不一一介绍了，相信大家都能从字面上大体了解。

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


下面我将开始介绍短信服务需要的主要配置 - 点击国内消息--签名管理--添加签名

    短信签名：相信大家在右上角处 都能查看控制台提供的文档，我叙述的肯定不如文档写的全面，那我再此举一个通俗易懂的简单实例，帮助大家更好的去理解。

### 短信实例

>【天猫超市】水果！1！元！包！邮！还送15元红包！仅限今天，错过后悔！椱ァ製这段描述￥rCIuYr5yL91￥后到手机淘宝 回t退订

>【腾讯科技】王者荣耀四周岁庆典明日开启，参与活动得婉儿周年庆限定，26日皮肤返场，登录抽百万内测！url.cn/5vKYnEb  回T退订

此处是我收到的2条短信，其中【天猫超市】与【腾讯科技】即为签名，大家可以 查看一下自己手机里面的短信，是不是发现每条短信开头部分都是【XXXX】，是不是发现自己以前从来没 注意过观察过，现在看来是不是特别神奇？

## 短信签名

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


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

上面的申请签名的过程我就不过多叙述了，大家应该都能轻易获取到，下面我将介绍 短信模板

## 短信模板

> 短信模版，即具体发送的短信内容。

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

此处我也不再举例，相信大家根据上面实例都能理解的很透彻。

## API密钥

签名与模板配置完后，在实际开发中还需要添加访问阿里API的密钥

首先点击右上角用户，添加一个处理短信的用户

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

添加完成后，自动跳转到用户信息页面，自行保存 `AccessKeySecret` ，关闭页面后，你将再也看不到 `AccessKeySecret`，这个很重要

:::warning{title="注意"}
此处的账户信息AccessKey ID 与 AccessKeySecret 在项目中进行使用，请谨慎保存
:::

给账户授权， 使账户可以管理短信服务

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


## Java SDK 测试

当 签名与 模板 申请下来以后，可以在线进行测试，具体参数介绍请查看API文档

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

此时收到短信了没？写到此处，控制台 配置 与 测试 便结束了，相信大家的签名与模板都能申请下来，接下来我们将进入代码的世界，准备好了吗？

## Java 实现
上面 SDK Demo中已经给出实例，我将结合实际需求写一个小Demo；

需求：发送短信验证码进行用户注册，且60秒内不能重复发送短信，验证码有效期为5分钟

环境准备：装有 RabbitMQ,Redis 环境的虚拟机

1.pom文件
```xml
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
 
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
 
        
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-core</artifactId>
            <version>4.1.0</version>
        </dependency>
 
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.43</version>
        </dependency>
 
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
 
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
```

2.application.yml配置（IP、端口 根据实际环境自行配置）

```yaml
spring:
  #redis地址 端口号默认6379
  redis:
    host: 192.168.80.129
  #rabbitmq配置
  rabbitmq:
    host: 192.168.80.131
    port: 5672
    username: guest
    password: guest
    publisher-confirms: true    #  消息发送到交换机确认机制,是否确认回调
 
 
#自定义配置项
sms:
  accessKeyId: 填写控制台配置用户时，记录的用户accessKeyId
  accessSecret: 填写控制台配置用户时，记录的用户accessSecret
  signName: 申请的签名  #签名
  templateCode: 模板的CODE #模板CODE
  domain: dysmsapi.aliyuncs.com
  action: SendSms  #API 的名称
```


 3.常量定义
 
 ```java
/**
 * 常量定义
 * @author: diego
 * @create: 2019/10/9
 */
public class DataDict {
 
    //redis-key 手机号限流前缀
    public final static String SMS_PHONE_NUMBER = "sms:phone:";
 
    //redis-key 验证码前缀
    public final static String SMS_PHONE_VERIFICATION  = "sms:phone:verification:";
 
}
```

4.属性定义
```java
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
 
/**
 * 配置项属性
 * @author: diego
 * @create: 2019/10/9
 */
@Data
@Component
@ConfigurationProperties(prefix = "sms")
public class SmsProperties {
 
    private String accessKeyId;
    private String accessSecret;
    private String SignName;
    private String templateCode;
    private String domain;
    private String action;
 
    @Override
    public String toString() {
        return "SmsProperties{" +
                "accessKeyId='" + accessKeyId + '\'' +
                ", accessSecret='" + accessSecret + '\'' +
                ", SignName='" + SignName + '\'' +
                ", templateCode='" + templateCode + '\'' +
                ", domain='" + domain + '\'' +
                ", action='" + action + '\'' +
                '}';
    }
}
```

5.短信工具类
```java
import com.alibaba.fastjson.JSON;
import com.aliyuncs.CommonRequest;
import com.aliyuncs.CommonResponse;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.exceptions.ServerException;
import com.aliyuncs.http.MethodType;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.utils.StringUtils;
import com.example.demo.dict.DataDict;
import lombok.extern.slf4j.Slf4j;
import lombok.val;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
 
import java.util.Map;
import java.util.concurrent.TimeUnit;
 
/**
 * 短信发送工具类
 * @author: diego
 * @create: 2019/10/9
 */
@Slf4j
@Component
@EnableConfigurationProperties(SmsProperties.class)
public class SmsUtils {
 
    @Autowired
    SmsProperties smsProperties;
 
    @Autowired
    StringRedisTemplate redisTemplate;
 
    /**
     * 短信发送方法
     * demo：https://api.aliyun.com/?spm=a2c4g.11186623.2.13.63ee50a4NKRQsm#/?product=Dysmsapi&lang=JAVA
     * @param phoneNumbers
     * @param signName
     * @param templateCode
     * @return
     */
    public CommonResponse SendSms(String phoneNumbers,String signName,String templateCode,String templateParam){
        try {
            //限流校验
            val s = redisTemplate.boundValueOps(DataDict.SMS_PHONE_NUMBER + phoneNumbers).get();
            if(StringUtils.isNotEmpty(s)){
                System.err.println(s);
                if (System.currentTimeMillis() - Long.valueOf(s) < 60000){
                    log.info("手机号码发送频繁，稍后再试！");
                    return null;
                }
            }
 
            DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou",
                    smsProperties.getAccessKeyId(), smsProperties.getAccessSecret());
            IAcsClient client = new DefaultAcsClient(profile);
 
            CommonRequest request = new CommonRequest();
            request.setMethod(MethodType.POST);
            request.setDomain(smsProperties.getDomain());
            request.setVersion("2017-05-25"); //当前日期 格式：yyyy-MM-dd
            request.setAction(smsProperties.getAction());
            request.putQueryParameter("PhoneNumbers", phoneNumbers);
            request.putQueryParameter("SignName", signName);
            request.putQueryParameter("TemplateCode", templateCode);
            if(StringUtils.isNotEmpty(templateParam)){
                request.putQueryParameter("TemplateParam", templateParam);
            }
 
            CommonResponse response = client.getCommonResponse(request);
            Map<String,String> map = JSON.parseObject(response.getData(),Map.class);
            if("OK".equals(map.get("Code"))){
                log.info("短信发送成功！返回消息："+response.getData());
                //短信发送成功，设置计时器 开始限流
                redisTemplate.boundValueOps(DataDict.SMS_PHONE_NUMBER + phoneNumbers).set(
                        String.valueOf(System.currentTimeMillis()),1, TimeUnit.MINUTES);
            }else{
                log.info("短信发送失败！状态码为："+map.get("Code")+"   错误信息为："+map.get("Message"));
            }
            return response;
        } catch (ServerException e) {
            e.printStackTrace();
            log.info("短信发送失败！服务异常信息为："+ e);
        } catch (ClientException e) {
            e.printStackTrace();
            log.info("短信发送失败！客户端异常信息为："+ e);
        } catch (Exception e){
            e.printStackTrace();
            log.info("短信发送失败！异常信息为："+ e);
        }
        return null;
    }
}
```

6.短信监听
```java
import com.alibaba.fastjson.JSON;
import com.example.demo.dict.DataDict;
import com.example.demo.sms.SmsProperties;
import com.example.demo.sms.SmsUtils;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
 
import java.util.Map;
 
/**
 * 短信监听
 * @author: diego
 * @create: 2019/10/9
 */
@Component
public class SmsListener {
 
    @Autowired
    SmsProperties smsProperties;
 
    @Autowired
    SmsUtils smsUtils;
 
    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(
                            value = "sms_amqp_queue",durable = "true"),
                    exchange = @Exchange(
                            value = "sms_amqp_exchange", type = ExchangeTypes.TOPIC),
                    key = {"#.#"}
            )
    )
    public void listenSmsSend(Map<String,String> map){
        //校验map
        if(CollectionUtils.isEmpty(map)){
            return;
        }
        //从map中删除key为phone  返回key的值
        String phone = map.remove("phone");
        //校验返回的key为phone的返回值
        if (StringUtils.isEmpty(phone)){
            return;
        }
        System.out.println(JSON.toJSONString(map));
        smsUtils.SendSms(phone,smsProperties.getSignName(), smsProperties.getTemplateCode(), JSON.toJSONString(map));
    }
 
}
```

7.测试

```java
import com.example.demo.dict.DataDict;
import com.example.demo.sms.SmsProperties;
import com.example.demo.sms.SmsUtils;
import lombok.val;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
 
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
 
@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {
 
    @Autowired
    SmsProperties smsProperties;
 
    @Autowired
    StringRedisTemplate redisTemplate;
 
    @Autowired
    SmsUtils smsUtils;
 
    @Autowired
    RabbitTemplate rabbitTemplate;
 
    /**
     * 获取Application.yml中短信参数配置测试
     */
    @Test
    public void propertiesTest() {
        System.err.println(smsProperties.toString());;
    }
 
    /**
     * redis连通性测试
     */
    @Test
    public void redisTest() {
        redisTemplate.boundValueOps("test").set("测试redis是否可用！");
 
        val test = redisTemplate.boundValueOps("test").get();
        System.out.println(test);
    }
 
    /**
     * 短信发送服务测试
     */
    @Test
    public void smsSend() {
        smsUtils.SendSms("1510110XXXX",smsProperties.getSignName(),
                smsProperties.getTemplateCode(),"{\"code\":\"888888\"}");
    }
 
    /**
     * 消息队列 - 短信发送服务测试
     */
    @Test
    public void smsSendToRabbitMQ() {
        Map<String,String> map = new HashMap<>();
        map.put("phone","1510110XXXX");
        map.put("code","888888");
        rabbitTemplate.convertAndSend("sms_amqp_exchange", "a.b", map);
 
        //短信验证码有效期
        redisTemplate.boundValueOps(DataDict.SMS_PHONE_VERIFICATION+"1510110XXXX").set("888888",5, TimeUnit.MINUTES);
    }
 
}
```
此处的代码可以根据阿里提供的官方Demo，按照实际业务需求自行编写；

## 小心有坑

阅读到这里，你是否有一个疑问，我并没有在控制台中购买短信服务套餐，为什么短信发送成功了呢？

哈哈，这是一个比较深的坑，大家此时查看一下控制台中 费用统计，短信服务是预扣，已经开始欠费了

![image.png](https://blog.liushigong.cn/static/img/8207e602f39d77fd3d1a32b9ba8f2903.image.webp)

点击上方费用按钮，可查看账户信息，进入账户充值即可

![image.png](https://blog.liushigong.cn/static/img/72637f574389cfe8814a5dbccc679e1f.image.webp)

短信服务的账单是 每月一结算，记得保证账户余额充足^_^。

Java实现阿里云短信云服务

最近项目中不同微服务之间的LocalDateTime时间交互，格式上出现了差异，一个服务入参返参都是默认的 `yyyy-MM-dd'T'HH:mm:ss`，一个服务定义了全局时间格式，入参与返参是 `yyyy-MM-dd HH:mm:ss`，导致服务调用失败。正常情况下，所有服务应该做到格式统一，今天我就从源码上，来分析下全局定义时间格式的几种方式。



# Date 的处理
先聊一下 Date 的处理，Jackson 配置中包含了对 Date 的格式处理，可以通过 `spring.jaskson.dateformat` 进行修改，主要在 yaml 中配置时间格式、时区、国家

```yaml
spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
    locale: zh_CN
```

## 源码中的处理

根据定义的 dateFormat，在Spring容器中查找此类型的Bean实例信息，如果找到，调用 #dateFormat 方法。

如果找不到，就会使用默认的 SimpleDateFormat 进行处理。

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

通过以上的源码分析得出，我们可以自定义对 Date 格式的处理，只需要继承 **DateFormat** 在 Jackson 中的实现类 **StdDateFormat** ，配置yaml属性为该处理类的包路径即可。

```java
@Component
public class MyDateFormat extends StdDateFormat {

    @Override
    public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition fieldPosition) {
        return null;
    }

    @Override
    public Date parse(String source, ParsePosition pos) {
        return null;
    }

}
```

配置：

```yaml
spring:
  jackson:
    date-format: cn.liushigong.boot.MyDateFormat
    time-zone: GMT+8
    locale: zh_CN
```

# LocalDateTime 的处理

Date 说完了，来说一下Java8 以后的时间处理 LocalDateTime。

## @JsonFormat
LocalDateTime 默认的返回格式是 `yyyy-MM-dd'T'HH:mm:ss`，我们可以通过使用 @JsonFormat 注解修饰属性，进行格式化处理，不过当所有的时间都需要格式处理的时候，此种方式太过繁琐，我们需要一种与 Date 一样的全局处理的方式。

```java
@JsonFormat(pattern = "yyyy-MM-dd HH:mm", timezone = "GMT+8")
private LocalDateTime createTime;
```

## 全局格式化
查看Jackson源码，发现其对类型序列化是通过 Jackson2ObjectMapperBuilder 构建的，找到此对象的配置信息

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

从以上代码分析得知，Jackson2ObjectMapperBuilder 对象在创建的时候，通过注入 Jackson2ObjectMapperBuilderCustomizer 的Bean实例信息，循环调用 #customize 方法

```java
@FunctionalInterface
public interface Jackson2ObjectMapperBuilderCustomizer {

	/**
	 * Customize the JacksonObjectMapperBuilder.
	 * @param jacksonObjectMapperBuilder the JacksonObjectMapperBuilder to customize
	 */
	void customize(Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder);

}
```

通过此接口，查找到默认的实现类

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

了解其思路后，我们需要对 Jackson2ObjectMapperBuilder 进行扩展，添加日期格式的序列化与反序列化，就可以通过注册 Jackson2ObjectMapperBuilderCustomizer Bean实例对象进行处理，代码如下

```java
@Configuration
public class LocalDateTimeConfig {

    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return builder ->
        // 序列化与反序列化日期时间格式
        builder.serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)))
                .serializerByType(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)))
                .serializerByType(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN)))
                .deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)))
                .deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)))
                .deserializerByType(LocalTime.class, new LocalTimeDeserializer(DatePattern.NORM_TIME_FORMATTER));
    }
}

```


## 思考

:::tip{title="思考"}
注册了 Jackson2ObjectMapperBuilder 的 Bean 实例对象，他是在哪里被使用，又是如何处理 Controller 中接口返回的数据呢？
:::

带着疑问，我们继续分析，查看 Jackson2ObjectMapperBuilder 的引用有哪些。

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

在茫茫代码中，我立马就看到了 WebMvcConfigurationSupport 配置类，回想到 SpringMVC 的执行流程，结合源码，猜测是在消息转换处理器中进行的数据转换操作。

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

从上面源码中，可以看到 MappingJackson2HttpMessageConverter 消息转换器在创建的时候，注入了一个对象 ObjectMapper，此对象是从 Jackson2ObjectMapperBuilder 中构建出来的

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

查看 MappingJackson2HttpMessageConverter 源码中对 ObjectMapper 的处理，在父类找到以下代码

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

此时串下思路：

通过 Jackson2ObjectMapperBuilder 添加序列化信息，而 Jackson2ObjectMapperBuilder #build() 方法构建出 ObjectMapper，ObjectMapper 添加在 HttpMessageConverter 消息转换器中。

结合源码想到在 WebMvcConfigurationSupport（ 或者是 WebMvcConfigurer ） 中，可以手动实现 #extendMessageConverters 方法，对内置的消息处理器进行管理，而消息转换器又可以单独设置 ObjectMapper 对象，那我们就可以替换代码中默认生成的 ObjectMapper，手动创建 Jackson2ObjectMapperBuilder 对象去重构 ObjectMapper，代码如下：

```java
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    /**
     * Override this method to extend or modify the list of converters after it has
     * been configured. This may be useful for example to allow default converters
     * to be registered and then insert a custom converter through this method.
     *
     * @param converters the list of configured converters to extend
     * @since 4.1.3
     */
    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        // 重构Jackson对象映射器的序列化与反序列化日期时间格式
        converters.stream().filter(x -> MappingJackson2HttpMessageConverter.class.isAssignableFrom(x.getClass())).findFirst().ifPresent(x -> {
            MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter = (MappingJackson2HttpMessageConverter) x;
            // 自定义Jackson对象映射器构建器定制器
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json();
            // 序列化与反序列化日期时间格式
            builder.serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)));
            builder.serializerByType(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
            builder.serializerByType(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN)));
            builder.deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)));
            builder.deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
            builder.deserializerByType(LocalTime.class, new LocalTimeDeserializer(DatePattern.NORM_TIME_FORMATTER));
            // 对象映射器
            mappingJackson2HttpMessageConverter.setObjectMapper(builder.build());
        });
    }
}

```

经过测试，以上代码也可实现全局的日期格式处理，可以省略了Bean注册信息的过程。


## 衍生

在从源码中衍生，就会发现创建的序列化对象存储在 Jackson2ObjectMapperBuilder serializers 属性中，通过构建 ObjectMapper 时，注入到此对象中

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

那我们是否可以直接 new ObjectMapper() 此对象，然后将序列化对象添加到 SimpleModule 中

```java
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    /**
     * Override this method to extend or modify the list of converters after it has
     * been configured. This may be useful for example to allow default converters
     * to be registered and then insert a custom converter through this method.
     *
     * @param converters the list of configured converters to extend
     * @since 4.1.3
     */
    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        // 重构Jackson对象映射器的序列化与反序列化日期时间格式
        converters.stream().filter(x -> MappingJackson2HttpMessageConverter.class.isAssignableFrom(x.getClass())).findFirst().ifPresent(x -> {
            MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter = (MappingJackson2HttpMessageConverter) x;
            
            // 模块
            SimpleModule module = new SimpleModule();
            module.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)));
            module.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
            module.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN)));
            module.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)));
            module.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
            module.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DatePattern.NORM_TIME_FORMATTER));

            // 注册模块
            ObjectMapper objectMapper = mappingJackson2HttpMessageConverter.getObjectMapper();
            objectMapper.registerModule(module);
        });
    }
}
```

以上是根据源码分析出的3种全局处理日期格式的方案，本质就是找到切入点替换默认的序列化格式，实现方式千千万，没有最优，只有更优。

SpringBoot 全局处理 LocalDateTime 的序列化与反序列化格式

baidu-site-verification

本人自己的博客，对工作与学习过程中的总结、一些场景设计的实现方案、遇到过的疑难问题与解决、以及面试总结等。