发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

一、从头开始

SpringMvc会通过DispatcherServlet来处理所有的请求，展开这个方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        AsyncExecutionChain asyncChain = AsyncExecutionChain.getForCurrentRequest(request);
        try {
            ModelAndView mv = null;
            Exception dispatchException = null;
            try {
                processedRequest = checkMultipart(request);
                // 确定当前请求的处理器（HandlerExecutionChain 包含Handler和Interceptor列表）
                mappedHandler = getHandler(processedRequest, false);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);//404异常
                    return;
                }
                // 确定当前请求的处理器适配器
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
                //......省略诸多代码......
                // 调用处理处理器方法，返回ModelAndView对象
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
            }//处理返回结果
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
    }

下面展开getHandler是怎么做的：

阅读全文 »

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

一、从@AutoWaired开始

在@AutoWaired中有下面的一段代码，其中populateBean负责属性的加载。而initializeBean完成属性属性加载后的自定义操作。

1
2
3
4
5
6
7
Object exposedObject = bean;
        try {
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }

来看一下initializeBean的实现。

阅读全文 »

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

一、解析类

通常如果我们希望通过注解的方式来进行Spring MVC开发，我们都会在*-servlet.xml中加入标签来告诉Spring我们的目的。找到对应的实现类是org.springframework.web.servlet.config.AnnotationDrivenBeanDefinitionParser。
通过阅读类注释文档，我们发现这个类主要是用来向工厂中注册了

1
2
3
4
5
6
7
8
RequestMappingHandlerMapping 
BeanNameUrlHandlerMapping
RequestMappingHandlerAdapter
HttpRequestHandlerAdapter
SimpleControllerHandlerAdapter
ExceptionHandlerExceptionResolver 
ResponseStatusExceptionResolver 
DefaultHandlerExceptionResolver

前两个是HandlerMapping接口的实现类，用来处理请求映射的。其中第一个是处理@RequestMapping注解的。第二个会将controller类的名字映射为请求url。

中间三个是用来处理请求的。具体点说就是确定调用哪个controller的哪个方法来处理当前请求。第一个处理@Controller注解的处理器，支持自定义方法参数和返回值（很酷）。第二个是处理继承HttpRequestHandler的处理器。第三个处理继承自Controller接口的处理器。

后面三个是用来处理异常的解析器。

阅读全文 »

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2015/05/21/Spring MVC 之 @Autowired/

访问原文「Spring MVC 之 @Autowired」

一、准备工作

POJO类Parent

1
2
3
package com.test.mvc;
public class Parent {
}

Controller类HomeController

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Controller
public class HomeController {
	@Autowired
	Parent parent;
	private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
	/**
	 * Simply selects the home view to render by returning its name.
	 */
	@RequestMapping(value = "/", method = RequestMethod.GET)
	public String home(Locale locale, Model model) {
		logger.info("Welcome home! The client locale is {}. ", locale);
		logger.info(parent.toString());		
		Date date = new Date();
		DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);		
		String formattedDate = dateFormat.format(date);		
		model.addAttribute("serverTime", formattedDate );
		return "home"; 
	}
}

root-context.xml

1
<bean id="parent" class="com.test.mvc.Parent" ></bean>

web.xml略。

二、回忆

在Spring 使用简单Demo进行源码调试（六）这篇文章中介绍了bean参数的赋值，AutoWired也是在这个地方实现自动加载的。首先展开文章中的doCreateBean。这里省略了很多代码。首先看pplyMergedBeanDefinitionPostProcessors这个方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	//.......
        //.......
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
 			mbd.postProcessed = true;
		}
	}
	//......
        //......
	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		populateBean(beanName, mbd, instanceWrapper);
		if (exposedObject != null) {
			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);
		}
	}
	//......
        //......
	// Register bean as disposable.
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}
	return exposedObject;
}

断点运行到后去homeController的，后处理为AutowiredAnnotationBeanPostProcessor，如下图。
断点在homeController
展开AutowiredAnnotationBeanPostProcessor中的findAutowiringMetadata方法。这一步中的重点是在buildAutowiringMetadata，构建元数据。buildAutowiringMetadata首先去缓存里面找元数据，找不到就遍历bean的和父类的字段域和方法，如果别标记为@Autowired并且不是静态的就添加到InjectionMetadata中，并添加到缓存中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
	// 回到使用类名作为缓存键,保持自定义命令向后兼容性
	String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
	InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
	if (InjectionMetadata.needsRefresh(metadata, clazz)) {
		synchronized (this.injectionMetadataCache) {
			metadata = this.injectionMetadataCache.get(cacheKey);
			if (InjectionMetadata.needsRefresh(metadata, clazz)) {
				if (metadata != null) {
					metadata.clear(pvs);
				}
				try {
                                        //构建元数据
					metadata = buildAutowiringMetadata(clazz);
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
				catch (NoClassDefFoundError err) {
					throw new IllegalStateException("Failed to introspect bean class [" + clazz.getName() +
							"] for autowiring metadata: could not find class that it depends on", err);
				}
			}
		}
	}
	return metadata;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
	LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>();
	Class<?> targetClass = clazz;
	do {//这里一个循环，因为要考虑父类的字段和方法
		LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<InjectionMetadata.InjectedElement>();
                //这里循环字段，找到被标记为@Autowired的字段
		for (Field field : targetClass.getDeclaredFields()) {
			AnnotationAttributes ann = findAutowiredAnnotation(field);
			if (ann != null) {
				if (Modifier.isStatic(field.getModifiers())) {
					if (logger.isWarnEnabled()) {
						logger.warn("Autowired annotation is not supported on static fields: " + field);
					}
					continue;
				}
				boolean required = determineRequiredStatus(ann);
                                //创建AutowiredFieldElement。
				currElements.add(new AutowiredFieldElement(field, required));
			}
		}
                 //这里循环方法
		for (Method method : targetClass.getDeclaredMethods()) {
			Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
			if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
				continue;
			}
			AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
			if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
				if (Modifier.isStatic(method.getModifiers())) {
					if (logger.isWarnEnabled()) {
						logger.warn("Autowired annotation is not supported on static methods: " + method);
					}
					continue;
				}
				if (method.getParameterTypes().length == 0) {
					if (logger.isWarnEnabled()) {
						logger.warn("Autowired annotation should be used on methods with actual parameters: " + method);
					}
				}
				boolean required = determineRequiredStatus(ann);
				PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                                //创建AutowiredMethodElement。
				currElements.add(new AutowiredMethodElement(method, required, pd));
			}
		}
		elements.addAll(0, currElements);
		targetClass = targetClass.getSuperclass();
	}
	while (targetClass != null && targetClass != Object.class);
        //将InjectionElement集合添加到新建的InjectionMetadata中。
	return new InjectionMetadata(clazz, elements);
}

三、自动装载

代码运行到populateBean方法。这个方法太长，这里就不贴出来了，直接走到postProcessPropertyValues方法,获得InjectionMetadata对象后便遍历其中的所有InjectionElement对象，调用其中的inject方法。接着对每一个injectedElement进行inject。最后的inject进行真正的属性赋值。

1
2
3
4
5
6
7
8
9
10
11
public PropertyValues postProcessPropertyValues(
		PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
	InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
	try {
		metadata.inject(bean, beanName, pvs);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
	}
	return pvs;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
	Collection<InjectedElement> elementsToIterate =
			(this.checkedElements != null ? this.checkedElements : this.injectedElements);
	if (!elementsToIterate.isEmpty()) {
		boolean debug = logger.isDebugEnabled();
		for (InjectedElement element : elementsToIterate) {
			if (debug) {
				logger.debug("Processing injected element of bean '" + beanName + "': " + element);
			}
			element.inject(target, beanName, pvs);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
		Field field = (Field) this.member;
		try {
			Object value;
			if (this.cached) {
				value = resolvedCachedArgument(beanName, this.cachedFieldValue);
			}
			else {
				DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
				desc.setContainingClass(bean.getClass());
				Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
				TypeConverter typeConverter = beanFactory.getTypeConverter();
                                //获取真正的属性值。
				value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
				synchronized (this) {
					if (!this.cached) {
						if (value != null || this.required) {
							this.cachedFieldValue = desc;
							registerDependentBeans(beanName, autowiredBeanNames);
							if (autowiredBeanNames.size() == 1) {
								String autowiredBeanName = autowiredBeanNames.iterator().next();
								if (beanFactory.containsBean(autowiredBeanName)) {
									if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
										this.cachedFieldValue = new RuntimeBeanReference(autowiredBeanName);
									}
								}
							}
						}
						else {
							this.cachedFieldValue = null;
						}
						this.cached = true;
					}
				}
			}
			if (value != null) {
				ReflectionUtils.makeAccessible(field);
                                //最终赋值
				field.set(bean, value);
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException("Could not autowire field: " + field, ex);
		}
	}
}

看一下resolveDependency。 这个方法其实就是根据类型到bean工厂中查找类型匹配的bean实例，然后就看到了这几个条件分支语句，如果是数组，集合，映射表，自定义类型都执行了差不多的操作，findAutowireCandidate方法。这个方法会去工厂中执行类型匹配的查找，将匹配的结果集返回，不同的是，集合数组类型会通过TypeConverter进行结果的转换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
	Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
	Class<?> type = descriptor.getDependencyType();
	Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
	if (value != null) {
		if (value instanceof String) {
			String strVal = resolveEmbeddedValue((String) value);
			BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
			value = evaluateBeanDefinitionString(strVal, bd);
		}
		TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
		return (descriptor.getField() != null ?
				converter.convertIfNecessary(value, type, descriptor.getField()) :
				converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
	}
	if (type.isArray()) {
                //如果属性类型是数组
		//......
		return result;
	}
	else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
                //如果属性是集合，并且是接口
		//......
		return result;
	}
	else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
                //如果属性是Map并且是接口
		//......
		return matchingBeans;
	}
	else {//自定义类型
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
		if (matchingBeans.isEmpty()) {
			if (descriptor.isRequired()) {
				raiseNoSuchBeanDefinitionException(type, "", descriptor);
			}
			return null;
		}
		if (matchingBeans.size() > 1) {
			String primaryBeanName = determineAutowireCandidate(matchingBeans, descriptor);
			if (primaryBeanName == null) {
				throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());
			}
			if (autowiredBeanNames != null) {
				autowiredBeanNames.add(primaryBeanName);
			}
			return matchingBeans.get(primaryBeanName);
		}
		// We have exactly one match.
		Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
		if (autowiredBeanNames != null) {
			autowiredBeanNames.add(entry.getKey());
		}
		return entry.getValue();
	}
}

到此为止，找到了属性的匹配值，然后反射赋值就完成了整个的自动装配过程。可以看出，@Autowired是通过类型来进行自动装配的。

上面是属性的赋值过程也就是InjectionFieldElement的inject方法，InjectionMethodElement的inject方法大致相同只是对每一个方法参数执行一次resolveDependency方法来获取参数值，然后反射执行方法。

到此为止，整个实例化和装配过程也就讲完了，我们总结一下：

1）一切都是从bean工厂的getBean方法开始的，一旦该方法调用总会返回一个bean实例，无论当前是否存在，不存在就实例化一个并装配，否则直接返回。

2）实例化和装配过程中会多次递归调用getBean方法来解决类之间的依赖。

3）Spring几乎考虑了所有可能性，所以方法特别复杂但完整有条理。

4）@Autowired最终是根据类型来查找和装配元素的，但是我们设置了后会影响最终的类型匹配查找。因为在前面有根据BeanDefinition的autowire类型设置PropertyValue值得一步，其中会有新实例的创建和注册。就是那个autowireByName方法。

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2015/05/19/Spring MVC 之 contextcomponent-scan/

访问原文「Spring MVC 之 <context:component-scan/>」

一、ContextLoader
通过阅读SpringMVC的源码可知，SpringMVC的初始化在ContextLoaderListener类中的contextInitialized方法，跟一下代码发现实际上是在ContextLoader中的initWebApplicationContext方法中进行初始化。初始化的代码如下,首先会创建一个WebApplicationContext对象，然后加载父类，接着使用configureAndRefreshWebApplicationContext初始化这个WebApplicactionContext对象，是在configureAndRefreshWebApplicationContext方法中进行了配置文件的加载和组件的扫描。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
if (this.context == null) {
	this.context = createWebApplicationContext(servletContext);
}
if (this.context instanceof ConfigurableWebApplicationContext) {
	ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
	if (!cwac.isActive()) {
		// The context has not yet been refreshed -&gt; provide services such as
		// setting the parent context, setting the application context id, etc
		if (cwac.getParent() == null) {
			// The context instance was injected without an explicit parent -&gt;
			// determine parent for root web application context, if any.
			ApplicationContext parent = loadParentContext(servletContext);
			cwac.setParent(parent);
		}
		configureAndRefreshWebApplicationContext(cwac, servletContext);
	}
}

展开createWebApplicationContext方法。该方法初始化根WebApplicationContext，这个WebApplicationContext可以使默认的context也尅进行定制。

1
2
3
4
5
6
7
8
protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
	Class&lt;?&gt; contextClass = determineContextClass(sc);
	if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
		throw new ApplicationContextException(&quot;Custom context class [&quot; + contextClass.getName() +
				&quot;] is not of type [&quot; + ConfigurableWebApplicationContext.class.getName() + &quot;]&quot;);
	}
	return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
}

展开determineContextClass方法。这个方法比较简单，首先查看有没有配置CONTEXT_CLASS_PARAM这个属性，有的话使用这个属性配置的类进行加载，否则使用默认的类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
protected Class&lt;?&gt; determineContextClass(ServletContext servletContext) {
	String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
	if (contextClassName != null) {
		try {
			return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
		}
		catch (ClassNotFoundException ex) {
			throw new ApplicationContextException(
					&quot;Failed to load custom context class [&quot; + contextClassName + &quot;]&quot;, ex);
		}
	}
	else {
		contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
		try {
			return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
		}
		catch (ClassNotFoundException ex) {
			throw new ApplicationContextException(
					&quot;Failed to load default context class [&quot; + contextClassName + &quot;]&quot;, ex);
		}
	}
}

再看configureAndRefreshWebApplicationContext方法。configureAndRefreshWebApplicationContext最后的refresh方法已经在前面的Spring 使用简单Demo进行源码调试（一）系列文章里进行了简单的分析调试。

二、 <context:component-scan/>
我们在SpringMVC开发项目中，有的用注解和XML配置Bean,这两种都各有自己的优势，数据源配置比较经常用XML配置，控制层依赖的service比较经常用注解等（在部署时比较不会改变的），我们经常比较常用的注解有@Component是通用标注，@Controller标注web控制器，@Service标注Servicec层的服务，@Respository标注DAO层的数据访问。SpringMVC启动时怎么被自动扫描然后解析并注册到Bean工厂中去（放到DefaultListableBeanFactory中的Map beanDefinitionMap中 以BeanName为key）？我们今天带着这些问题来了解分析这实现的过程，我们在分析之前先了解一下这些注解。
@Controller标注web控制器，@Service标注Service层的服务，@Respository标注DAO层的数据访问。@Component是通用标注，只是定义为一个类为Bean，SpringMVC会把所有添加@Component注解的类作为使用自动扫描注入配置路径下的备选对象。@Controller、@Service\@Respository只是更加的细化，都是被@Component标注，所以我们比较不推荐使用@Component。源代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Target({ElementType.TYPE})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Component  
public @interface Service {  
    String value() default &quot;&quot;;  
}  
@Target({ElementType.TYPE})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Component  
public @interface Controller {  
    String value() default &quot;&quot;;  
}  
@Target({ElementType.TYPE})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Component  
public @interface Repository {  
    String value() default &quot;&quot;;  
}

都是有标示@Component
我们在配置文件中，标示配置需要扫描哪些包下，也可以配置对某个包下不扫描，代码如下：

1
2
3
4
&lt;context:component-scan base-package=&quot;cn.test&quot;&gt;  
        &lt;context:exclude-filter type=&quot;regex&quot; expression=&quot;cn.test.*.*.controller&quot;/&gt;  
        &lt;context:exclude-filter type=&quot;regex&quot; expression=&quot;cn.test.*.*.controller2&quot;/&gt;  
&lt;/context:component-scan&gt;

说明：
指定的不扫描包，指定的扫描包
SpringMVC先读取配置文件，然后根据context:component-scan中属性base-package去扫描指定包下的class和jar文件，把标示@Controller标注web控制器，@Service标注Servicec层的服务，@Respository标注DAO层的数据访问等注解的都获取，并注册为Bean类放到Bean工厂。

三、ComponentScanBeanDefinitionParser
通过阅读源码，知道接口BeanDefinitionParser可以实现将自定义的标签转化为 BeanDefinition类。而则是由ComponentScanBeanDefinitionParser进行解析的。

展开ComponentScanBeanDefinitionParser中的parse方法。可以看到主要完成以下工作。
（1）获取context:component-scan 配置的属性base-package的值，然后放到数组。
（2）创建扫描对应包下的class和jar文件的对象ClassPathBeanDefinitionScanner ，由这个类来实现扫描包下的class和jar文件并把注解的Bean包装成BeanDefinition。
（3）BeanDefinition注册到Bean工厂。

1
2
3
4
5
6
7
8
9
10
11
public BeanDefinition parse(Element element, ParserContext parserContext) {
	String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
	basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
	String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
			ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
	// Actually scan for bean definitions and register them.
	ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
	Set&lt;BeanDefinitionHolder&gt; beanDefinitions = scanner.doScan(basePackages);
	registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
	return null;
}

再展开configureScanner方法。首先通过findCandidateComponents获取候选bean definition。然后注册到registry中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
protected Set&lt;BeanDefinitionHolder&gt; doScan(String... basePackages) {
	Assert.notEmpty(basePackages, &quot;At least one base package must be specified&quot;);
	Set&lt;BeanDefinitionHolder&gt; beanDefinitions = new LinkedHashSet&lt;BeanDefinitionHolder&gt;();
	for (String basePackage : basePackages) {
		Set&lt;BeanDefinition&gt; candidates = findCandidateComponents(basePackage);
		for (BeanDefinition candidate : candidates) {
			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);
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}

四、筛选类
展开findCandidateComponents方法。首先获取路径下的资源Resource，然后判断资源是否可读，并且获取可读资源的MetadataReader对象，然后再调用isCandidateComponent(MetadataReader)判段是否是候选组件，如果是，则生成该metadataReader的ScannedGenericBeanDefinition对象。最后判断ScannedGenericBeanDefinition是否为候选的，如果是则添加到工厂中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public Set&lt;BeanDefinition&gt; findCandidateComponents(String basePackage) {
	Set&lt;BeanDefinition&gt; candidates = new LinkedHashSet&lt;BeanDefinition&gt;();
	try {
		String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
				resolveBasePackage(basePackage) + &quot;/&quot; + this.resourcePattern;
		Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
		boolean traceEnabled = logger.isTraceEnabled();
		boolean debugEnabled = logger.isDebugEnabled();
		for (Resource resource : resources) {
			if (traceEnabled) {
				logger.trace(&quot;Scanning &quot; + resource);
			}
			if (resource.isReadable()) {
				try {
					MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
					if (isCandidateComponent(metadataReader)) {
						ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
						sbd.setResource(resource);
						sbd.setSource(resource);
						if (isCandidateComponent(sbd)) {
							if (debugEnabled) {
								logger.debug(&quot;Identified candidate component class: &quot; + resource);
							}
							candidates.add(sbd);
						}
						else {
							if (debugEnabled) {
								logger.debug(&quot;Ignored because not a concrete top-level class: &quot; + resource);
							}
						}
					}
					else {
						if (traceEnabled) {
							logger.trace(&quot;Ignored because not matching any filter: &quot; + resource);
						}
					}
				}
				catch (Throwable ex) {
					throw new BeanDefinitionStoreException(
							&quot;Failed to read candidate component class: &quot; + resource, ex);
				}
			}
			else {
				if (traceEnabled) {
					logger.trace(&quot;Ignored because not readable: &quot; + resource);
				}
			}
		}
	}
        catch (IOException ex) {
	       throw new BeanDefinitionStoreException(&quot;I/O failure during classpath scanning&quot;, ex);
	}
	return candidates;
}

展开isCandidateComponent方法。通过变量excludeFilters, includeFilters去匹配传递进来的MetadataReader，如果与excludeFilter匹配成功返回false， 与includeFilter匹配成功返回true。

1
2
3
4
5
6
7
8
9
10
11
12
13
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
	for (TypeFilter tf : this.excludeFilters) {
		if (tf.match(metadataReader, this.metadataReaderFactory)) {
			return false;
		}
	}
	for (TypeFilter tf : this.includeFilters) {
		if (tf.match(metadataReader, this.metadataReaderFactory)) {
			return isConditionMatch(metadataReader);
		}
	}
	return false;
}

五、注册bean factory

在上面doScan方法中有

1
2
//注册到工厂中
registerBeanDefinition(definitionHolder, this.registry);

这样一行代码将beanDefinition注册到registry中,这是一个BeanDefinitionRegistry，下面是它的接口定义及继承结构：

1
2
3
4
5
6
7
8
9
10
public interface BeanDefinitionRegistry extends AliasRegistry {
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException;
    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    boolean containsBeanDefinition(String beanName);
    String[] getBeanDefinitionNames();
    int getBeanDefinitionCount();
    boolean isBeanNameInUse(String beanName);
}

我们可以看到接口中定义了诸多beandefinition的注册，删除，获取等方法，并且Spring为我们提供了三个内部实现，那么运行时，和之前文章的分析一样，使用了DefaultListableBeanFactory。
展开registerBeanDefinition方法。可以看出，所有的beanDefinition都由实例变量beanDefinitionMap来保存管理，他是一个ConcurrentHashMap，beanName作为键，beanDefinition对象作为值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
		throws BeanDefinitionStoreException {
	Assert.hasText(beanName, &quot;Bean name must not be empty&quot;);
	Assert.notNull(beanDefinition, &quot;BeanDefinition must not be null&quot;);
	if (beanDefinition instanceof AbstractBeanDefinition) {
		try {
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					&quot;Validation of bean definition failed&quot;, ex);
		}
	}
	BeanDefinition oldBeanDefinition;
	oldBeanDefinition = this.beanDefinitionMap.get(beanName);
	if (oldBeanDefinition != null) {
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					&quot;Cannot register bean definition [&quot; + beanDefinition + &quot;] for bean '&quot; + beanName +
					&quot;': There is already [&quot; + oldBeanDefinition + &quot;] bound.&quot;);
		}
		else if (oldBeanDefinition.getRole() &lt; beanDefinition.getRole()) {
			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
			if (this.logger.isWarnEnabled()) {
				this.logger.warn(&quot;Overriding user-defined bean definition for bean '&quot; + beanName +
						&quot;' with a framework-generated bean definition: replacing [&quot; +
						oldBeanDefinition + &quot;] with [&quot; + beanDefinition + &quot;]&quot;);
			}
		}
		else {
			if (this.logger.isInfoEnabled()) {
				this.logger.info(&quot;Overriding bean definition for bean '&quot; + beanName +
						&quot;': replacing [&quot; + oldBeanDefinition + &quot;] with [&quot; + beanDefinition + &quot;]&quot;);
			}
		}
	}
	else {
		this.beanDefinitionNames.add(beanName);
		this.manualSingletonNames.remove(beanName);
		this.frozenBeanDefinitionNames = null;
	}
	this.beanDefinitionMap.put(beanName, beanDefinition);
	if (oldBeanDefinition != null || containsSingleton(beanName)) {
		resetBeanDefinition(beanName);
	}
}

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

接上篇日志Spring 使用简单Demo进行源码调试（六）继续。

经过前面几章详（gai）细（kuo）的调试，最后来到了Demo中的第二步，

1
Animal a = ctx.getBean(&quot;animal&quot;, Animal.class);// 创建bean的引用对象

展开getBean，代码如下。这一步通过getBeanFactory方法获取bean factory，然后使用bean factory获取对应的bean。

1
2
3
public &lt;T&gt; T getBean(String name, Class&lt;T&gt; requiredType) throws BeansException {
		return getBeanFactory().getBean(name, requiredType);
	}

阅读全文 »

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

接上篇日志Spring 使用简单Demo进行源码调试（五）继续。

接上一篇转日志的第十一步，这一步主要完成单例的初始化。直接进入这一步中的beanFactory.preInstantiateSingletons();这一步的功能主要在对每一个bean进行getBean(beanName);操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isInfoEnabled()) {
			this.logger.info(&quot;Pre-instantiating singletons in &quot; + this);
		}
		List&lt;String&gt; beanNames;
		synchronized (this.beanDefinitionMap) {
			// Iterate over a copy to allow for init methods which in turn register new bean definitions.
			// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
			beanNames = new ArrayList&lt;String&gt;(this.beanDefinitionNames);
		}
		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() &amp;&amp; bd.isSingleton() &amp;&amp; !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					final FactoryBean&lt;?&gt; factory = (FactoryBean&lt;?&gt;) getBean(FACTORY_BEAN_PREFIX + beanName);
					boolean isEagerInit;
					if (System.getSecurityManager() != null &amp;&amp; factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(new PrivilegedAction&lt;Boolean&gt;() {
							public Boolean run() {
								return ((SmartFactoryBean&lt;?&gt;) factory).isEagerInit();
							}
						}, getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &amp;&amp;
								((SmartFactoryBean&lt;?&gt;) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
				else {
					getBean(beanName);
				}
			}
		}
	}

阅读全文 »

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

接上篇日志Spring 使用简单Demo进行源码调试（四）继续。

还记得refresh()函数嘛，记得也模糊了吧，贴出来好了。其中的第二步 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()已经用大篇幅描述了基本流程。接着看以下几步。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 为了刷新准备上下文
            prepareRefresh();
            // 利用子类完成内部bean factory的刷新
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            // 使用本地上下文准备bean factory
            prepareBeanFactory(beanFactory);
            try {
                // 允许在上下文子类中完成bean factory后处理
                postProcessBeanFactory(beanFactory);
                // 调用上下文注册的bean factory处理器
                invokeBeanFactoryPostProcessors(beanFactory);
                // 注册拦截bean创建的bean处理器
                registerBeanPostProcessors(beanFactory);
                // 初始化上下文中消息源
                initMessageSource();
                // 初始化上下文中的事件多播
                initApplicationEventMulticaster();
                // 在特定上下文子类中初始化其他特殊bean
                onRefresh();
                // 检查监听器bean并注册 
                registerListeners();
                // 实例化所有剩余(non-lazy-init)单例
                finishBeanFactoryInitialization(beanFactory);
                // 发布相应的事件
                finishRefresh();
            }
            catch (BeansException ex) {
                logger.warn(&quot;Exception encountered during context initialization - cancelling refresh attempt&quot;, ex);
                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();
                // Reset 'active' flag.
                cancelRefresh(ex);
                // Propagate exception to caller.
                throw ex;
            }
        }
    }

阅读全文 »

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

接上篇日志Spring 使用简单Demo进行源码调试（三）继续。

第一步
展开loadBeanDefinitions(resources)。这个代码比较简单，是对每一个资源进行加载。

1
2
3
4
5
6
7
8
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
	Assert.notNull(resources, &quot;Resource array must not be null&quot;);
	int counter = 0;
	for (Resource resource : resources) {
		counter += loadBeanDefinitions(resource);
	}
	return counter;
}

展开loadBeanDefinitions(resource)。这一步为从特定的XML文件中加载bean factory，使用EncodedResource包装传来的resource，然后进一步加载。EncodedResource结合特定编码的资源描述符或特定字符集用于阅读资源，这里的资源描述符和特定字符集都为。

1
2
3
4
5
/**
	 * 从特定的XML文件中加载bean factory
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}

阅读全文 »

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

接上篇日志Spring 使用简单Demo进行源码调试（二）继续。

上篇提到了主要的初始化函数refresh，函数源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 为了刷新准备上下文
            prepareRefresh();
            // 利用子类完成内部bean factory的刷新
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            // 使用本地上下文准备bean factory
            prepareBeanFactory(beanFactory);
            try {
                // 允许在上下文子类中完成bean factory后处理
                postProcessBeanFactory(beanFactory);
                // 调用上下文注册的bean factory处理器
                invokeBeanFactoryPostProcessors(beanFactory);
                // 注册拦截bean创建的bean处理器
                registerBeanPostProcessors(beanFactory);
                // 初始化上下文中消息源
                initMessageSource();
                // 初始化上下文中的事件多播
                initApplicationEventMulticaster();
                // 在特定上下文子类中初始化其他特殊bean
                onRefresh();
                // 检查监听器bean并注册 
                registerListeners();
                // 实例化所有剩余(non-lazy-init)单例
                finishBeanFactoryInitialization(beanFactory);
                // 发布相应的事件
                finishRefresh();
            }
            catch (BeansException ex) {
                logger.warn(&quot;Exception encountered during context initialization - cancelling refresh attempt&quot;, ex);
                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();
                // Reset 'active' flag.
                cancelRefresh(ex);
                // Propagate exception to caller.
                throw ex;
            }
        }
    }

先把prepareRefresh的代码贴出来。这段代码主要功能是初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
	 * Prepare this context for refreshing, setting its startup date and
	 * active flag as well as performing any initialization of property sources.
	 */
	protected void prepareRefresh() {
		this.startupDate = System.currentTimeMillis();
		synchronized (this.activeMonitor) {
			this.active = true;
		}
		if (logger.isInfoEnabled()) {
			logger.info(&quot;Refreshing &quot; + this);
		}
		// Initialize any placeholder property sources in the context environment
		initPropertySources();
		// Validate that all properties marked as required are resolvable
		// see ConfigurablePropertyResolver#setRequiredProperties
		getEnvironment().validateRequiredProperties();
	}

阅读全文 »