带我的粉丝们一起揭秘spring aop底层原理及实现
Posted Java架构没有996
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了带我的粉丝们一起揭秘spring aop底层原理及实现相关的知识，希望对你有一定的参考价值。
实在是不知道写什么了，博主变low了呀。spring aop使得我们的aop开发工作变得简单，这是众所周知的
今天还是带我的粉丝们一起揭秘spring aop底层原理及实现吧 哈哈哈哈
AOP面向切面编程：主要是通过切面类来提高代码的复用，降低业务代码的耦合性，从而提高开发效率。主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
-
AOP实现原理：aop是通过cglib的动态代理实现的。
-
jdk动态代理：利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
-
cglib动态代理：将代理对象类的class文件加载进来，通过ASM字节码技术修改其字节码生成子类来处理。
区别：JDK动态代理只能对实现了接口的类生成代理，而不能针对类 。CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法 。因为是继承，所以该类或方法最好不要声明成final ，final可以阻止继承和多态。【参考文献】
使用
要分析spring aop的底层原理，首先要会使用，先创建一个普通maven webapp项目，引入spring-context依赖，版本为5.1.1RELEASE
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.1.RELEASE</version>
</dependency>
然后我使用aspectj作为aop的语法实现，和spring整合起来
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
接下来我全称用注解的形式来模拟spring aop的使用，先创建一个配置类去扫描包，开启aspectJ的自动代理支持
@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.ww")
public class Wconfig {
}
然后新建一个接口和接口的实现类
public interface Dao {
void query();
}
@Component
public class IndexDao implements Dao{
@Override
public void query() {
System.out.println("query......");
}
}
创建切面
//代表是一个切面
@Aspect
@Component
public class WAspect {
/**
* execution表达式，可以百度写法
*/
@Pointcut("execution(* com.ww.dao.*.*(..))")
public void point(){
}//加入Java开发交流君样：756584822一起吹水聊天
/**
* 在切点上进行前置通知
*/
@Before("point()")
public void beforeAd(){
System.out.println("before-------------");
}
}
创建测试方法
public class TestAspect {
public static void main(String[] args) {
AnnotationConfigApplicationContext configApplicationContext = new AnnotationConfigApplicationContext(Wconfig.class);
Dao dao = configApplicationContext.getBean(Dao.class);
dao.query();
}
}
执行方法，可以看到在打印query…之前打印了before----------
这个时候我们很想知道为什么这句before会打印在query之前呢，稍微对spring aop有所了解的人应该知道，spring是通过动态代理和字节码技术来实现aop操作的，也就是经常说的jdk动态代理和cglib动态代理两种模式，那么，spring究竟是怎么创建的代理对象，又是什么时候产生的代理对象呢，下面我们来一起探究一下源码，来揭开这个谜底【参考文献】
源码分析
首先我们透过现象看本质，我先把断点打在测试方法的最后一行，我们来看这个时候的dao对象
那么接下来我们就要去找到什么时候这个dao对象变成了动态代理对象的，既然在最后一行的时候对象已经变成了代理对象，那么我门自然就猜想是在上一句代码的位置spring执行了创建代理对象的操作，我们把断点移到上一行，debug进去
这行代码我看方法名觉得应该是有用的代码，方法意思应该是spring处理好的bean，跟进去看看\\
@Nullable
private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
//这行代码最有用，处理有beanName的bean，debug进入看一下
NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull);
if (namedBean != null) {
return namedBean.getBeanInstance();
}
BeanFactory parent = getParentBeanFactory();
if (parent instanceof DefaultListableBeanFactory) {
return ((DefaultListableBeanFactory) parent).resolveBean(requiredType, args, nonUniqueAsNull);
}
else if (parent != null) {
ObjectProvider<T> parentProvider = parent.getBeanProvider(requiredType);
if (args != null) {
return parentProvider.getObject(args);
}
else {
return (nonUniqueAsNull ? parentProvider.getIfUnique() : parentProvider.getIfAvailable());
}
}
return null;
}//加入Java开发交流君样：756584822一起吹水聊天
@SuppressWarnings("unchecked")
@Nullable
private <T> NamedBeanHolder<T> resolveNamedBean(
ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException {
Assert.notNull(requiredType, "Required type must not be null");
Class<?> clazz = requiredType.getRawClass();
Assert.notNull(clazz, "Required type must have a raw Class");
//候选name列表，直觉告诉我这行代码比较重要
String[] candidateNames = getBeanNamesForType(requiredType);
if (candidateNames.length > 1) {
List<String> autowireCandidates = new ArrayList<>(candidateNames.length);
for (String beanName : candidateNames) {
if (!containsBeanDefinition(beanName) || getBeanDefinition(beanName).isAutowireCandidate()) {
autowireCandidates.add(beanName);
}
}
if (!autowireCandidates.isEmpty()) {
candidateNames = StringUtils.toStringArray(autowireCandidates);
}
}
//因为我的代码里只有一个bean，所以我觉得应该会执行这里的代码
if (candidateNames.length == 1) {
String beanName = candidateNames[0];
return new NamedBeanHolder<>(beanName, (T) getBean(beanName, clazz, args));
}//加入Java开发交流君样：756584822一起吹水聊天
else if (candidateNames.length > 1) {
Map<String, Object> candidates = new LinkedHashMap<>(candidateNames.length);
for (String beanName : candidateNames) {
if (containsSingleton(beanName) && args == null) {
Object beanInstance = getBean(beanName);
candidates.put(beanName, (beanInstance instanceof NullBean ? null : beanInstance));
}
else {
candidates.put(beanName, getType(beanName));
}
}
String candidateName = determinePrimaryCandidate(candidates, clazz);
if (candidateName == null) {
candidateName = determineHighestPriorityCandidate(candidates, clazz);
}
if (candidateName != null) {
Object beanInstance = candidates.get(candidateName);
if (beanInstance == null || beanInstance instanceof Class) {
beanInstance = getBean(candidateName, clazz, args);
}
return new NamedBeanHolder<>(candidateName, (T) beanInstance);
}
if (!nonUniqueAsNull) {
throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
}
}
return null;
}
执行完getBeanNamesForType(requiredType)后，我们看idea的变量显示，果然有一个bean，name是IndexDao
那么接下来自然会进到length==1的那个代码块，这时候我再debug进入，这里还是一个getBean方法【参考文献】
在spring容器中还有一些没有name的其他的bean需要被创建，所以这里我用上了条件断点，当beanName等于indexDao的时候，才会进入断点，但是当我F8跑完这行代码的时候，出乎意料的事情发生了
惊不惊喜，意不意外，getSingleton这行代码执行结束之后，代理对象就已经被创建了，所以需要debug进入这行代码去看
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//spring所有的bean被放在ioc容器中的地方，就是这个singletonObjects，这是一个concorrentHashMap。
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}//加入Java开发交流君样：756584822一起吹水聊天
}
}
}
return singletonObject;
}
但是我在这里只看到了get方法，那么这些bean是什么时候放到singletonObjects里的呢，我来找找
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
在DefaultSingletonBeanRegistry注册器中，我找到了singletonObjects.put方法，代表bean是这个时候被放到这个map里去的，接下来我在这行代码上进行条件断点，然后我们来看它的调用链，找出是什么时候执行的addSingleton方法，其实从这个时候我已经知道，断点打在测试方法的倒数第二行是不对的，在getBean之前其实代理对象已经产生了
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//创建bean，核心代码
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}//加入Java开发交流君样：756584822一起吹水聊天
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
在createBean方法上，我也加上条件断点，然后debug进入
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
//加入Java开发交流君样：756584822一起吹水聊天
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//核心代码，创建bean实例，需要断点进入
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
接下来我debug进入doCreateBean方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
//加入Java开发交流君样：756584822一起吹水聊天
// Initialize the bean instance.
//重要的部分从这里开始
//暴露的bean实例
Object exposedObject = bean;
try {
//填充bean，这个方法也很重要，但是和aop无关，这次不细讲
populateBean(beanName, mbd, instanceWrapper);
//初始化bean，重要方法，需要debug跟进
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
以上是关于带我的粉丝们一起揭秘spring aop底层原理及实现的主要内容，如果未能解决你的问题，请参考以下文章