代码
java
public abstract class AbstractSyncTaskHandler implements SyncTaskHandler, BeanSelfAware {
protected AbstractSyncTaskHandler self;
/**
* 注入自身对象.
*
* @param proxyBean 代理bean
*/
@Override
public void setSelf(Object proxyBean) {
self = (AbstractSyncTaskHandler) proxyBean;
}
@Override
public void batchExecute(List<SyncTaskBO> syncTaskBOs, SyncTaskJobParamConfig syncTaskJobParamConfig) throws InterruptedException {
List<SyncTaskBO> syncTaskBOS = self.refreshSyncTask(syncTaskBOs, syncTaskJobParamConfig);
// 任务执行时间较长且并发较高的情况, 可能会出现上下文中日志记录文件错误的情况
XxlJobContext xxlJobContext = XxlJobContext.getXxlJobContext();
CountDownLatch countDownLatch = new CountDownLatch(syncTaskBOS.size());
List<SyncTaskContext> contexts = CollUtil.newArrayList();
syncTaskBOS.forEach(syncTaskBO -> {
customerThreadPool.getSyncTaskPool().execute(() -> {
XxlJobContext.setXxlJobContext(xxlJobContext);
SyncTaskContext context = new SyncTaskContext();
contexts.add(context);
context.setSyncTaskBO(syncTaskBO);
// 处理前置逻辑
beforeExecute(context);
boolean result = self.execute(context, syncTaskJobParamConfig);
// 处理后置逻辑
if (result) {
afterExecute(context);
}
XxlJobContext.setXxlJobContext(null);
countDownLatch.countDown();
});
});
countDownLatch.await();
batchMessageRule(contexts, syncTaskJobParamConfig);
}
@XLock(prefix = "ORDER_CENTER_REFRESH_TASK", keys = {"#syncTaskBOs[0].orderType", "#syncTaskBOs[0].type", "#syncTaskBOs[0].syncSystem", "#syncTaskJobParamConfig.handlerSuffix", "#syncTaskJobParamConfig.orderSources"},
waitTime = 30, leaseTime = 30, errorMessage = "任务执行中，请勿重复执行")
public List<SyncTaskBO> refreshSyncTask(List<SyncTaskBO> syncTaskBOs, SyncTaskJobParamConfig syncTaskJobParamConfig) {
@XLock(prefix = "ORDER_CENTER", keys = {"#context.syncTaskBO.orderType", "#context.syncTaskBO.referenceId"}, waitTime = 30, leaseTime = 30, errorMessage = "任务执行中，请勿重复执行")
@Override
public boolean execute(SyncTaskContext context, SyncTaskJobParamConfig syncTaskJobParamConfig) {疑问
为什么不通过这种方式注入
@Resource
protected AbstractSyncTaskHandler self;为什么不通过 @Resource 注入自身
这是一个很好的问题。虽然表面上看起来使用 `@Resource` 注入自身更简洁，但实际上存在多个技术和设计层面的问题：
1. Spring容器循环依赖问题
1.1 自注入会导致循环依赖
```java
@Component
public class AbstractSyncTaskHandler {
@Resource
protected AbstractSyncTaskHandler self; // 自身依赖自身 - 循环依赖
// ...
}
```
1.2 Spring处理循环依赖的限制
-
Spring默认只能解决单例Bean之间的setter循环依赖
-
构造器循环依赖会导致启动失败
-
自注入属于极端的循环依赖情况
2. 代理对象与原始对象的区别
2.1 代理对象的特殊性
```java
// Spring创建的结构：
// 原始Bean: AbstractSyncTaskHandler (实际业务逻辑)
// 代理Bean: Proxy (包含AOP增强逻辑)
// 如果使用@Resource注入自身：
@Resource
protected AbstractSyncTaskHandler self;
// 注入的可能是原始对象，而不是代理对象
// 这样AOP注解(@XLock)仍然不会生效
```
2.2 自注入机制的优势
```java
// 通过setSelf方式：
@Override
public void setSelf(Object proxyBean) {
self = (AbstractSyncTaskHandler) proxyBean; // 确保获得的是代理对象
}
```
3. 抽象类的特殊性
3.1 抽象类无法直接实例化
```java
// AbstractSyncTaskHandler是抽象类
public abstract class AbstractSyncTaskHandler implements SyncTaskHandler, BeanSelfAware {
// ...
}
// @Resource无法直接注入抽象类实例
```
3.2 实际注入的是具体子类
```java
// 实际运行时，注入的是具体子类的代理对象
// 如: SalesCreateSyncTaskHandler的代理对象
```
4. Spring生命周期考虑
4.1 Bean创建时机问题
```java
// 使用@Resource方式可能在Bean完全初始化前就尝试注入
// 导致注入失败或注入不完整的Bean
// 而setSelf在Bean完全初始化后由容器调用
// 确保注入的是完整可用的代理对象
```
5. 设计模式对比
5.1 @Resource方式的问题
```java
@Component
public abstract class AbstractSyncTaskHandler {
@Resource
protected AbstractSyncTaskHandler self; // 问题：可能注入原始对象而非代理对象
public void methodA() {
// AOP注解可能不生效
}
public void methodB() {
self.methodA(); // 可能绕过AOP
}
}
```
5.2 setSelf方式的优势
```java
@Component
public abstract class AbstractSyncTaskHandler implements BeanSelfAware {
protected AbstractSyncTaskHandler self; // 由容器在适当时机注入代理对象
@Override
public void setSelf(Object proxyBean) {
// 确保注入的是Spring代理对象
self = (AbstractSyncTaskHandler) proxyBean;
}
@XLock(...)
public void methodA() {
// AOP注解生效
}
public void methodB() {
self.methodA(); // 通过代理调用，AOP生效
}
}
```
6. 实际验证
如果尝试使用 `@Resource` 注入自身，很可能会遇到以下问题：
-
Spring启动时报循环依赖错误
-
注入的不是代理对象，导致AOP失效
-
抽象类无法直接注入的问题
总结
使用 [setSelf](file://C:\Users\NLDS\workspace\cloud-order\order-portal\src\main\java\com\cloud\order\sync\handler\AbstractSyncTaskHandler.java#L465-L468) 方法而非 `@Resource` 注入自身的原因：
-
**避免循环依赖**：防止Spring容器启动时出现循环依赖问题
-
**确保代理对象**：保证获得的是包含AOP增强的代理对象而非原始对象
-
**生命周期控制**：在Bean完全初始化后才进行注入
-
**抽象类兼容性**：正确处理抽象类的注入问题
-
**设计模式标准**：这是Spring框架推荐的处理同类调用AOP失效的标准解决方案
这是Spring生态系统中解决AOP代理调用问题的成熟方案，具有良好的可靠性和可维护性。