Spring启动流程解析(总)

别名循环检查：A为名称，B为A的别名，需要注册别名<B, A>

1. 检查B是否有别名，如果没有则返回false

2. 如果B有别名C，检查C是否与A相同。如果相同返回true，说明有别名循环。如果不相同递归hasAlias(C, B)方法

3. 如果C无别名，返回false；如果C有别名D且等于A，返回true。如果不相同继续递归hasAlias(D, B)

Bean注册

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // 解析XML中的BeanDefinition元素
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // 注册BeanDefinition
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                                     bdHolder.getBeanName() + "'", ele, ex);
        }
        // 发送注册事件
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    // 获取id属性
    String id = ele.getAttribute(ID_ATTRIBUTE);
    // 获取name属性
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    // 定义别名list
    List<String> aliases = new ArrayList<String>();
    if (StringUtils.hasLength(nameAttr)) {
        // 因为可以多个别名用，所以解析成别名数组
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    // beanName默认为id
    String beanName = id;
    // 如果没有beanName，那么取出别名数组中的第一个作为beanName
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        beanName = aliases.remove(0);
        if (logger.isDebugEnabled()) {
            logger.debug("No XML 'id' specified - using '" + beanName +
                         "' as bean name and " + aliases + " as aliases");
        }
    }

    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }

    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) {
                    // 生成Bean名
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                        beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    // 生成Bean名
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    String beanClassName = beanDefinition.getBeanClassName();
                    if (beanClassName != null &&
                        beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                        !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                        aliases.add(beanClassName);
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Neither XML 'id' nor 'name' specified - " +
                                 "using generated bean name [" + beanName + "]");
                }
            }
            catch (Exception ex) {
                error(ex.getMessage(), ele);
                return null;
            }
        }
        String[] aliasesArray = StringUtils.toStringArray(aliases);
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}

// 解析Bean定义不考虑名称或别名。如果在Bean解析过程中产生异常，则返回null
public AbstractBeanDefinition parseBeanDefinitionElement(
    Element ele, String beanName, BeanDefinition containingBean) {

    this.parseState.push(new BeanEntry(beanName));

    String className = null;
    // 解析Bean的class属性
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }

    try {
        String parent = null;
        // 解析parent属性
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }
        // 为指定的类名和Parent名称创建一个BeanDefinition
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);

        // 解析Bean元素的属性并应用于Bean
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        // 设置Bean的描述信息
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

        // 解析Bean定义的元数据信息（meta以键值对形式存在）
        parseMetaElements(ele, bd);
        // 解析lookup-method元素
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        // 解析replaced-method元素
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        // 解析构造函数参数
        parseConstructorArgElements(ele, bd);
        // 解析property元素
        parsePropertyElements(ele, bd);
        // 解析qualifier元素
        parseQualifierElements(ele, bd);

        bd.setResource(this.readerContext.getResource());
        bd.setSource(extractSource(ele));

        return bd;
    }
    catch (ClassNotFoundException ex) {
        error("Bean class [" + className + "] not found", ele, ex);
    }
    catch (NoClassDefFoundError err) {
        error("Class that bean class [" + className + "] depends on not found", ele, err);
    }
    catch (Throwable ex) {
        error("Unexpected failure during bean definition parsing", ele, ex);
    }
    finally {
        this.parseState.pop();
    }

    return null;
}

public static String generateBeanName(
    BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean)
    throws BeanDefinitionStoreException {

    String generatedBeanName = definition.getBeanClassName();
    if (generatedBeanName == null) {
        // 如果有父类，名称为：definition.getParentName() + “$child”
        if (definition.getParentName() != null) {
            generatedBeanName = definition.getParentName() + "$child";
        }
        // 如果有指定的工厂类，名称为：definition.getFactoryBeanName() + “$created”
        else if (definition.getFactoryBeanName() != null) {
            generatedBeanName = definition.getFactoryBeanName() + "$created";
        }
    }
    if (!StringUtils.hasText(generatedBeanName)) {
        throw new BeanDefinitionStoreException("Unnamed bean definition specifies neither " +
                                               "'class' nor 'parent' nor 'factory-bean' - can't generate bean name");
    }

    String id = generatedBeanName;
    if (isInnerBean) {
        // 如果是innerBean，名称为
        id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition);
    }
    else {
        // 如果不是InnerBean则为顶层Bean，使用简单的类名。计数器加1
        int counter = -1;
        while (counter == -1 || registry.containsBeanDefinition(id)) {
            counter++;
            id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + counter;
        }
    }
    return id;
}

// 手动注册的单例名称列表
private volatile Set<String> manualSingletonNames = new LinkedHashSet<String>(16);

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");

    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            // 对于AbstractBeanDefinition属性中的methodOverrides校验
            // 校验methodOverrides是否与工厂方法并存或者methodOverrides对应的方法根本不存在
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                                                   "Validation of bean definition failed", ex);
        }
    }

    // 从缓存中根据beanName获取BeanDefinition
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    if (existingDefinition != null) {
        // 如果BeanDefinition存在并且不允许同名覆盖，则抛出异常
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                                                   "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                                                   "': There is already [" + existingDefinition + "] bound.");
        }
        // Bean的角色检查
        else if (existingDefinition.getRole() < beanDefinition.getRole()) {
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (logger.isWarnEnabled()) {
                logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                            "' with a framework-generated bean definition: replacing [" +
                            existingDefinition + "] with [" + beanDefinition + "]");
            }
        }
        // 如果名字相同，但是BeanDefinition不同打印覆盖日志
        else if (!beanDefinition.equals(existingDefinition)) {
            if (logger.isInfoEnabled()) {
                logger.info("Overriding bean definition for bean '" + beanName +
                            "' with a different definition: replacing [" + existingDefinition +
                            "] with [" + beanDefinition + "]");
            }
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("Overriding bean definition for bean '" + beanName +
                             "' with an equivalent definition: replacing [" + existingDefinition +
                             "] with [" + beanDefinition + "]");
            }
        }
        // 在缓存中注册Bean
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    else {
        // 检查工厂的Bean创建阶段是否已经开始
        if (hasBeanCreationStarted()) {
            // 进入创建阶段，此时无法再修改启动时集合元素（为了稳定迭代）
            synchronized (this.beanDefinitionMap) {
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                // beanName在manualSingletonNames中，说明是手动注册
                if (this.manualSingletonNames.contains(beanName)) {
                    Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
                    updatedSingletons.remove(beanName);
                    this.manualSingletonNames = updatedSingletons;
                }
            }
        }
        else {
            // 工厂还未到创建阶段，仍然在注册阶段
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    // 待注册的Bean的已经在beanDefinitionMap缓存中存在，或者已经存在于单例Bean缓存中
    if (existingDefinition != null || containsSingleton(beanName)) {
        // 重置给定Bean的所有BeanDefinition缓存，包括从其派生的Bean的缓存
        resetBeanDefinition(beanName);
    }
}

// 保存在至少被创建过一次的beanName
// 如果这个集合中存在beanName，那么说明已经进入了Bean创建阶段
private final Set<String> alreadyCreated =
			Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(256))

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 内部BeanFactory使用Context上下文的类加载器
    beanFactory.setBeanClassLoader(getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // 配置BeanFactory的Context上下文回调
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // BeanFactory接口不在普通工厂中注册为可解析类型
    // MessageSource 注册（找到并自动装配）为一个Bean
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // Register early post-processor for detecting inner beans as ApplicationListeners.
    // 注册早期的后处理器用来将内部Bean检测为ApplicationListeners。
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 如果发现LoadTimeWeaver，则准备织入
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        // 给类型匹配设置一个临时的ClassLoader
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // 注册默认的environment
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    // 注册systemProperties
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    // 注册systemEnvironment
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

// 创建实例，填充实例，应用后处理器
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean '" + beanName + "'");
    }
    // 合并的BeanDefinition
    RootBeanDefinition mbdToUse = mbd;

    // 确保解析并加载Bean的Class
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    // 如果解析的类在合并的BeanDefinition不存在，则克隆Bean定义
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        // 设置Bean的Class
        mbdToUse.setBeanClass(resolvedClass);
    }

    try {
        // Spring将lookup-method和replace-method统称为override method，这里主要就是处理这2个函数
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                                               beanName, "Validation of method overrides failed", ex);
    }

    try {
        // 该函数的作用是给 BeanPostProcessors 后置处理器返回一个代理对象的机会
        // 这里是实现AOP处理的重要地方
        // AOP是通过BeanPostProcessor机制实现的，而接口InstantiationAwareBeanPostProcessor是实现代理的重点
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                                        "BeanPostProcessor before instantiation of bean failed", ex);
    }

    // 如果后处理器返回的Bean为空，则调用doCreateBean执行创建Bean的过程
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}

// 实际创建指定的Bean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {

    // BeanWrapper 是一个用于包装Bean实例的接口，通过这个接口可以设置/获取Bean实例的属性
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        // 从未完成的实例缓存中获取
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    // 如果缓存中不存在，则执行创建（三种方式）
    if (instanceWrapper == null) {
        // 创建 bean 实例，并将实例封装在BeanWrapper中返回。createBeanInstance中包含三种创建方式：
        // 1.工厂方法创建Bean实例
        // 2.通过构造方法自动注入（autowire by constructor）的方式创建
        // 3.通过无参构造方法方法创建
        // 如果Bean配置了lookup-method和replace-method，则使用CGLIB增强Bean实例
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // 获取包装的Bean实例
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    // 获取包装的Class
    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    // 待解析的目标类型
    mbd.resolvedTargetType = beanType;

    // 允许BeanPostProcessor修改合并的BeanDefinition。这里主要是合并Bean的定义信息
    // Autowired等注解就是在这一步完成预解析，并且将注解需要的信息放入缓存
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                // 应用MergedBeanDefinitionPostProcessor后处理器
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }

    // earlySingletonExposure 是一个重要的变量，用于表示是否提前暴露单例Bean，用于解决循环依赖。
    // earlySingletonExposure 由三个条件组成：是否是单例、是否允许循环引用、当前Bean是否处于创建的状态中
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isDebugEnabled()) {
            logger.debug("Eagerly caching bean '" + beanName +
                         "' to allow for resolving potential circular references");
        }
        // 避免循环依赖，在Bean初始化完成前添加ObjectFactory到singletonFactories缓存。
        addSingletonFactory(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
                // 此回调使后处理器有机会提前曝光Bean（即在目标Bean完全初始化之前）。通常是为了解决循环依赖
                return getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }

    // 下面是初始化Bean的流程
    Object exposedObject = bean;
    try {
        // 使用BeanDefinintion的属性值填充Bean实例
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            // 初始化Bean
            // 如果Bean实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口则设置
            // 应用BeanPostProcessor后处理器
            // 执行自定义init-method方法
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
    }
    catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }

    if (earlySingletonExposure) {
        // 从提前曝光的Bean缓存中查询，目的是验证是否存在循环依赖
	// 如果存在循环依赖，在这里earlySingletonReference不为空
        Object earlySingletonReference = getSingleton(beanName, false);
        // 在检测到循环依赖的情况下，earlySingletonReference不会为null
        if (earlySingletonReference != null) {
            // 如果exposedObject没有在initializeBean初始化方法中被改变，说明没有被增强
            // 初始化之后的Bean等于原始的bean说明不是proxy对象
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                // 确定是否已经给指定的beanName称注册了依赖
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                // Bean创建后其依赖的Bean一定也是已经创建的
                // 如果actualDependentBeans不为空，则表示依赖的Bean并没有被创建完，即存在循环依赖
                if (!actualDependentBeans.isEmpty()) {
                    // 抛出异常
                    // throw new BeanCurrentlyInCreationException(....)
                }
            }
        }    }

    // Register bean as disposable.
    // 如果Bean实现了Disposable，则注册该Bean为
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

// 创建Bean实例
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(.....);
    }

    // 如果工厂方法不为空
    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);
        }
    }

    // Candidate constructors for autowiring?
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
        mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    // 调用实例化策略接口来实例化Bean，这里使用无参构造
    return instantiateBean(beanName, mbd);
}

// 实例化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>() {
                @Override
                public Object run() {
                    return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                }
            }, getAccessControlContext());
        }
        else {
            // InstantiationStrategy负责进行实例化
            // SimpleInstantiationStrategy是一个简单的用于Bean实例化的类。如：由Bean类的默认构造函数、带参构造函数或者工厂方法等来实例化Bean。不支持方法注入。
            // CglibSubclassingInstantiationStrategy如果方法需要被覆盖来实现“方法注入”，使用CGLIB动态生成子类
            beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
        }
        // 实例化后的Bean使用BeanWrapper包装。BeanWrapper可以设置以及访问被包装对象的属性值
        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        // 初始化BeanWrapper包装包含了2个工作：设置ConversionService和CustomerEditor
        initBeanWrapper(bw);
        return bw;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    }
}

// 初始化Bean
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
                invokeAwareMethods(beanName, bean);
                return null;
            }
        }, getAccessControlContext());
    }
    else {
        // 设置Aware
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 调用初始化前处理器
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 执行自定义初始化方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        // 调用初始化后处理器
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

// 注册名称返回单例对象，检查已经实例化的单例，并允许提前引用当前创建的单例对象（解析循环引用）
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 从单例缓存中根据Bean名字获取单例对象
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果单例对象为空，并且单例对象正在创建中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 注意synchronized关键字
        synchronized (this.singletonObjects) {
            // 从earlySingletonObjects缓存中通过Bean名称获取对象
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果单例对象仍然为空，并且允许提前引用为true
            // allowEarlyReference参数含义：是否允许提前曝光
            if (singletonObject == null && allowEarlyReference) {
                // 从singletonFactories中根据Bean名称获取对应的单例工厂
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 通过工厂创建单例对象（此时还未进行依赖注入）
                    singletonObject = singletonFactory.getObject();
                    // 把创建的单例对象放到提前引用的缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 移除该单例对象的工厂
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
}

public interface MessageSource {
    // 用来从MessageSource获取消息的基本方法。如果在指定的locale中没有找到消息，则使用默认的消息
    // args中的参数将使用标准类库中的MessageFormat来替换消息中的值
    String getMessage(String code, Object[] args, String default, Locale loc)：

    // 与上一个方法相同，不同之处在于：没有指定默认值。如果没找到消息，会抛出一个NoSuchMessageException异常。
    String getMessage(String code, Object[] args, Locale loc) throws NoSuchMessageException;

    // 与上面的方法不同之处在于：将code、args等属性封装到MessageSourceResolvable中
    String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException;
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
​
    <bean id="messageSource"
          class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basenames">
            <list>
                <value>locale.messages</value>
                <value>locale.exceptions</value>
            </list>
        </property>
    </bean>
​
</beans>

# exceptions_en_US.properties文件
exceptions.illegal = The user {0} attempted to login, time: {1}
​
# exceptions_zh_CN.properties文件
exceptions.illegal = \u975e\u6cd5\u7528\u6237{0}\u5c1d\u8bd5\u767b\u5f55, \u65f6\u95f4\uff1a{1}
​
# message_en_US.properties文件
id.ilegal = userid {0} is illegal! time: {1}
password.empty = username{0}'s password is empty!
​
# message_zh_CN.properties文件
id.ilegal = \u7528\u6237\u7f16\u53f7{0}\u975e\u6cd5\u767b\u5f55\uff01{1}
password.empty = \u7528\u6237\u540d{0}\u7684\u5bc6\u7801\u4e0d\u80fd\u4e3a\u7a7a\uff01

protected void initMessageSource() {
    // 获取BeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();

    // beanFactory中是否包含名字为messageSource的Bean
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        // 创建MessageSource类型的Bean
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // 判断messageSource是否有parent MessageSource
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            // 设置MessageSource的parent MessageSource.
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                // 如果未注册任何父MessageSource，则仅将父上下文的MessageSource设置为父MessageSource
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Using MessageSource [" + this.messageSource + "]");
        }
    }
    // beanFactory中不包含名字为messageSource的Bean
    else {
        // 新建DelegatingMessageSource对象
        DelegatingMessageSource dms = new DelegatingMessageSource();
        // 设置DelegatingMessageSource的parent MessageSource
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        // 向BeanFactory中注册MessageSource
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                         "': using default [" + this.messageSource + "]");
        }
    }
}

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 检查配置中是否有applicationEventMulticaster的Bean定义
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        // 如果有则获取（实例化Bean）
        this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isDebugEnabled()) {
            logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        // 如果没有手动创建SimpleApplicationEventMulticaster的实例
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        // 把创建的SimpleApplicationEventMulticaster注册到BeanFactory
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                         APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                         "': using default [" + this.applicationEventMulticaster + "]");
        }
    }
}

public interface Subject {
    // 添加观察者
    public void addObserver(Observer o);
    // 删除观察者
    public void removeObserver(Observer o);
    // 通知观察者
    public void notifyObserver();
}

public interface Observer {
    // 当被观察者调用notify()方法时，观察者的update()方法会被回调
    public void update(String message);
}

/**
 * 被观察者
 * 实现了Subject接口，对Subject接口的三个方法进行了具体实现
 */
public class ConcreteSubject implements Subject {
    
    // 保存观察者的集合
    private List<Observer> list;
    private String message;
    
    public ConcreteSubject() {
        list = new ArrayList<Observer>();
    }
    
    @Override
    public void addObserver(Observer o) {
        list.add(o);
    }
    
    @Override
    public void removeObserver(Observer o) {
        if(!list.isEmpty())
            list.remove(o);
    }

    //遍历
    @Override
    public void notifyObserver() {
        for(int i = 0; i < list.size(); i++) {
            Observer oserver = list.get(i);
            oserver.update(message);
        }
    }
    
    public void setMessage(String s) {
        this.message = s;
        System.out.println("服务消息： " + s);
        //消息更新，通知所有观察者
        notifyObserver();
    }
}

public class User implements Observer {

    private String name;
    private String message;
    
    public User(String name) {
        this.name = name;
    }
    
    @Override
    // 实现update方法
    public void update(String message) {
        this.message = message;
        read();
    }

    public void read() {
        System.out.println(name + " 收到推送消息： " + message);
    }
}

public class Test {
    public static void main(String[] args) {
        ConcreteSubject cs = new ConcreteSubject();

        Observer user1 = new User("Zhangsan");
        Observer user2 = new User("Lisi");
        Observer user3 = new User("Wangwu");

        cs.addObserver(user1);
        cs.addObserver(user2);
        cs.addObserver(user3);
        cs.setMessage("发布了消息1");

        System.out.println("----------------------------------------------");
        cs.removeObserver(userZhang);
        cs.setMessage("发布了消息2");
    }
}

public class JDKEventObject extends EventObject {

    private Object source;

    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public JDKEventObject(JDKEventSource source) {
        super(source);
        this.source = source;
    }

    @Override
    public Object getSource() {
        return source;
    }
}

public interface JDKEventListener extends EventListener {
    public void handleEvent(JDKEventObject event);
}

public class JDKEventSource {
    private Set<EventListener> listeners = new HashSet();

    private String message;

    public void addListener(EventListener event) {
        listeners.add(event);
    }

    public void removeListener(EventListener event) {
        if (listeners.contains(event))
            listeners.remove(event);
    }

    public void fireEvent() {
        Iterator<EventListener> iter = listeners.iterator();
        while (iter.hasNext()) {
            JDKEventListener listener = (JDKEventListener) iter.next();
            listener.handleEvent(new JDKEventObject(this));
        }
    }
}

public class JDKEventTest {
    public static void main(String[] args) {
        JDKEventSource eventSource = new JDKEventSource();

        eventSource.addListener(new JDKEventListener() {
            @Override
            public void handleEvent(JDKEventObject event) {
                System.out.println("事件1......");
            }
        });
        eventSource.addListener(new JDKEventListener() {
            @Override
            public void handleEvent(JDKEventObject event) {
                System.out.println("事件2......");
            }
        });
        eventSource.fireEvent();
    }
}

// 生命周期接口，任何Spring管理的对象都可以实现该接口
public interface Lifecycle {
    void start();
    void stop();
    boolean isRunning();
}

// 管理ApplicationContext生命周期
public interface LifecycleProcessor extends Lifecycle {
    void onRefresh();
    void onClose();
}

public interface SmartLifecycle extends Lifecycle, Phased {
    // Lifecycle Bean是否自动启动
    boolean isAutoStartup();

    // 停止的时候执行回调，默认超时时间30秒
    void stop(Runnable callback);
}

// Phased最小的对象首先启动，停止时，顺序和启动时相反
public interface Phased {
    // SmartLifecycle的实现类默认Phase为0
    int getPhase();
}

// 实现Lifecycle的测试类
public class TestLifeCycle implements Lifecycle {

    private boolean running = false;

    public TestLifeCycle() {
        System.out.println("TestLifeCycle.......");
    }

    @Override
    public void start() {
        System.out.println("TestLifeCycle.start().......");
        running = true;
    }

    @Override
    public void stop() {
        System.out.println("TestLifeCycle.start().......");
        running = false;
    }

    @Override
    public boolean isRunning() {
        return running;
    }
}

// 实现SmartLifecycle的测试类
public class TestSmartLifecycle implements SmartLifecycle {

    private boolean running = false;

    public TestSmartLifecycle() {
        System.out.println("TestSmartLifecycle.......");
    }

    @Override
    public boolean isAutoStartup() {
        return true;
    }

    @Override
    public int getPhase() {
        return 10000;
    }

    @Override
    public void start() {
        System.out.println("TestSmartLifecycle.start().......");
        running = true;
    }

    @Override
    public void stop() {
        System.out.println("TestSmartLifecycle.stop().......");
        running = false;
    }

    @Override
    public void stop(Runnable callback) {
        System.out.println("TestSmartLifecycle.stop(Runnable callback).......");
        running = false;
    }

    @Override
    public boolean isRunning() {
        return running;
    }
}

// Spring容器检测到Service实现了ApplicationEventPublisherAware接口，会自动调用setApplicationEventPublisher
public class SpringService implements ApplicationEventPublisherAware {

    private List<String> nameList;
    private ApplicationEventPublisher publisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    public void setNameList(List<String> list) {
        this.nameList = list;
    }

    // 要发布自定义ApplicationEvent，需要在ApplicationEventPublisher上调用publishEvent方法
    public void sendMessage(String name) {
        if (nameList.contains(name)) {
            publisher.publishEvent(new SpringEvent(this, name));
            return;
        }
    }
}

// 要接收自定义的ApplicationEvent，需要实现ApplicationListener监听器
public class SpringListener implements ApplicationListener<SpringEvent> {

    String notifier;

    public void setNotifier(String notifier) {
        this.notifier = notifier;
    }

    @Override
    public void onApplicationEvent(SpringEvent event) {
        System.out.println("onApplicationEvent: "+ notifier);
    }
}

public class SpringEvent extends ApplicationEvent {

    String name;

    /**
     * Create a new ApplicationEvent.
     *
     * @param source the object on which the event initially occurred (never {@code null})
     */
    public SpringEvent(Object source, String name) {
        super(source);
        this.name = name;
    }
}

protected void onRefresh() throws BeansException {
    // For subclasses: do nothing by default.
}

<?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" xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

	<mvc:default-servlet-handler />
	<mvc:annotation-driven  />

	<context:component-scan base-package="xxx.xxx" />

	<!-- 视图解析 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/" />
		<property name="suffix" value=".jsp" />
	</bean>

	<!-- Theme主题资源 -->
	<bean id="themeSource" class="org.springframework.ui.context.support.ResourceBundleThemeSource">
		<property name="basenamePrefix" value="theme." />
	</bean>

	<!-- Theme主题解析器 -->
	<bean id="themeResolver" class="org.springframework.web.servlet.theme.CookieThemeResolver">
		<property name="defaultThemeName" value="blue" />
	</bean>

	<!-- Theme主题拦截器 -->
	<mvc:interceptors>
		<bean id="themeInterceptor" class="org.springframework.web.servlet.theme.ThemeChangeInterceptor">
			<property name="paramName" value="theme" />
		</bean>
	</mvc:interceptors>
</beans>

------------------------------
blue.properties
------------------------------
# css对应位置
styleSheet=/css/blue.css
# 图片对应位置
background=images/blue.png