在日常工作中，我们经常会遇到很多改数据与sql的优化或异常的情况，改数据的大多数可以编写sql来实现，但是小部分，需要通过现有逻辑的代码才行，这就需要发版迭代出一个改数据的接口；另一种就是线上sql的优化或调整，也只能通过发版来解决；由此我提出了“探针”方式，可以让我们探入系统中由于使用双手一样的丝滑。

## 任意调用 Bean 的方法

第一道探针比较简单，实现思路是通过 `BeanFacroty` 来获取对应的 `Bean` 信息，然后结合反射，调用想要执行的方法，通过 `controller` 接口进行触发，以 `Bean`、`Method` 的信息作为入参

```
java

@Data
public class ProbeDTO {

 /**
 * bean名称
 */
 private String beanName;

 /**
 * 类名
 */
 private String className;

 /**
 * 方法名
 */
 private String methodName;

 /**
 * 参数
 */
 private Object[] params;
}
```

`Controller` 接口中通过实现 `BeanFactoryAware` 来获取到 `BeanFactory` ,由于使用数组接收参数，实际调用反射的过程中，还需要将参数转为对应 `Method` 的入参类型，由于不同API的Bean转换与反射调用各有差异，出现过各种异常，所以此处兼容不同转换与反射的api调用，总有一种可用的方式

```
java

@RestController
public class ProbeController implements BeanFactoryAware {

 private BeanFactory beanFactory;

 @PostMapping("/probe")
 public Object probe(@RequestBody ProbeDTO probeDTO) {
 try {
 // 类信息
 Class<?> clazz = Class.forName(probeDTO.getClassName());
 // 获取bean
 Object bean = beanFactory.getBean(probeDTO.getBeanName(), clazz);
 Assert.notNull(bean, "bean is null");
 // 通过反射调用方法
 Method method = ReflectUtil.getMethodByName(clazz, probeDTO.getMethodName());
 Assert.notNull(method, "method is null");

 Object[] params = new Object[ArrayUtil.isEmpty(probeDTO.getParams()) ? 0 : probeDTO.getParams().length];
 if (ArrayUtil.isNotEmpty(method.getParameterTypes())) {
 for (int i = 0; i < method.getParameterTypes().length; i++) {
 // 基础类型 - 无需处理
 if (method.getParameterTypes()[i].isPrimitive()) {
 params[i] = probeDTO.getParams()[i];
 continue;
 }

 // 字符串类型 - 无需处理
 if (method.getParameterTypes()[i].getName().equals(String.class.getName())) {
 params[i] = probeDTO.getParams()[i];
 continue;
 }

 // 其他类型，list、map、set、bean
 try {
 // 类型转换器
 SimpleTypeConverter simpleTypeConverter = new SimpleTypeConverter();
 params[i] = simpleTypeConverter.convertIfNecessary(probeDTO.getParams()[i].toString(), method.getParameterTypes()[i]);
 } catch (Exception e) {
 try {
 // Hutool 转换
 params[i] = JSONUtil.toBean(JSONUtil.toJsonStr(probeDTO.getParams()[i]), method.getParameterTypes()[i]);
 } catch (Exception e1) {
 try {
 // Fastjson 转换
 params[i] = JSONObject.parseObject(probeDTO.getParams()[i].toString(), method.getParameterTypes()[i]);
 } catch (Exception e2) {
 // 转换不了，听天由命
 params[i] = probeDTO.getParams()[i];
 }
 }
 }
 }
 }

 try {
 // Hutool 反射调用，有时候不好用
 return ReflectUtil.invoke(bean, method, params);
 } catch (Exception e) {
 e.printStackTrace();
 // Spring 反射调用
 return ReflectionUtils.invokeMethod(method, bean, params);
 }
 } catch (Exception e) {
 e.printStackTrace();
 return e.getMessage();
 }
 }

 /**
 * Callback that supplies the owning factory to a bean instance.
 * Invoked after the population of normal bean properties
 * but before an initialization callback such as
 * {@link InitializingBean#afterPropertiesSet()} or a custom init-method.
 *
 * @param beanFactory owning BeanFactory (never {@code null}).
 * The bean can immediately call methods on the factory.
 * @throws BeansException in case of initialization errors
 * @see BeanInitializationException
 */
 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 this.beanFactory = beanFactory;
 }
}
```

## 基于 Nacos 动态优化SQL

在工作中经常遇到访问慢的情况，需要优化，或者生产中由于某个条件写错导致sql执行异常等问题，此探针就是为解决此类问题而生。

整体实现思路是结合 Nacos 的动态配置，与 Mapper 的方法全限名结合，在 `Mybatis` 的拦截器中动态替换 `MapperStatement` 中的执行语句。

### 拦截器的实现

拦截器的代码逻辑实现如下

* 拦截 Executor 的 query 和 update 方法。
* 根据 statementId（如 com.example.UserMapper.selectById）匹配动态 SQL。
* 通过反射创建新的 MappedStatement，确保参数映射一致。

```
java

@Intercepts({
 @Signature(
 type = Executor.class,
 method = "query",
 args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}
 ),
 @Signature(
 type = Executor.class,
 method = "update",
 args = {MappedStatement.class, Object.class}
 ),
})
@Slf4j
@Component
public class DynamicSqlInterceptor implements Interceptor {

 @Resource
 private NacosDynamicSqlLoader nacosDynamicSqlLoader;

 @Override
 public Object intercept(Invocation invocation) throws Throwable {
 // 参数
 Object[] args = invocation.getArgs();
 // 映射语句
 MappedStatement mappedStatement = (MappedStatement) args[0];
 // 查询参数
 Object parameter = args[1];
 // 执行器
 Executor executor = (Executor) invocation.getTarget();
 // 映射语句Id
 String statementId = mappedStatement.getId();

 // 获取原始 BoundSql
 BoundSql originalBoundSql = null;
 if (args.length == 6) { // query 方法
 originalBoundSql = (BoundSql) args[5];
 } else if (args.length == 2) { // update 方法
 originalBoundSql = mappedStatement.getBoundSql(parameter);
 } else {
 return invocation.proceed();
 }
 log.info("{}:原始 SQL:{}", statementId, originalBoundSql.getSql());

 // 获取动态 SQL
 String dynamicSql = nacosDynamicSqlLoader.getDynamicSql(statementId);
 log.info("{}:动态 SQL:{}", statementId, dynamicSql);
 if (dynamicSql != null && !dynamicSql.isEmpty()) {
 // 1. 创建新的 BoundSql（完整复制参数）
 BoundSql newBoundSql = new BoundSql(
 mappedStatement.getConfiguration(),
 dynamicSql,
 originalBoundSql.getParameterMappings(),
 originalBoundSql.getParameterObject()
 );

 // 2. 复制附加参数（关键！）
 if (originalBoundSql.getAdditionalParameters() != null) {
 for (Map.Entry<String, Object> entry : originalBoundSql.getAdditionalParameters().entrySet()) {
 newBoundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
 }
 }

 // 3. 创建新的 MappedStatement
 MappedStatement newMappedStatement = copyMappedStatement(mappedStatement, new BoundSqlSqlSource(newBoundSql));
 args[0] = newMappedStatement;

 // 清除一级二级缓存标记
 boolean cleared = nacosDynamicSqlLoader.isCleared(statementId);

 // 4. 处理查询方法参数
 if (args.length == 6) {
 // 更新 BoundSql 参数
 args[5] = newBoundSql;

 // 5. 重新生成 CacheKey（关键！）
 RowBounds rowBounds = (RowBounds) args[2];
 CacheKey newCacheKey = executor.createCacheKey(
 newMappedStatement,
 parameter,
 rowBounds,
 newBoundSql
 );
 // 更新 CacheKey 参数
 args[4] = newCacheKey;

 // 6. 清除一级缓存
 if (!cleared) {
 executor.clearLocalCache();
 }
 }

 // 7. 清除二级缓存
 if (!cleared) {
 clearMapperCache(mappedStatement);
 nacosDynamicSqlLoader.clearDynamicSql(statementId);
 }
 }

 return invocation.proceed();
 }

 /**
 * 清除二级缓存
 */
 private void clearMapperCache(MappedStatement ms) {
 try {
 Cache cache = ms.getCache();
 if (cache != null) {
 cache.clear();
 }
 } catch (Exception e) {
 // 避免因缓存异常导致主流程失败
 }
 }

 /**
 * 复制并替换 MappedStatement 的 BoundSql
 */
 private MappedStatement copyMappedStatement(MappedStatement ms, BoundSqlSqlSource boundSql) {
 try {
 // 通过反射创建新的 MappedStatement
 MappedStatement.Builder builder = new MappedStatement.Builder(
 ms.getConfiguration(),
 ms.getId(),
 boundSql,
 ms.getSqlCommandType()
 );

 builder.resource(ms.getResource())
 .fetchSize(ms.getFetchSize())
 .statementType(ms.getStatementType())
 .keyGenerator(ms.getKeyGenerator())
 .timeout(ms.getTimeout())
 .parameterMap(ms.getParameterMap())
 .resultMaps(ms.getResultMaps())
 .cache(ms.getCache())
 .flushCacheRequired(ms.isFlushCacheRequired())
 .useCache(ms.isUseCache());

 // 处理主键生成（可选）
 if (ms.getKeyProperties() != null && ms.getKeyProperties().length != 0) {
 builder.keyProperty(String.join(",", ms.getKeyProperties()));
 }

 return builder.build();
 } catch (Exception e) {
 log.error("{}:动态SQL拦截器复制 MappedStatement 失败", ms.getId(), e);
 return ms;
 }
 }

 /**
 * 自定义 SqlSource 包装 BoundSql
 */
 static class BoundSqlSqlSource implements SqlSource {
 private final BoundSql boundSql;

 public BoundSqlSqlSource(BoundSql boundSql) {
 this.boundSql = boundSql;
 }

 @Override
 public BoundSql getBoundSql(Object parameterObject) {
 return boundSql;
 }
 }
}
```

### Nacos 配置刷新实现

通过 `ApplicationListener<EnvironmentChangeEvent>` 监听配置变更事件，每次刷新本地动态SQL缓存，提供查询性能，具体实现如下

* 动态 SQL 缓存在内存中，避免每次执行 SQL 时访问 Nacos。
* 注意清除Mybatis的一级缓存、二级缓存。

```
java

@Component
public class NacosDynamicSqlLoader implements EnvironmentAware, ApplicationListener<EnvironmentChangeEvent>, ApplicationRunner {

 /**
 * Nacos配置 - 动态SQL前缀
 */
 public static final String DYNAMIC_SQL_PREFIX = "dynamicSql.";

 private Environment environment;

 /**
 * 动态SQL缓存
 */
 private final Map<String, String> DYNAMIC_SQL_CACHE = new ConcurrentHashMap<>();

 /**
 * 动态SQL缓存已清除标记
 */
 private final Map<String, Boolean> DYNAMIC_SQL_CLEAR_FLAG = new ConcurrentHashMap<>();

 public String getDynamicSql(String statementId) {
 return DYNAMIC_SQL_CACHE.get(statementId);
 }

 /**
 * 是否已清除
 */
 public boolean isCleared(String statementId) {
 return DYNAMIC_SQL_CLEAR_FLAG.getOrDefault(statementId, false);
 }

 /**
 * 添加已清除标记
 */
 public void clearDynamicSql(String statementId) {
 DYNAMIC_SQL_CLEAR_FLAG.put(statementId, true);
 }

 /**
 * Handle an application event.
 *
 * @param event the event to respond to
 */
 @Override
 public void onApplicationEvent(EnvironmentChangeEvent event) {
 // 监听到配置变更事件
 loadConfig();
 }

 /**
 * Set the {@code Environment} that this component runs in.
 *
 * @param environment
 */
 @Override
 public void setEnvironment(Environment environment) {
 this.environment = environment;
 }

 /**
 * Callback used to run the bean.
 *
 * @param args incoming application arguments
 * @throws Exception on error
 */
 @Override
 public void run(ApplicationArguments args) throws Exception {
 // 项目启动完成后加载配置
 loadConfig();
 }

 /**
 * 加载Nacos配置，更新动态SQL缓存
 *
 * 
 * 项目启动时加载配置
 * 配置变更时加载配置
 * 
 */
 private void loadConfig() {
 // 获取本地的配置
 for (PropertySource<?> propertySource : ((ConfigurableEnvironment) environment).getPropertySources()) {
 if (propertySource instanceof BootstrapPropertySource<?>) {
 BootstrapPropertySource<?> bootstrapPropertySource = (BootstrapPropertySource<?>) propertySource;
 if (((Map<?, ?>) bootstrapPropertySource.getSource()).isEmpty()) {
 continue;
 }
 // 更新动态SQL
 parseAndUpdateCache((LinkedHashMap<String, Object>) bootstrapPropertySource.getSource());
 }
 }
 }

 /**
 * 解析配置内容，更新动态SQL缓存
 *
 * 
 * dynamicSql:
 * # 格式：Mapper接口全类名.方法名
 * com.example.UserMapper.selectById: "SELECT * FROM user WHERE id = #{id} AND status = 1"
 * 
 * @param contextMap 配置内容，key: dynamicSql.com.example.UserMapper.selectById, value: SELECT * FROM user WHERE id = #{id} AND status = 1
 */
 private void parseAndUpdateCache(LinkedHashMap<String, Object> contextMap) {
 // 清空缓存，防止直接put存留被删除的sql
 DYNAMIC_SQL_CACHE.clear();
 DYNAMIC_SQL_CLEAR_FLAG.clear();

 // 添加缓存
 if (contextMap == null || contextMap.isEmpty()) {
 return;
 }
 contextMap.forEach((key, value) -> {
 if (key.startsWith(DYNAMIC_SQL_PREFIX)) {
 String id = key.replace(DYNAMIC_SQL_PREFIX, "");
 DYNAMIC_SQL_CACHE.put(id, value.toString());
 DYNAMIC_SQL_CLEAR_FLAG.put(id, false);
 }
 });
 }
}
```

Nacos 配置属性如下

```
java

dynamicSql:
 # 格式：Mapper接口全类名.方法名
 cn.liushigong.system.mapper.UsersMapper.selectList: "SELECT * FROM users WHERE age = ? or age= ?"
 cn.liushigong.system.mapper.UsersMapper.selectByUser: "SELECT * FROM users WHERE name = ? and age = ? and sex = ?"
```

日志输出

```
java

原始 SQL:SELECT id,name,age,sex,create_time FROM users WHERE (age > ? AND age >= ?)
动态 SQL:SELECT * FROM users WHERE age = ? or age= ?
c.l.i.c.s.mapper.UsersMapper.selectList : ==> Preparing: SELECT * FROM users WHERE age = ? or age= ?
c.l.i.c.s.mapper.UsersMapper.selectList : ==> Parameters: 10(Integer), 50(Integer)

原始 SQL:select * from users WHERE name like concat('%',?,'%') and age = ? and sex = ?
动态 SQL:SELECT * FROM users WHERE name = ? and age = ? and sex = ?
c.l.i.c.s.m.UsersMapper.selectByUser : ==> Preparing: SELECT * FROM users WHERE name = ? and age = ? and sex = ?
c.l.i.c.s.m.UsersMapper.selectByUser : ==> Parameters: 张三(String), 18(Integer), 男(String)
```

动态SQL注意项

原SQL会解析占位符 `?`，每个占位符对应的参数都是固定的，在调整动态SQL的过程中，需要保持占位符 `?`的数量、查询参数的顺序与原SQL保持一致

## 查看死锁的线程

```
java

// 死锁测试
@RequestMapping("/{id}")
public String index(@PathVariable String id) {
 // 创建死锁场景
 final UserTest lock1 = new UserTest("张三");
 final UserTest lock2 = new UserTest("李四");

 Thread thread1 = new Thread(() -> {
 synchronized (lock1) {
 System.out.println("Thread 1: Holding lock 1...");
 try { 
 Thread.sleep(10); 
 } catch (InterruptedException e) {}

 System.out.println("Thread 1: Waiting for lock 2...");
 synchronized (lock2) {
 System.out.println("Thread 1: Acquired lock 2!");
 }
 }
 }, id + "-1");

 Thread thread2 = new Thread(() -> {
 synchronized (lock2) {
 System.out.println("Thread 2: Holding lock 2...");
 try { 
 Thread.sleep(10); 
 } catch (InterruptedException e) {}

 System.out.println("Thread 2: Waiting for lock 1...");
 synchronized (lock1) {
 System.out.println("Thread 2: Acquired lock 1!");
 }
 }
 }, id + "-2");

 thread1.start();
 thread2.start();

 try {
 thread1.join();
 thread2.join();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }

 return "Deadlock scenario created!";
}

// 打印死锁线程信息
@RequestMapping("/hello")
public String hello() {
 ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
 long[] threadIds = threadBean.findDeadlockedThreads();
 if (threadIds != null) {
 ThreadInfo[] infos = threadBean.getThreadInfo(threadIds);
 // 打印死锁线程信息
 for (ThreadInfo info : infos) {
 StringBuilder threadInfo = new StringBuilder(info.toString());
 for (StackTraceElement stackTraceElement : info.getStackTrace()) {
 threadInfo.append(stackTraceElement.toString());
 }
 System.out.println("Deadlocked Thread: " + threadInfo);
 }
 }
 return "Hello World!";
}
```

## 安全性问题

探针虽然带来了一些遍历，但同时要注意其产生的安全性问题，例如任意调用Bean信息，没有记录留痕，没有`traceId` 的记录，无法定位到 `操作凶手`，随意更改sql，导致系统的安全性与稳定性无法得到保障。

给项目中添加一道保险 - “探针”

对于 Nacos 的动态配置大家都很熟悉，在此我提出个疑问❓ **如何在 Nacos 配置中定义 Bean 信息且实现动态的添加删除 Bean 呢？** 本文是结合工作中的实践，来讲下在 **动态的可插拔式插件设计** 的实现思路，可结合业务场景动态切换告警信息、短信服务商、动态线程池等等

## Nacos 配置中 Bean 的定义

既然要动态的配置 Bean，那么首先需要在配置中定义好 Bean 的结构，需要哪些属性。接下来我将以班级、学生与学生做的事来讲述代码思路

首先定义班级的属性，其中班级下有一群学生，对应的属性为 `students`，每个学生都会做同一件事，接下来我们会将学生做一些事转换为动态的，可通过Nacos配置进行 **增删改**

```
java

@Data
@ConfigurationProperties(prefix = ClassProperties.PREFIX)
public class ClassProperties {

 /**
 * 配置属性的前缀
 */
 public static final String PREFIX = "class";

 /**
 * 属性名
 */
 public static final String STU_PROPERTY_NAME = "class.students";

 /**
 * BeanName Template Name
 */
 public static final String BEANNAME_TEMPLATE = "class.students[%s]";

 /**
 * 班级名称
 */
 private String className;

 /**
 * 年级
 */
 private String gradeName;

 /**
 * 班级学生
 * 
 * key:学号，value:学生信息
 * 
 */
 private Map<String, Student> students;

}
```

学生对象的属性

```
java

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
 private String name;
 private Integer age;
 private String sex;
}
```

声明学生所做的事情，本质上来说，这就是我们真实要处理业务场景的逻辑，可自行调整

```
java

public interface StudentHandler {
 String doSomething();
}

@Data
public class StudentDoSomethingHandler implements StudentHandler {

 private String key;

 private Student student;

 public StudentDoSomethingHandler(String key, Student student) {
 this.key = key;
 this.student = student;
 }

 @Override
 public String doSomething() {
 // do something
 return "【" + key + "】学生【" + student.getName() + "】，今年【" + student.getAge() + "岁】，性别【" + student.getSex() + "】,开始做点什么了...";
 }
}
```

对象定义完了，来描述下Nacos中的属性, `2025140001` 即为 `Map<String, Student> students` 的key，此为 **唯一标识**，用来进行学生的查找，同时也是 `StudentDoSomethingHandler` 中的属性 `key`，而其下的学生信息对应着对象 `student`。

```
yaml

class:
 className: 十四班
 gradeName: 初一
 students:
 2025140001:
 name: 张三
 age: 18
 sex: 男
 2025140002:
 name: 紫馨
 age: 20
 sex: 女
 2025140003:
 name: 狗五松溪
 age: 13
 sex: 男
 2025140004:
 name: 构思
 age: 10
 sex: 未知
```

## 动态的注册Bean对象

定义好属性后，我们需要将配置的Bean信息在项目启动时，注入到Spring容器中，交由Spring容器管理。

核心逻辑为：将定义的 `Map<String, Student> students` 转换成 `StudentDoSomethingHandler` 对象，注入到Spring容器中，其中 BeanName 使用模板 `class.students[%s]` 声明，将 `key` 替换到占位符中，最终定义为 `class.students[2025140001]`,此方式便于随时查找Bean对象，整体实现代码如下

```
java

@Component
public class StudentBeanDefinitionRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {

 /**
 * 班级的属性配置
 */
 private ClassProperties classProperties;

 /**
 * Register bean definitions as necessary based on the given annotation metadata of
 * the importing {@code @Configuration} class.
 * Note that {@link BeanDefinitionRegistryPostProcessor} types may not be
 * registered here, due to lifecycle constraints related to {@code @Configuration}
 * class processing.
 * The default implementation is empty.
 *
 * @param importingClassMetadata annotation metadata of the importing class
 * @param registry current bean definition registry
 */
 @Override
 public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
 // 配置的学生信息
 Map<String, Student> students = classProperties.getStudents();
 if (!CollectionUtils.isEmpty(students)) {
 // 将配置对象转换成Bean，注册到Spring容器中
 students.forEach((key, student) -> {
 // key:beanName, value:beanDefinition
 registry.registerBeanDefinition(buildBeanName(key), buildBeanDefinition(StudentDoSomethingHandler.class, key, student));
 });
 }
 }

 /**
 * 根据 Environment 中的属性名进行构建
 *
 * 
 * 示例：class.students[...]
 * 
 */
 public String buildBeanName(String key) {
 return String.format(ClassProperties.BEANNAME_TEMPLATE, key);
 }

 /**
 * 构建 BeanDefinition
 *
 * @param clazz 构建 Bean 对象的类型
 * @param constructorArguments Bean 的构造参数
 * @param <T> -
 * @return BeanDefinition
 */
 public static <T> BeanDefinition buildBeanDefinition(Class<T> clazz, Object... constructorArguments) {
 // 定义 BeanDefinition
 BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(clazz).getBeanDefinition();
 ConstructorArgumentValues constructorArgumentValues = beanDefinition.getConstructorArgumentValues();

 // 构建参数
 for (int i = 0; i < constructorArguments.length; i++) {
 constructorArgumentValues.addIndexedArgumentValue(i, constructorArguments[i]);
 }
 return beanDefinition;
 }

 /**
 * Set the {@code Environment} that this component runs in.
 *
 * @param environment
 */
 @Override
 public void setEnvironment(Environment environment) {
 // 绑定属性
 classProperties = PropertiesBinder.bindProperties(ClassProperties.PREFIX, environment, ClassProperties.class);
 }
}
```

BeanName 的生成

BeanName 的生成各种各样，并没有什么规则，但是有一点需要注意，那就是 **保证唯一性**，上述规则中就是根据 key 进行的生成，即保证了唯一性，同时在后续 **删改** 的过程中,可根据调整的 Nacos 配置属性随时定位到修改前的 Bean 对象进行处理。

依赖关系破坏

若实现过程中，其他的 Bean 引用了被移除的 Bean（简称 `引用 Bean`），可能导致 `NoSuchBeanDefinitionException` 或空指针，我们应该避免此类情况。

如果无法避免的情况下，如果是 **属性变更** 导致的移除，只需要将引用过 **被移除 Bean** 的对象进行缓存，在移除 Bean 的同时，构建新的 Bean，在将引用 Bean 中的属性进行覆盖，或者移除引用 Bean，进行重新添加

如果是纯移除 Bean，其他引用到此移除 Bean 导致产生异常的，那只能通过调整代码来解决了

提供一个 `Environment` 环境属性中转换对象的工具类

```
java

public class PropertiesBinder {

 @SneakyThrows
 public static <T> T bindProperties(String prefix, Environment environment, Class<T> clazz) {
 // 构建对象
 T t = clazz.getDeclaredConstructor().newInstance();
 Binder binder = Binder.get(environment);
 Bindable<?> target = Bindable.of(ResolvableType.forClass(clazz)).withExistingValue(t);
 binder.bind(prefix, target);
 return t;
 }
}
```

## Nacos配置修改Bean信息

实现了项目启动时，配置中 Bean 对象的初始化以后，我们接下来实现对配置中 Bean 对象的 **增删改**，来保证Spring容器中构建的对象为最新调整的属性

### Nacos 配置的变更

首先，当Nacos 平台上对配置进行变更时，我们需要做出扩展，触发Bean的动态刷新操作。从源码中可以得知，当配置变更时，客户端的 `RefreshEventListener` 监听器，会监听到 `RefreshEvent` 事件，执行 `ContextRefresher #refresh()` 方法，此方法中调用了内部方法 `refreshEnvironment()`，而这个内部方法将会变更本地的配置，同时将变更的属性提取出来，并且发布了 `EnvironmentChangeEvent` 事件，那我们只需要监听这个事件即可

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

上述逻辑中提取的变更属性有3种操作情况，分别是

1. 修改属性：会记录到变更的属性中，修改哪个属性，则记录哪个，例如修改了某个学生的年龄，则会存在一条变更的属性 `class.students[2025140001].age`
2. 删除属性：同修改属性一样，删除了哪些属性，也会记录哪些属性是变更的属性，例如删除了某个key以及对应的学生，则会将学生的对象都会记录上 `class.students[2025140001].name`、`class.students[2025140001].age`、`class.students[2025140001].sex`
3. 新增属性，同修改删除一样，但凡新增的都会记录到变更的属性中

### Bean 的增删改

监听到Nacos配置的变更后，我们需要从变更的属性中，只需要找出 `ClassProperties #students` 的属性变更，其中配置变更的操作也是3种，分别对应上述的配置变更的3种情况

1. 修改属性：确认对象是否在Spring容器中存在，存在则可能为更新或删除属性，接下来确认变更的属性是否还在 `Environment` 中，如果还在，则为更新
2. 删除属性：如果变更的属性不在`Environment` 中，则视为删除属性
3. 新增属性：Spring容器中不存在此变更的属性对象，则为新增属性

结合上述思路，代码实现如下

```
java

@Component
public class StudentConfigChangeListener implements EnvironmentAware, BeanFactoryAware, ApplicationListener<EnvironmentChangeEvent> {

 private DefaultListableBeanFactory beanFactory;

 private Environment environment;

 /**
 * Handle an application event.
 *
 * @param event the event to respond to
 */
 @Override
 public void onApplicationEvent(EnvironmentChangeEvent event) {
 // 将当前符合的信息进行变更，其他变更过滤
 parseBeanName(event.getKeys()).forEach(beanName -> {
 // Environment 中是否还存在 Bean 的属性信息
 boolean isExist = false;
 Field[] fields = Student.class.getDeclaredFields();
 for (int i = 0; i < fields.length && !isExist; i++) {
 if (environment.containsProperty(beanName + "." + fields[i].getName())) {
 isExist = true;
 }
 }

 // 添加 Bean
 if (isExist) {
 registerBean(beanName);
 }
 // 删除 Bean
 else {
 removeBean(beanName);
 }
 });
 }

 /**
 * 从变更的属性中解析出自定义的 BeanName
 */
 public Set<String> parseBeanName(Set<String> keys) {
 return keys.stream().filter(key -> key.startsWith(ClassProperties.STU_PROPERTY_NAME)).map(key -> key.substring(0, key.indexOf("]") + 1)).collect(Collectors.toSet());
 }

 /**
 * 删除 Bean
 */
 public void removeBean(String beanName) {
 try {
 StudentFactory.LOCK.writeLock().lock();
 // 删除 BeanDefinition
 if (beanFactory.containsBeanDefinition(beanName)) {
 beanFactory.removeBeanDefinition(beanName);
 }

 // 销毁单例实例
 if (beanFactory.containsSingleton(beanName)) {
 beanFactory.destroySingleton(beanName);
 }

 // 删除缓存
 StudentFactory.STUDETN_HANDLER.remove(beanName);
 } finally {
 StudentFactory.LOCK.writeLock().unlock();
 }
 }

 /**
 * 添加 Bean
 */
 public void registerBean(String beanName) {
 try {
 StudentFactory.LOCK.writeLock().lock();
 // 当前 Bean存在，则先删除 Bean
 if (beanFactory.containsSingleton(beanName)) {
 removeBean(beanName);
 }

 // 注册 BeanDefinition
 String key = beanName.substring(beanName.indexOf("[") + 1, beanName.indexOf("]"));
 Student student = PropertiesBinder.bindProperties(beanName, environment, Student.class);
 beanFactory.registerBeanDefinition(beanName, StudentBeanDefinitionRegister.buildBeanDefinition(StudentDoSomethingHandler.class, key, student));

 // 添加缓存
 StudentFactory.STUDETN_HANDLER.put(beanName, beanFactory.getBean(beanName, StudentHandler.class));
 } finally {
 StudentFactory.LOCK.writeLock().unlock();
 }
 }

 /**
 * Set the {@code Environment} that this component runs in.
 *
 * @param environment
 */
 @Override
 public void setEnvironment(Environment environment) {
 this.environment = environment;
 }

 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 this.beanFactory = (DefaultListableBeanFactory) beanFactory;
 }
}
```

插件设计

需要注意的一点，以上的代码为插件的设计，尤其是Spring项目启动时自动注册Bean信息实现的 `ImportBeanDefinitionRegistrar` 接口，只会在自动装配中生效，2.7版本以前需要添加到 `META-INF/spring.factories`, 2.7版本以后添加到 `META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports` ，具体实现可以查看 [SpringBoot 自动装配原理的满分解读](/post/16)

单例 Bean 的生命周期

单例 Bean 的实例会被容器缓存，移除定义后需手动销毁实例，可查看 `StudentConfigChangeListener #removeBean` 方法中的代码实现

### 门面调用

构建一个门面方法 `doPlan`,根据指定的学生key（也就是nacos配置中的学号 `2025140001`）来执行一些事情的方法

```
java

public class StudentFactory {

 /**
 * 读写锁，保证动态Bean信息的线程安全
 */
 public static final ReadWriteLock LOCK = new ReentrantReadWriteLock();

 /**
 * 每个学生对应的处理器缓存，可用来做一些事情
 *
 * 
 * key -> beanName, 对应的格式为: class.students[...]
 * value -> StudentHandler, 学生对应的处理器对象
 * 
 */
 public static Map<String, StudentHandler> STUDETN_HANDLER = new ConcurrentHashMap<>();

 /**
 * 执行学生的计划
 *
 * @param key 学生的key
 * @return 学生的做一些事的结果
 */
 public static String doPlan(String key) {
 try {
 LOCK.readLock().lock();
 StudentHandler studentHandler = STUDETN_HANDLER.get(String.format(ClassProperties.BEANNAME_TEMPLATE, key));
 Assert.notNull(studentHandler, "StudentHandler is null!");
 return studentHandler.doSomething();
 } finally {
 LOCK.readLock().unlock();
 }
 }
}
```

并发问题

动态修改容器可能引发安全问题，通过可重入读写锁 `ReentrantReadWriteLock` 来确保操作原子性，在添加或删除Bean时使用写锁，在读取动态Bean时使用读锁，依赖读写互斥的特性，来解决并发问题。

### 测试示例

在项目中添加接口进行测试

```
java

@RestController
public class TestController {

 /**
 * 获取所有学生
 */
 @GetMapping("/get")
 public Object get() {
 Map<String, StudentHandler> beansOfType = SpringUtil.getBeansOfType(StudentHandler.class);
 return JSON.toJSON(beansOfType);
 }
 
 /**
 * 让某个学生做一些事，例如让百度服务商发短信，或其他服务商发短信
 */
 @GetMapping("/getStudent")
 public String getStudent(String key) {
 return StudentFactory.doPlan(key);
 }
}
```

调整 Nacos 平台上的配置后，以上的Bean对象中也会跟着动态调整，访问 `/get` 接口查看，在更新配置后，刷新接口看内容是否发生变更

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

访问 `/getStudent` 接口，可让不同学生执行某些事情

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

## 插件设计的场景

在工作中，我是以此思路实现了 **告警组件**，结合el表达式，可动态调整告警信息。通过某次技术分享后，同事借鉴此思路实现了动态切换短信服务商，可结合实际的业务场景，自行实现动态的插件

插件设计 - 基于 Nacos 配置实现动态 Bean 的注入

在排查生产日志的时候，发现 RocketMQ 的消费端的日志没有输出 traceId, 导致链路查询无法衔接，通过查看当前项目架构底层的实现，发现原来是没有处理过异步的链路日志

为了查询更便捷，对此架构进行优化，实现完整版的全链路的日志ID记录

在 SpringBoot 中，MDC（Mapped Diagnostic Context）是最常见的日志上下文关联方式。

其实现原理就是在请求链路上添加 traceId 到 MDC，在请求链路结束时清除 traceId。

MDC（Mapped Diagnostic Context）

> 是SLF4J提供的一个线程安全的诊断上下文工具。它允许开发者在同一线程上下文中存储多个键值对信息，这些信息可以自动附加到日志输出中，实现日志的上下文关联。

TraceId（分布式系统中用于唯请求全链路的唯一标识符）

> 通过 traceId，可以将一个请求在不同服务、不同节点、不同线程中的日志串联起来，形成完整的调用链路，方便快速定位问题、分析性能瓶颈或监控系统行为。

## Http 处理

在 SpringMVC 中对于 http 的处理，最常用的是 `HandlerInterceptor` 接口进行实现，在接口处理前存储到 MDC，在接口的后置处理中清空 MDC 上下文，防止内存泄漏

```
java

public class MdcHandlerInterceptor implements HandlerInterceptor {

 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 // 解析token，获取用户唯一标识
 String userId = "123";

 // 接口地址
 String url = request.getRequestURI();

 // 日志处理
 String traceId = request.getHeader(MdcTraceContext.TRACE_HEADER_KEY);
 MdcTraceContext.initTraceId(userId, url, traceId);
 return HandlerInterceptor.super.preHandle(request, response, handler);
 }

 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
 MdcTraceContext.clearTraceId();
 }
}
```

在 WebMvcConfig 中添加上拦截器才可生效

```
java

@Configuration
public class MeWebMvcConfig extends WebMvcConfigurationSupport {

 @Override
 protected void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(new MdcHandlerInterceptor());
 }
}
```

MDC 的上下文内容，可以通过 MdcTraceContext 进行获取和设置

> 看过好多方案，除了定义 MDC 以外还会自己存储一份 ThreadLocal，其实从 MDC 底层来看，MDC 就是 ThreadLocal，所以 MDC 的设置和获取，与自定义 ThreadLocal 没有任何区别，没有必要使用 ThreadLocal 在浪费内存存储一份 traceId。

TraceId 可任意组成，最好带有唯一的识别作用

> 此处 traceId 的构成是使用用户的唯一标识、接口请求的地址和当前请求的唯一标识，这样在日志中，就可以通过不同内容对 traceId 进行链路追踪，方便快速定位问题。

```
java

public class MdcTraceContext {

 /**
 * logback.xml 中全链路标识的占位符
 */
 public static final String TRACE_ID_PATTERN = "traceId";

 /**
 * 请求头的链路Key
 */
 public static final String TRACE_HEADER_KEY = "X-Requested-Id";

 /**
 * 当前操作人的唯一标识
 */
 public static final String $userId = "$userId";

 /**
 * 请求url
 */
 public static final String $url = "$url";

 /**
 * 当前请求的唯一标识
 *
 * 前端添加到请求头中 or 网关生成的uuid 
 */
 public static final String $requestId = "$requestId";

 /**
 * 链路ID
 */
 public static String TRACE_ID = "<" + $userId + "> <" + $url + "> <" + $requestId + ">";

 /**
 * 初始化TraceId
 */
 public static void initTraceId(String userId, String url, String requestId) {
 String traceId = TRACE_ID.replace($userId, StringUtils.isEmpty(userId) ? "" : userId)
 .replace($url, StringUtils.isEmpty(url) ? "" : url)
 .replace($requestId, StringUtils.isEmpty(requestId) ? "" : requestId);
 MDC.put(TRACE_ID_PATTERN, traceId);
 }

 /**
 * 初始化TraceId
 */
 public static void initTraceId(String traceId) {
 MDC.put(TRACE_ID_PATTERN, traceId);
 }

 /**
 * 获取当前TraceId
 */
 public static String getTraceId() {
 return MDC.get(TRACE_ID_PATTERN);
 }

 /**
 * 清除TraceId
 */
 public static void clearTraceId() {
 MDC.remove(TRACE_ID_PATTERN);
 }

 /**
 * 清除底层数据
 */
 public static void clear() {
 MDC.clear();
 }
}
```

其中 logback.xml 的模板配置需要生效必要设置环境变量，以下提供了dev环境的配置 `sppring.profiles.active = dev`，可根据需要自行配置

```
xml

<?xml version="1.0" encoding="UTF-8"?>

<configuration>
 
 <property name="log.path" value="log"/>
 <property name="log.maxHistory" value="15"/>
 <property name="log.colorPattern" value="%magenta(%d{yyyy-MM-dd HH:mm:ss}) %highlight(%-5level) %boldCyan(%X{traceId}) %yellow(%thread) %green(%logger{50}) %msg%n"/>
 <property name="log.pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %X{traceId} %thread %logger{50} %msg%n"/>

 
 <springProfile name="dev">
 
 <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
 <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
 <level>DEBUG</level>
 </filter>
 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
 <FileNamePattern>${log.path}/info.%d{yyyy-MM-dd}.log</FileNamePattern>
 </rollingPolicy>
 <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
 <pattern>${log.colorPattern}</pattern>
 </encoder>
 </appender>

 
 <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
 <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
 <level>DEBUG</level>
 </filter>
 <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
 <pattern>${log.colorPattern}</pattern>
 </encoder>
 </appender>

 
 <logger name="code72" level="DEBUG" additivity="false">
 <appender-ref ref="STDOUT"/>
 <appender-ref ref="FILE"/>
 </logger>

 
 <root level="INFO">
 <appender-ref ref="STDOUT"/>
 <appender-ref ref="FILE"/>
 </root>
 </springProfile>

</configuration>
```

以上内容就实现了Htt请求处理的全链路日志追踪，接下来还有分布式微服务下的处理

## Feign 微服务调用处理

在 Feign 中，对于异步处理的处理，也是通过拦截器进行实现，在请求头中添加上traceId，下一个微服务种即可从执行上面的 Http 处理，从请求头获取 traceId 进行链路追踪。

```
java

@Slf4j
@Component
public class MdcRequestInterceptor extends MdcTraceContext implements RequestInterceptor {

 /**
 * Called for every request. Add data using methods on the supplied {@link RequestTemplate}.
 *
 * @param template
 */
 @Override
 public void apply(RequestTemplate template) {
 if(StringUtils.isNotBlank(getTraceId())){
 template.header(TRACE_HEADER_KEY, getTraceId());
 }else{
 // 本次请求没有traceId，
 log.debug("This request does not have a traceId!");
 }
 }
}
```

## RocketMQ 生产消费端处理

在 RocketMQ 中，需要在发送消息与消费消息的时候添加钩子进行处理，目前在源码中添加钩子的入口不太好找，需要对源码有一定的了解，要从生产者 `DefaultMQProducer` 与消费者 `DefaultMQPushConsumer` 进行拦截处理，具体代码如下：

```
java

@Slf4j
@Component
public class MdcApplicationRunner implements ApplicationContextAware, ApplicationRunner {

 private ApplicationContext applicationContext;

 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 this.applicationContext = applicationContext;
 }

 /**
 * Callback used to run the bean.
 *
 * @param args incoming application arguments
 * @throws Exception on error
 */
 @Override
 public void run(ApplicationArguments args) throws Exception {
 // 注册生产者消息hook
 registerSendMessageHook();
 // 注册消费者消息hook
 registerConsumeMessageHook();
 }

 /**
 * 注册生产者消息hook
 */
 private void registerSendMessageHook(){
 DefaultMQProducer defaultMQProducer = applicationContext.getBean(DefaultMQProducer.class);
 defaultMQProducer.getDefaultMQProducerImpl().registerSendMessageHook(new MdcSendMessageHook());
 log.info("DefaultMQProducer #registerSendMessageHook Success.");
 }

 /**
 * 注册消费者消息hook
 */
 private void registerConsumeMessageHook(){
 Map<String, DefaultRocketMQListenerContainer> beansOfType = applicationContext.getBeansOfType(DefaultRocketMQListenerContainer.class);
 for (DefaultRocketMQListenerContainer defaultRocketMQListenerContainer : beansOfType.values()) {
 defaultRocketMQListenerContainer.getConsumer().getDefaultMQPushConsumerImpl().registerConsumeMessageHook(new MdcConsumeMessageHook());
 log.info("{}:DefaultMQPushConsumer #registerConsumeMessageHook Success.", defaultRocketMQListenerContainer.getRocketMQListener().getClass().getSimpleName());
 }
 }
}
```

版本兼容问题

对于 RocketMQ 的配置，此处我是基于4.9.3版本的调整，在源码 5.1.0 的版本测试，对于其他版本具体需要对查看源码测试核验

### 源码解读

对于 `DefaultRocketMQListenerContainer` 对象，是一个mq监听容器，每个容器对象都是由 `@RocketMQMessageListener` 注释的消费端生成的，由 Spring 容器管理。

![RocketMQMessageListener加载的源码.png](https://blog.liushigong.cn/static/img/762eb1d4ccdda81eb951537bcea7562a.RocketMQMessageListener%C3%A5%C2%8A%C2%A0%C3%A8%C2%BD%C2%BD%C3%A7%C2%9A%C2%84%C3%A6%C2%BA%C2%90%C3%A7%C2%A0%C2%81.webp)

![RocketMQMessageListener注册的源码.png](https://blog.liushigong.cn/static/img/bf42015bd7e94b9383885dc023028c59.RocketMQMessageListener%C3%A6%C2%B3%C2%A8%C3%A5%C2%86%C2%8C%C3%A7%C2%9A%C2%84%C3%A6%C2%BA%C2%90%C3%A7%C2%A0%C2%81.webp)

在容器内部，创建 `DefaultMQPushConsumer` 对象，也就是每个容器都会有一个 `DefaultMQPushConsumer` 对象，所以上述的代码实现中是获取的 `Map<String, DefaultRocketMQListenerContainer>`,然后对每个容器得 `DefaultMQPushConsumer` 都进行添加钩子处理。

![DefaultMQPushConsumer创建对象的源码.png](https://blog.liushigong.cn/static/img/443855c19f504412e662be540dc80eec.DefaultMQPushConsumer%C3%A5%C2%88%C2%9B%C3%A5%C2%BB%C2%BA%C3%A5%C2%AF%C2%B9%C3%A8%C2%B1%C2%A1%C3%A7%C2%9A%C2%84%C3%A6%C2%BA%C2%90%C3%A7%C2%A0%C2%81.webp)

### 生产者钩子

在发送消息前，从请求的本地线程中获取到traceId，并设置到消息的 Property 属性中即可，保证 traceId 会与消息一起传递

```
java

@Slf4j
public class MdcSendMessageHook extends MdcTraceContext implements SendMessageHook {

 @Override
 public String hookName() {
 return MdcSendMessageHook.log.getName();
 }

 @Override
 public void sendMessageBefore(SendMessageContext context) {
 // 从MDC获取TraceId
 if (StringUtils.isNotEmpty(getTraceId())) {
 context.getMessage().putUserProperty(TRACE_HEADER_KEY, getTraceId());
 }
 }

 @Override
 public void sendMessageAfter(SendMessageContext context) {
 // 无需处理
 }
}
```

### 消费者钩子

消费者钩子，在消费消息前，从消息的 Property 中获取到 traceId，并设置到 MDC 的本地线程中，注意消息处理完成后，需要清除 MDC 的本地线程，保证线程池中的线程不会影响其他线程的链路追踪。

```
java

@Slf4j
public class MdcConsumeMessageHook extends MdcTraceContext implements ConsumeMessageHook {

 @Override
 public String hookName() {
 return MdcConsumeMessageHook.class.getName();
 }

 @Override
 public void consumeMessageBefore(ConsumeMessageContext context) {
 List<MessageExt> msgList = context.getMsgList();
 if (!msgList.isEmpty()) {
 // MDC设置TraceId
 initTraceId(msgList.get(0).getProperty(TRACE_HEADER_KEY));
 }
 }

 @Override
 public void consumeMessageAfter(ConsumeMessageContext context) {
 // 清除MDC的TraceId
 clear();
 }
}
```

注意

对于异步执行的线程，当执行完成时，需要执行 `clear()` 方法清除全部缓存信息。

## JUC线程池处理

对于线程池 ThreadPoolExecutor，核心问题在于子线程无法自动获取父线程的MDC内容。

解决方案

使用 **装饰器模式** 包装任务，封装 `Runnable` 或 `Callable`，在任务执行前将父线程的 traceId 传递到子线程的 MDC 中，执行后再清理。

### 装饰 Callable

```
java

@Slf4j
public class MdcCallable<V> extends MdcTraceContext implements Callable<V> {

 private Callable<V> callable;
 private Map<String, String> parentMdc;

 public MdcCallable(Callable<V> callable) {
 this.callable = callable;
 // 捕获父线程的 MDC
 this.parentMdc = MDC.getCopyOfContextMap();
 }

 /**
 * Computes a result, or throws an exception if unable to do so.
 *
 * @return computed result
 * @throws Exception if unable to compute a result
 */
 @Override
 public V call() throws Exception {
 if (parentMdc != null) {
 // 将 MDC 传递给子线程
 MDC.setContextMap(parentMdc);
 parentMdc.clear();
 parentMdc = null;
 }
 try {
 V call = callable.call();
 callable = null;
 return call;
 } finally {
 // 清理子线程的 MDC，避免内存泄漏
 clear();
 }
 }
}
```

### 装饰 Runnable

```
java

@Slf4j
public class MdcRunnable extends MdcTraceContext implements Runnable {

 private Runnable runnable;
 private Map<String, String> parentMdc;

 public MdcRunnable(Runnable runnable) {
 this.runnable = runnable;
 // 捕获父线程的 MDC
 this.parentMdc = MDC.getCopyOfContextMap();
 }

 @Override
 public void run() {
 if (parentMdc != null) {
 // 将 MDC 传递给子线程
 MDC.setContextMap(parentMdc);
 parentMdc.clear();
 parentMdc = null;
 }
 try {
 runnable.run();
 runnable = null;
 } finally {
 // 清理子线程的 MDC，避免内存泄漏
 clear();
 }
 }
}
```

测试示例：

```
java

public void test(){
 ExecutorService executorService = Executors.newFixedThreadPool(50);
 for (int i = 0; i < 10; i++) {
 int finalI = i;
 executorService.submit(new MdcRunnable(() -> log.info("测试 - " + finalI)));
 executorService.submit(new MdcCallable<>(() -> {
 log.info("测试 - " + finalI);
 return "测试 - " + finalI;
 }));
 }
}
```

## Spring 异步线程处理

Spring 默认的线程池同样存在MDC传递的问题。

解决方案

为了确保MDC的上下文能够传递到异步线程，在自定义异步线程池的同时，添加 `TaskDecorator` 装饰处理，

```
java

@Configuration
@EnableAsync
public class AsyncConfig extends AsyncConfigurerSupport {

 @Override
 public Executor getAsyncExecutor() {
 ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
 //线程核心数目
 threadPoolTaskExecutor.setCorePoolSize(5);
 threadPoolTaskExecutor.setAllowCoreThreadTimeOut(true);
 //最大线程数
 threadPoolTaskExecutor.setMaxPoolSize(20);
 //配置队列大小
 threadPoolTaskExecutor.setQueueCapacity(400);
 //配置线程池前缀
 threadPoolTaskExecutor.setThreadNamePrefix("Custom-async-thread-");
 //配置拒绝策略
 threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
 //数据初始化
 threadPoolTaskExecutor.initialize();
 //是否等待所有线程执行完毕才关闭线程池，默认值为false。
 threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);
 //awaitTerminationSeconds：waitForTasksToCompleteOnShutdown的等待的时长，默认值为0，即不等待。
 threadPoolTaskExecutor.setAwaitTerminationSeconds(60);
 // 注入装饰器
 threadPoolTaskExecutor.setTaskDecorator(new MdcTaskDecorator());
 threadPoolTaskExecutor.initialize();
 return threadPoolTaskExecutor;
 }
}
```

```
java

public class MdcTaskDecorator implements TaskDecorator {
 /**
 * Decorate the given {@code Runnable}, returning a potentially wrapped
 * {@code Runnable} for actual execution, internally delegating to the
 * original {@link Runnable#run()} implementation.
 *
 * @param runnable the original {@code Runnable}
 * @return the decorated {@code Runnable}
 */
 @Override
 public Runnable decorate(Runnable runnable) {
 return new MdcRunnable(runnable);
 }
}
```

测试示例：

```
java

@Slf4j
@Service
public class MyService {
 @Async
 public void asyncMethod() {
 log.info("异步方法执行，traceId: {}", MdcTraceContext.getTraceId());
 }
}
```

插件设计 - 全链路日志 TraceId 穿透异步线程与MQ消息

线上性能问题 - 玩转 MAT 分析内存泄漏

在工作过程中，各种性能问题的出现总是让人猝不及防，出现问题不可怕，怕的对于自身解决问题的能力不到位。

其实性能问题总结来说无非两种，一种cpu飙升问题，一种是内存问题。今天就来聊下内存问题中内存泄漏的排查思路。

## 内存泄漏

在工作中一般是如何定位到当前问题是内存泄漏问题呢？

我们首先需要了解什么是内存泄漏，内存泄漏是指无用对象（不再使用的对象）持续占有内存或无用对象的内存得不到及时释放，从而造成内存空间的浪费称为内存泄漏。

造成的现象就是随着垃圾回收器活动的增加以及内存占用的不断增加，程序性能会逐渐表现出来下降，极端情况下，会引发 `java.lang.OutOfMemoryError` 导致程序崩溃。

**内存泄漏的本质** 就是我们常用的虚拟机是使用 **可达性分析** 来判断对象是否可回收，其实现实判断一个对象是否还被引用，如果没有引用则回收。在开发的过程中，由于代码的编写问题就会出现很多种内存泄漏问题，让GC垃圾回收器误以为此对象还在引用中，无法回收，造成内存泄漏。

内存泄漏和内存溢出辨析

* 内存溢出：实实在在的内存空间不足导致；
* 内存泄漏：该释放的对象没有释放，常见于使用容器保存元素的情况下。

## 内存泄漏产生的原因分析

其实产生的原因说到底还是代码编写的问题，总会有各种各样的情况导致内存泄漏，大多数是以下几种情况

### 代码问题导致资源没释放

ThreadLocal 是 Java 中的一个线程局部变量工具，它为每个使用该变量的线程都提供一个独立的变量副本，每个线程都可以独立地改变自己的副本，而不会影响其他线程所对应的副本。不过，若使用不当，ThreadLocal 可能会造成内存泄漏。 ThreadLocal 的底层实现是通过 ThreadLocalMap，ThreadLocal 作为键，存储的值作为值。当线程执行完任务后，如果没有调用 remove() 方法，ThreadLocalMap 中仍然保留着对 BigObject 的引用。由于线程池中的线程是复用的，这些 BigObject 对象不会被垃圾回收，从而导致内存泄漏。

```
java

// 自定义大对象类
class BigObject {
 private final byte[] data = new byte[1024 * 1024]; // 1MB 的数据

 public BigObject() {
 System.out.println("BigObject created");
 }
}

public class ThreadLocalMemoryLeakExample {
 // 创建一个 ThreadLocal 变量
 private static final ThreadLocal<BigObject> threadLocal = new ThreadLocal<>();

 public static void main(String[] args) {
 // 创建一个固定大小的线程池
 ExecutorService executorService = Executors.newFixedThreadPool(2);

 for (int i = 0; i < 10; i++) {
 executorService.submit(() -> {
 // 为当前线程设置 ThreadLocal 变量
 threadLocal.set(new BigObject());

 // 模拟一些业务操作
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }

 // 这里没有调用 threadLocal.remove() 方法

 System.out.println("Task completed");
 });
 }

 // 关闭线程池
 executorService.shutdown();
 }
}
```

### 长生命周期的对象持有短生命周期对象的引用

Lambda 表达式也会捕获外部变量，这类似于匿名内部类持有外部类的引用。若 Lambda 表达式的生命周期较长，就可能造成内存泄漏。

```
java

public class LambdaLeakExample {

 public void startScheduledTask() {
 ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
 // Lambda 表达式
 executor.scheduleAtFixedRate(() -> {
 System.out.println("Value from outer: " + 20);
 }, 0, 1, TimeUnit.SECONDS);
 }

 public static void main(String[] args) {
 LambdaLeakExample example = new LambdaLeakExample();
 example.startScheduledTask();
 // 即使 example 不再被使用，由于 Lambda 表达式持有其引用，example 无法被回收
 example = null;
 }
}
```

### 静态集合类使用不恰当导致内存泄漏

静态集合类（如static List、static Map）的生命周期与应用程序一致。如果在集合中添加了对象，但未及时移除不再使用的对象，这些对象将一直被引用，无法被回收。

```
java

private static List<Object> staticList = new ArrayList<>();
staticList.add(new Object()); // 对象未被移除，长期驻留内存
```

### 资源未关闭造成内存泄漏

平常使用的数据库连接、网络连接和文件IO连接等，只有连接被关闭后，垃圾回收器才会回收对应的对象。

```
java

FileInputStream in = new FileInputStream("file.txt");
// 未调用 in.close()，资源未释放
```

从代码上解决内存泄漏的几种方式

1. 尽量减少使用静态变量，或者使用完及时清空或者赋值为 null。
2. 明确内存对象的有效作用域，尽量缩小对象的作用域，能用局部变量处理的不用成员变量，因为局部变量弹栈会自动回收；
3. 减少长生命周期的对象持有短生命周期的引用；
4. 各种连接（数据库连接，网络连接，文件IO连接）操作，务必显示调用close关闭。
5. 对于不需要使用的对象手动设置null值，不管GC何时会开始清理，我们都应及时的将无用的对象标记为可被清理的对象；

## 内存泄漏的排查思路

这个时候可以根据生产问题的情况进行定位了，首先开始确认是否是内存泄漏问题，它主要表现就是内存不足，接下来开始排查

**1、查询内存情况**

主要分析重点：查找重复出现的自定义类，大数量对象，分析内存空间使用率

```
sh

# 堆内存信息
jcmd <pid> GC.heap_info
```

**2、分析GC运行情况**

主要分析重点：查看Old区、Metaspace使用率，查看 Full GC 次数

```
sh

# 每秒输出GC数据
jstat -gcutil <pid> 1000

# 每2秒打印GC原因
jstat -gccause <pid> 2000

# 强制触发 GC
jcmd <pid> GC.run
```

* S0 — Heap上的 Survivor space 0 区已使用空间的百分比
* S1 — Heap上的 Survivor space 1 区已使用空间的百分比
* E — Heap上的 Eden space 区已使用空间的百分比
* O — Heap上的 Old space 区已使用空间的百分比
* P — Perm space 区已使用空间的百分比
* YGC — 从应用程序启动到采样时发生 Young GC 的次数
* YGCT– 从应用程序启动到采样时 Young GC 所用的时间(单位秒)
* FGC — 从应用程序启动到采样时发生 Full GC 的次数
* FGCT– 从应用程序启动到采样时 Full GC 所用的时间(单位秒)
* GCT — 从应用程序启动到采样时用于垃圾回收的总时间(单位秒)
* LGCC - 进行GC的原因（低版本jdk可能没有这一列）

从这里观察gc是否异常，也可以根据这个进行jvm内存分配调优，来提高性能降低gc对性能的损耗

**3、查看内存占用情况**

把JVM中的对象全部打印出来， 但是这样太多了，那么我们选择前20的对象展示出来，

```
sh

# 堆内存直方图，查看前20条
jcmd <pid> GC.class_histogram | head -20

# 输出到文件
jcmd <pid> GC.class_histogram > histo.txt
```

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

根据以上对象，确认下版本新增代码的改动，尽快从代码上找出问题。在这一步，是快速定位问题的关键，如果根据对象分析出问题所在，那到此也就结果了；如果无法分析出问题，那我们还得继续排查

非内存泄漏问题去调优解决

调优过程：首先确认逻辑问题，查看内存中对象的数量和大小，判断是否在合理的范围，如果在合理的范围内，增大内存配置，调整内存比例就可以了。

**4、导出Dump日志进行分析(优先命令分析，分析不出再导出Dump日志)**

在此之前，优化开启以下参数

```
sh

-XX:+HeapDumpOnOutOfMemoryError 
-XX:OnError 
-XX:+ShowMessageBoxOnError
```

或者使用 jinfo 调整参数，添加 HeapDumpOnOutOfMemoryError

```
sh

jinfo -flag +HeapDumpOnOutOfMemoryError 9356
```

好，这个时候重新跑，我们就能够得到 Dump 日志

JDK提供jhat（JVM Heap Analysis Tool）命令与jmap搭配使用，但是jmap会响应服务性能，此处采用 jcmd 来生成堆转储快照。

```
sql

jcmd <pid> GC.heap_dump ./dump.hprof
```

**5、内存分析工具 - VisualVM 分析Dump**

用于生成堆转储快照（一般称为heapdump或dump文件），接下来我们使用 VisualVM 进行分析

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

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

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

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

VisualVm 属于比较寒酸的工具，基本上跟jmap之类的命令没多少区别，它只是可以事后看，通过dump信息来看，里面没有多少可以做分析的功能。

我们一般都是采用 MAT 进行分析，对于MAT如何分析，请看 【[线上性能问题 - 玩转MAT分析内存泄漏](/post/89)】。