Spring的优势

• 方便解耦，简化开发

• AOP编程思想

• 声明式事务的支持

• 方便程序的测试

• 方便集成各种优秀框架

• 降低JavaEE api难度

核心思想

IOC（控制反转）

IOC是一个思想，具体实现由Spring实现的。IOC就是控制反转，将原来的new对象交给Spring容器管理。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yup5ElF7-1591713386731)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1588675742143.png)]

AOP（面向切面编程）

AOP是OOP（继承、封装、多态）的延续，AOP的提出解决了横向逻辑代码的增强，根本上解耦合，避免横切逻辑代码重复。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8uZSTWkk-1591713386734)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1588680327772.png)]

手写IOC和AOP问题分析

存在的问题

问题一：传统开发方式new关键字将三层架构耦合在一起；

问题二：传统开发方式没有添加事务控制，可能出现数据错乱。

问题分析

问题一：

（1）new关键字是实例化对象，解决办法可以通过反射技术获得实例化对象（Class.forName(“权限定名”)）。将类的权限定名配置在xml中。

（2）一个项目中要实例化很多个对象，可以采用工厂模式与反射技术的集合实例化对象。工厂模式是解耦合的非常好的一种方式。

问题二：

​ 分析数据库事务归根结底还是Connection事务，connection.commit()提交事务；Connection.rollback()回滚事务。

（1）两次update方法是使用的两个connection，这样就肯定不是属于一个事务控制了。

（2）事务控制目前在dao层，没有控制在service层。

解决方法:

（1）两次update方法是属于同一个线程执行的，我们可以将当前线程绑定一个connection，每次去操作数据库的时候就去调动绑定的connection（从当前线程中获取）。

Spring容器启动方式

Java环境下启动IOC容器

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

web环境下启动IOC容器

• 从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>

• 从配置类中启动容器

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

Spring IOC实例化对象的三种方式

无参构造函数

在默认情况下，它会使用反射调用无参构造函数来春创建对象，如果类中没有无参构造函数，将创建失败。

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

使用有参构造方法时，需要在标签中加上 < constructor-arg> 来指定参数。

<bean id="userService" class="com.lagou.service.impl.TransferServiceImpl"><constructor-arg index="0" value="hehe"/><constructor-arg index="1" value="shida"/>
</bean>

使用静态工厂方法创建

使用这种方式除了指定class属性，还要指定factory-method属性来实例化对象。

public class PersonServiceBeanFactory {  public static PersonServiceBean createPersonServiceBean(){  return new PersonServiceBean();  }  }  

<bean id=”personService” class=”com.spring.service.impl.PersonServiceBeanFactory” factory-method=”createPersonServiceBean”/>  

实例工厂方法创建

使用这种方法不能指定了class属性，此时必须使用factory-bean属性来指定工厂bean， factory-method属性指定实例化Bean的方法 。

public class PersonServiceBeanFactory {  public PersonServiceBean createPersonServiceBean2(){  return new PersonServiceBean();  }  
}  

<bean id=”personService” class=”com.spring.service.impl.PersonServiceBeanFactory” factory-bean=”PersonServiceBeanFacotory”  factory-method=”createPersonServiceBean”/>  

Spring Bean的生命周期

Spring创建的Bean的作用范围

Spring 创建的bean一共提供了五种作用范围，如下：

作用范围（scope）	描述
singleton（单例）	表示单例，Spring IOC容器中只会创建一个对象
prototype（原型）	改配置对Bean的请求的时候都会创建一个Bean
request	每一次的http请求，都会创建一个Bean
Session	针对每一次会话都只创建一个Bean
global

不同作用域Spring Bean的生命周期

1、单例模式（Singleton）

对象出⽣：当创建容器时，对象就被创建了。

对象活着：只要容器在，对象⼀直活着。

对象死亡：当销毁容器时，对象就被销毁了。

⼀句话总结：单例模式的bean对象⽣命周期与容器相同。

2、原型模式（prototype）

对象出⽣：当使⽤对象时，创建新的对象实例。

对象活着：只要对象在使⽤中，就⼀直活着。

对象死亡：当对象⻓时间不⽤时，被java的垃圾回收器回收了。

⼀句话总结：多例模式的bean对象，spring框架只负责创建，不负责销毁。

SpringBean的生命周期图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NJDtpUKg-1591713386735)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1589121472624.png)]

整个流程成为IOC容器。

Spring注入值的方式（DI）

构造函数注入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WiY2BFj9-1591713386737)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1589121665794.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hde3B8GI-1591713386739)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1589121653379.png)]

set方法注入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kWqOWP4h-1591713386740)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1589121694493.png)]

Spring中注解与xml开发方式的对应关系

xml形式	对应的注解形式
标签	@Component(“accountDao”)，注解加在类上 bean的id属性内容直接配置在注解后⾯如果不配置，默认定义个这个bean的id为类 的类名⾸字⺟⼩写； 另外，针对分层代码开发提供了@Componenet的三种别名@Controller、 @Service、@Repository分别⽤于控制层类、服务层类、dao层类的bean定义，这 四个注解的⽤法完全⼀样，只是为了更清晰的区分⽽已
标签的Scope属性	@Scope(“prototype”)，默认单例，注解加在类上
标签的 initmethod 属性	@PostConstruct，注解加在⽅法上，该⽅法就是初始化后调⽤的⽅法
标签的 destorymethod 属性	@PreDestory，注解加在⽅法上，该⽅法就是销毁前调⽤的⽅法

BeanFactory和FactoryBean

BeanFactory是容器的最顶层接口（详情见4.1章节），定义了容器的一些基础行为，是负责生产和管理Bean的一个工厂。

Spring中Bean有两种方式，一种是普通Bean，另一种是工厂Bean（FactoryBean），FactoryBean可以生产某一个类型的Bean的实例给我们，也就是说我们可以借助FactoryBean完成自定义Bean的创建过程。

Spring创建Bean的三种方式中的静态方法、实例化方法与FactoryBean作用类似。

// 可以让我们⾃定义Bean的创建过程（完成复杂Bean的定义）
public interface FactoryBean<T> {@Nullable// 返回FactoryBean创建的Bean实例，如果isSingleton返回true，则该实例会放到Spring容器的单例对象缓存池中MapT getObject() throws Exception;@Nullable// 返回FactoryBean创建的Bean类型Class<?> getObjectType();// 返回作⽤域是否单例default boolean isSingleton() {return true;}
}

ComanyFactoryBean类

public class CompanyFactoryBean implements FactoryBean<Company> {private String companyInfo; // 公司名称,地址,规模public void setCompanyInfo(String companyInfo) {this.companyInfo = companyInfo;}@Overridepublic Company getObject() throws Exception {// 模拟创建复杂对象CompanyCompany company = new Company();String[] strings = companyInfo.split(",");company.setName(strings[0]);company.setAddress(strings[1]);company.setScale(Integer.parseInt(strings[2]));return company;}@Overridepublic Class<?> getObjectType() {return Company.class;}@Overridepublic boolean isSingleton() {return true;}
}

XMl配置

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

测试

Object companyBean = applicationContext.getBean("companyBean");
System.out.println("bean:" + companyBean);
// 结果如下
bean:Company{name='拉勾', address='中关村', scale=500}

后置处理器

Spring提供了两种Bean的后置处理接口，一种是BeanPostProcessor和BeanFactoryPostProcessor。两者在使用上是有区别的。BeanPostProcessor是Bean级别的处理器，针对具体某个Bean进行处理。BeanFactoryPostProcessor是BeanFactory级别的处理器，是针对整个Bean工厂进行处理。

源码

public interface BeanPostProcessor {//bean初始化之前调用@Nullabledefault Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {return bean;}//bean初始化之后调用@Nullabledefault Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {return bean;}
}

public interface BeanFactoryPostProcessor {//可以通过beanFactory获取bean定义信息void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;}

SpringIOC源码分析

构建spring源码需要同maven一样的Gradle版本控制器。

Spring IOC容器体系

IOC容器是Spring的核心模块，是抽象对象管理、依赖关系管理的框架解决方案。Spring提供了很多的容器，最顶层的就是BeanFactory，它定义了所有IOC容器必须遵循的一些原则。具体的容器可以增加额外的功能。最常用的就是ApplicationContext容器。

BeanFactory具有的方法：

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gBq7cZSs-1591713386740)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1589101193236.png)]

BeanFactory容器的体系：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-28RUVVdC-1591713386741)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1589101225634.png)]

注意：

​ 许多博客说IOC容器就是一个map，这种说法不准确，IOC容器是包含SpringBean的整个生命周期。

Spring IoC容器初始化流程

Spring IoC容器初始化关键在与AbstractApplicationContext下的refresh方法。方法中包括BeanFactory的创建和处理和Bean对象的创建和处理

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

BeanFactory的创建流程

获取BeanFactory的时序图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mRCjlXMC-1591713386741)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1589104694953.png)]

Spring循环依赖

什么事循环依赖

循环依赖就是循环引用，也就是两个或两个以上的Bean互相持有对方，最终形成闭环。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J8NSzeoS-1591713386742)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1589113572985.png)]

Spring循环依赖的场景：

• 构造函数循环依赖（构造函数注入值）
• Filed属性循环依赖（set方法注入值）

其中构造函数循环依赖无法解决，只能跑出 BeanCurrentlyInCreationException 异常；在Spring中解决依赖是采用提前暴露对象的方法。

循环依赖处理机制

• 单例的bean构造参数无法解决

• prototype原型bean无法解决（因为每次请求都会创建一个bean，原型bean的管理不会交给Spring）

• 单例bean通过Set方法和@Autowired注入可以解决

  Spring解决此类循环依赖是基于java的引用传递，当获得对象的引用时，对象的属性值可以通过延后设置的。Spring通过Set方法和@Autowired方法解决循环依赖的问题就是通过以前暴露一个objectFactory的对象来完成的，简单来说就是ClassA在调用构造函数完成对象的实例化后，在调用ClassA的set方法之前将ClassA的实例化对象通过ObjectFactory暴露出来。

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OBmCzaZ6-1591713386742)(C:\Users\18180408327\AppData\Roaming\Typora\typora-user-images\1589114327835.png)]

  • Spring容器初始化ClassA通过构造器初始化对象后立马放入三级缓存。
  • ClassA调用setClassB方法，此时Spring尝试初始化ClassB。
  • Spring初始化过程中也会方如三级缓存中暴露自己，同时发现依赖ClassA，就会去三级缓存中找尚未成型的ClassA。同时ClassB赋值完成之后，会升级到二级缓存中。
  • CLassB创建完成之后就会放在一级缓存中（单例池）。
  • 此时ClassA调用setClassB方法，就回去单例池中去找ClassB。

AOP高级应用与源码分析

Aop的本质：在不改变原有业务逻辑的前提下增强横切逻辑，横切逻辑代码往往是权限校验、日志代码、事务控制代码、性能监控代码。

AOP相关术语

名词	解释
Joinpoint(连接点)	方法开始时、方法介绍时、方法完成时、方法异常时等这些异常时机点。
Pointcut（切入点）	指定AOP思想想要影响的具体方法。
Advice（增强）	分为两个层次： 第一个层次：横切逻辑。 第二个层次：方位点，（在某一个连接点上加入横切逻辑，那么这些连接点就叫方位点）
Target（目标对象）	指代理的目标对象，即被代理的对象
Proxy（代理对象）	指一个类被AOP织入增强后，产生的代理对象
Aspect(切面)	切面就是上述的的一个综合体 Aspect切面=切入点+增强=切入点+横切逻辑+方位点

众多的概念，⽬的就是为了锁定要在哪个地⽅插⼊什么横切逻辑代码

Spring AOP的配置方式

纯Xml方式

引入jar包

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

五种通知类型

• 前置通知

  配置方式：aop:before标签

  <!--作⽤：⽤于配置前置通知。出现位置：它只能出现在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" pointcutref="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:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>
  

  最终通知的执⾏时机是在切⼊点⽅法（业务核⼼⽅法）执⾏完成之后，切⼊点⽅法返回之前执⾏。 换句话说，⽆论切⼊点⽅法执⾏是否产⽣异常，它都会在返回之前执⾏。 最终通知执⾏时，可以获取到通知⽅法的参数。同时它可以做⼀些清理操作。

• 环绕通知

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

  **特别说明**环绕通知，它是有别于前⾯四种通知类型外的特殊通知。前⾯四种通知（前置，后置，异常和最终）
  它们都是指定何时增强的通知类型。⽽环绕通知，它是Spring框架为我们提供的⼀种可以通过编码的
  ⽅式，控制增强代码何时执⾏的通知类型。它⾥⾯借助的ProceedingJoinPoint接⼝及其实现类，
  实现⼿动触发切⼊点⽅法的调⽤。
  

xml+注解

• XML 中开启 Spring 对注解 AOP 的⽀持

<!--开启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;}
}

注解

• 在使⽤注解驱动开发aop时，我们要明确的就是，是注解替换掉配置⽂件中的下⾯这⾏配置：

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

• 在配置类中使⽤如下注解进⾏替换上述配置

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

Spring声明式事务

事务的特性

• 原子性： 事务操作时一组不可分割的操作。事务中的操作要么都发送，要么都不发生。
• 一致性：事务必须使数据库从一个一致性状态到另一个一致性状态。
• 隔离性：每个事务是互相不影响的。
• 持久性：事务一旦被提交是不可逆转的，是永久性的改变。

事务的隔离级别

不考虑事务隔离级别的话，会发生以下情况：

• 脏读 ： 一个线程中的事务读到了另一个事务尚未提交的数据。
• 不可重复读： 针对的是update操作。一个线程的事务读到了另一个事务已经提交的update操作。（数据前后不一致）
• 虚读： 针对的是insert和delete操作。一个线程的事务读到了另一个事务已经提交的insert和delete操作。（前后数据个数不一致）

数据库事务隔离级别

• Serializable （串行化）:可以避免脏读、不可重复读、虚读。就是事务来的时候，一个一个排队操作
• Repeatable read (可重复读)：可以避免脏读、不可重复读。对要update记录行枷锁。
• Read Committed（读已提交）：可以避免脏读。
• Read Uncommitted(读未提交)：最低级别 ，什么都无法保证。

事务的传播行为

传播行为	含义
PROPAGATION_REQUIRED	如果当前没有事务，就新建⼀个事务，如果已经存在⼀个事务中， 加⼊到这个事务中。这是最常⻅的选择。
PROPAGATION_SUPPORTS	⽀持当前事务，如果当前没有事务，就以⾮事务⽅式执⾏。
PROPAGATION_MANDATORY	使⽤当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED	以⾮事务⽅式执⾏操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER	以⾮事务⽅式执⾏，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执⾏。如果当前没有事务，则 执⾏与PROPAGATION_REQUIRED类似的操作。

基于XMl+注解的方式

XML

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

注解

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

Spring用到的设计模式

工厂模式

单例模式

策略模式（一个题不同的解法）

适配器模式

装饰者模式

模板方法模式

代理模式

静态代理

动态代理

​ 动态代理有JDK自带的JDK动态代理和第三方实现的CGLIB动态代理，两者区别在于：JDK动态代理需要被代理对象实现接口，而CGLIB不需要被代理对象实现接口。所以Spring在设计时选择动态代理时，是根据被代理对象是否实现接口来选择代理模式。也可以配置强制使用某种代理模式。

JDK动态代理

CGLIB动态代理

存在事务，则抛出异常。 |
| PROPAGATION_NESTED | 如果当前存在事务，则在嵌套事务内执⾏。如果当前没有事务，则 执⾏与PROPAGATION_REQUIRED类似的操作。 |

基于XMl+注解的方式

XML

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

注解

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

Spring用到的设计模式

工厂模式

单例模式

策略模式（一个题不同的解法）

适配器模式

装饰者模式

模板方法模式

代理模式

静态代理

动态代理

​ 动态代理有JDK自带的JDK动态代理和第三方实现的CGLIB动态代理，两者区别在于：JDK动态代理需要被代理对象实现接口，而CGLIB不需要被代理对象实现接口。所以Spring在设计时选择动态代理时，是根据被代理对象是否实现接口来选择代理模式。也可以配置强制使用某种代理模式。

JDK动态代理

CGLIB动态代理