Spring源码阅读笔记

其他 2018-07-06 10:44:25 阅读次数: 0

对于没有任何源码阅读经验的人，而且大局观整体概念很差的人来说，源码真的是太难读了，可能还是人笨吧。所以我只能采取老办法，所谓书读百遍，其义自现，读源码应该也是同样的道理。

到开始写本篇笔记开始，前前后后已经花了整整3周时间，期间各种debug，打了上百个断点，不厌其烦的一遍又一遍跟踪跟进，从服务器启动开始，

从HttpServletBean的init()进入，再到initWebApplicationContext()，再到refresh()，再到refreshBeanFactory()，再到finishRefresh()，直到服务器启动成功。不知道读了多少遍，

但是源码的东西实在的太多了，想要完全读懂，完全理清头绪，还差很远啊。所以我只重点关注了两块内容，就是bean的定位加载解析注册、bean的实例化两大块内容，其他地方稍作了解，没有太过深入。

整个容器的启动流程，都在AbstractApplicationContext的refresh()的模板方法中了。

复制代码 
 1 public void refresh() throws BeansException, IllegalStateException {
 2         synchronized (this.startupShutdownMonitor) {
 3             // Prepare this context for refreshing.
 4             prepareRefresh();
 5 
 6             // Tell the subclass to refresh the internal bean factory.
 7             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 8 
 9             // Prepare the bean factory for use in this context.
10             prepareBeanFactory(beanFactory);
11 
12             try {
13                 // Allows post-processing of the bean factory in context subclasses.
14                 postProcessBeanFactory(beanFactory);
15 
16                 // Invoke factory processors registered as beans in the context.
17                 invokeBeanFactoryPostProcessors(beanFactory);
18 
19                 // Register bean processors that intercept bean creation.
20                 registerBeanPostProcessors(beanFactory);
21 
22                 // Initialize message source for this context.
23                 initMessageSource();
24 
25                 // Initialize event multicaster for this context.
26                 initApplicationEventMulticaster();
27 
28                 // Initialize other special beans in specific context subclasses.
29                 onRefresh();
30 
31                 // Check for listener beans and register them.
32                 registerListeners();
33 
34                 // Instantiate all remaining (non-lazy-init) singletons.
35                 finishBeanFactoryInitialization(beanFactory);
36 
37                 // Last step: publish corresponding event.
38                 finishRefresh();
39             }
40 
41             catch (BeansException ex) {
42                 // Destroy already created singletons to avoid dangling resources.
43                 destroyBeans();
44 
45                 // Reset 'active' flag.
46                 cancelRefresh(ex);
47 
48                 // Propagate exception to caller.
49                 throw ex;
50             }
51         }
52     }
复制代码

 

其实，我并没有上来就看源码，而是先从看书开始，稍微了解，知道了一些关键点，关键流程，自己产生了一堆疑问，然后带着疑问去读源码，读着读着，发现有些疑问就这么解决了。

看书：主要以《SPRING技术内幕：深入解析SPRING架构与设计原理》为主，仅仅才看了前两章节，关于Spring Framework的核心实现，AOP什么，事务控制什么的都还没看。

看博客：看源码过程中，有些不理解的，就上网查博客，然后再回头读源码。觉得写得还可以的博客文章我记录了下来，供以后参考(希望管理员不要因为有外部链接，就把我踢掉了)。

 

正如上文所说，因为水平有限，本篇随笔并非是解析源码的文章，因为源码很多看不懂的地方并不敢妄下断言， 网上各种解析源码，画UML图，时序图（我不会画图%>_<%）的文章也有很多，

我是抱着解决疑问的态度来分析读源码的，另外在大神眼中，有些问题看起来可能问的很愚蠢，但是谁让我是菜鸟呢。

以上是我的心路历程，不看也罢。

 

那么，列出有疑问的地方（目前主要针对IOC相关部分、问题将不断补充）

（补充：我用来阅读并且debug的demo是基于注解配置的，另外以下说明都纯属个人谬论，如果错漏，请予以批评指正。）

问题1：我为什么要使用Spring?

问题2：Spring怎么这么聪明，知道哪些bean需要被实例化？

问题3：Spring中Bean是什么时候被实例化的？

问题4：依赖的bean是何时被注入的？

问题5：bean的单例模式？原型模式是什么东西？分别是何时被实例化的？

问题6：采用注解注入时，为什么只声明接口就可以将其实现类注入？

问题7：采用注解注入时，接口与实现类为何都能注入成功？区别？

问题8：加上了autowired的属性是什么时候实例化的？

问题9：网络上经常说的“第一次使用bean的时候实例化该bean”是什么意思？

问题10：发送一个请求，是怎么定位到具体的Controller的某一个方法的？

问题11：HandlerMapping、HandlerAdater与Controller到底是什么关系？

 

问题1：我为什么要使用Spring?

　　这个问题其实比较尴尬，因为其实我入行比较晚， 这个时候，已经有一大波比较成熟的框架体系了，早期的什么繁琐的臃肿的框架基本上没用过几个，再加上项目经验比较单一，用来用去就那么几个框架，用起来都大差不差，

用的熟练了，感觉都差不多。所以说，完全没有能力来横向比较，谁谁谁架构合理，谁谁谁扩展性强，只能勉强说这个框架的那种写法挺方便，比起单纯的Servlet写法要方便之类的....其他的，我都呵呵就好了。

如果你要强行问我为什么使用Spring，那我只能回答你：因为大家都在用啊，呵呵...

 

问题2：Spring怎么这么聪明，知道哪些bean需要被实例化？

　　　  什么控制反转、依赖注入，说到底就是程序在需要使用一个bean的时候，Spring框架确保该bean已经被实例化了，可以直接拿来使用。那么这时候，我想要知道，Spring是如何知道哪些bean需要实例化？

其实程序总归是程序，程序是很笨的，它并不知道要实例化哪些东西，除非你告诉它。

首先需要配置DispatcherServlet，这是web应用的总入口，也可以说是中央处理器，就是通过它，一步一步的启动Spring容器的。

在web.xml中

复制代码 
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:/spring/readspring-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
复制代码

另外还需要配置另外一个文件：readspring-servlet.xml，这个东西叫做上下文，主要是告诉Spring，在启动的时候干些什么事情，启动哪些功能，实例化哪些Bean。

上一个最简单的配置：

复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
                           http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context-3.1.xsd">

    <!-- 扫描指定目录 -->
    <context:component-scan base-package="com.readspring" />

    <!-- 不拦截静态资源 -->
    <mvc:default-servlet-handler />

    <!-- 启动注解支持 -->
    <mvc:annotation-driven />

    <!-- 配置视图解析器 -->
    <bean id="internalResourceViewResolver"
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>

</beans>
复制代码

 

我不逐一解读每句话的意思，还是针对上面的问题，Spring如何知道哪些bean要被实例化？

或者说的具体一点，Spring是如何知道要实例化我们写的Controller、Service、Dao的。

是这段配置告诉它的。

    <!-- 扫描指定目录 -->
    <context:component-scan base-package="com.readspring" />

从字面意思可以看出，component-scan就是组件扫描的意思，然后有一个base-package，告诉它需要扫描的文件路径。　　

　组件自动扫描是在Spring2.5加上的，在一个稍大的项目中通常会有上百个组件，如果都使用XML的bean定义来配置组件的话，显然会增加配置文件的体积，

　查找及维护也不方便，而Spring2.5就为我们引入了组件自动扫描机制，它可以在classpath下寻找标注了@Service、@Repository、@Controller、@Component注解的类 

　并把这些类纳入Spring容器中管理，它的作用和在XML中使用bean节点配置组件是一样的。

另外补充说明，既然是component扫描，为什么标注了@Service等也会被扫描到，可以看一下源码。

Service注解本身也被标注了@Component注解，所以说可以被扫描到，相当于继承自@Component。

下面，我大概的描述一下，容器启动的过程中，如何根据配置，来扫描指定类的。

容器启动过程中，首先调用DispatcherSerlvet的init方法，init方法内部根据web.xml的配置，读取配置的上下文readspring-servlet.xml，然后逐句解析该上下文，

当它读取到context:component-scan标签时，就启动对应的解析器，也可以叫做扫描器，对应的Class为：ComponentScanBeanDefinitionParser

有这么一个对应关系的Class，可以让Spring知道，为什么读取到这个标签，就实例化ComponentScanBeanDefinitionParser这个类。

复制代码 
public class ContextNamespaceHandler extends NamespaceHandlerSupport {

    public void init() {
        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());
    }

}
复制代码

看一下这个类ComponentScanBeanDefinitionParser中调用了doScan方法，可以看到传了一个参数：basePackages，就是我们配置的路径。

复制代码 
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        String[] basePackages = StringUtils.tokenizeToStringArray(element.getAttribute(BASE_PACKAGE_ATTRIBUTE),
                ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

        // Actually scan for bean definitions and register them.
        ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
        Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
        registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
        return null;
    }
复制代码

具体的扫描逻辑，在这个类中ClassPathScanningCandidateComponentProvider.findCandidateComponents(...)

这样，就读取到了需要被实例化的所有类，之后这些类的信息会被封装成一个一个的BeanDefinition，然后保存到DefaultListableBeanFactory的beanDefinitionMap中供后续使用。

    /** Map of bean definition objects, keyed by bean name */
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();

这个问题算是解决了。 

 

问题3：Spring中Bean是什么时候被实例化的？

           一般开发web应用时，有controller、service、dao等不同的bean，这些bean到底是怎么实例化的？什么时候被实例化的？有顺序吗？

首先回答该问题：所有的这些Bean，在容器启动的时候，已经全部被实例化了。

下面看代码一探究竟，还得看模板方法，AbstractApplicationContext.refresh()，其中有这么一个方法

  // Instantiate all remaining (non-lazy-init) singletons.
  finishBeanFactoryInitialization(beanFactory);

 

看注释知道：实例化剩下的所有单例。

Spring中的Bean默认都是单例的，除非显示的声明为prototype。

剩下的（remaining）的意思是有一些Spring自身的处理器、解析器等Bean不是在这里实例化的，我们自己编写的常规类Controller、Service等全部都是在此处实例化。

下面我用伪代码的形式简要的说明一下实例化的过程

以TestController为例子

Class TestController {

　@Autowired

   private ITestService testService;

   ...

}

// 首先循环所有的BeanDefinition列表

for(String beanName : 之前获取到的beanDefiniton的List){

　　String  beanName = "testController"; // 以TestController为例子

　　// 调用getbean方法

　　getBean(beanName){

           // 检查是否已经被实例化

　　　　Object  instance = getSingleton(beanName);

　　　　if (instance  == null) {

           　　// 如果没有，准备实例化

　　　　　　bean = createBean(beanName){

                      // 执行实例化过程，正式实例化就是在这个方法中

　　　　　　　  bean = createBeanInstance(){

　　　　　　　　　　// 这里具体的实例化是利用cglib类库，通过Java反射原理，构造函数实例化方式实例化

　　　　　　　　　　ReflectionUtils.makeAccessible(ctor);
　　　　　　　　　　Constructor.newInstance(args);

　　　　　　　　}

　　　　　　　  // 组装Bean，所谓的组装就是把该bean的属性给设置一下，如testService

                      populateBean(bean){

　　　　　　　　　// 以TestController为例子，这个方法里面，testService的实例的引用会被注入（Inject）到TestConroller的实例中的这个属性testService中

　　　　　　　　　// 如果testService的实例不存在，就会递归调用getBean()方法，直到一个没有任何依赖的Bean为止。

　　　　　　　　　Object serviceInstance =  getBean(testService);

　　　　　　　　　// 注入属性实例，相当于 testConroller.testService = serviceInstance;（依赖注入就是在这里实现的）

　　　　　　　　　inject(serviceInstance);

　　　　　　　　}

　　　　　　　　// 实例化成功后，实例会被保存到singletonObjects Map中

　　　　　　　　addSingleton(beanName, serviceInstance);

　　　　　　}

　　　　}

　　}

}

（此处省略了大量细节，只关注整体实现流程）

 所有的Bean被实例化后，会被存入这个Map中供后续使用。

DefaultSingletonBeanRegistry.java

    /** Cache of singleton objects: bean name --> bean instance */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>();

 

从上面的说明中，大体可以了解实例化Bean的流程，下面再来看一下源码实例化的一些具体细节实现。

1.Bean的实例化

首先看AbstractAutowireCapableBeanFactory.createBeanInstance(...)

复制代码 
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
        // Make sure bean class is actually resolved at this point.
        Class beanClass = resolveBeanClass(mbd, beanName);

        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }

        if (mbd.getFactoryMethodName() != null)  {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }

        // Shortcut when re-creating the same bean...
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) {
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                return instantiateBean(beanName, mbd);
            }
        }

        // Need to determine the constructor...
        Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        // No special handling: simply use no-arg constructor.
        return instantiateBean(beanName, mbd);
    } 
复制代码

经过一些列的必要性验证，最终调用了instantiateBean（...），有两个参数：一个beanName，一个是该bean的定义信息

复制代码 
    protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
        try {
            Object beanInstance;
            final BeanFactory parent = this;
            if (System.getSecurityManager() != null) {
                beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                    }
                }, getAccessControlContext());
            }
            else {
                beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
            }
            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            initBeanWrapper(bw);
            return bw;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
        }
    }
复制代码

在这里可以看到获取了实例化策略：getInstantiationStrategy()，点进去可以看到，默认采取的是Cglib的实例化策略。

    /** Strategy for creating bean instances */
    private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

然后继续跟进instantiate方法，

复制代码 
public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
        // Don't override the class with CGLIB if no overrides.
        if (beanDefinition.getMethodOverrides().isEmpty()) {
            Constructor<?> constructorToUse;
            synchronized (beanDefinition.constructorArgumentLock) {
                constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
                    final Class clazz = beanDefinition.getBeanClass();
                    if (clazz.isInterface()) {
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }
                    try {
                        if (System.getSecurityManager() != null) {
                            constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {
                                public Constructor run() throws Exception {
                                    return clazz.getDeclaredConstructor((Class[]) null);
                                }
                            });
                        }
                        else {
                            constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
                        }
                        beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
                    }
                    catch (Exception ex) {
                        throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                    }
                }
            }
            return BeanUtils.instantiateClass(constructorToUse);
        }
        else {
            // Must generate CGLIB subclass.
            return instantiateWithMethodInjection(beanDefinition, beanName, owner);
        }
    }
复制代码

可以看到，首先获取Bean的Class对象，然后根据Class对象获取构造器，最终调用BeanUtils.instantiateClass方法。

经过了一层又一层的嵌套调用，终于看到了真正的Bean实例化方式，通过Java的反射机制，根据Class的默认构造器实例化Bean对象。

复制代码 
    public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
        Assert.notNull(ctor, "Constructor must not be null");
        try {
            ReflectionUtils.makeAccessible(ctor);
            return ctor.newInstance(args);
        }
        catch (InstantiationException ex) {
            throw new BeanInstantiationException(ctor.getDeclaringClass(),
                    "Is it an abstract class?", ex);
        }
        catch (IllegalAccessException ex) {
            throw new BeanInstantiationException(ctor.getDeclaringClass(),
                    "Is the constructor accessible?", ex);
        }
        catch (IllegalArgumentException ex) {
            throw new BeanInstantiationException(ctor.getDeclaringClass(),
                    "Illegal arguments for constructor", ex);
        }
        catch (InvocationTargetException ex) {
            throw new BeanInstantiationException(ctor.getDeclaringClass(),
                    "Constructor threw exception", ex.getTargetException());
        }
    }
复制代码

2.依赖注入

还是参考之前的例子

Class TestController {

　@Autowired

   private ITestService testService;

   ...

}

TestController依赖于testService，如果想要正常使用TestController，首先TestController需要被实例化，然后其属性testService也需要被实例化。

通过之前1.Bean的实例化，已经知道TestController是如何被实例化的，但是尽管TestController有了实例，但是如果你Debug会发现，其属性值testService

此时仍然是testService == null，这个时候就需要把testService的实例（确切的说，应该是实例的引用），像“打针”一样，注入到TestController实例的testService属性中。

这段逻辑发生在上面伪代码的populateBean（...）方法中，具体在AbstractAutowireCapableBeanFactory.populateBean(...)

在这个方法中，有这么一段

复制代码 
        if (hasInstAwareBpps || needsDepCheck) {
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
            if (needsDepCheck) {
                checkDependencies(beanName, mbd, filteredPds, pvs);
            }
        }
        applyPropertyValues(beanName, mbd, bw, pvs);
复制代码

因为我是采用的@Autowired注解注入的方式，所以此次实际上调用的是AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(...)方法

复制代码 
    @Override
    public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
　　　　 // 根据bean的Class对象获取其对于的Field以及method
        InjectionMetadata metadata = findAutowiringMetadata(bean.getClass());
        try {
　　　　　　　// 调用注入方法
            metadata.inject(bean, beanName, pvs);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
        }
        return pvs;
    }
复制代码

因为可能有多个需要注入的属性，所以需要循环注入

复制代码 
    public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
        if (!this.injectedElements.isEmpty()) {
            boolean debug = logger.isDebugEnabled();
            for (InjectedElement element : this.injectedElements) {
                if (debug) {
                    logger.debug("Processing injected method of bean '" + beanName + "': " + element);
                }
                element.inject(target, beanName, pvs);
            }
        }
    }
复制代码

执行真正的注入(此处获取testService实例时，如果实例不存在，将会触发获取testService实例的递归调用)

复制代码 
        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 descriptor = new DependencyDescriptor(field, this.required);
                    Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
                    TypeConverter typeConverter = beanFactory.getTypeConverter();
                    value = beanFactory.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);
                    synchronized (this) {
                        if (!this.cached) {
                            if (value != null || this.required) {
                                this.cachedFieldValue = descriptor;
                                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;
                        }
                    }
                }
　　　　　　　　　// 利用Java反射机制，将filed的对象注入bean的属性当中
　　　　　　　　　// 相当于执行了 testController.setTestService(testService)
　　　　　　　　  if (value != null) {
                    ReflectionUtils.makeAccessible(field);
                    field.set(bean, value);
                }
            }
            catch (Throwable ex) {
                throw new BeanCreationException("Could not autowire field: " + field, ex);
            }
        }
    }
复制代码

这就注入好了。

 

问题4：依赖的bean是何时被注入的？

这个问题其实问题3的2.依赖注入中已经解答了，当其父Bean在实例化后，调用组装Bean的时候（populateBean方法），执行了依赖Bean的实例化以及注入操作。

 

问题5：bean的单例？多例是什么东西？分别是何时被实例化的？

首先来看看什么是Spring的scope

目前，scope的取值有5种。

在Spring 2.0之前，有singleton和prototype两种；

在Spring 2.0之后，为支持web应用的ApplicationContext，推出另外三种：request、session和global session类型。

1. singleton （单一实例）

一个容器中只存在一个实例，所有对该类型bean的依赖都引用这一单一实例。此外，singleton类型的bean定义，从容器启动，到他第一次被请求而实例化开始，只要容器不销毁或退出，该类型的bean的单一实例就会一直存活。

SpringMVC中，默认都是采用singleton模式。

2. prototype（多例）

spring容器在进行输出prototype的bean 对象时，会每次都重新生成一个新的对象给请求方，虽然这种类型的对象的实例化以及属性设置等工作都是由容器负责的，但是只要准备完毕，

并且对象实例返回给请求方之后，容器就不在拥有当前对象的引用，请求方需要自己负责当前对象后继生命周期的管理工作，包括该对象的销毁。

3. request 、session和global session

他们只适用于web程序，通常是和XmlWebApplicationContext共同使用。

可以参考一下这篇博文：Spring对象生存周期(Scope)的分析

 

下面看一下源码：AbstractBeanFactory.doGetBean(...)，可以看到，在实例化Bean的时候，首先判断了该bean的scope范围，

单例、多例、还是其他范围，然后最终都调用了createBean方法，所以说不管是什么作用范围，其实例化的过程都是一样的，可以参考上面的说明。

另外可以看到，单例时，从getSingleton(...)中取值，这个方法中会缓存所有已经实例化的单例Bean。而多例时，可以看到每次都是直接调用的createBean方法，返回了新生成Bean。

复制代码 
protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {

            ...// Create bean instance.
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                    public Object getObject() throws BeansException {
                        try {
                            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;
                        }
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            else {
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                        public Object getObject() throws BeansException {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName,
                            "Scope '" + scopeName + "' is not active for the current thread; " +
                            "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                            ex);
                }
            }
        
       ...return (T) bean;
    }
复制代码

 

问题6：采用注解注入时，为什么只声明接口就可以将其实现类注入？

看如下例子：

复制代码 
@Controller
Class TestController {

　 @Autowired
   private ITestService testService;

   ...

}

@Service
public class TestServiceImpl implements ITestService {

　　...

}
复制代码

一般情况下，采用非注解方式注入的时候，都需要显式的声明变量与实现类的对应关系，类似于

<bean id="testService" class="com.readspring.service.impl.TestServiceImpl" />

但是在基于注解的配置中，并不需要这段配置却仍然可以正常的实现注入。

例如：在TestController中，其成员变量testService被声明为接口类型：ITestService，但是Spring在实例化TestController时，

却可以将TestServiceImpl的实例成功注入到testService中。

那么，使用注解方式配置时，Spring是如何根据接口找到其实现类的呢？

答：Spring主要利用了Class.isAssignableFrom()方法来实现接口与实现类的匹配。

　　Class1.isAssignableFrom(Class2)：如果Class1是Class2本身或者是其接口或者父类，则返回true，否则返回false;

以testService的实例化为例，当Spring容器启动的时候，首先会读取配置文件，经过定位、加载、解析、注册，最终把标注了注解的类(例如：标注了@Service的TestServiceImpl)注册到BeanDefination的Map中并且缓存。

然后，在实例化testService的时候，Spring此刻并不知道testService的实现类是哪个，而是循环遍历BeanDefinitionMap中的Bean，逐一与ITestService接口进行类型匹配，一旦匹配上就认定为其实现类，并对其进行实例化。

用伪代码表示就是：

for(BeanDefinition bean: BeanDefinitionList) {

　Class testServiceImplClass = Class.forName(bean.getBeanClassName());

　if (ITestService.class.isAssignableFrom(testServiceImplClass)) {

　　// 成功定位到ITestService接口的实现类

　　return testServiceImplClass;

　}

}

以上这段处理主要是发生在依赖注入阶段（请参考之前的2.依赖注入）。

在之前依赖注入的描述中，侧重描述了属性注入其实就是通过Java反射来实现的，并没有讲解如何获得注入的实例，请看下面红色代码。

复制代码 
@Override
        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 descriptor = new DependencyDescriptor(field, this.required);
                    Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
                    TypeConverter typeConverter = beanFactory.getTypeConverter();
                    // 根据接口定位到实现类的过程发生此处
                    value = beanFactory.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);
                    synchronized (this) {
                        if (!this.cached) {
                            if (value != null || this.required) {
                                this.cachedFieldValue = descriptor;
                                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);
            }
        }
复制代码

 

继续跟进，定位到DefaultListableBeanFactory.doResolveDependency(...)，本方法主要判断属性类型，根据不同的类型做相应处理。

复制代码 
protected Object doResolveDependency(DependencyDescriptor descriptor, Class<?> type, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException  {

        ...
        
        if (type.isArray()) {
            ...
        }
        else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
            ...
        }
        else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
            ...
        }
        else {
// Find bean instances that match the required type.
            // 根据实际的类型找到对应的实例
            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 = determinePrimaryCandidate(matchingBeans, descriptor);
                if (primaryBeanName == null) {
                    throw new NoSuchBeanDefinitionException(type, "expected single matching bean but found " +
                            matchingBeans.size() + ": " + 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();
        }
    }
复制代码

 

层层深入，最终定位到DefaultListableBeanFactory.getBeanNamesForType(...)

根据方法名可以看出，本方法可以根据类型找到对应的类名，换句话说就是：根据我们例子中提供的接口ITestService可以找到其实现类TestServiceImpl

猜你喜欢

转载自blog.csdn.net/qq_14955245/article/details/80757680
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022