原视频:https://www.bilibili.com/video/BV1Fi4y1S7ix?p=1 P1~P42
目录
建议学习完maven项目结构与设计模式后学习
Spring 技术是JavaEE开发必备技能,企业开发技术选型命中率>90%,从专业角度上来说Spring能够帮我们简化开发,减低企业级开发的复杂度,并且能高效的整合其他技术,提高企业级应用开发与一运行效率。
我们就简化开发和框架整合这两个特点我们进行学习。Spring提供了两个大的核心技术IOC、AOP,正是因为有这两个技术的存在,才能够简易开发。而在AOP思想下又衍生出了事务处理,它是Spring中的一个亮点,能让我们的事务编写更高效、更简单、并且功能更强大。
Spring 框架还整合了市面上主流的几乎所有框架,如MyBatis、MyBatis-plus等等。
Spring 这项技术自诞生就一直爆火的原因不单单是提供了几项功能,而是诞生了非常不错的设计思想,这是我们需要重点去学习的。再去学习基础操作,思考操作与设计思想间的联系。
官网:https://spring.io/ Spring 发展到今天已经形成了一种开发的生态圈,Spring 提供了若干个项目,每个项目用于完成特定的功能
SpringBoot:使用SpringBoot技术可以在Spring技术的简化开发下加速开发,能让原先的Spring开发更加的简单、书写更少的东西
Spring Cloud:分布式开发相关技术
2002年,Rod Jahnson在《Expert One-on-One J2EE Design and Development》书中首次推出了Spring框架雏形interface21框架。
并在2004年时诞生了Spring 的第一个版本,每个版本都有各自的特点
Spring 1.0 使用纯配置的形式开发的 Spring 2.0 引入了注解的功能 Spring 3.0 可以不写配置的功能 Spring 4.0 紧跟JDK的更新,对部分API做了些许调整 Spring 5.0 全面支持JDK8,所有想做Spring开发JDK版本必须得是8或以上
Spring Framework是Spring生态圈中最基础的项目,是其他项目的根基。因为5版本最新的架构图官方并没有放出,所以我们主要学的是4版本的架构图。
Spring的架构是上层依赖下层运行的
IoC(Inversion of Control)控制反转
使用对象时,由主动new产生对象转换为由外部提供对象,此过程中对象创建控制权转移到外部,此思想称为控制反转
Spring技术对IoC思想进行了实现 Spring 提供了一个容器,称为IoC容器,用来充当IoC思想中的“外部”。IoC容器负责对象的创建、初始化等一系列工作,被创建或被管理的对象在IoC容器中统称为Bean
DI(Dependency Injection)依赖注入 在容器中建立bean与bean之间的依赖关系的整个过程,称为依赖注入
使用IoC容器管理bean(IoC),在IoC容器内将有依赖关系的bean进行关系绑定(DI)。这样在使用对象时不仅可以直接从IoC容器中获取,并且获取的bean已经绑定了所有的依赖关系,从而达到充分解耦的目的。
Ioc 主要是用来管理Service与Dao。通过配置文件通知被Ioc被管理的对象。被管理的对象交给Ioc容器,通过接口就能获取到Ioc容器。IoC容器得到后,再通过接口方法从容器中获取bean。使用Spring导入pox.xml坐标
实现步骤: ①:在pom.xml中导入Spring坐标
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
</dependencies>
点击刷新后,Maven项目依赖项中出现了如图依赖性即可进行下一步
②:定义Spring管理的类(接口)
package com.itheima.dao.impl;
public interface BookDao {
void save();
}
package com.itheima.dao.impl;
public class BookDaoImpl implements BookDao{
@Override
public void save() {
System.out.println("ok,兄弟们全体目光向我看齐");
}
}
package com.itheima.service.impl;
public interface BookService {
void save();
}
package com.itheima.service.impl;
import com.itheima.dao.impl.BookDao;
public class BookServiceImpl implements BookService {
BookDao bookDao = new BookDao();
public void save() {
System.out.println("ok,兄弟们全体目光向我看起,看我看我");
bookDao.save();
}
}
③:创建名为applicationContext.xml的Spring配置文件,配置对应类作为Spring管理的bean
<?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">
<!--1.导入spring的坐标spring-context,对应的版本是5.2.10.RELEASE-->
<!--2.配置bean-->
<!--bean标签表示配置bean
id属性表示给bean起名字
class属性表示给bean定义类型-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl"/>
</beans>
bean定义时id属性在同一个上下文中不能重复
④:初始化IoC容器(Spring核心容器/Spring容器),通过容器获取bean。创建一个新的App.Java文件
package com.itheima.dao.impl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
class APP {
public static void main(String[] args) {
//3.获取IoC容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//4.获取bean
BookService bookService =(BookService) ctx.getBean("bookService");
bookService.save();
}
}
单单到这,还不能称为充分解耦了,因为我们还在用new的方式创建对象。
基于IoC管理bean,通过配置的方式描述Service与Dao间的关系。service中不使用new的形式创建Dao对象。Service中需要的Dao对象通过我们提供的方法进入Service中。
实现步骤: ①:删除使用new的形式创建对象的代码,并提供了一个set方法
package com.itheima.service.impl;
import com.itheima.dao.impl.BookDao;
public class BookServiceImpl implements BookService {
//5.删除业务层中使用new的方式创建的dao对象
BookDao bookDao;
public void save() {
System.out.println("ok,兄弟们全体目光向我看起,看我看我");
bookDao.save();
}
//6.提供对应的set方法
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
}
②:配置service和dao之间的关系
<?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">
<!--1.导入spring的坐标spring-context,对应的版本是5.2.10.RELEASE-->
<!--2.配置bean-->
<!--bean标签表示配置bean
id属性表示给bean起名字
class属性表示给bean定义类型-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
<!--7.配置server与dao的关系-->
<!--property标签表示配置当前bean的属性
name属性表示配置哪一个具体的属性
ref属性表示参照哪一个bean-->
<property name="bookDao" ref="bookDao"/>
</bean>
</beans>
到这我们就完成了IoC与DI的入门,并完成了案例的解耦
基础配置
而在工作中,我们常常会跟其他程序员一同完成项目,而每个人的命名习惯不同,所以就有了bean可以起多个名称。也就是bean的别名
别名配置
bean的别名在非常多的地方都可以使用,也可以在ref中充当bean的名称,但一般不建议这么写
作用范围配置
单例与非单例就是说这个对象是一个还是多个,可以看下设计模式中的单例模式的描述了解一下。
bean作用范围说明 Spring容器主要是帮我们管理可以复用的对象,比如:
像有状态(记录成员变量属性)的封装实体的域对象就不适合交给容器管理。
所以bean的作用范围实际上就是控制bean创建的实例的数量的。
bean一共有以下三种实例化的方式:
对于bean来说本质上就是对象,创建bean当然也可以使用构造方法完成
无参构造方法如果不存在,将会抛出异常BeanCreationException
阅读异常小技巧
Spring 的异常报错是非常有规律的,当抛出异常信息后,直接从最下面一行开始阅读,当最下面一行问题解决了,异常也就解决了。如果没有解决就往上看,而上一行的信息其实后面往往会链着下一行的信息。
工厂说的是一种设计模式,能有效解耦。
factory-method:表示创建对象的方法 class:表示工厂类
通过观察实例工厂的使用方式,我们得知想要使用工厂,必须先创建工厂类的实例化对象。 所以需要先配置工厂对象的bean,再然后配置通过工厂对象创建的对象的bean。 但仔细观察,第一个除了用来被bean指定factory-bean属性外好像并没有任何用处,非常多余。 而且factory-method方法名不同每次需要配置,对此Spring对这两个缺点进行了改良。
Spring 为我们提供了一个 FactoryBean接口,泛型中指定的是工厂创建的对象。实例化接口,getObject返回值为对象实例。getObjectType()返回值为FactoryBean中指定的泛型的字节码。
这样创建出来的对象是一个单例对象,当然我们可以通过重写isSingleton()方法,将返回值改为true就能创建非单例对象。
生命周期表示从创建到消亡的完整过程。bean生命周期指bean从创建到销毁的整体过程。bean生命周期控制指的是在bean创建后到销毁前做一些事情。
而Spring也给我们提供了两种控制生命周期的方案: 1):配置控制
2):接口控制(了解即可)
bean的生命周期
向一个类中传递数据有普通方法(set)与构造方法。依赖注入描述了容器中建立bean与bean之间依赖关系的过程,如果bean运行需要数字或字符串,就需要区分引用类型与简单类型(基本数据类型与String)
依赖注入的方式一共有两种
它们之间又有简单类型与引用类型之分
引用类型
简单类型
引用类型(了解即可)
简单类型(了解即可)
参数适配(了解即可)
依赖注入方式选择
Ioc容器根据bean所依赖的资源在容器中自动查找并注入到bean的过程称为自动装配
自动装配的方式
依赖自动装配特征
只需要了解注入的格式即可,格式其实还是setter注入的格式
<property name="array">
<array>
<value>100</value>
<value>200</value>
<value>300</value>
</array>
</property>
<property name="list">
<list>
<value>a</value>
<value>b</value>
<value>c</value>
</list>
</property>
<property name="list">
<list>
<value>a</value>
<value>b</value>
<value>c</value>
</list>
</property>
<property name="set">
<set>
<value>a</value>
<value>b</value>
<value>c</value>
</set>
</property>
<property name="map">
<map>
<entry key="county" value="china"/>
<entry key="province" value="henan"/>
<entry key="city" value="kaifeng"/>
</map>
</property>
<property name="properties">
<props>
<prop key="country">china</prop>
<prop key="province">henan</prop>
<prop key="city">kaifeng</prop>
</props>
</property>
在开发的过程中,我们并不一定都是管理自己写的bean,有时还要管理同事写的或是第三发引入的bean。我们需要学会如何自行判断使用何种注入方式以及配置bean。
原视频讲解链接:https://www.bilibili.com/video/BV1Fi4y1S7ix?p=17&vd_source=8ae265768486246506e74053a00b60db
我们知道在开发中我们不一定会将对象值写死,尤其是用户名密码,更多的我们会放在properties文件中。spring也提供了我们加载properties文件的方法。
纯记忆,只需要记住是这么写的就行。并且还有一些格式上的去呗
创建容器
获取bean
类层次结构
容器每当发现需要增加新的功能时,就会增加一个子接口来丰富容器内容,这样的设计思想也是值得我们学习的
BeanFactory初始化
容器相关
bean相关
依赖注入相关
为了发挥Spring的强项,简化开发,从Spring 2.0开始,Spring 逐步提供了各种各样的注解
使用 @Component("组件名称")
定义bean
package com.itheima.dao.Impl;
import com.itheima.dao.BookDao;
import org.springframework.stereotype.Component;
@Component("bookDao")
public class BookDaoImpl implements BookDao {
public void save(){
System.out.println("book dao save...");
}
}
核心配置文件中通过<context:component-scan base-package="被扫描类的位置"/>
组件扫描加载bean
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.itheima.dao.Impl"/>
</beans>
为了方便我们开发理解,Spring提供@Component注解的三个衍生注解
这些衍生的注解与Component功能性是一样的,只是为了我们方便开发。
Spring3.0升级了纯注解开发模式,使用Java类替代配置文件,开启了Spring快速开发赛道
只需要下面两个注解,java类代替了原来的Spring核心配置文件
@Configuration
@ComponentScan("包名")
public class SpringConfig{
}
@ComponentScan({"com.service","com.dao"})
读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象
//加载配置文件初始化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//加载配置类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
使用@Scope
定义bean作用范围,与上面一样singleton为单例(默认),而prototype为非单例
@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
}
使用@PostConstruct
、@PreDestroy
定义bean生命周期
@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
public BookDaoImpl(){
System.out.println("book dao constructor ...");
}
@PostConstruct
public void init(){
System.out.println("book init ...");
}
@PreDestroy
public void destroy(){
System.out.println("book destroy ...");
}
}
@Service
public class BookServiceImpl implements BookService {
@Autowired
private BookDao bookDao;
public void save() {
System.out.println("book service save ...");
bookDao.save();
}
}
注意:自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据,因此无需提供setter方法
注意:自动装配建议使用无参构造方法创建对象(默认),如果不提供对应构造方法,请提供唯一的构造方法
@Qualifier
注解开启指定名称装配bean@Service
public class BookService implements BookService {
@Autowired
@Qualifier("bookDao")
private BookDao bookDao;
}
注意:@Qualifier注解无法单独使用,必须配合@Autowired注解使用
@Value
注解@Repositroy("bookDao")
public class BookDaoImpl implements BookDao {
@Value("100")
private String connectionNum;
}
@PropertySource
注解加载properties文件@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
public class SpringConfig {
}
注意:路径仅支持单一文件配置,多文件请使用数组格式配置,不允许使用通配符*
使用@Bean
配置第三方bean
@Configuration
public class SpringConfig{
//1.定义一个方法获得要管理的对象
//2.添加@Bean,表示当前方法的返回值是一个bean
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
ds.setUsername("root");
ds.setPassword("root");
return ds;
}
}
使用独立的配置类管理第三方bean,将独立的配置类加入核心配置
@Configuration
public class JdbcConfig{
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
ds.setUsername("root");
ds.setPassword("root");
return ds;
}
}
public class JdbcConfig {
@bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
//相关配置
return ds;
}
}
使用@Import注解手动加入配置类到核心配置,此注解只能添加一次,多个数据请用数组格式
@Configuration
@Import(JdbcConfig.class)
public class SpringConfig{
}
@Configuration
public class JdbcConfig {
@Bean
public DataSource dataSource() {
DruidDataSource ds = new DruidDataSource();
//相关配置
return ds;
}
}
使用@ComponentScan注解扫描配置类所在的包,加载对应配置类信息
@Configuration
@ComponentScan({"com.itheima.config","com.itheima.service","com.itheima.dao"})
public class SpringConfig{
}
由于第二种方式的隐藏性太强,我们常常找不到哪个用的哪个,所以不推荐使用
假如第三方bean需要依赖其他的bean时
首先需要在pom.xml引入两个新的包
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>SpringDemo</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>//spring核心
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>//数据源
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
<dependency>//mybatis
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<dependency>//mysql
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>//新:spring整合mybatis引入的jdbc包
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>//新:配合spring整合mybatis的包,它是由mybatis提供的
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
</dependencies>
</project>
将之前mybatis的配置文件替换成spring整合的,其实这个文件就可以删掉了。
但删掉归删掉,文件里面的配置还是需要有相对应的配置来转化
对于原来的映射配置的读取,也转换成一个bean
首先需要引入两个新包,与上面一样,一个是Spring整合Junit的包,一个是配合Spring整合的包
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.10.PELEASE</version>
</dependency>
测试用例一般测试的是业务层,所以代码要写在Service业务层
AOP(Aspect Oriented Programming)面向切面编程,一种编程范式,指导开发者如何组织程序结构。经常被人提起的还有OOP(Object Oriented Programming)面向对象编程,它们都是一种编程思想。
AOP的作用:在不惊动原始设计的基础上为其进行功能增强
在图中蓝色区域是一模一样的,属于共性功能,一般被称为通知,将其包装到新的类中,一般称这个类为通知类。而浅红色区域都可以被追加功能,我们称其为连接点。被追加功能的连接点,需要给它定义一个切入点,切入点说明了哪些连接点需要被添加新的功能。而切面描述的是通知的共性功能与切入点的关系,有了这个关系就知道各个方法追加的功能。
AOP入门案例 案例设计:在接口执行前输出当前系统时间。 开发模式:XML or 注解。 思路分析:
首先在BookDaoImpl类中,写好了save和updata两个方法
package com.itheima.dao.Impl;
import com.itheima.dao.BookDao;
import org.springframework.stereotype.Component;
@Component("bookDao")
public class BookDaoImpl implements BookDao {
public void save(){
System.out.println(System.currentTimeMillis());
System.out.println("book dao save...");
}
public void updata(){
System.out.println("book dao updata ...");
}
}
SpringConfig类中简单配置一下
package com.itheima.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}
APP类中加载Bean,运行执行save方法时会输出一次当前系统时间,而执行updata并不会
package com.itheima;
import com.itheima.config.SpringConfig;
import com.itheima.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App {
public static void main(String[] args){
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
bookDao.save();
}
}
要求在不改变BookDaoImpl中的代码,让我们在执行updata方法时也打印一次当前系统
接着按照上面拟定的顺序来开始编写 1.导入坐标
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
2.定义接口与实现类
public interface BookDao {
public void save();
public void updata();
}
@Repository
public class BookDaoImpl implements BookDao {
public void save(){
System.out.println(System.currentTimeMillis());
System.out.println("book dao save...");
}
public void updata(){
System.out.println("book dao updata ...");
}
}
3.定义通知类,制作通知
public class MyAdvice {
public void method(){
System.out.println(System.currentTimeMillis());
}
}
4.定义切入点
public class MyAdvice {
@Pointcut("executtion(void com.itheima.dao.BookDao.update()")
private void pt(){}
}
说明:切入点定义依托一个不具有实际意义的方法进行,即无参数,无返回值,方法体无实际逻辑
5.绑定切入点与通知的关系(切面),并指定通知添加到原始连接点的具体执行位置
public class MyAdvice {
@Pointcut("executtion(void com.itheima.dao.BookDao.update()")
private void pt(){}
@Before("pt()")
public void defore(){
System.out.println(System.currentTimeMillis());
}
}
6.定义通知类受Spring容器管理,并定义当前类为切面类
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Before("pt()")
public void before(){
System.out.println(System.currentTimeMillis());
}
}
7.开启Spring对AOP注解驱动支持
@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}
AOP 工作流程
AOP核心概念
SpringAOP本质就是代理模式
切入点:要进行增强的方法 切入点表达式:要进行增强的方法的描述方式
描述方式一:执行com.itheima.dao包下的BookDao接口中的无参数update方法
execution(void com.itheima.dao.BookDao.update())
描述方式二:执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法
execution(void com.itheima.dao.impl.BookDaoImpl.update())
因为是面向接口编程,实际上最后运行的还是实现类,所以这两种描述方式都可以
切入点表达式标准格式:动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数)异常名)
execution(public User com.itheima.service.UserService.findById(int))
可以使用通配符描述切入点,快速描述
execution (public * com.itheima.*.UserService.find* (*))
匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法
execution (public User com..UserService.findById (..))
匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法
execution(* *..*Service+.*(..))
书写技巧
AOP通知描述了抽取的共性功能,根据共性功能抽取的位置不同,最终运行代码时要将其加入到合理位置 AOP通知共分为5种类型,作用都是设置当前通知方法与切入点之间的绑定关系
@Before("pt()")
public void before(){
System.out.println("before advice...");
}
运行结果
before advice...
//原始切入点方法
@After("pt()")
public void after(){
System.out.println("after adivce...")
}
运行结果
//原始切入点方法
before advice...
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("around before advice ...");
Object ret = pjp.proceed();
System.out.println("around after advice ...");
return ret;
}
注意实现
@AfterReturning("pt()")
public void afterReturning() {
System.out.println("afterReturning advice ...");
}
@AfterThrowing("pt()")
public void AfterThrowing() {
System.out.println("afterThrowing advice ...");
}
五种通知类型都有相关属性:value(默认)切入点方法名,格式为类名.方法名()
案例:测量业务层接口万次执行效率
需求:任意业务层接口执行均可显示其执行效率(执行时长) 分析:
核心代码:
@Around("ProjectAdvice.servicePt()")
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currenTimeMillis();
for (int i = 0; i < 10000; i++) {
pjp.proceed();
}
long end = System.currentTimeMillis();
System.out.println("业务层接口万次执行时间:"+(end-start)+"ms");
}
但我们敲完运行后发现,结果确实可以测得切入点方法执行效率。但并不能区分执行的是哪个方法,需要做些修改
@Around("ProjectAdvice.servicePt()")
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
//获取执行签名信息
Signature signature = pjp.getSignature();
//通过签名获取执行类型(接口名)
String className = signature.getDeclaringTypeName();
//通过签名获取执行操作名称(方法名)
String methodName = signature.getName();
long start = System.currenTimeMillis();
for (int i = 0; i < 10000; i++) {
pjp.proceed();
}
long end = System.currentTimeMillis();
System.out.println("万次执行时间:"+className + "." + methodName + "---->" (end-start)+"ms");
}
获取方法数据的前提是获取的数据存在:如获取切入点方法的返回值,但方法使用的是前置通知,没有返回值,就不能获取。
获取切入点方法的数据有三种:
获取参数
JoinPoint对象描述了连接点方法的运行状态,可以获取到原始方法的调用参数
@Before("pt()")
public void before(JoinPoint jp) {
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
}
ProceedJoinPoint是JoinPoint的子类
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
Object ret = pjp.proceed();
return ret;
}
获取返回值
@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(String ret) {
System.out.println("afterReturning advice ..."+ret);
}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
Object ret = pjp.proceed();
return ret;
}
获取异常(了解)
@AfterReturning(value = "pt()",throwing = "t")
public void afterReturning(Throwable t) {
System.out.println("afterReturning advice ..."+t);
}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) {
Object ret = null;
try {
ret = pjp.proceed();
} catch (Throwable t) {
t.printStackTrace();
}
return ret;
}
事务的作用:在数据层保障一系列的数据库操作同成功同失败 Spring事务的作用:在数据层或业务层保障一系列的数据库操作同成功同失败
案例:银行账户转账 模拟银行账户间转账业务,A账户减钱,B账户加钱 分析: ①:数据层提供基础操作,指定账户减钱(outMoney),指定账户加钱(inMoney) ②:业务层提供转账操作(transfer),调用减钱与加钱的操作 ③:提供2个账号和操作金额执行转账操作 ④:基于Spring整合MyBatis环境搭建上述操作
首先数据库中就是Tom和Jerry两个账户的金额
业务层接口
public interface AccountService {
/**
* 转账操作
* @parom out 传出方
* @parom in 引入方
* @parom money 金额
*/
public void transfer(String out,String in,String money);
}
数据层接口
public interface AccountDao {
//进钱操作
@Update("updata tbl_account set money = money + #{money} where name = #{name}")
void inMoney(@Param("name") String name,@Param("money") Double money);
//出钱操作
@Update("updata tbl_account set money = money 1 #{money} where name = #{name}")
void outMoney(@Param("name") String name,@Param("money") Double money);
}
业务层实现类
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
//调用进钱和出钱的操作
public void transfer(String out,String in,Double money) {
accountDao.outMoney(out,money);
accountDao.inMoney(in,money);
}
}
测试用例
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer() throws IOException {
accountService.transfer("Tom","Jerry",100D )
}
}
调用测试用例后查看数据库数据,转账操作完成。
现在在业务层转账功能中间加上一段代码,模拟系统出现异常。
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
//调用进钱和出钱的操作
public void transfer(String out,String in,Double money) {
accountDao.outMoney(out,money);
int i = 1/0;
accountDao.inMoney(in,money);
}
}
程序出现异常后,转账失败,但是异常之前操作成功,异常之后操作失败,整体业务失败
Spring事务就是为了防止此类事件的发生,成则共成,败则同败。
Spring事务开启方法
①:在业务层接口上添加Spring事务管理
public interface AccountService {
@Transactional
public void transfer(String out,String in,Double money);
}
Spring注解式事务通知添加在业务层接口中而不会添加到业务层实现类中,降低耦合。 注解式事务可以添加到业务方法上表示当前方法开启事务,也可以添加到接口上表示当前接口所有方法开启事务
②:设定事务管理器
@Bean
Public PlatformTransactionManager transactionManager(DataSource dataSource){
DataSoureTransactionManager ptm = new DataSourceTransactionManager();
ptm.setDataSource(dataSource);
return ptm;
}
事务管理器要根据实现技术进行选择 Mybatis框架使用的是JDBC事务
③:开启注解式事务驱动
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}
Spring事务角色 在上述案例中的加钱和减钱操作其实也开启了事务
如果发生异常事务T1回滚了,事务T2并不会受到影响。
Spring事务是这样做的,业务层中的transfer开启了事务T,而事务T中又包含了T1、T2的方法,Spring干脆让T1、T2加入到T事务中,这样就只有一个事务了,发生异常后只需回滚T事务就能保证T1、T2同成功同失败。
这里的事务T就是我们的事务管理员,而T1、T2则是事务协调员。
事务相关配置
其中rollbackFor比较重要,它是用来设置事务回滚异常的。
在事务回滚异常中,遇到编译时异常就不会回滚,比如IOException。
public interface AccountService {
@Transactional(rollbackFor = {IOException.class})
public void transfer(String out,String in,Double money) throws IOException;
}
对事务进行rollbackFor配置后就可以回滚了
接着对上一个案例进行一点扩展
案例:转账业务追加日志 需求:实现任意两个账户转账操作,并对每次转账操作在数据库进行留痕 需求微缩:A账户减钱,B账户加钱,数据库记录日志 分析: ①:基于转账操作案例添加日志模块,实现数据库中记录日志 ②:业务层转账操作(transfer),调用减钱、加载与记录日志功能 实现效果预期: 无论转账是否成功,均进行转账操作的日志留痕
在之前的代码中加入了新的事务T3,写完后运行会发现三个事务同成功同失败,因为它们都加入了事务T中
这就是上面说的事务管理员和事务协调员的工作,现在我们想要的是让log留痕操作开启新的事务。
实现:在业务层接口上添加Spring事务,设置事务传播行为REQUIRES_NEW(需要新事务)
@Service
public class LogServiceImpl implements LogService {
@Autowired
private LogDao logDao;
@Transactional(propagation = PropagationREQUIRES_NEW)
public void log(String out,String in,Double money){
logDao.log("转账操作由"+out+"到"+in+",金额"+money);
}
}
事务传播行为