在之前的内容中已经讲述了 JMM内存模型与volatile，同时也讲述了保障线程安全的 **同步互斥** 与 **异步非阻塞** 两种方式，更描述了异步非阻塞中的 `CAS` 原理以及 `CAS` 的一些经典问题， 本文接下来继续完成我们的并发版图，了解下什么是 `Atomic`。



## 原子类实现原理

原子类是 Java 并发编程的核心组件，位于 java.util.concurrent.atomic 包中。它们基于 CAS 机制实现无锁线程安全操作，在高并发场景下性能显著优于传统锁机制。

### 原子类核心原理 CAS

在线程安全的那篇文章中描述过什么是CAS，此处我们回顾下

#### 比较并交换

翻译：Compare-and-Swap，简称 CAS

本质就是 乐观锁思想,也是无锁的思想

#### CAS 执行流程：

CAS指令需要三个操作数，分别是变量的内存地址，用V表示，旧值用A表示，新值用B表示。

- 内存位置（V）：需要更新的变量地址
- 预期原值（A）：读取到的变量值
- 新值（B）：希望设置的新值

CAS指令在执行时，当且当V符合A时，处理器才会用B更新V的值，否则就不更新不管是否更新了V值，都会返回V的旧值，这个处理过程是一个原子操作，执行期间不会被其他线程中断

```java
// 伪代码展示 CAS 原理
boolean compareAndSwap(V expectedValue, V newValue) {
    if (this.value == expectedValue) {
        this.value = newValue;
        return true;
    }
    return false;
}
```

💡 CAS 优势：避免线程阻塞，减少上下文切换开销

⚠️ ABA 问题：值从 A→B→A 的变化无法被检测（解决方案：AtomicStampedReference）


## 原子类分类

### 基本数据类型原子类

- AtomicInteger：一个int可能原子更新的值
- AtomicLong：一个long值可以用原子更新
- AtomicBoolean：一个boolean值可以用原子更新

**常用方法**

- int addAndGet（int delta）
    
        以原子方式将输入的数值与实例中的值（AtomicInteger里的 value）相加，并返回结果

- boolean compareAndSet（int expect，int update）
    
        如果输入的数值等于预期值，则以原子方 式将该值设置为输入的值
- int getAndIncrement()

        以原子方式将当前值加1，注意，这里返回的是自增前的值
        
- int getAndSet（int newValue）

        以原子方式设置为newValue的值，并返回旧值


**核心源码分析**

```java
public class AtomicInteger {
    private volatile int value; // volatile保证可见性
    
    // Unsafe类提供CAS底层操作
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    
    static {
        try {
            // 获取value字段的内存偏移地址
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    
    public final boolean compareAndSet(int expect, int update) {
        // 调用Unsafe的CAS指令
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
}
```

**执行流程图**

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

**代码示例**

```java
// 原子整型计数器
AtomicInteger counter = new AtomicInteger(0);

// 原子自增（线程安全）
int newValue = counter.incrementAndGet(); // 等同于 ++i
int current = counter.getAndIncrement();  // 等同于 i++

// CAS 更新示例
boolean updated = counter.compareAndSet(5, 10); 
// 当前值=5时更新为10
```




### 数组类型原子类

- AtomicIntegerArray：一个int数组，其中元素可以原子更新
- AtomicLongArray：一个long数组，其中元素可以原子更新
- AtomicReferenceArray：可以以原子方式更新元素的对象引用数组
 
**常用方法**

- int addAndGet（int i，int delta）
    
        以原子方式将输入值与数组中索引i的元素相加。
    
- boolean compareAndSet（int i，int expect，int update）

        如果当前值等于预期值，则以原子 方式将数组位置i的元素设置成update值


**代码示例**

```java
// 原子整型数组
AtomicIntegerArray atomicArray = new AtomicIntegerArray(10);

// 原子更新数组元素
atomicArray.set(0, 100); // 设置索引0的值为100
int prev = atomicArray.getAndAdd(0, 5); // 索引0的值+5，返回旧值

// CAS 更新数组
boolean success = atomicArray.compareAndSet(0, 105, 110);
```

### 引用类型原子类

- AtomicReference：可以原子更新的对象引用
- AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类 型的标记位和引用类型。
- AtomicStampedReference：：原子更新带有版本号的引用类型通过控制变量值的版本来保证CAS的正确性。解决CAS的“ABA”问题

```java
// 原子引用
AtomicReference<User> userRef = new AtomicReference<>();
User user1 = new User("Alice");
User user2 = new User("Bob");

userRef.set(user1);

// 原子更新引用
boolean updated = userRef.compareAndSet(user1, user2);

// 初始值=100, 版本号=0
AtomicStampedReference<Integer> money = new AtomicStampedReference<>(100, 0);

// 更新时检查值和版本号
int[] stampHolder = new int[1];
int currentStamp = money.getStamp();
int currentValue = money.getReference();

// 版本号+1防止ABA问题
boolean success = money.compareAndSet(
    currentValue, 
    currentValue + 50, 
    currentStamp, 
    currentStamp + 1
);
```

### 对象属性修改类型原子类

- AtomicIntegerFieldUpdater：原子更新整型的字段的更新器
- AtomicLongFieldUpdater：原子更新长整型字段的更新器
- AtomicReferenceFieldUpdate ：原子更新引用类型里的字段
 
**使用注意**

  对象的属性修改类型都是抽象类，所以在使用之前必须使用静态方法newUpdater创建一个新的更新器，然后参数传入需要更新的类和属性，属性名同时待修改的属性必须用public volatile关键字修饰
  
```java
public class AtomicIntegerFieldUpdaterTest { 
    // 创建原子更新器，并设置需要更新的对象类和对象的属性 
    private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater. 
    newUpdater(User.class， "old"); 
    public static void main(String[] args) { 
        // 设置柯南的年龄是10岁 
        User conan = new User("conan"， 10); 
        // 柯南长了一岁，但是仍然会输出旧的年龄 
        System.out.println(a.getAndIncrement(conan)); 
        // 输出柯南现在的年龄 
        System.out.println(a.get(conan)); 
    }
    public static class User { 
        private String name; 
        // 必须volatile修饰
        public volatile int old;
        public User(String name， int old) { this.name = name; this.old = old; }
    }
}

```


### 高性能原子类

目的是解决高并发环境下 AtomicLong 这种基于CAS算法的原子类自旋瓶颈问题，内部采用 **分段CAS机制**，高并发下性能优于 AtomicLong

- LongAccumulator：long类型的聚合器，需要传入一个long类型的二元操作，可以用来计算各种聚合操作，包括加乘等
- LongAdder：long类型的累加器，LongAccumulator的特例，只能用来计算加法，且从0开始计算
- DoubleAccumulator：double类型的聚合器，需要传入一个double类型的二元操作，可以用来计算各种聚合操作，包括加乘等
- DoubleAdder
  double类型的累加器，DoubleAccumulator的特例，只能用来计算加法，且从0开始计算
  
- Striped64：公共父类 Striped64 是实现中的核心，它实现一些核心操作，处理64位数据，很容易就能转化为其他基本类型，是个通用的类。

  
**实现思想**

采用分段的思想，提高CAS操作的成功率，AtomicLong中的成员变量value用来保存值，而在高并发的情况下value就变成了一个热点数据，也就是众多线程竞争一个 value ，将value值的操作分散到一个数组中，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行CAS操作，最后再把这些段的值相加得到最终的值。

**代码示例**

```java
// 高性能累加器（适合高并发统计）
LongAdder adder = new LongAdder();

// 多线程并发累加
parallelStream().forEach(i -> {
    adder.add(i);
});

// 获取结果（最终一致性）
long total = adder.sum();
```

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

:::tip{title="为什么会有高性能原子类"}
  AtomicLong 通过CAS算法提供了非阻塞的原子性操作，由于过多线程同时去竞争同一个变量的更新从而导致无限循环的自旋锁不停的尝试，这就是高并发下CAS性能低下的原因所在，所以推出了高性能原子类。
:::


## 适用场景

- 计数器、累加器
- 状态标志位更新
- 简单对象的状态变更
- 非阻塞算法实现


## 总结

原子类核心是基于 CAS 实现无锁线程安全，在低竞争场景性能远超传统锁，不同的场景下使用不同的类型体系：基本类型、引用类型、数组类型、对象属性修改类型，以及在高并发的场景下使用的高性能原子类类型。代码最佳实践如下：

```java
// 1. 简单计数
private AtomicInteger requestCount = new AtomicInteger(0);

// 2. 状态机更新
private AtomicReference<State> state = new AtomicReference<>(State.INIT);

// 3. 高并发统计
private LongAdder totalBytes = new LongAdder();
```

原子类作为 JUC 包的核心组件，合理使用可大幅提升并发程序性能，但需根据具体场景权衡其与锁机制的选用。

并发编程 - 深入理解 Atomic 原子类

并发编程 - 线程基础与线程安全

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




## 云服务
想实现 阿里云短信服务，必须的有阿里云的账号，此处文章前的你们是不是有备而来？点击下方注册 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 的序列化与反序列化格式

由于对 SpringBoot 的版本升级，从 knife4j-spring-boot-starter 3.0.3 版本迭代到 knife4j-openapi2-spring-boot-starter 4.2.0 版本，其中 host 与 basePath 参数不能动态修改的问题，结合源码进行扩展。



# 源码分析
从页面的展示现象上与代码的配置上结合分析，两个版本之间的文档属性 host 与 basePath 应该为接口内部自动处理。
当我配置域名后，host、basepath 不能检测变更，导致接口调用全部失败。

基于以上问题，我决定找到源码中对应的点进行扩展，将 host、basepath 也作为动态可配置的参数。

## 查找切入点

首先通过 `F12` doc.html 文档页面，发现主体数据是通过 `/V2/docs-api` 接口返回数据进行页面填充，知道了接口是什么，接下来分析接口在源码的哪个类中。

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


:::tip{title="思考"}
**怎么快速定位到源码中的接口？**
:::


结合学习过的源码知识，我此时想到了通过 SpringMVC 的执行流程源码来定位，打开 `DispatcherServlet #doDispatch` 方法，在处理器执行链那一行打个断点

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

刷新 doc.html 页面，看断点进来的接口有哪些，几次过后就发现了 `/V2/docs-api` 接口的调用

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

通过控制台查看 mappedHandler 对象内部的 handler 属性，同时能查看到处理器的实现类，点击 `Navigate` 可定位到处理器的实现类

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

找到接口的出处 `Swagger2ControllerWebMvc`类，查看接口，发现其内部获取 `Swagger` 对象后，单独设置了 host 与 basePath 属性，到了此时，已经定位了接口在源码中的位置，逻辑也已经完全清晰，接下来开始思考如何改造才能动态扩展出 host 与 basePath 属性？

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

## 切入方式的选择


:::tip{title="思考"}
**怎么扩展源码中Controller接口返回的数据？**
:::

对于 Controller 接口的处理，切入点还是比较多的，例如 HandlerInterceptor、ResponseBodyAdvice。

不过由于处理的是Jar包中的 Controller，它在加载到Spring容器的时候，方法的 HandlerInterceptor 已经确认，所以只能使用 ResponseBodyAdvice 方式。

## 代码实现

定义动态的属性配置，通过 application.yaml 隔离

```yml
# dev
knife4j:
  base-path: /
  host: localhost:${server.port}
```

```yml
# prod
knife4j:
  base-path: /yonger
  host: liushigong.cn
```

声明 @RestControllerAdvice 的类，实现 ResponseBodyAdvice 接口

```java 
@RestControllerAdvice
public class Knife4jResponseAdvice implements ResponseBodyAdvice<Json> {

    @Value("${knife4j.base-path}")
    private String basePath;

    @Value("${knife4j.host}")
    private String host;

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return returnType.getDeclaringClass().equals(Swagger2ControllerWebMvc.class);
    }

    @SneakyThrows
    @Override
    public Json beforeBodyWrite(Json body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        if (body != null) {
            // 重写host 和 basePath
            Swagger swagger = JSONObject.parseObject(body.value(), Swagger.class);
            swagger.setHost(host);
            swagger.setBasePath(basePath);
            return new Json(JSONObject.toJSONString(swagger));
        }
        return null;
    }
}
```

**思路：**

- 实现 ResponseBodyAdvice 接口，由于 `/V2/docs-api` 接口返回的是 Json 对象，所以泛型是 Json
- 声明了动态的 host 、 basePath 属性进行注入
- 调用 #supports 方法校验是否需要拦截，如果处理类是 `Swagger2ControllerWebMvc.class` 方法返回true
- #supports为true后，会调用 #beforeBodyWrite 方法，内部将Json中返回的对象值转换为 Swagger对象，填充动态配置的 host、basePath 属性。

## 实现效果

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

## 总结
在平常遇到问题时，会去想如何去解决，当有一定的技术深度，掌握部分源码以后，遇到此类问题，脑海中会立马构思出一套思路，排查此类问题就会轻而易举，这就体现出了学习源码的价值。<span style="color:#ff9900;">**解决问题最重要的就是思路，提高深度就是拓展思路最好的方式!** </span>

SpringBoot 整合 Knife4J 文档动态 host 与 basePath 处理

baidu-site-verification

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