Bean自定义标签解析以及ComponentScan的扫描过程

雨点打透心脏的1/2处 2022-11-02 15:28 167阅读 0赞

解析入口：

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseBeanDefinitions
    -> org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseCustomElement(org.w3c.dom.Element)
    	-> org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseCustomElement(org.w3c.dom.Element, org.springframework.beans.factory.config.BeanDefinition)

## parseCustomElement ##

1.  获取自定义标签的namespace命令空间，例如：http://www.springframework.org/schema/context  
    。
2.  根据命名空间获取NamespaceHandler对象。
3.  调用NamespaceHandler对象的parse()进行解析。

// org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseCustomElement(org.w3c.dom.Element, org.springframework.beans.factory.config.BeanDefinition)
    public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) { 
    	// 获得namespace，如http://www.springframework.org/schema/context
    	String namespaceUri = getNamespaceURI(ele);
    	if (namespaceUri == null) { 
    		return null;
    	}
    	/** * @see DefaultNamespaceHandlerResolver#resolve(java.lang.String) */
    	NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    	if (handler == null) { 
    		error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
    		return null;
    	}
    	/** * @see NamespaceHandlerSupport#parse(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext) */
    	// 开始解析自定义标签
    	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
    }

## resolve ##

1.  获取所有的handlerMappings  
    。
2.  根据namespace从handlerMappings  
    中获得NamespaceHandler。
3.  如果解析器是类名，就通过反射进行实例化，并放入handlerMappings  
    中，第二次使用时就是对象，不再需要实例化了。
4.  调用NamespaceHandler的init()方法进行初始化。

// org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver#resolve
    public NamespaceHandler resolve(String namespaceUri) { 
    	// 获取所有的handlerMappings
    	Map<String, Object> handlerMappings = getHandlerMappings();
    	// 根据key获得value，如org.springframework.context.config.ContextNamespaceHandler
    	Object handlerOrClassName = handlerMappings.get(namespaceUri);
    	if (handlerOrClassName == null) { 
    		return null;
    	}
    	else if (handlerOrClassName instanceof NamespaceHandler) { 
    		// 第二次及后续解析相同的namespace时，就会进入这里，类在下面的else中被缓存了
    		return (NamespaceHandler) handlerOrClassName;
    	}
    	else { 
    		String className = (String) handlerOrClassName;
    		try { 
    			Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
    			if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) { 
    				throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
    						"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
    			}
    			// 实例化NamespaceHandler
    			NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
    			// 调用NamespaceHandler的init()方法
    			namespaceHandler.init();
    			handlerMappings.put(namespaceUri, namespaceHandler);
    			return namespaceHandler;
    		}
    ... ...
    	}
    }

## getHandlerMappings ##

加载所有`META-INF/spring.handlers`中的内容封装为一个Map。

// org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver#getHandlerMappings
    private Map<String, Object> getHandlerMappings() { 
    	Map<String, Object> handlerMappings = this.handlerMappings;
    	// 只初始化一次
    	if (handlerMappings == null) { 
    		synchronized (this) { 
    			handlerMappings = this.handlerMappings;
    			if (handlerMappings == null) { 
    				if (logger.isTraceEnabled()) { 
    					logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
    				}
    				try { 
    					/** * @see DefaultNamespaceHandlerResolver#DEFAULT_HANDLER_MAPPINGS_LOCATION */
    					// 加载所有META-INF/spring.handlers为Properties
    					Properties mappings =
    							PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
    					if (logger.isTraceEnabled()) { 
    						logger.trace("Loaded NamespaceHandler mappings: " + mappings);
    					}
    					handlerMappings = new ConcurrentHashMap<>(mappings.size());
    					// 将Properties的内容转化为Map
    					CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
    					this.handlerMappings = handlerMappings;
    				}
    				catch (IOException ex) { 
    					throw new IllegalStateException(
    							"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
    				}
    			}
    		}
    	}
    	return handlerMappings;
    }

下面来看下`META-INF/spring.handlers`的内容是什么，这里以spring-context为例，spring的其他jar下面也有这个文件：

http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler
    http\://www.springframework.org/schema/jee=org.springframework.ejb.config.JeeNamespaceHandler
    http\://www.springframework.org/schema/lang=org.springframework.scripting.config.LangNamespaceHandler
    http\://www.springframework.org/schema/task=org.springframework.scheduling.config.TaskNamespaceHandler
    http\://www.springframework.org/schema/cache=org.springframework.cache.config.CacheNamespaceHandler

## init ##

NamespaceHandler的init()只是往往父类的parsers属性中添加各种解析器  
，方便后续parse时使用。

// org.springframework.context.config.ContextNamespaceHandler#init
    public void init() { 
    	// 往父类的parsers属性中添加各种解析器
    	registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
    	registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
    	registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
    	registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
    	registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
    	registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    	registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
    	registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
    }

## NamespaceHandler\#parse ##

根据localName获得具体的解析器BeanDefinitionParser：

public BeanDefinition parse(Element element, ParserContext parserContext) { 
    	// ComponentScanBeanDefinitionParser
    ，根据名字获得具体的解析器
    	BeanDefinitionParser parser = findParserForElement(element, parserContext);
    	/** * @see org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext) */
    	return (parser != null ? parser.parse(element, parserContext) : null);
    }
    
    private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) { 
    	// localName为context:component-scan中的component-scan
    	String localName = parserContext.getDelegate().getLocalName(element);
    	// parsers这个属性一般是前面调用NamespaceHandler.init()时添加的
    	BeanDefinitionParser parser = this.parsers.get(localName);
    	if (parser == null) { 
    		parserContext.getReaderContext().fatal(
    				"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
    	}
    	return parser;
    }

## BeanDefinitionParser\#parse ##

这里以ComponentScanBeanDefinitionParser为例，来研究component-scan是怎么扫描的：

// org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse
    public BeanDefinition parse(Element element, ParserContext parserContext) { 
    	// 获得base-package指定的包名
    	String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
    	basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
    	// base-package中可能有多个，用逗号分隔，转换为数组
    	String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
    			ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
    
    	// Actually scan for bean definitions and register them.
    	// 创建扫描器
    	ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
    	// 开始扫描
    	Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
    
    
    	// 注册了一些组件
    	// ConfigurationClassPostProcessor
    	// AutowiredAnnotationBeanPostProcessor
    	// CommonAnnotationBeanPostProcessor
    	// EventListenerMethodProcessor
    	// DefaultEventListenerFactory
    	registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
    
    	return null;
    }

## doScan ##

开始扫描：

// org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) { 
    	Assert.notEmpty(basePackages, "At least one base package must be specified");
    	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
    	for (String basePackage : basePackages) { 
    		// 查找basePackage下所有被@Component注解修饰了的类
    		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
    		for (BeanDefinition candidate : candidates) { 
    			// 上面findCandidateComponents只是为BD设置了几个属性，BD的其他属性并没有初始化，所以需要遍历一次初始化属性并注册到registry
    			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
    			candidate.setScope(scopeMetadata.getScopeName());
    			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
    			if (candidate instanceof AbstractBeanDefinition) { 
    				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
    			}
    			if (candidate instanceof AnnotatedBeanDefinition) { 
    				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
    			}
    			if (checkCandidate(beanName, candidate)) { 
    				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
    				definitionHolder =
    						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    				beanDefinitions.add(definitionHolder);
    				// 注册到registry
    				registerBeanDefinition(definitionHolder, this.registry);
    			}
    		}
    	}
    	return beanDefinitions;
    }

## scanCandidateComponents ##

查找basePackage下所有被@Component注解修饰了的类  
：

// org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents
    private Set<BeanDefinition> scanCandidateComponents(String basePackage) { 
    	Set<BeanDefinition> candidates = new LinkedHashSet<>();
    	try { 
    		String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
    				resolveBasePackage(basePackage) + '/' + this.resourcePattern;
    		Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
    		boolean traceEnabled = logger.isTraceEnabled();
    		boolean debugEnabled = logger.isDebugEnabled();
    		for (Resource resource : resources) { 
    			if (traceEnabled) { 
    				logger.trace("Scanning " + resource);
    			}
    			if (resource.isReadable()) { 
    				try { 
    					// 使用ASM将class文件的内容封装为MetadataReader对象
    					// 注意这里用的不是反射，反射会加载类，占用堆空间
    					MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
    					// 判断类是否包含@Component注解
    					if (isCandidateComponent(metadataReader)) { 
    						// 封装为BD
    						ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
    						sbd.setSource(resource);
    						if (isCandidateComponent(sbd)) { 
    							if (debugEnabled) { 
    								logger.debug("Identified candidate component class: " + resource);
    							}
    							candidates.add(sbd);
    						}
    ... ...
    	return candidates;
    }

## registerAnnotationConfigProcessors ##

注册了多种重要的组件：

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    		BeanDefinitionRegistry registry, @Nullable Object source) { 
    
    	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    	if (beanFactory != null) { 
    		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) { 
    			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
    		}
    		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) { 
    			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
    		}
    	}
    
    	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
    
    	// BeanFactoryPostProcessor
    	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
    		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
    		def.setSource(source);
    		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    	}
    
    	// BeanPostProcessor
    	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
    		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
    		def.setSource(source);
    		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    	}
    
    	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
    		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
    		def.setSource(source);
    		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    	}
    
    	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
    		RootBeanDefinition def = new RootBeanDefinition();
    		try { 
    			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
    					AnnotationConfigUtils.class.getClassLoader()));
    		}
    		catch (ClassNotFoundException ex) { 
    			throw new IllegalStateException(
    					"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
    		}
    		def.setSource(source);
    		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    	}
    
    	// BeanFactoryPostProcessor
    	if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) { 
    		RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
    		def.setSource(source);
    		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    	}
    
    	if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) { 
    		RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
    		def.setSource(source);
    		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    	}
    
    	return beanDefs;
    }

## 总结 ##

### BeanDefinition的各种类型： ###

*  经过解析XML注入的BeanDefinition的类型为GenericBeanDefinition。
 *  经过ComponentScan扫描注入的BeanDefinition的类型为ScannedGenericBeanDefinition。

### bean标签 ###

XML值的bean元素解析后会被封装为一个BeanDefinition对象，所以BeanDefinition对象会有一个属性来存储bean元素中的属性。

bean标签的属性总结：

*  id：Bean的唯一标识名。它必须是合法的XMLID，在整个XML文档中唯一。
 *  name：用来为id创建一个或多个别名。它可以是任意的字母符合。多个别名之间用逗号或空格分开。
 *  class:用来定义类的全限定名（包名＋类名）。只有子类Bean不用定义该属性。
 *  parent:子类Bean定义它所引用它的父类Bean。这时前面的class属性失效。子类Bean会继承父类Bean的所有属性，子类Bean也可以覆盖父类Bean的属性。注意：子类Bean和父类Bean是同一个Java类。
 *  abstract（默认为”false”）：用来定义Bean是否为抽象Bean。它表示这个Bean将不会被实例化，一般用于父类Bean，因为父类Bean主要是供子类Bean继承使用。
 *  singleton（默认为“true”）：定义Bean是否是Singleton（单例）。如果设为“true”,则在BeanFactory作用范围内，只维护此Bean的一个实例。如果设为“flase”，Bean将是Prototype（原型）状态，BeanFactory将为每次Bean请求创建一个新的Bean实例。
 *  lazy-init（默认为“default”）：用来定义这个Bean是否实现懒初始化。如果为“true”，它将在BeanFactory启动时初始化所有的SingletonBean。反之，如果为“false”，它只在Bean请求时才开始创建SingletonBean。
 *  autowire（自动装配，默认为“default”）：它定义了Bean的自动装载方式。
    
     *  “no”:不使用自动装配功能。
     *  “byName”:通过Bean的属性名实现自动装配。
     *  “byType”:通过Bean的类型实现自动装配。
     *  “constructor”:类似于byType，但它是用于构造函数的参数的自动组装。
     *  “autodetect”:通过Bean类的反省机制（introspection）决定是使用“constructor”还是使用“byType”。
 *  dependency-check（依赖检查，默认为“default”）：它用来确保Bean组件通过JavaBean描述的所以依赖关系都得到满足。在与自动装配功能一起使用时，它特别有用。
    
     *  none：不进行依赖检查。
     *  objects：只做对象间依赖的检查。
     *  simple：只做原始类型和String类型依赖的检查
     *  all：对所有类型的依赖进行检查。它包括了前面的objects和simple。
 *  depends-on（依赖对象）：这个Bean在初始化时依赖的对象，这个对象会在这个Bean初始化之前创建。
 *  init-method:用来定义Bean的初始化方法，它会在Bean组装之后调用。它必须是一个无参数的方法。
 *  destroy-method：用来定义Bean的销毁方法，它在BeanFactory关闭时调用。同样，它也必须是一个无参数的方法。它只能应用于singletonBean。
 *  factory-method：定义创建该Bean对象的工厂方法。它用于下面的“factory-bean”，表示这个Bean是通过工厂方法创建。此时，“class”属性失效。
 *  factory-bean:定义创建该Bean对象的工厂类。如果使用了“factory-bean”则“class”属性失效。
 *  autowire-candidate：采用xml格式配置bean时，将元素的autowire-candidate属性设置为false，这样容器在查找自动装配对象时，将不考虑该bean，即它不会被考虑作为其它bean自动装配的候选者，但是该bean本身还是可以使用自动装配来注入其它bean的。

### Spring SPI与Java SPI的区别 ###

*  Java中的SPI，文件名即接口，文件中的内容为接口的实现类，文件内容中的所有类都会被加载。
 *  Spring中的SPI，文件中内容为key-value格式，可以实现不同接口的类放在一个文件中，还可以按需加载，节省内存。