SpringAop (二、AOP源码解析之创建 BeanDefinition)

╰半橙微兮° 2021-11-10 21:38 269阅读 0赞

还是从Spring Boot 自动配置开始看。

spring.factories# Auto Configure
    org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\

# AopAutoConfiguration #

@Configuration
    @ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class,
    		AnnotatedElement.class })
    @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
    public class AopAutoConfiguration {
    
    	@Configuration
    	@EnableAspectJAutoProxy(proxyTargetClass = false)
    	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false)
    	public static class JdkDynamicAutoProxyConfiguration {
    
    	}
    
    	@Configuration
    	@EnableAspectJAutoProxy(proxyTargetClass = true)
    	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true)
    	public static class CglibAutoProxyConfiguration {
    
    	}
    
    }

首先看到的是注解：`@ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class, AnnotatedElement.class })`  
其次我们看到，下面有两个内部类：`JdkDynamicAutoProxyConfiguration` 以及 `CglibAutoProxyConfiguration`？？这不是代理吗，JDK代理以及Cglib代理？所以可以猜测，AOP原理是依靠动态代理实现的。

一步一步来。先看`EnableAspectJAutoProxy`

# EnableAspectJAutoProxy #

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(AspectJAutoProxyRegistrar.class)
    public @interface EnableAspectJAutoProxy {
    
    	/**
    	 * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
    	 * to standard Java interface-based proxies. The default is {@code false}.
    	 */
    	boolean proxyTargetClass() default false;
    
    	/**
    	 * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
    	 * for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
    	 * Off by default, i.e. no guarantees that {@code AopContext} access will work.
    	 * @since 4.3.1
    	 */
    	boolean exposeProxy() default false;
    
    }

## AspectJAutoProxyRegistrar ##

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    
    	/**
    	 * Register, escalate, and configure the AspectJ auto proxy creator based on the value
    	 * of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing
    	 * {@code @Configuration} class.
    	 */
    	@Override
    	public void registerBeanDefinitions(
    			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    		// 注册
    		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
    
    		AnnotationAttributes enableAspectJAutoProxy =
    				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
    		if (enableAspectJAutoProxy != null) {
    			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
    				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
    			}
    			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
    				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
    			}
    		}
    	}

### registerOrEscalateApcAsRequired ###

/**
    	 * The bean name of the internally managed auto-proxy creator.
    	 */
    	public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
    			"org.springframework.aop.config.internalAutoProxyCreator";
    			
    	@Nullable
    	private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry,
    			@Nullable Object source) {
    			
    		// 判断BeanDefinitionRegistry 是否为null
    		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    		
    		// 判断beanDefinitionMap 中是否存在 key"org.springframework.aop.config.internalAutoProxyCreator"
    		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
    			
    			// 获取BeanDefinition 实例
    			BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
    			
    			// 判断类名是否 和 BeanDefinition中类名相同
    			if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
    			
    				// 获取 并 判断 类的优先级，并保存优先级高的
    				int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
    				int requiredPriority = findPriorityForClass(cls);
    				
    				if (currentPriority < requiredPriority) {
    					// 将 BeanDefinition实例类名 设置为 cls的类名
    					apcDefinition.setBeanClassName(cls.getName());
    				}
    			}
    			return null;
    		}
    
    		// 创建beanDefinition 实例，并进行参数赋值
    		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    		beanDefinition.setSource(source);
    		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    
    		// 向容器中注册代理构建器的BeanDefinition对象
    		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    		return beanDefinition;
    	}

#### registerBeanDefinition ####

//---------------------------------------------------------------------
    	// Implementation of BeanDefinitionRegistry interface
    	//---------------------------------------------------------------------
    
    	@Override
    	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    			throws BeanDefinitionStoreException {
    		// 判断参数是否为null
    		Assert.hasText(beanName, "Bean name must not be empty");
    		Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    
    		// 强转
    		if (beanDefinition instanceof AbstractBeanDefinition) {
    			try {
    				((AbstractBeanDefinition) beanDefinition).validate();
    			}
    			catch (BeanDefinitionValidationException ex) {
    				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    						"Validation of bean definition failed", ex);
    			}
    		}
    
    		BeanDefinition oldBeanDefinition;
    
    		// 根据BeanName 获取 BeanDefinition实例
    		oldBeanDefinition = this.beanDefinitionMap.get(beanName);
    		
    		// 判断当前oldBeanDefinition 不为空的话
    		if (oldBeanDefinition != null) {
    			
    			// 是否允许ID相同的Bean覆盖，不指定时默认为true
    			if (!isAllowBeanDefinitionOverriding()) {
    				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
    						"': There is already [" + oldBeanDefinition + "] bound.");
    			}
    			// 判断 BeanDefinition 的 级别(Role)
    			else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
    				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
    				if (this.logger.isWarnEnabled()) {
    					this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
    							"' with a framework-generated bean definition: replacing [" +
    							oldBeanDefinition + "] with [" + beanDefinition + "]");
    				}
    			}
    
    			// 判断两个Bean 是否相同
    			else if (!beanDefinition.equals(oldBeanDefinition)) {
    				if (this.logger.isInfoEnabled()) {
    					this.logger.info("Overriding bean definition for bean '" + beanName +
    							"' with a different definition: replacing [" + oldBeanDefinition +
    							"] with [" + beanDefinition + "]");
    				}
    			}
    			
    			// 判断当前是否启用调试日志记录
    			else {
    				if (this.logger.isDebugEnabled()) {
    					this.logger.debug("Overriding bean definition for bean '" + beanName +
    							"' with an equivalent definition: replacing [" + oldBeanDefinition +
    							"] with [" + beanDefinition + "]");
    				}
    			}
    
    			// 将 beanDefinition 加入到 beanDefinitionMap中
    			this.beanDefinitionMap.put(beanName, beanDefinition);
    		}
    
    		// 判断当前oldBeanDefinition 为空的话
    		else {
    			
    			// 检查该工厂的bean创建阶段是否已经开始，即是否同时将任何bean标记为已创建
    			if (hasBeanCreationStarted()) {
    				// Cannot modify startup-time collection elements anymore (for stable iteration)
    				synchronized (this.beanDefinitionMap) {
    					this.beanDefinitionMap.put(beanName, beanDefinition);
    					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
    					updatedDefinitions.addAll(this.beanDefinitionNames);
    					updatedDefinitions.add(beanName);
    
    					// 更新beanName
    					this.beanDefinitionNames = updatedDefinitions;
    					if (this.manualSingletonNames.contains(beanName)) {
    						Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
    						updatedSingletons.remove(beanName);
    						this.manualSingletonNames = updatedSingletons;
    					}
    				}
    			}
    			// 如果没开始创建
    			else {
    				// 将 beanDefinition 加入 beanDefinitionMap 中
    				// Still in startup registration phase
    				this.beanDefinitionMap.put(beanName, beanDefinition);
    				this.beanDefinitionNames.add(beanName);
    				this.manualSingletonNames.remove(beanName);
    			}
    			this.frozenBeanDefinitionNames = null;
    		}
    		
    		// 如果有同名的bean，重置
    		if (oldBeanDefinition != null || containsSingleton(beanName)) {
    			resetBeanDefinition(beanName);
    		}
    	}

在上述代码中，一直出现了一个beanDefinitionMap。

/** Map of bean definition objects, keyed by bean name */
    	// bean定义对象的映射，由beanName 作为key，BeanDefinition作为 value 。且初始容量为 256
    	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

ok上述 说完了 `EnableAspectJAutoProxy.class`，我们已经成功创建BeanDefinition，并将其放进 beanDefinitionMap 中。有点像IOC啊。。那下一步，我们应该[获取Bean][Bean]了吧。

[Bean]: https://blog.csdn.net/java_yes/article/details/98209495