Spring学习总结—IOC和AOP

1. 概述

1.1 简介

Spring是分层的full-stack（全栈）轻量级开源框架，以 IoC 和 AOP 为核心思想，提供了展现层Spring MVC和业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三⽅框架和类库，已经成为使⽤最多的 Java EE 企业应⽤开源框架。

1.2 架构

Spring框架是一个轻量级的解决方案，可以一站式地构建企业级应用。Spring是模块化的，所以可以只使用其中需要的部分。主要包括几大模块：数据处理模块、Web模块、AOP/Aspects模块、Core Container模块和Test模块。

 

a）、Spring核心容器（Core Container）

容器是Spring框架最核心的部分，它管理着Spring应用中bean的创建、配置和管理。在该模块中包括了Spring bean工厂，它为Spring提供了DI的功能。基于bean工厂，我们还会发现有多种Spring应用上下文的实现。所有的Spring模块都构建于核心容器之上。

• Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）；

• Spring Core：核心类库，所有功能都依赖于该类库，提供IOC和DI服务；

b)、面向切面编程（AOP）/Aspects

Spring对面向切面编程提供了丰富的支持。这个模块是Spring应用系统中开发切⾯的基础，与DI⼀样，AOP可以帮助应用对象解耦。

c）、数据访问与集成（Data Access/Integration）

• Spring DAO：对JDBC的抽象封装，简化了数据访问异常的处理，并能统一管理JDBC事务；

• Spring ORM：对现有的ORM框架的支持；

• Spring的JDBC和DAO模块封装了大量的样板代码，这样可以使得数据库代码变得简洁，也可以更专注于我们的业务，还可以避免数据库资源释放失败而引起的问题。 另外，Spring AOP为数据访问提供了事务管理服务，同时Spring还对ORM进行了集成，如Hibernate、MyBatis等。该模块由JDBC、Transactions、ORM、OXM 和 JMS 等模块组成。

d)、Web 模块

提供了SpringMVC框架给Web应用，还提供了多种构建和其它应用交互的远程调用方案。 SpringMVC框架在Web层提升了应用的松耦合水平。

• Spring Web：提供了基本的面向Web的综合特性，提供对常见框架如Struts2的支持，Spring能够管理这些框架，将Spring的资源注入给框架，也能在这些框架的前后插入拦截器；

• Spring MVC：提供面向Web应用的Model-View-Controller，即MVC实现。

e)、Test

为了使得开发者能够很⽅便的进行测试，Spring提供了模块以致力于Spring应用的测试。 通过该模块，Spring为使⽤Servlet、JNDI等编写单元测试提供了⼀系列的mock对象实现。

 1.3 优势

（1）Spring属于低侵入式设计，代码的污染极低；

（2）Spring的DI机制将对象之间的依赖关系交由框架处理，降低组件的耦合性；

（3）Spring提供了AOP技术，支持将一些通用任务，如安全、事务、日志、权限等进行集中式管理，从而提供更好的复用。

（4）Spring对于主流的应用框架提供了集成支持。

 

2. IoC应用及分析

2.1 控制反转IoC

IoC： Inversion of Control (控制反转/反转控制)，注意它是⼀个技术思想，不是⼀个技术实现 。

Q1: 为什么叫做控制反转？

控制：指的是对象创建（实例化、管理）的权利

反转：控制权交给外部环境了（Spring框架、 IoC容器）

IoC解决对象之间的耦合问题 。

Q2: IoC和DI的区别？

DI： Dependancy Injection（依赖注⼊）

 

2.2 IoC应用

2.2.1 容器启动

Java环境下启动IoC容器：

• ClassPathXmlApplicationContext：从类的根路径下加载配置⽂件（推荐使⽤）
• FileSystemXmlApplicationContext：从磁盘路径上加载配置⽂件
• AnnotationConfigApplicationContext：纯注解模式下启动Spring容器
   

Web环境下启动IoC容器：

1. 从xml启动容器：

<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
    <display-name>Archetype Created Web Application</display-name>
    <!--配置Spring ioc容器的配置⽂件-->
    <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--使⽤监听器启动Spring的IOC容器-->
<listener>
    <listenerclass>org.springframework.web.context.ContextLoaderListener</listenerclass>
</listener>
</web-app>

2. 从配置类启动容器

<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
    <display-name>Archetype Created Web Application</display-name>
    <!--告诉ContextloaderListener 指定使⽤注解的⽅式启动ioc容器-->
    <context-param>
        <param-name>contextClass</param-name>
        <paramvalue>org.springframework.web.context.support.AnnotationConfigWebAppli  cationContext</param-value>
    </context-param>
    <!--配置启动类的全限定类名-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>com.lagou.edu.SpringConfig</param-value>
    </context-param>
    <!--使⽤监听器启动Spring的IOC容器-->
    <listener>
       <listenerclass>org.springframework.web.context.ContextLoaderListener</listenerclass>
    </listener>
</web-app>

@Configuration
@ComponentScan({"com.lagou.edu"})
@PropertySource({"classpath:jdbc.properties"})
public class SpringConfig {

    @Value("${jdbc.driver}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;


    @Bean("dataSource")
    public DataSource createDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driverClassName);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return  druidDataSource;
    }
}

2.2.2 Bean的实例化

⽅式⼀：使用无参构造函数实例化

<!--配置service对象-->
<bean id="userService" class="com.lagou.service.impl.TransferServiceImpl">
</bean>

方式二：使用静态工厂方法实例化：factory-method指定实例化Bean对应的Class的静态方法。

<!--使⽤静态⽅法创建对象的配置⽅式-->
<bean id="userService" class="com.lagou.factory.BeanFactory"
factory-method="getTransferService"></bean>

⽅式三：使用实例工厂实例化：factory-bean指定用来实例化bean的对应对象；factory-method指定工厂实例中用来实例化该bean的方法。

<!--使⽤实例⽅法创建对象的配置⽅式-->
<bean id="beanFactory"
class="com.lagou.factory.instancemethod.BeanFactory"></bean>
<bean id="transferService" factory-bean="beanFactory" factory-method="getTransferService"></bean>

 

2.3 源码剖析

2.3.1 BeanFactory与ApplicationContext区别

BeanFactory是Spring框架中IoC容器的顶层接口,它定义⼀些基础规范，而ApplicationContext是它的⼀个子接口，所以ApplicationContext是具备BeanFactory提供的全部功能的。
通常，我们称BeanFactory为SpringIOC的基础容器， ApplicationContext是容器的高级接口，比
BeanFactory要拥有更多的功能，比如国际化和资源访问（xml， java配置类）等等。

 

2.3.2 BeanFactory和FactoryBean区别

BeanFactory是接口，提供了IoC容器最基本的形式，给具体的IOC容器的实现提供了规范，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。FactoryBean也是接口，是个Bean，是一个能生产或者修饰对象生成的工厂Bean。

Spring中Bean有两种，⼀种是普通Bean，⼀种是工厂Bean（FactoryBean）。FactoryBean可以生成某⼀个类型的Bean实例，也就是说可以借助它自定义Bean的创建过程。FactoryBean在IOC容器的基础上给Bean的实现加上了一个简单工厂模式和装饰者模式，我们可以在getObject()方法中灵活配置。在Spring源码中有很多FactoryBean的实现类。

// ⾃定义Bean的创建过程（完成复杂Bean的定义）
public interface FactoryBean<T> {
       // 返回FactoryBean创建的Bean实例，如果isSingleton返回true，则该实例会放到Spring容器的单例对象缓存池中Map
    @Nullable    
    T getObject() throws Exception;
    
    // 返回FactoryBean创建的Bean类型
    @Nullable    
    Class<?> getObjectType();

    // 是否单例
    default boolean isSingleton() {
        return true;
    }
}

 

2.3.3 BeanPostProcessor和BeanFactoryPostProcessor区别

public interface BeanPostProcessor {
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws 	BeansException {
		return bean;
	}
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws 		BeansException {
		return bean;
	}
}

BeanPostProcessor是针对Bean级别的后置处理器，可以针对某个具体的Bean。接口提供了两个方法，分别在Bean的初始化方法前和初始化方法后执行。

定义⼀个类实现了BeanPostProcessor，默认是会对整个Spring容器中所有的bean进行处理。如果要对具体的某个bean处理，可以通过方法参数判断，两个类型参数分别为Object和String，第⼀个参数是每个bean的实例，第⼆个参数是每个bean的name或者id属性的值。所以我们可以通过第⼆个参数，来判断我们将要处理的具体的bean。处理是发生在Spring容器的实例化和依赖注入之后。

@FunctionalInterface
public interface BeanFactoryPostProcessor {
   void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

BeanFactoryPostProcessor 是BeanFactory级别的后置处理器，典型应用:PropertyPlaceholderConfigurer。

接口只提供了⼀个方法postProcessBeanFactory，也就是Spring IoC运行BeanFactoryPostProcessor在容器实例化任何其他的bean之前读取配置元数据，并可能修改它。方法参数ConfigurableListableBeanFactory，应用上下文环境获取指定的bean；

注：调用BeanFactoryPostProcessor方法时，这时候bean还没有实例化，此时bean刚被解析成BeanDefinition对象。

BeanDefinition对象：我们在XML中定义的bean标签，Spring解析bean标签成为⼀个JavaBean，这个JavaBean就是BeanDefinition。

 

2.3.4 ApplicationContext启动流程

以ClassPathXmlApplicationContext启动容器为例：

ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");

跟踪ClassPathXmlApplicationContext构造方法，构造函数调用了父类AbstractApplicationContext的refresh()方法：

public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            // 1、刷新前的预处理
            this.prepareRefresh();
            /* 2、获取BeanFactory；默认实现是DefaultListableBeanFactory
加载BeanDefition 并注册到 BeanDefitionRegistry */
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            // 3、对BeanFactory进行各种功能填充,比如context的类加载器等            
            this.prepareBeanFactory(beanFactory);
            try {
                // 4、BeanFactory准备⼯作完成后进⾏的后置处理⼯作，提供给子类覆盖做扩展处理
                this.postProcessBeanFactory(beanFactory);
                // 5、触发beanFactory的后置处理，实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean
                this.invokeBeanFactoryPostProcessors(beanFactory);
                // 6、注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后执行
                this.registerBeanPostProcessors(beanFactory);
                // 7、初始化MessageSource组件
                this.initMessageSource();
                // 8、初始化事件派发器
                this.initApplicationEventMulticaster();
                // 9、⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑
                this.onRefresh();
                // 10、注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器bean
                this.registerListeners();
                // 11、初始化所有剩下的⾮懒加载的单例bean
                this.finishBeanFactoryInitialization(beanFactory);
                /* 12、完成context的刷新。
                主要是调⽤LifecycleProcessor的onRefresh()⽅法，
                并且发布事件 （ContextRefreshedEvent）*/
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }
                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }

 

a、创建BeanFactory容器子流程

方法obtainFreshBeanFactory完成bean工厂的实例化：obtainFreshBeanFactory调用了
AbstractRefreshableApplicationContext的refreshBeanFactory()方法完成BeanFactory的刷新：

protected final void refreshBeanFactory() throws BeansException {
        // 判断是否已存在beanFactory
        if (this.hasBeanFactory()) {
            this.destroyBeans();
            this.closeBeanFactory();
        }
        try {
            // 实例化DefaultListableBeanFactory
            DefaultListableBeanFactory beanFactory = this.createBeanFactory();
            // 设置序列化ID
            beanFactory.setSerializationId(this.getId());
            // 定制bean工厂的一些属性（是否覆盖、是否允许循环依赖）
            this.customizeBeanFactory(beanFactory);
            // 加载应用中的BeanDefinition 
            this.loadBeanDefinitions(beanFactory);
            synchronized(this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        } catch (IOException var5) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
        }
    }

 

 

b、BeanDefinition加载注册子流程

流程入口在AbstractRefreshableApplicationContext#refreshBeanFactory方法中，调用AbstractXmlApplicationContext#loadBeanDefinitions(beanFactory)方法

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // 创建XmlBeanDefinitionReader -> AbstractBeanDefinitionReader
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        // resource loading environment.
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
        this.initBeanDefinitionReader(beanDefinitionReader);
        // 通过reader加载BeanDefinition
        this.loadBeanDefinitions(beanDefinitionReader);
    }

依次调用了多个类的loadBeanDefinitions方法 —>AbstractXmlApplicationContext ​ —>
AbstractBeanDefinitionReader —> XmlBeanDefinitionReader

一直执行到XmlBeanDefinitionReader的doLoadBeanDefinitions方法

    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
        try {
            // 读取xml信息，将信息保存到Document对象
            Document doc = this.doLoadDocument(inputSource, resource);
            // 解析document对象，封装BeanDefinition对象并注册
            int count = this.registerBeanDefinitions(doc, resource);
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Loaded " + count + " bean definitions from " + resource);
            }

            return count;
        } 
        ...
 catch (Throwable var10) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "Unexpected exception parsing XML document from " + resource, var10);
        }
    }

重点观察XmlBeanDefinitionReader类的registerBeanDefinitions方法：

    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
   int countBefore = getRegistry().getBeanDefinitionCount();
    // documentReader注册BeanDefinition
   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
   return getRegistry().getBeanDefinitionCount() - countBefore;
}

    // 创建XmlReaderContext
    public XmlReaderContext createReaderContext(Resource resource) {
		return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
				this.sourceExtractor, this, getNamespaceHandlerResolver());
	}
	
    public NamespaceHandlerResolver getNamespaceHandlerResolver() {
		if (this.namespaceHandlerResolver == null) {
			this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
		}
		return this.namespaceHandlerResolver;
	}

    // 此处完成了NamespaceHandlerResolver 的初始化。
    protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
		ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
		return new DefaultNamespaceHandlerResolver(cl);
	}

完成context创建后，调用注册方法DefaultBeanDefinitionDocumentReader的具体实现，doRegisterBeanDefinitions方法:

protected void doRegisterBeanDefinitions(Element root) {
		BeanDefinitionParserDelegate parent = this.delegate;
        // 根据上下文创建代理对象
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				// We cannot use Profiles.of(...) since profile expressions are not supported
				// in XML config. See SPR-12458 for details.
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isDebugEnabled()) {
						logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					return;
				}
			}
		}
		preProcessXml(root);
		// 解析元素为beanDefinition方法
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}

元素解析方法parseDefaultElement，关注bean的解析方法processBeanDefinition：

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, "import")) {
            this.importBeanDefinitionResource(ele);
        } else if (delegate.nodeNameEquals(ele, "alias")) {
            this.processAliasRegistration(ele);
        } else if (delegate.nodeNameEquals(ele, "bean")) {
            // 处理bean标签
            this.processBeanDefinition(ele, delegate);
        } else if (delegate.nodeNameEquals(ele, "beans")) {
            this.doRegisterBeanDefinitions(ele);
        }

    }

processBeanDefinition方法：beanDefinition解析，注册到beanDefinitionMap

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   // 解析bean元素为BeanDefinitionHolder 包含BeanDefinition
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {
        // 包装成Holder对象
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // 注册到beanDefinitionMap
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" +
               bdHolder.getBeanName() + "'", ele, ex);
      }
      // Send registration event.
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}

DefaultListableBeanFactory中beanDefinitionMap定义

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap(256);

BeanDefinition加载解析时序图：

 

启动过程总结：

1. 初始化前的准备工作，例如对系统属性或者环境变量进行准备及验证。

2. 初始化BeanFactory并对XML配置文件读取解析，加载BeanDefition并注册到 BeanDefitionRegistry。

3. 对BeanFactory进行各种功能填充。@Qualifier @Autowired这两个注解正是在这个步骤中增加的支持。

4. 子类覆盖postProcessBeanFactory(beanFactory)方法做后置处理。

5. 激活实现了BeanFactoryPostProcessor的所有BeanFactory后置处理器。

6. 注册拦截 bean 创建的 bean后置处理器，这里只是注册，真正的调用是在getBean 时候。

7. 为上下文初始化 Message 源，即对不同语言的消息体进行国际化处理。

8. 初始化消息广播器

9. 自定义子类刷新逻辑

10. 在所有注册的bean中查找ApplicationListener注册到消息广播器中

11. 初始化所有非延迟加载的单例bean

12. 完成刷新过程，通知生命周期处理器LifecycleProcessor刷新过程，同时发出 ContextRefreshEvent通知。

 

2.3.5 Bean的创建流程

bean创建子流程入口：AbstractApplicationContext#refresh()方法的finishBeanFactoryInitialization(beanFactory)

 查看finishBeanFactoryInitialization方法：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		......

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
        // 实例化所有的非延迟加载的单例bean
		beanFactory.preInstantiateSingletons();
	}

 

继续进入DefaultListableBeanFactory类的preInstantiateSingletons⽅法，找到触发实例化的代码，看到工厂Bean或者普通Bean，最终都是通过getBean的⽅法获取实例：

        // Trigger initialization of all non-lazy singleton beans...
        // 触发所有非延迟加载的单例初始化
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            // 是否单例 是否非延迟加载，懒加载的bean是在第一次调用context.getBean初始化
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
                    // FactoryBean前缀符号&，通过符号前缀获取实例
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					// FactoryBean处理
                    if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
                    // 实例化当前bean
					getBean(beanName);
				}
			}
		}

继续追踪到了AbstractBeanFactory类的doGetBean方法：

在AbstractAutowireCapableBeanFactory类的createBean方法，找到以下代码部分

 进入doCreateBean方法，关注两块重点：

• 创建Bean实例，此时尚未设置属性

• 给Bean填充属性，调用初始化方法，应用BeanPostProcessor后置处理器

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException 
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {            
		    // 实例化bean
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		......
        // 使用三级缓存解决循环依赖问题
        // 单例并且存在循环依赖 则提前暴露给三级缓存
        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }

            this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });
        }

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
		    // 给Bean填充属性
			populateBean(beanName, mbd, instanceWrapper);
			// 调⽤初始化⽅法，应⽤BeanPostProcessor后置处理器
			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;
	}

Spring Bean的生命周期

 1. 实例化、属性填充、aware属性设置

以AbstractAutowireCapableBeanFactory为例，initializeBean方法完成实例初始化；

其中第一部分的invokeAwareMethods：

private void invokeAwareMethods(String beanName, Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware)bean).setBeanName(beanName);
            }

            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = this.getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                }
            }

            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware)bean).setBeanFactory(this);
            }
        }

    }

调用实现Aware接口的BeanNameAware完成beanName的设置；

BeanClassLoaderAware完成BeanClassLoader设置；

BeanFactoryAware完成BeanFactory设置；

2. BeanPostProcessor处理、InitializingBean的After处理、init-method调用

initializeBean方法剩余逻辑：

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        }

        try {
            this.invokeInitMethods(beanName, wrappedBean, mbd);
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
        }

        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

执行BeanPostProcessor 的Before方法；调用InitializingBean的afterPropertiesSet 方法，定制的init-method方法；执行 BeanPostProcessor 的after方法。

 

 

总结：

BeanPostProcessor初始化时机：AbstractApplicationContext类refresh⽅法的registerBeanPostProcessors(beanFactory);

postProcessBeforeInitialization调用时机：AbstractApplicationContext类refresh⽅法的
finishBeanFactoryInitialization(beanFactory);

postProcessAfterInitialization调用时机：AbstractApplicationContext类refresh⽅法的
finishBeanFactoryInitialization(beanFactory);

 

 

 

2.3.6 循环依赖问题

Spring中循环依赖场景有：

• 构造器的循环依赖（构造器注⼊）
• Field 属性的循环依赖（set注⼊）

其中，构造器的循环依赖问题无法解决，只能拋出 BeanCurrentlyInCreationException 异常，在解决属性循环依赖时，spring采用的是提前暴露对象的⽅法。

 

循环依赖处理机制

1. 单例 bean 构造器参数循环依赖（⽆法解决）

2. prototype 原型 bean循环依赖（⽆法解决）

   if (isPrototypeCurrentlyInCreation(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
   }

3. 单例bean通过setXxx或者@Autowired进行循环依赖；

Spring使用的方法，可以形象的比喻为三级缓存机制。 比如A依赖B，B也依赖于A时，Spring的创建过程大概如下：

1. 先实例化A，执行构造函数，A的属性还没有处理完成，然后将对象A放入三级缓存

2. 接着处理A的属性，发现A依赖于B，这时候要开始创建B

3. 实例化B完成以后，开始处理B的属性，发现B依赖于A，此时就先去三级缓存中找A

4. 找到A之后，将A转移到二级缓存

5. 这时对象B已经完成了创建，被放入一级缓存

6. 接着A继续设置属性，此时一级有完整的B，A的创建也可以完成。

源码

// 一级缓存 单例对象缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
// 三级缓存 单例对象工厂缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
// 二级缓存 提前暴露的单例对象缓存
private final Map<String, Object> earlySingletonObjects = new HashMap(16);

缓存存入时机：AbstractAutowireCapableBeanFactory的doCreateBean方法；

单例对象获取过程：如果存在循环依赖的情况，依赖的对象属性已提前存入三级缓存则当前单例能够获取到属性完成初始化。

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        // 获取不到或者正在创建中（即存在依赖其他bean的情况）
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            synchronized(this.singletonObjects) {
                // 从二级缓存中获取
                singletonObject = this.earlySingletonObjects.get(beanName);
                // 获取不到并允许从三级缓存中获取
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                    // 如果从三级缓存中获取到则将从缓存中移除，并放入二级缓存
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }

        return singletonObject;
    }

 

 

3. AOP应用及分析

3.1 AOP概述

AOP: Aspect Oriented Programming，面向切面编程。
未采用AOP思想的程序，有大量的重复代码，独立性差：

 

 

横切逻辑代码：在多个纵向流程中出现的相同子流程代码；

存在的问题：

• 横切代码重复问题；
• 横切逻辑代码和业务代码混杂在⼀起，代码臃肿，维护不方便。

引入AOP后：

 

AOP的本质：在不改变原有业务逻辑情况下，增强横切逻辑代码，根本上解耦合，避免横切逻辑代码重复。横切逻辑代码主要是权限校验、日志记录、事务控制、性能监控等业务。

切：指的是横切逻辑，原有业务逻辑代码我们不能动，只能操作横切逻辑代码，所以面向横切逻辑面：横切逻辑代码往往要影响的是很多方法，每⼀个方法都如同⼀个点，多个点构成⾯，有⼀个 面的概念在里面。

 

相关术语

Aspect（切面）：增强代码所关注的方面，通常定义为一个类，包含Advice和Pointcut。

Joinpoint(连接点)：指的是那些可以用于把增强代码加⼊到业务主线中的点，通常指调用的方法

Pointcut（切入点）：指那些已经加入增强代码后的连接点。

Advice（通知/增强）：切面中用于提供增强功能的方法。

Target（目标对象）：包含连接点的对象，代理的目标对象。

Proxy（代理）：被AOP织入增强后产生的代理类。

Weaving（织入）：把增强应用到目标对象创建新的代理对象的过程。

Spring实现AOP思想使⽤的是动态代理技术。默认情况下Spring会根据目标对象是否实现接口来选择使用JDK还是CGLIB。没有任何接口时，会选择CGLIB，实现接口会选择JDK动态代理。同时支持配置强制使用CGLIB。

 

 

3.2 AOP应用

3.2.1 AOP实现方式

配置方式主要有三种：

• 使用XML配置

<bean id="logUtil" class="com.lagou.utils.LogUtil"></bean>
<!--开始aop的配置-->
<aop:config>
    <!--配置切⾯-->
    <aop:aspect id="logAdvice" ref="logUtil">
        <!--配置前置通知 切入点表达式-->
        <aop:before method="printLog" pointcut="execution(public * com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account))">                               
        </aop:before>
    </aop:aspect>
</aop:config>
    

定义切面：

<aop:aspect>

五种通知类型：

前置通知：<aop:before>

切入点正常执⾏时通知：<aop:after-returning>

异常通知：<aop:after-throwing>

最终通知：<aop:after>

环绕通知：<aop:around>

切入点表达式：

public void com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)

访问修饰符可以省略；返回值可以用*表示任意；包名可以使用..表示当前包及其子包；

 

• 使用XML+注解组合

开启AOP注解:

<aop:aspectj-autoproxy/>

 

@Aspect
public class LogUtil {
    
    // 指定切入点表达式
    @Pointcut("execution(* com.lagou.service.impl.*.*(..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void beforePrintLog(JoinPoint jp){
        Object[] args = jp.getArgs();
        System.out.println("前置通知： beforePrintLog，参数是： "+
        Arrays.toString(args));
    }
}

 

• 使用纯注解配置

开启注解：

@Configuration
@ComponentScan("com.lagou")
@EnableAspectJAutoProxy //开启spring对注解AOP的⽀持
public class SpringConfiguration {
}

 

3.2.2 Spring声明式事务支持

事务概念

事务的特性ACID

原⼦性（Atomicity） 原⼦性是指事务是⼀个不可分割的⼯作单位，事务中的操作要么都发⽣，要么都不发⽣。

⼀致性（Consistency） 事务必须使数据库从⼀个⼀致性状态变换到另外⼀个⼀致性状态。

隔离性（Isolation） 事务的隔离性是多个⽤户并发访问数据库时，数据库为每⼀个⽤户开启的事务，每个事务不能被其他事务的操作数据所⼲扰，多个并发事务之间要相互隔离。

持久性（Durability）是指⼀个事务⼀旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发⽣故障也不应该对其有任何影响。
 

事务隔离级别

 

事务传播行为

 

 

Spring的事务API

PlatformTransactionManager是Spring事务管理器核心接口。Spring本身并不支持事务实现，只是负责提供标准，应用底层支持什么样的事务，需要提供具体的实现类。此处也是策略模式的具体应用。常用的DataSourceTransactionManager、HibernateTransactionManager即具体实现。

 

事务失效场景分析？