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

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




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

学习源码之前先思考一个问题，我们为什么要学习源码？有什么用？



**工作这么多年我总结了以下几点原因**

- 第一点：应付面试！现在Java开发人员越来越多，公司的要求也变得越来越高，源码成为我们必不可少的面点！
- 第二点：核心竞争！现在氛围好点的公司中，大家工作中对技术讨论还是比较多的，如果你不懂源码的话就没办法参与到源码这部分的讨论中，更不用说参与一些核心代码的开发工作
- 第三点：学以致用！之前部署一套新Cloud服务的时候，同事遇到Feign调用其他服务报 ClientException 异常的问题，在大家轮番上场都一筹莫展的时候，我运用学习源码时的思路，逐步分析Ribbon源码，最终解决了问题
- 第四点：组件封装！学会源码以后，就可以根据源码扩展出各种组件，是高级开发必备技能

## 开篇
我在学习Spring源码的过程中略有心得，通过流程图记录下源码执行流程、各种扩展点以及一些自己的理解。

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

- Spring在启动时会先创建 BeanFactory，默认是ConfigurableListableBeanFactory，
- 通过BeanDefinitionReader解析xml、注解等定义的Bean信息包装成BeanDefinition存到BeanFactory中的BeanDefinitionMap中，
- 然后调用BeanFactoryPostProcessor接口进行扩展，
- 进行实例化前的准备工作：注册BeanPostProcesser、初始化国际化资源、初始化事件多播器、注册监听器。
- 准备完成后对所有非延迟加载的单例进行实例化，通过反射的形式创建对象，进行属性填充，然后进行相应的Aware接口的感知调用，
- 执行BeanPostProcesser的前置处理，在初始化方法调用之后执行BeanPostProcesser的后置处理，
- 此时Bean的对象创建完成

源码的学习，都是从上面的流程学起，面试经常问题的Spring Bean的生命周期，就是上面图中，Bean创建的流程，在`BeanFactory`中有对应的注释，如下：

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

在源码中 AbstractApplicationContext #refresh 方法即为Spring Bean完整生命周期的体现
```java
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

        // Prepare this context for refreshing.
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);

            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
            // Invoke factory processors registered as beans in the context.
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();

            // Initialize message source for this context.
            initMessageSource();

            // Initialize event multicaster for this context.
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            onRefresh();

            // Check for listener beans and register them.
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                                    "cancelling refresh attempt: " + ex);
            }

            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }

        finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
            contextRefresh.end();
        }
    }
}

```


## 总结

想要掌握Spring源码应该先掌握Spring的生命周期（Bean信息是怎么加载、解析、实例化、初始化、使用、销毁的），脑海中有一个框架轮廓，知道Spring先做了什么，后做了什么，有一个大概了解。

脑海中有了Spring的轮廓之后，开始思考细节，例如：Bean信息是怎么加载的？加载的Bean信息是直接生成可用的Bean吗？每一步流程都动脑思考扩展点，怎么应用到业务中，这个扩展适合哪些业务场景等。

在看源码的过程中，要学会关联思考，源码中往往是初始化数据后，n个方法后会用到的。

最后一点，学过源码后一定要思考、做笔记，回头来看学过的知识点能在脑海中立马回忆起来，争取做到对源码为所欲为的境界！！！

Spring 源码分析之 Bean 的全生命周期

baidu-site-verification

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