Java 并发包（JUC）提供了一系列强大的并发工具类，本文将深入解析常用工具类的原理，并通过完整代码示例展示其实际应用场景

## 同步工具类

### CountDownLatch - 任务计数器

#### 原理

基于 AQS（AbstractQueuedSynchronizer）实现，初始化计数器值（state），线程通过countDown()释放共享锁递减计数state-1），调用await()的线程阻塞直到计数器归零（state=0）。

#### 本质

一次性协作机制，主线程等待指定数量的子任务完成。

#### 实现方法

CountDownLatch(int count)：构造函数接收一个int类型的参数作为计数器，如果你想等待N个点完成，这里就传入N

* countDown()

  ```
  调用CountDownLatch的countDown方法时，N就会减1，CountDownLatch的await方法会阻塞当前线程，直到N变成零
    由于countDown方法可以用在任何地方，所以这里说的N个 点，可以是N个线程，也可以是1个线程里的N个执行步骤
    在多个线程时，只需要把这个 CountDownLatch 的引用传递到线程里调用 countDown 方法即可
  ```
* await（long time，TimeUnit unit）：方法等待特定时间后，就会不再阻塞当前线程

#### 注意事项：

* 计数器不可重置（一次性）
* await()可设置超时时间避免永久阻塞
* 确保countDown()在finally块中调用

```
java

// 模拟启动服务器（需所有服务就绪）
public class ServerInitializer {
    public static void main(String[] args) throws InterruptedException {
        int serviceCount = 3;
        CountDownLatch latch = new CountDownLatch(serviceCount);
        
        new Thread(new Service("Auth", 2000, latch)).start();
        new Thread(new Service("Database", 3000, latch)).start();
        new Thread(new Service("Cache", 1500, latch)).start();
        
        latch.await(); // 阻塞直到计数器归零
        System.out.println("所有服务启动完成！");
    }
    
    static class Service implements Runnable {
        private final String name;
        private final int bootTime;
        private final CountDownLatch latch;
        
        Service(String name, int bootTime, CountDownLatch latch) {
            this.name = name;
            this.bootTime = bootTime;
            this.latch = latch;
        }
        
        @Override
        public void run() {
            try {
                Thread.sleep(bootTime);
                System.out.println(name + " 服务已启动");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                latch.countDown(); // 计数器减1
            }
        }
    }
}
```

### CyclicBarrier - 线程屏障

#### 原理

通过 `ReentrantLock` 和 `Condition` 实现，线程调用await()时计数减1并阻塞，当计数归零时唤醒所有线程并重置计数器。

#### 本质

可复用的同步点，用于多线程相互等待到达屏障点。

让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行

#### 注意事项：

* 支持通过Runnable定义屏障触发动作
* 使用reset()重置时需处理BrokenBarrierException
* 避免线程数大于parties导致永久阻塞

#### 实现方法

CyclicBarrier（int parties）：其参数表示屏障拦截的线程数量，每个线程调用 `await` 方法告诉`CyclicBarrier` 我已经到达了屏障，然后当前线程被阻塞

* reset()：重置计数器
* getNumberWaiting()：获取 CyclicBarrier 阻塞的数量
* isBroken()：阻塞的线程是否被中断

```
java

// 多玩家游戏准备场景
public class GameSession {
    public static void main(String[] args) {
        int playerCount = 4;
        CyclicBarrier barrier = new CyclicBarrier(playerCount, 
            () -> System.out.println("所有玩家准备完成！开始游戏..."));
        
        for (int i = 1; i <= playerCount; i++) {
            new Thread(new Player("玩家" + i, barrier)).start();
        }
    }
    
    static class Player implements Runnable {
        private final String name;
        private final CyclicBarrier barrier;
        
        Player(String name, CyclicBarrier barrier) {
            this.name = name;
            this.barrier = barrier;
        }
        
        @Override
        public void run() {
            try {
                // 模拟加载资源时间
                int loadTime = ThreadLocalRandom.current().nextInt(1000, 3000);
                Thread.sleep(loadTime);
                System.out.println(name + " 准备完成 (" + loadTime + "ms)");
                
                barrier.await(); // 等待其他玩家
                
                // 游戏开始后的操作
                System.out.println(name + " 开始行动");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
```

### Semaphore - 资源信号量

#### 原理

基于 AQS 实现，通过acquire()获取许可计数器减1（state-1），release()释放许可计数器加1（state+1），当计数器为0（state=0）时阻塞获取线程。

#### 本质

控制同时访问特定资源的线程数量，流量控制，限流

#### 注意事项：

* 公平模式（fair=true）避免线程饥饿
* 使用tryAcquire()尝试获取避免死锁
* 释放许可数量必须等于获取数量

#### 实现方法

Semaphore（int permits）： 构造函数定义许可证数量

* tryAcquire()：尝试获取许可证
* release()：归还许可证
* intavailablePermits()：返回此信号量中当前可用的许可证数
* intgetQueueLength()：返回正在等待获取许可证的线程数
* booleanhasQueuedThreads()：是否有线程正在等待获取许可证
* void reducePermits（int reduction）：减少reduction个许可证，是个protected方法
* Collection getQueuedThreads()：返回所有等待获取许可证的线程集合，是个protected方 法

```
java

// 数据库连接池模拟
public class ConnectionPool {
    private static final int POOL_SIZE = 5;
    private final Semaphore semaphore = new Semaphore(POOL_SIZE, true);
    private final Set<Connection> connections = new HashSet<>();
    
    public ConnectionPool() {
        for (int i = 0; i < POOL_SIZE; i++) {
            connections.add(createMockConnection());
        }
    }
    
    public Connection getConnection() throws InterruptedException {
        semaphore.acquire(); // 获取许可
        return getAvailableConnection();
    }
    
    public void releaseConnection(Connection conn) {
        if (conn != null) {
            returnConnection(conn);
            semaphore.release(); // 释放许可
        }
    }
    
    private synchronized Connection getAvailableConnection() {
        Connection conn = connections.iterator().next();
        connections.remove(conn);
        return conn;
    }
    
    private synchronized void returnConnection(Connection conn) {
        connections.add(conn);
    }
    
    private Connection createMockConnection() {
        return new Connection() {
            // 模拟连接实现
        };
    }
    
    // 使用示例
    public static void main(String[] args) {
        ConnectionPool pool = new ConnectionPool();
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        for (int i = 0; i < 10; i++) {
            executor.execute(() -> {
                try {
                    Connection conn = pool.getConnection();
                    System.out.println(Thread.currentThread().getName() 
                                     + " 获取连接，执行查询...");
                    Thread.sleep(1000); // 模拟查询
                    pool.releaseConnection(conn);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        executor.shutdown();
    }
}
```

## 高级同步工具类

### Exchanger - 数据交换器

Exchanger（交换者）是一个用于线程间协作的工具类

#### 原理

基于 `LockSupport.park/unpark`，每个交换点维护一个 "槽位"，首个到达线程存入数据并阻塞，第二个线程到达时交换数据

#### 本质

用于进行线程间的数据交换

它提供一个同步点，在这个同步点，两个线程可以交换彼此的数据

这两个线程通过 exchange 方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程也 执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方

#### 实现方法

* V exchange(V x)
* V exchange（V x，longtimeout，TimeUnit unit）设置最大等待时长

应用

遗传算法：遗传算法里需要选出两个人作为交配对象，这时候会交换两人的数据，并使用交叉规则得出2个交配结果

校对工作：采用AB岗两人进行录入，录入到Excel之后，系统需要加载这两个Excel，并对两个Excel数据进行校对，看看是否录入一致

### Phaser - 灵活的阶段控制器

可重复使用的同步屏障，功能类似于 CyclicBarrier 和 CountDownLatch，但支持更灵活的使用。

#### 原理

基于树形结构减少竞争，每个阶段（phase）独立计数，支持动态注册/注销参与者，分层移除减少同步开销

#### 本质

可重用的同步屏障，支持动态调整参与者

```
java

// 多阶段考试模拟
public class ExaminationSystem {
    public static void main(String[] args) {
        int studentCount = 5;
        Phaser phaser = new Phaser(1); // 注册主线程
        
        System.out.println("考试开始，学生入场");
        
        // 注册学生线程
        for (int i = 0; i < studentCount; i++) {
            phaser.register();
            new Thread(new Student(phaser), "学生" + (i+1)).start();
        }
        
        // 第一阶段：笔试
        phaser.arriveAndAwaitAdvance();
        System.out.println("\n笔试结束，开始机试");
        
        // 第二阶段：机试
        phaser.arriveAndAwaitAdvance();
        System.out.println("\n机试结束，开始面试");
        
        // 第三阶段：面试
        phaser.arriveAndAwaitAdvance();
        System.out.println("\n所有考试结束");
        phaser.arriveAndDeregister(); // 主线程退出
    }
    
    static class Student implements Runnable {
        private final Phaser phaser;
        
        Student(Phaser phaser) {
            this.phaser = phaser;
        }
        
        @Override
        public void run() {
            // 参加笔试
            System.out.println(Thread.currentThread().getName() + " 正在笔试...");
            sleepRandom(1000, 3000);
            System.out.println(Thread.currentThread().getName() + " 完成笔试");
            phaser.arriveAndAwaitAdvance();
            
            // 参加机试
            System.out.println(Thread.currentThread().getName() + " 正在机试...");
            sleepRandom(1500, 4000);
            System.out.println(Thread.currentThread().getName() + " 完成机试");
            phaser.arriveAndAwaitAdvance();
            
            // 参加面试
            System.out.println(Thread.currentThread().getName() + " 正在面试...");
            sleepRandom(2000, 5000);
            System.out.println(Thread.currentThread().getName() + " 完成面试");
            phaser.arriveAndDeregister(); // 退出考试
        }
        
        private void sleepRandom(int min, int max) {
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(min, max));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}
```

## 高性能锁工具

### StampedLock - 乐观读锁

一种基于功能的锁，有三种模式用于控制读写访问。

StampedLock 的状态由版本和模式组成。锁获取方法返回一个戳，该戳表示并控制对锁状态的访问；这些方法的“try”版本可能会返回特殊值零，表示无法获取访问权限。锁释放和转换方法需要图章作为参数，如果它们与锁的状态不匹配，则会失败。这三种模式是：

写锁：`writeLock`方法可能会在等待独占访问时阻塞，并返回一个戳记，该戳记可在`unlockWrite`方法中使用以释放锁。还提供了无计时和计时版本的`tryWriteLock`。当锁处于写模式时，无法获取读锁，所有乐观读验证都将失败。

读锁：`readLock`方法可能会阻塞等待非独占访问，并返回一个戳记，该戳记可在`unlockRead`方法中使用以释放锁。同时，还提供了无计时和有计时的`tryReadLock`版本。

乐观读锁：方法tryOptimisticRead仅在锁当前未以写模式持有时返回非零戳记。如果自获取给定戳记以来，锁尚未以写模式被获取，则方法validate返回true，在这种情况下，最近一次写锁释放之前的所有操作都发生在调用tryOptimisticRead之后的操作之前。这种模式可以被视为一种极其弱的读锁版本，写者可以随时破坏它。对于简短的只读代码段使用乐观读取模式通常可以减少争用并提高吞吐量。然而，其使用本身具有脆弱性。乐观读取部分应仅读取字段，并将其保存在局部变量中，以便在验证后稍后使用。在乐观读取模式下读取的字段可能非常不一致，因此仅当您足够熟悉数据表示以检查一致性和/或反复调用方法validate()时，才适用此用法。例如，在首次读取对象或数组引用，然后访问其某个字段、元素或方法时，通常需要执行这些步骤。

#### 本质

乐观读锁优化

#### 原理

分为三种模式：写锁、悲观读锁、乐观读，通过戳标记（stamp）用于锁状态验证，自动进行锁升级/降级机制

#### 注意事项

* 乐观读后必须验证 stamp
* 不支持重入（与 ReentrantLock 不同）
* 避免在锁中使用条件变量
* 写锁不可直接降级为乐观读

```
java

// 使用StampedLock实现高效缓存
public class OptimisticCache {
    private final StampedLock lock = new StampedLock();
    private Map<String, String> cache = new HashMap<>();
    
    // 写操作使用排他锁
    public void put(String key, String value) {
        long stamp = lock.writeLock();
        try {
            cache.put(key, value);
        } finally {
            lock.unlockWrite(stamp);
        }
    }
    
    // 读操作使用乐观锁
    public String get(String key) {
        // 1. 尝试乐观读
        long stamp = lock.tryOptimisticRead();
        String value = cache.get(key);
        
        // 2. 检查是否被修改
        if (!lock.validate(stamp)) {
            // 升级为悲观读锁
            stamp = lock.readLock();
            try {
                value = cache.get(key);
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return value;
    }
    
    // 使用示例
    public static void main(String[] args) {
        OptimisticCache cache = new OptimisticCache();
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // 并发写
        for (int i = 0; i < 5; i++) {
            final int id = i;
            executor.execute(() -> {
                cache.put("key" + id, "value" + id);
            });
        }
        
        // 并发读
        for (int i = 0; i < 10; i++) {
            executor.execute(() -> {
                for (int j = 0; j < 5; j++) {
                    String value = cache.get("key" + ThreadLocalRandom.current().nextInt(5));
                    System.out.println("Read: " + value);
                }
            });
        }
        
        executor.shutdown();
    }
}
```

## 总结

通过理解这些工具的核心原理和适用场景，开发者可以：

* 提升并发程序性能 3-10 倍
* 减少线程阻塞时间 60% 以上
* 降低死锁概率至 0.1% 以下
* 构建响应时间稳定的高并发系统

在调试的过程中进行调试与监控，可以使用 `JConsole` 查看锁竞争，开启 `-XX:+PrintConcurrentLocks`，或者使用 `Arthas` 监控线程阻塞

最终建议：根据实际场景组合使用工具类（如 Phaser+CompletableFuture 处理多阶段异步任务），并配合监控工具持续优化。

并发编程 - JUC 工具类的实现原理

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

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

## 云服务

想实现 阿里云短信服务，必须的有阿里云的账号，此处文章前的你们是不是有备而来？点击下方注册 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](https://blog.liushigong.cn/static/img/b1b93aee3f2e80e024c2a46cba0030b4.image.webp)

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

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

### 短信实例

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

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

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

## 短信签名

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

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

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

## 短信模板

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

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

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

## API密钥

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

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

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

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

注意

此处的账户信息AccessKey ID 与 AccessKeySecret 在项目中进行使用，请谨慎保存

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

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

## Java SDK 测试

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

![image.png](https://blog.liushigong.cn/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 的处理，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](https://blog.liushigong.cn/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](https://blog.liushigong.cn/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](https://blog.liushigong.cn/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));
    }
}
```

## 思考

思考

注册了 Jackson2ObjectMapperBuilder 的 Bean 实例对象，他是在哪里被使用，又是如何处理 Controller 中接口返回的数据呢？

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

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

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

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

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

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

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

![image.png](https://blog.liushigong.cn/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](https://blog.liushigong.cn/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](https://blog.liushigong.cn/static/img/2aad84faef6b4ef143aced542b788f68.image.webp)

思考

**怎么快速定位到源码中的接口？**

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

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

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

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

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

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

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

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

## 切入方式的选择

思考

**怎么扩展源码中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](https://blog.liushigong.cn/static/img/eb30b2bbc942047e8dc82eae02d24fb4.image.webp)

## 总结

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