一. Spring核心概念
在Spring核心概念这部分内容中主要包含IOC/DI
、IOC容器
和Bean
,那么问题就来了,这些都是什么呢?
1. 目前项目中的问题
要想解答这个问题,就需要先分析下目前咱们代码在编写过程中遇到的问题:
(1)业务层需要调用数据层的方法,就需要在业务层new数据层的对象
(2)如果数据层的实现类发生变化,那么业务层的代码也需要跟着改变,发生变更后,都需要进行编译打包和重部署
(3)所以,现在代码在编写的过程中存在的问题是:耦合度偏高
问题就是,业务层不想new对象,运行的时候又需要这个对象,该咋办呢?
针对这个问题,Spring就提出了一个解决方案:
-
使用对象时,在程序中不要主动使用new产生对象,转换为由外部提供对象
这种实现思就是Spring的一个核心概念
2. IOC、IOC容器、Bean、DI
① IOC(Inversion of Control)控制反转
(1)什么是控制反转呢?
-
使用对象时,由主动new产生对象转换为由外部提供对象,此过程中对象创建控制权由程序转移到外部,此思想称为控制反转。
-
业务层要用数据层的类对象,以前是自己
new
的 -
现在自己不new了,交给
别人[外部]
来创建对象 -
别人[外部]
就反转控制了数据层对象的创建权 -
这种思想就是控制反转
-
别人[外部]指定是什么呢?继续往下学
-
(2)Spring和IOC之间的关系是什么呢?
-
Spring技术对IOC思想进行了实现
-
Spring提供了一个容器,称为IOC容器,用来充当IOC思想中的"外部"
-
IOC思想中的
别人[外部]
指的就是Spring的IOC容器
(3)IOC容器的作用以及内部存放的是什么?
-
IOC容器负责对象的创建、初始化等一系列工作,其中包含了数据层和业务层的类对象
-
被创建或被管理的对象在IOC容器中统称为Bean
-
IOC容器中放的就是一个个的Bean对象
(4)当IOC容器中创建好service和dao对象后,程序能正确执行么?
-
不行,因为service运行需要依赖dao对象
-
IOC容器中虽然有service和dao对象
-
但是service对象和dao对象没有任何关系
-
需要把dao对象交给service,也就是说要绑定service和dao对象之间的关系
像这种在容器中建立对象与对象之间的绑定关系就要用到DI:
② DI(Dependency Injection)依赖注入
(1)什么是依赖注入呢?
-
在容器中建立bean与bean之间的依赖关系的整个过程,称为依赖注入
-
业务层要用数据层的类对象,以前是自己
new
的 -
现在自己不new了,靠
别人[外部其实指的就是IOC容器]
来给注入进来 -
这种思想就是依赖注入
-
(2)IOC容器中哪些bean之间要建立依赖关系呢?
-
这个需要程序员根据业务需求提前建立好关系,如业务层需要依赖数据层,service就要和dao建立依赖关系
介绍完Spring的IOC和DI的概念后,我们会发现这两个概念的最终目标就是:充分解耦,具体实现靠:
-
使用IOC容器管理bean(IOC)
-
在IOC容器内将有依赖关系的bean进行关系绑定(DI)
-
最终结果为:使用对象时不仅可以直接从IOC容器中获取,并且获取到的bean已经绑定了所有的依赖关系.
③ 核心概念小结
这节比较重要,重点要理解什么是IOC/DI思想
、什么是IOC容器
和什么是Bean
:
(1)什么IOC/DI思想?
-
IOC:控制反转,控制反转的是对象的创建权
-
DI:依赖注入,绑定对象与对象之间的依赖关系
(2)什么是IOC容器?
Spring创建了一个容器用来存放所创建的对象,这个容器就叫IOC容器
(3)什么是Bean?
容器中所存放的一个个对象就叫Bean或Bean对象
二. IOC相关内容
1. bean基础配置
对于bean的配置中,主要会讲解bean基础配置
,bean的别名配置
,bean的作用范围配置
(重点),这三部分内容:
2. bean实例化
对象已经能交给Spring的IOC容器来创建了,但是容器是如何来创建对象的呢?
就需要研究下bean的实例化过程
,在这块内容中主要解决两部分内容,分别是
-
bean是如何创建的
-
实例化bean的三种方式,
构造方法
,静态工厂
和实例工厂
在讲解这三种创建方式之前,我们需要先确认一件事:
bean本质上就是对象,对象在new的时候会使用构造方法完成,那创建bean也是使用构造方法完成的。
基于这个知识点出发,我们来验证spring中bean的三种创建方式
构造方法实例化
静态工厂实例化
具体实现步骤为:
(1)在spring的配置文件application.properties中添加以下内容:
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>
class:工厂类的类全名
factory-mehod:具体工厂类中创建对象的方法名
(2)在AppForInstanceOrder运行类,使用从IOC容器中获取bean的方法进行运行测试
public class AppForInstanceOrder { public static void main(String[] args) { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); OrderDao orderDao = (OrderDao) ctx.getBean("orderDao"); orderDao.save(); } }
(3)运行后,可以查看到结果
看到这,可能有人会问了,你这种方式在工厂类中不也是直接new对象的,和我自己直接new没什么太大的区别,而且静态工厂的方式反而更复杂,这种方式的意义是什么?
主要的原因是:
-
在工厂的静态方法中,我们除了new对象还可以做其他的一些业务操作,这些操作必不可少,如:
public class OrderDaoFactory { public static OrderDao getOrderDao(){ System.out.println("factory setup....");//模拟必要的业务操作 return new OrderDaoImpl(); } }
之前new对象的方式就无法添加其他的业务内容,重新运行,查看结果
介绍完静态工厂实例化后,这种方式一般是用来兼容早期的一些老系统,所以了解为主。
实例工厂与FactoryBean
具体实现步骤为:
(1)在spring的配置文件中添加以下内容:
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/> <bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
实例化工厂运行的顺序是:
-
创建实例化工厂对象,对应的是第一行配置
-
调用对象中的方法来创建bean,对应的是第二行配置
-
factory-bean:工厂的实例对象
-
factory-method:工厂对象中的具体创建对象的方法名,对应关系如下:
-
factory-mehod:具体工厂类中创建对象的方法名
(2)在AppForInstanceUser运行类,使用从IOC容器中获取bean的方法进行运行测试
public class AppForInstanceUser { public static void main(String[] args) { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao) ctx.getBean("userDao"); userDao.save(); } }
(3)运行后,可以查看到结果
实例工厂实例化的方式就已经介绍完了,配置的过程还是比较复杂,所以Spring为了简化这种配置方式就提供了一种叫FactoryBean
的方式来简化开发。
FactoryBean的使用
具体的使用步骤为:
(1)创建一个UserDaoFactoryBean的类,实现FactoryBean接口,重写接口的方法
public class UserDaoFactoryBean implements FactoryBean<UserDao> { //代替原始实例工厂中创建对象的方法 public UserDao getObject() throws Exception { return new UserDaoImpl(); } //返回所创建类的Class对象 public Class<?> getObjectType() { return UserDao.class; } }
(2)在Spring的配置文件中进行配置
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>
(3)AppForInstanceUser运行类不用做任何修改,直接运行
这种方式在Spring去整合其他框架的时候会被用到,所以这种方式需要大家理解掌握。
查看源码会发现,FactoryBean接口其实会有三个方法,分别是:
T getObject() throws Exception; Class<?> getObjectType(); default boolean isSingleton() { return true; }
方法一:getObject(),被重写后,在方法中进行对象的创建并返回
方法二:getObjectType(),被重写后,主要返回的是被创建类的Class对象
方法三:没有被重写,因为它已经给了默认值,从方法名中可以看出其作用是设置对象是否为单例,默认true,从意思上来看,我们猜想默认应该是单例,如何来验证呢?
思路很简单,就是从容器中获取该对象的多个值,打印到控制台,查看是否为同一个对象。
public class AppForInstanceUser { public static void main(String[] args) { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao1 = (UserDao) ctx.getBean("userDao"); UserDao userDao2 = (UserDao) ctx.getBean("userDao"); System.out.println(userDao1); System.out.println(userDao2); } }
打印结果,如下:
通过验证,会发现默认是单例,那如果想改成单例具体如何实现?
只需要将isSingleton()方法进行重写,修改返回为false,即可
//FactoryBean创建对象 public class UserDaoFactoryBean implements FactoryBean<UserDao> { //代替原始实例工厂中创建对象的方法 public UserDao getObject() throws Exception { return new UserDaoImpl(); } public Class<?> getObjectType() { return UserDao.class; } public boolean isSingleton() { return false; } }
重新运行AppForInstanceUser,查看结果
从结果中可以看出现在已经是非单例了,但是一般情况下我们都会采用单例,也就是采用默认即可。所以isSingleton()方法一般不需要进行重写。
3. bean实例化小结
通过这一节的学习,需要掌握:
(1)bean是如何创建的呢?
构造方法
(2)Spring的IOC实例化对象的三种方式分别是:
-
构造方法(常用)
-
静态工厂(了解)
-
实例工厂(了解)
-
FactoryBean(实用)
-
这些方式中,重点掌握构造方法
和FactoryBean
即可。
需要注意的一点是,构造方法在类中默认会提供,但是如果重写了构造方法,默认的就会消失,在使用的过程中需要注意,如果需要重写构造方法,最好把默认的构造方法也重写下。
三. bean的生命周期
关于bean的相关知识还有最后一个是bean的生命周期
,对于生命周期,我们主要围绕着bean生命周期控制
来讲解:
-
首先理解下什么是生命周期?
-
从创建到消亡的完整过程,例如人从出生到死亡的整个过程就是一个生命周期。
-
-
bean生命周期是什么?
-
bean对象从创建到销毁的整体过程。
-
-
bean生命周期控制是什么?
-
在bean创建后到销毁前做一些事情。
-
生命周期设置
接下来,在上面这个环境中来为BookDao添加生命周期的控制方法,具体的控制有两个阶段:
-
bean创建之后,想要添加内容,比如用来初始化需要用到资源
-
bean销毁之前,想要添加内容,比如用来释放用到的资源
步骤1:添加初始化和销毁方法
针对这两个阶段,我们在BooDaoImpl类中分别添加两个方法,方法名任意
public class BookDaoImpl implements BookDao { public void save() { System.out.println("book dao save ..."); } //表示bean初始化对应的操作 public void init(){ System.out.println("init..."); } //表示bean销毁前对应的操作 public void destory(){ System.out.println("destory..."); } }
步骤2:配置生命周期
在配置文件添加配置,如下:
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
步骤3:运行程序
运行AppForLifeCycle打印结果为:
从结果中可以看出,init方法执行了,但是destroy方法却未执行,这是为什么呢?
-
Spring的IOC容器是运行在JVM中
-
运行main方法后,JVM启动,Spring加载配置文件生成IOC容器,从容器获取bean对象,然后调方法执行
-
main方法执行完后,JVM退出,这个时候IOC容器中的bean还没有来得及销毁就已经结束了
-
所以没有调用对应的destroy方法
知道了出现问题的原因,具体该如何解决呢?
close关闭容器
-
ApplicationContext中没有close方法
-
需要将ApplicationContext更换成ClassPathXmlApplicationContext
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
-
调用ctx的close()方法
ctx.close();
-
运行程序,就能执行destroy方法的内容
注册钩子关闭容器
-
在容器未关闭之前,提前设置好回调函数,让JVM在退出之前回调此函数来关闭容器
-
调用ctx的registerShutdownHook()方法
ctx.registerShutdownHook();
注意:registerShutdownHook在ApplicationContext中也没有
-
运行后,查询打印结果
两种方式介绍完后,close和registerShutdownHook选哪个?
相同点:这两种都能用来关闭容器
不同点:close()是在调用的时候关闭,registerShutdownHook()是在JVM退出前调用关闭。
分析上面的实现过程,会发现添加初始化和销毁方法,即需要编码也需要配置,实现起来步骤比较多也比较乱。
Spring提供了两个接口来完成生命周期的控制,好处是可以不用再进行配置init-method
和destroy-method
接下来在BookServiceImpl完成这两个接口的使用:
修改BookServiceImpl类,添加两个接口InitializingBean
, DisposableBean
并实现接口中的两个方法afterPropertiesSet
和destroy
public class BookServiceImpl implements BookService, InitializingBean, DisposableBean { private BookDao bookDao; public void setBookDao(BookDao bookDao) { this.bookDao = bookDao; } public void save() { System.out.println("book service save ..."); bookDao.save(); } public void destroy() throws Exception { System.out.println("service destroy"); } public void afterPropertiesSet() throws Exception { System.out.println("service init"); } }
重新运行AppForLifeCycle类
那第二种方式的实现,我们也介绍完了。
小细节
-
对于InitializingBean接口中的afterPropertiesSet方法,翻译过来为
属性设置之后
。 -
对于BookServiceImpl来说,bookDao是它的一个属性
-
setBookDao方法是Spring的IOC容器为其注入属性的方法
-
思考:afterPropertiesSet和setBookDao谁先执行?
-
从方法名分析,猜想应该是setBookDao方法先执行
-
验证思路,在setBookDao方法中添加一句话
public void setBookDao(BookDao bookDao) { System.out.println("set ....."); this.bookDao = bookDao; }
-
重新运行AppForLifeCycle,打印结果如下:
验证的结果和我们猜想的结果是一致的,所以初始化方法会在类中属性设置之后执行。
-
bean生命周期小结
(1)关于Spring中对bean生命周期控制提供了两种方式:
-
在配置文件中的bean标签中添加
init-method
和destroy-method
属性 -
类实现
InitializingBean
与DisposableBean
接口,这种方式了解下即可。
(2)对于bean的生命周期控制在bean的整个生命周期中所处的位置如下:
-
初始化容器
-
1.创建对象(内存分配)
-
2.执行构造方法
-
3.执行属性注入(set操作)
-
4.执行bean初始化方法
-
-
使用bean
-
1.执行业务操作
-
-
关闭/销毁容器
-
1.执行bean销毁方法
-
(3)关闭容器的两种方式:
-
ConfigurableApplicationContext是ApplicationContext的子类
-
close()方法
-
registerShutdownHook()方法
-
四. DI相关内容
1.两种注入方式
-
setter注入
-
简单类型
-
引用类型
-
-
构造器注入
-
简单类型
-
引用类型
-
-
setter注入
-
简单数据类型
<bean ...> <property name="" value=""/> </bean>
-
引用数据类型
<bean ...> <property name="" ref=""/> </bean>
-
-
构造器注入
-
简单数据类型
<bean ...> <constructor-arg name="" index="" type="" value=""/> </bean>
-
引用数据类型
<bean ...> <constructor-arg name="" index="" type="" ref=""/> </bean>
-
-
依赖注入的方式选择上
-
建议使用setter注入
-
第三方技术根据情况选择
-
2. 自动配置
前面花了大量的时间把Spring的注入去学习了下,总结起来就一个字麻烦。
问:麻烦在哪?
答:配置文件的编写配置上。
问:有更简单方式么?
答:有,自动配置
什么是自动配置以及如何实现自动配置,就是接下来要学习的内容:
什么是依赖自动装配?
-
IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配
自动装配方式有哪些?
-
按类型(常用)
-
按名称
-
按构造方法
-
不启用自动装配
@Component等
名称 | @Component/@Controller/@Service/@Repository |
---|---|
类型 | 类注解 |
位置 | 类定义上方 |
作用 | 设置该类为spring管理的bean |
属性 | value(默认):定义bean的id |
@Configuration
名称 | @Configuration |
---|---|
类型 | 类注解 |
位置 | 类定义上方 |
作用 | 设置该类为spring配置类 |
属性 | value(默认):定义bean的id |
@ComponentScan
名称 | @ComponentScan |
---|---|
类型 | 类注解 |
位置 | 类定义上方 |
作用 | 设置spring配置类扫描路径,用于加载使用注解格式定义的bean |
属性 | value(默认):扫描路径,此路径可以逐层向下扫描 |
@Scope
名称 | @Scope |
---|---|
类型 | 类注解 |
位置 | 类定义上方 |
作用 | 设置该类创建对象的作用范围 可用于设置创建出的bean是否为单例对象 |
属性 | value(默认):定义bean作用范围, 默认值singleton(单例),可选值prototype(非单例) |
@PostConstruct
名称 | @PostConstruct |
---|---|
类型 | 方法注解 |
位置 | 方法上 |
作用 | 设置该方法为初始化方法 |
属性 | 无 |
@PreDestroy
名称 | @PreDestroy |
---|---|
类型 | 方法注解 |
位置 | 方法上 |
作用 | 设置该方法为销毁方法 |
属性 | 无 |
@Autowired
名称 | @Autowired |
---|---|
类型 | 属性注解 或 方法注解(了解) 或 方法形参注解(了解) |
位置 | 属性定义上方 或 标准set方法上方 或 类set方法上方 或 方法形参前面 |
作用 | 为引用类型属性设置值 |
属性 | required:true/false,定义该属性是否允许为null |
@Qualifier
名称 | @Qualifier |
---|---|
类型 | 属性注解 或 方法注解(了解) |
位置 | 属性定义上方 或 标准set方法上方 或 类set方法上方 |
作用 | 为引用类型属性指定注入的beanId |
属性 | value(默认):设置注入的beanId |
@Value
名称 | @Value |
---|---|
类型 | 属性注解 或 方法注解(了解) |
位置 | 属性定义上方 或 标准set方法上方 或 类set方法上方 |
作用 | 为 基本数据类型 或 字符串类型 属性设置值 |
属性 | value(默认):要注入的属性值 |
@PropertySource
名称 | @PropertySource |
---|---|
类型 | 类注解 |
位置 | 类定义上方 |
作用 | 加载properties文件中的属性值 |
属性 | value(默认):设置加载的properties文件对应的文件名或文件名组成的数组 |
@Bean
名称 | @Bean |
---|---|
类型 | 方法注解 |
位置 | 方法定义上方 |
作用 | 设置该方法的返回值作为spring管理的bean |
属性 | value(默认):定义bean的id |
@Import
名称 | @Import |
---|---|
类型 | 类注解 |
位置 | 类定义上方 |
作用 | 导入配置类 |
属性 | value(默认):定义导入的配置类类名, 当配置类有多个时使用数组格式一次性导入多个配置类 |
@RunWith
名称 | @RunWith |
---|---|
类型 | 测试类注解 |
位置 | 测试类定义上方 |
作用 | 设置JUnit运行器 |
属性 | value(默认):运行所使用的运行期 |
@ContextConfiguration
名称 | @ContextConfiguration |
---|---|
类型 | 测试类注解 |
位置 | 测试类定义上方 |
作用 | 设置JUnit加载的Spring核心配置 |
属性 | classes:核心配置类,可以使用数组的格式设定加载多个配置类 locations:配置文件,可以使用数组的格式设定加载多个配置文件名称 |
五. AOP简介
前面我们在介绍Spring的时候说过,Spring有两个核心的概念,一个是IOC/DI
,一个是AOP
。
前面已经对IOC/DI
进行了系统的学习,接下来要学习它的另一个核心内容,就是AOP。
对于AOP,我们前面提过一句话是:AOP是在不改原有代码的前提下对其进行增强。
对于下面的内容,我们主要就是围绕着这一句话进行展开学习,主要学习两方面内容AOP核心概念
,AOP作用
:
1.什么是AOP?
-
AOP(Aspect Oriented Programming)面向切面编程,一种编程范式,指导开发者如何组织程序结构。
-
OOP(Object Oriented Programming)面向对象编程
-
我们都知道OOP是一种编程思想,那么AOP也是一种编程思想,编程思想主要的内容就是指导程序员该如何编写程序,所以它们两个是不同的编程范式
。
2. AOP作用
-
作用:在不惊动原始设计的基础上为其进行功能增强,前面咱们有技术就可以实现这样的功能即代理模式。
前面咱们有技术就可以实现这样的功能即代理模式
。
(1)前面一直在强调,Spring的AOP是对一个类的方法在不进行任何修改的前提下实现增强。对于上面的案例中BookServiceImpl中有save
,update
,delete
和select
方法,这些方法我们给起了一个名字叫连接点
(2)在BookServiceImpl的四个方法中,update
和delete
只有打印没有计算万次执行消耗时间,但是在运行的时候已经有该功能,那也就是说update
和delete
方法都已经被增强,所以对于需要增强的方法我们给起了一个名字叫切入点
(3)执行BookServiceImpl的update和delete方法的时候都被添加了一个计算万次执行消耗时间的功能,将这个功能抽取到一个方法中,换句话说就是存放共性功能的方法,我们给起了个名字叫通知
(4)通知是要增强的内容,会有多个,切入点是需要被增强的方法,也会有多个,那哪个切入点需要添加哪个通知,就需要提前将它们之间的关系描述清楚,那么对于通知和切入点之间的关系描述,我们给起了个名字叫切面
(5)通知是一个方法,方法不能独立存在需要被写在一个类中,这个类我们也给起了个名字叫通知类
至此AOP中的核心概念就已经介绍完了,总结下:
-
连接点(JoinPoint):程序执行过程中的任意位置,粒度为执行方法、抛出异常、设置变量等
-
在SpringAOP中,理解为方法的执行
-
-
切入点(Pointcut):匹配连接点的式子
-
在SpringAOP中,一个切入点可以描述一个具体方法,也可也匹配多个方法
-
一个具体的方法:如com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
-
匹配多个方法:所有的save方法,所有的get开头的方法,所有以Dao结尾的接口中的任意方法,所有带有一个参数的方法
-
-
连接点范围要比切入点范围大,是切入点的方法也一定是连接点,但是是连接点的方法就不一定要被增强,所以可能不是切入点。
-
-
通知(Advice):在切入点处执行的操作,也就是共性功能
-
在SpringAOP中,功能最终以方法的形式呈现
-
-
通知类:定义通知的类
-
切面(Aspect):描述通知与切入点的对应关系。
小结
这一节中主要讲解了AOP的概念与作用,以及AOP中的核心概念,学完以后大家需要能说出:
-
什么是AOP?
-
AOP的作用是什么?
-
AOP中核心概念分别指的是什么?
-
连接点
-
切入点
-
通知
-
通知类
-
切面
-
@EnableAspectJAutoProxy
名称 | @EnableAspectJAutoProxy |
---|---|
类型 | 配置类注解 |
位置 | 配置类定义上方 |
作用 | 开启注解格式AOP功能 |
@Aspect
名称 | @Aspect |
---|---|
类型 | 类注解 |
位置 | 切面类定义上方 |
作用 | 设置当前类为AOP切面类 |
@Pointcut
名称 | @Pointcut |
---|---|
类型 | 方法注解 |
位置 | 切入点方法定义上方 |
作用 | 设置切入点方法 |
属性 | value(默认):切入点表达式 |
@Before
名称 | @Before |
---|---|
类型 | 方法注解 |
位置 | 通知方法定义上方 |
作用 | 设置当前通知方法与切入点之间的绑定关系,当前通知方法在原始切入点方法前运行 |
3. AOP核心概念
在上面介绍AOP的工作流程中,我们提到了两个核心概念,分别是:
-
目标对象(Target):原始功能去掉共性功能对应的类产生的对象,这种对象是无法直接完成最终工作的
-
代理(Proxy):目标对象无法直接完成工作,需要对其进行功能回填,通过原始对象的代理对象实现
上面这两个概念比较抽象,简单来说,
目标对象就是要增强的类[如:BookServiceImpl类]对应的对象,也叫原始对象,不能说它不能运行,只能说它在运行的过程中对于要增强的内容是缺失的。
SpringAOP是在不改变原有设计(代码)的前提下对其进行增强的,它的底层采用的是代理模式实现的,所以要对原始对象进行增强,就需要对原始对象创建代理对象,在代理对象中的方法把通知[如:MyAdvice中的method方法]内容加进去,就实现了增强,这就是我们所说的代理(Proxy)。
4.切入点表达式
-
切入点表达式标准格式:动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数)异常名)
execution(* com.itheima.service.*Service.*(..))
-
切入点表达式描述通配符:
-
作用:用于快速描述,范围描述
-
*
:匹配任意符号(常用) -
..
:匹配多个连续的任意符号(常用) -
+
:匹配子类类型
-
-
切入点表达式书写技巧
1.按标准规范开发 2.查询操作的返回值建议使用*匹配 3.减少使用..的形式描述包 4.对接口进行描述,使用*表示模块名,例如UserService的匹配描述为*Service 5.方法名书写保留动词,例如get,使用*表示名词,例如getById匹配描述为getBy* 6.参数根据实际情况灵活调整
5. 五种通知类型
-
前置通知
-
后置通知
-
环绕通知(重点)
-
环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
-
环绕通知可以隔离原始方法的调用执行
-
环绕通知返回值设置为Object类型
-
环绕通知中可以对原始方法调用过程中出现的异常进行处理
-
-
返回后通知
-
抛出异常后通知
通知中获取参数
-
获取切入点方法的参数,所有的通知类型都可以获取参数
-
JoinPoint:适用于前置、后置、返回后、抛出异常后通知
-
ProceedingJoinPoint:适用于环绕通知
-
-
获取切入点方法返回值,前置和抛出异常后通知是没有返回值,后置通知可有可无,所以不做研究
-
返回后通知
-
环绕通知
-
-
获取切入点方法运行异常信息,前置和返回后通知是不会有,后置通知可有可无,所以不做研究
-
抛出异常后通知
-
环绕通知
-
@EnableTransactionManagement
名称 | @EnableTransactionManagement |
---|---|
类型 | 配置类注解 |
位置 | 配置类定义上方 |
作用 | 设置当前Spring环境中开启注解式事务支持 |
@Transactional
名称 | @Transactional |
---|---|
类型 | 接口注解 类注解 方法注解 |
位置 | 业务层接口上方 业务层实现类上方 业务方法上方 |
作用 | 为当前业务层方法添加事务(如果设置在类或接口上方则类或接口中所有方法均添加事务) |