<!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>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
</web-app>

<!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>
    <param-value>
        org.springframework.web.context.support.AnnotationConfigWebApplicationContext
     </param-value>
</context-param>
 <!--配置启动类的全限定类名-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>com.lagou.edu.SpringConfig</param-value>
</context-param>
<!--使⽤监听器启动Spring的IOC容器-->
<listener>
	<listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>
</web-app>

<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">

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

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

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

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

public class TransferServiceImpl {
	@Autowired
	private AccountDao accountDao;
}

public class TransferServiceImpl {
    @Autowired
    @Qualifier(name="jdbcAccountDaoImpl")
    private AccountDao accountDao;
}

public class TransferService {
   @Resource
   private AccountDao accountDao;
   @Resource(name="studentDao")
   private StudentDao studentDao;
   @Resource(type="TeacherDao")
   private TeacherDao teacherDao;
   @Resource(name="manDao",type="ManDao")
   private ManDao manDao;
}

<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

<bean id="testBean" class="cn.lagou.LazyBean" />
该bean默认的设置为:
<bean id="testBean" calss="cn.lagou.LazyBean" lazy-init="false" />

<bean id="testBean" calss="cn.lagou.LazyBean" lazy-init="true" />

<beans default-lazy-init="true">
<!-- no beans will be eagerly pre-instantiated... -->
</beans>

public interface FactoryBean<T> {
// 返回FactoryBean创建的Bean实例，如果isSingleton返回true，则该实例会放到Spring容器的单例对象缓存池中Map
	T getObject() throws Exception;

	@Nullable
	// 返回FactoryBean创建的Bean类型
	Class<?> getObjectType();
	// 返回作⽤域是否单例
    default boolean isSingleton(){
        return true;
    }
}

<bean id="companyBean" class="com.lagou.edu.factory.CompanyFactoryBean">
	<property name="companyInfo" value="拉勾,中关村,500"/>
</bean>

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor() {
        System.out.println("BeanPostProcessor 实现类构造函数...");
    }

        public Object postProcessBeforeInitialization(Object bean, String beanName)throws BeansException {
            if("lagouBean".equals(beanName)) {
            System.out.println("BeanPostProcessor 实现类postProcessBeforeInitialization ⽅法被调⽤中");
        }
    return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName)throws BeansException {
        if("lagouBean".equals(beanName)) {
        System.out.println("BeanPostProcessor 实现类postProcessAfterInitialization ⽅法被调⽤中");
        }
        return bean;
    }
}

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public MyBeanFactoryPostProcessor() {
    	System.out.println("BeanFactoryPostProcessor的实现类构造函数...");
    }
    public void postProcessBeanFactory(ConfigurableListableBeanFactory
    beanFactory) throws BeansException {
    	System.out.println("BeanFactoryPostProcessor的实现⽅法调⽤中	  ");
    }
}

<?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
https://www.springframework.org/schema/beans/spring-beans.xsd"/>
<bean id="lagouBean" class="com.lagou.LagouBean"/>
<bean id="myBeanFactoryPostProcessor"class="com.lagou.MyBeanFactoryPostProcessor"/>
<bean id="myBeanPostProcessor" class="com.lagou.MyBeanPostProcessor"/></beans>

/*
* Ioc 容器源码分析基础案例
*/
@Test
public void testIoC() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
	LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
	System.out.println(lagouBean);
}

Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
    // 第⼀步：刷新前的预处理
    prepareRefresh();
    /*
    第二步:获取BeanFactory；默认实现是DefaultListableBeanFactory
    加载BeanDefition 并注册到 BeanDefitionRegistry
    */
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
	// 第三步:：BeanFactory的预准备⼯作（BeanFactory进⾏⼀些设置，⽐如context的类加
	prepareBeanFactory(beanFactory);
    try {  
        // 第四步：BeanFactory准备⼯作完成后进⾏的后置处理⼯作
        postProcessBeanFactory(beanFactory);
		// 第五步：实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean
		invokeBeanFactoryPostProcessors(beanFactory);

		// 第六步：注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执
		registerBeanPostProcessors(beanFactory);
        
        // 第七步：初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
        initMessageSource();
        // 第⼋步：初始化事件派发器
        initApplicationEventMulticaster();
        
		// 第九步：⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑
		onRefresh();
		// 第⼗步：注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器
		registerListeners();
        /*第⼗⼀步：
        初始化所有剩下的⾮懒加载的单例bean
        初始化创建⾮懒加载⽅式的单例Bean实例（未设置属性）
        填充属性
        初始化⽅法调⽤（⽐如调⽤afterPropertiesSet⽅法、init-method⽅法）
        调⽤BeanPostProcessor（后置处理器）对实例bean进⾏后置处
		*/
        finishBeanFactoryInitialization(beanFactory);
        /*
        完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事
        件	（ContextRefreshedEvent）
        */
       	finishRefresh();
    }

}

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

public void preInstantiateSingletons() throws BeansException {
	// 所有beanDefinition集合
	List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
	// 触发所有非懒加载单例bean的初始化
	for (String beanName : beanNames) {
		// 获取bean 定义
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// 判断是否是懒加载单例bean，如果是单例的并且不是懒加载的则在容器创建时初始化
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 判断是否是 FactoryBean
			if (isFactoryBean(beanName)) {
				final FactoryBean<?> factory = (FactoryBean<?>)getBean(FACTORY_BEAN_PREFIX + beanName);
				boolean isEagerInit;
				if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
					isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
						@Override
						public Boolean run() {
						return ((SmartFactoryBean<?>) factory).isEagerInit();
						}
					}, getAccessControlContext());
				}	
			}else {
				/*如果是普通bean则进⾏初始化并依赖注⼊，此 getBean(beanName)接下来触发的逻辑
				懒加载时 context.getBean("beanName") 所触发的逻辑是⼀样的
				*/		
				getBean(beanName);
			}
		}
	}
}

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

protected boolean isPrototypeCurrentlyInCreation(String beanName) {
	Object curVal = this.prototypesCurrentlyInCreation.get();
	return (curVal != null &&(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>)curVal).contains(beanName))));
}

try {
    //创建原型bean之前添加标记
    beforePrototypeCreation(beanName);
    //创建原型bean
    prototypeInstance = createBean(beanName, mbd, args);
}
finally {
    //创建原型bean之后删除标记
    afterPrototypeCreation(beanName);
}

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");
        }
        //将初始化后的对象提前已ObjectFactory对象注⼊到容器中
        addSingletonFactory(beanName, new ObjectFactory<Object>() {
        @Override
        public Object getObject() throws BeansException {
        return getEarlyBeanReference(beanName, mbd, bean);
        }
    });
}

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.1.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

<!--
Spring基于XML的AOP配置前期准备：
在spring的配置⽂件中加⼊aop的约束
xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
Spring基于XML的AOP配置步骤：
第⼀步：把通知Bean交给Spring管理
第⼆步：使⽤aop:config开始aop的配置
第三步：使⽤aop:aspect配置切⾯
第四步：使⽤对应的标签配置通知的类型
⼊⻔案例采⽤前置通知，标签为aop:before
-->
<!--把通知bean交给spring来管理-->
<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>

全限定⽅法名 访问修饰符 返回值 包名.包名.包名.类名.⽅法名(参数列表)
全匹配⽅式：
public void com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
访问修饰符可以省略
void com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
返回值可以使⽤*，表示任意返回值
*
com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
    包名可以使⽤.表示任意包，但是有⼏级包，必须写⼏个
*
TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
包名可以使⽤..表示当前包及其⼦包
*
..TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account
)
类名和⽅法名，都可以使⽤.表示任意类，任意⽅法
* ...(com.lagou.pojo.Account)
参数列表，可以使⽤具体类型
基本类型直接写类型名称 ： int
引⽤类型必须写全限定类名：java.lang.String
参数列表可以使⽤*，表示任意参数类型，但是必须有参数
* *..*.*(*)
参数列表可以使⽤..，表示有⽆参数均可。有参数可以是任意类型
* *..*.*(..)
全通配⽅式：
* *..*.*(..)

<aop:config proxy-target-class="true">

<! 此标签是基于XML和注解组合配置AOP时的必备标签，表示Spring开启注解配置AOP
的⽀持-->
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-
autoproxy>

<!--
    作⽤：
    ⽤于配置前置通知。
    出现位置：
    它只能出现在aop:aspect标签内部
    属性：
    method：⽤于指定前置通知的⽅法名称
    pointcut：⽤于指定切⼊点表达式
    pointcut-ref：⽤于指定切⼊点表达式的引⽤
>
<aop:before method="printLog" pointcut-ref="pointcut1"></aop:before>

<!--
    作⽤：
    ⽤于配置正常执⾏时通知
    出现位置：
    它只能出现在aop:aspect标签内部
    属性：
    method:⽤于指定后置通知的⽅法名称
    pointcut:⽤于指定切⼊点表达式
    pointcut-ref:⽤于指定切⼊点表达式的引⽤
-->
<aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>

<!--
    作⽤：
    ⽤于配置异常通知。
    出现位置：
    它只能出现在aop:aspect标签内部
    属性：
    method:⽤于指定异常通知的⽅法名称
    pointcut:⽤于指定切⼊点表达式
    pointcut-ref:⽤于指定切⼊点表达式的引⽤
-->
<aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"
></aop:after-throwing>

<!--
    作⽤：
    ⽤于配置环绕通知。
    出现位置：
    它只能出现在aop:aspect标签的内部
    属性：
    method:⽤于指定环绕通知的⽅法名称
    pointcut:⽤于指定切⼊点表达式
    pointcut-ref:⽤于指定切⼊点表达式的引⽤
-->
<aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>

<!--开启spring对注解aop的⽀持-->
<aop:aspectj-autoproxy/>

@Component
@Aspect
public class LogUtil {
/**
* 我们在xml中已经使⽤了通⽤切⼊点表达式，供多个切⾯使⽤，那么在注解中如何使⽤呢？
* 第⼀步：编写⼀个⽅法
* 第⼆步：在⽅法使⽤@Pointcut注解
* 第三步：给注解的value属性提供切⼊点表达式
* 细节：
* 1.在引⽤切⼊点表达式时，必须是⽅法名+()，例如"pointcut()"。
* 2.在当前切⾯中使⽤，可以直接写⽅法名。在其他切⾯中使⽤必须是全限定⽅法名。*/
@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));
}


@AfterReturning(value = "pointcut()",returning = "rtValue")
public void afterReturningPrintLog(Object rtValue){
	System.out.println("后置通知：afterReturningPrintLog，返回值是："+rtValue);
}
    
@AfterThrowing(value = "pointcut()",throwing = "e")
public void afterThrowingPrintLog(Throwable e){
	System.out.println("异常通知：afterThrowingPrintLog，异常是："+e);
}
    
@After("pointcut()")
public void afterPrintLog(){
	System.out.println("最终通知：afterPrintLog");
}
/**
* 环绕通知
* @param pjp
* @return
*/
@Around("pointcut()")
public Object aroundPrintLog(ProceedingJoinPoint pjp){
    Object rtValue = null;
    try{
        //前置通知
        System.out.println("前置通知");
        //1.获取参数
        Object[] args = pjp.getArgs();
        //2.执⾏切⼊点⽅法
        rtValue = pjp.proceed(args);
        //后置通知
        System.out.println("后置通知");
    }catch (Throwable t){
        //异常通知
        System.out.println("异常通知");
        t.printStackTrace();
    }finally {
        //最终通知
        System.out.println("最终通知");
    }
	return rtValue;
}

<!--开启spring对注解aop的⽀持-->
<aop:aspectj-autoproxy/>

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

/*转出账户减钱*/
update account set money=money-100 where name=‘a’;
/**转⼊账户加钱*/
update account set money=money+100 where name=‘b’;

public interface PlatformTransactionManager {
    /*
    * 获取事务状态信息
    */
   TransactionStatus getTransaction(@Nullable TransactionDefinition definition)throws TransactionException;
    /**	
    ** 提交事务
    */
    void commit(TransactionStatus status) throws TransactionException;
    /**
    ** 回滚事务
    */
    void rollback(TransactionStatus status) throws TransactionException;
}

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring context</artifactId>
    <version>5.1.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.12.RELEASE</version>
 </dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.1.12.RELEASE</version>
</dependency>

<tx:advice id="txAdvice" transaction manager="transactionManager">
<!--定制事务细节，传播⾏为、隔离级别等-->
<tx:attributes>
<!--⼀般性配置-->
<tx:method name="*" read-only="false"
propagation="REQUIRED" isolation="DEFAULT" timeout="-1"/>
<!--针对查询的覆盖性配置-->
<tx:method name="query*" read-only="true"
propagation="SUPPORTS"/>
</tx:attributes>
</tx:advice>
<aop:config>
<!--advice-ref指向增强=横切逻辑+⽅位-->
<aop:advisor advice ref="txAdvice" pointcut="execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))"/>
</aop:config>

<!--配置事务管理器-->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--开启spring对注解事务的⽀持-->
<tx:annotation-driven transaction-manager="transactionManager"/>

@Transactional(readOnly = true,propagation = Propagation.SUPPORTS)

@EnableTransactionManagement//开启spring注解事务的⽀持
	public class SpringConfiguration {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
    
}

public class InfrastructureAdvisorAutoProxyCreator extends
AbstractAdvisorAutoProxyCreator
public abstract class AbstractAdvisorAutoProxyCreator extends
AbstractAutoProxyCreator
public abstract class AbstractAutoProxyCreator extends
ProxyProcessorSupport
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Role;
import
org.springframework.transaction.config.TransactionManagementConfigUtils;import
org.springframework.transaction.interceptor.BeanFactoryTransactionAttribut eSourceAdvisor;
import
org.springframework.transaction.interceptor.TransactionAttributeSource;import org.springframework.transaction.interceptor.TransactionInterceptor;


/*
* {@code @Configuration} class that registers the Spring infrastructure beans
* necessary to enable proxy-based annotation-driven transactionmanagement.
*
* @author Chris Beams
* @since 3.1
* @see EnableTransactionManagement
* @see TransactionManagementConfigurationSelector
*/
@Configuration
public class ProxyTransactionManagementConfiguration extends
AbstractTransactionManagementConfiguration {



TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(){
    // 事务增强器
    BeanFactoryTransactionAttributeSourceAdvisor advisor = new
    BeanFactoryTransactionAttributeSourceAdvisor();
    // 向事务增强器中注⼊ 属性解析器 transactionAttributeSource
    advisor.setTransactionAttributeSource(transactionAttributeSource());
    // 向事务增强器中注⼊ 事务拦截器 transactionInterceptor
    advisor.setAdvice(transactionInterceptor());
    if (this.enableTx != null) {
    	advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
    }
	return advisor;
}



@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
// 属性解析器 transactionAttributeSource
public TransactionAttributeSource transactionAttributeSource() {
    return new AnnotationTransactionAttributeSource();
}
@Bean
@Role(BeanDefinition.ROLE INFRASTRUCTURE)
// 事务拦截器 transactionInterceptor
public TransactionInterceptor transactionInterceptor() {
    TransactionInterceptor interceptor = new TransactionInterceptor();
    interceptor.setTransactionAttributeSource(transactionAttributeSource());
    if (this.txManager != null) {
    	interceptor.setTransactionManager(this.txManager);
    }
	return interceptor;
	}
}