最近需要在同一个类里面调用标注@Async 异步调用。所以,注入的类需要是代理对象。但注入的却不是代理对象
package tk.mybatis.springboot.service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
/**
* 测试依赖注入
* 异步注解不生效问题 测试
* <p>
* 创建代理对象 方法
* org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary(java.lang.Object, java.lang.String, java.lang.Object)
* <p>
* 问题点:为什么@lazy注入的就是代理对象 (理解错误,看着是一个代理对象,但那个对象是错误的)
* 为什么@PostConstruct 方法是在代理对象执行后执行的,但获取的bean却不是代理对象?
*
*
*
* @author liuzh
* @since 2016-01-31 21:42
*/
@Slf4j
@Service
public class TestAsyncService extends AbstractProduce implements ApplicationContextAware, InitializingBean {
@Autowired
private TestAsyncService testAsyncService;
/**
* InitDestroyAnnotationBeanPostProcessor
*/
@PostConstruct
public void init() {
TestAsyncService bean = applicationContext.getBean(TestAsyncService.class);
System.out.println(bean.getClass().getName());
//testAsyncService = bean;
}
@Autowired
public TestAsyncService(@Lazy TestAsyncService testAsyncService) {
System.out.println(testAsyncService.getClass().getName());
if (this.testAsyncService != null) {
System.out.println(this.testAsyncService.getClass().getName());
}
this.testAsyncService = testAsyncService;
}
@Override
public void test() {
TestAsyncService bean = applicationContext.getBean(TestAsyncService.class);
System.out.println(bean.getClass().getName());
System.out.println("======== test {}" + Thread.currentThread().getName());
testAsyncService.testAsync();
}
@Async
public void testAsync() {
System.out.println("=========async test {}" + Thread.currentThread().getName());
System.out.println("async lll");
}
ApplicationContext applicationContext;
@Override
public void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
@Override
public void afterPropertiesSet() throws Exception {
TestAsyncService bean = applicationContext.getBean(TestAsyncService.class);
// testAsyncService = bean;
}
}
我们常用的在本类中注入自己 是循环依赖 可以用 如何解决循环依赖处理
但这上面的方式注入的都是注入的没有进行AOP增强的原始类。
![](https://i-blog.csdnimg.cn/blog_migrate/20b4100823984604b03d4f46c0bf4e30.png)
看起来@Lazy的是增强的,但仔细一看不是。
![](https://i-blog.csdnimg.cn/blog_migrate/d74dd703f0842541a8169eac1cae20d8.png)
@PostConstruct 最后执行但还不是代理类
![](https://i-blog.csdnimg.cn/blog_migrate/17fea372b91fa2f062830778c11cea24.png)
这个方法是增强创建代理类的方法。打断点是最最后执行的