本文详细介绍了Spring框架的核心特性，包括IOC（控制反转）、AOP（面向切面编程）以及声明式事务管理。首先阐述了Spring的基本理念和优势，然后逐步讲解了IOC的理论推导，如依赖注入的不同方式，以及通过Java配置和注解进行对象管理。接着，文章深入探讨了AOP的概念，展示了如何在Spring中实现动态代理和自定义切面。最后，文章讨论了Spring的声明式事务管理，强调了事务的ACID原则，并给出了整合Mybatis和事务管理的示例。
1.Spring
1.1 简介
- Spring：春天------>给软件行业带来了春天！
- 2002年首次推出spring框架的雏形：interface21 框架！
- Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版
- Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
- Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
- SSH：Struct2 + Spring + Hibernate!
- SSM：SpringMVC + Spring + Mybatis!（现在企业常用）
官网：https://spring.io/projects/spring-framework#overview
官方下载地址：https://repo.spring.io/release/org/springframework/spring/
GitHub：https://github.com/spring-projects/spring-framework
spring依赖jar:
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
1.2 优点
- Spring是一个免费开源框架
- Spring是一个轻量级、非入侵式框架
- 控制反转（IOC），面向切面编程（AOP）！
- 支持事务的处理，对框架整合的支持！
总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！
1.3 组成
1.4 拓展
现代化的Java开发！说白就是基于Spring的开发！
- Spring Boot
- 一个快速开发的脚手架。
基于SpringBoot可以快速的开发单个微服务。
约定大于配置。
- 一个快速开发的脚手架。
- Spring Cloud
- SpringCloud是基于SpringBoot实现的
因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用！
弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“配置地狱！”
2. IOC 理论推导
2.1 传统开发
dao层：
-
UserDao接口
public interface UserDao { void getUser(); } -
UserDaoImpl实现类 实现UserDao接口
public class UserDaoImpl implements UserDao { public void getUser() { System.out.println("默认获取用户数据"); } }
Service层：
-
UserService 业务接口
public interface UserService { void getUser(); } -
UserServiceImpl 实现类实现userService 接口,利用组合调用dao层实现类方法
public class UserServiceImpl implements UserService { private UserDao userDao = new UserDaoImpl(); public void getUser() { userDao.getUser(); } }
2.2 利用set方法创建创建对象
-
在传统模式上的UserServiceImpl实现类中利用set方法创建对象
public class UserService2Impl implements UserService{ private UserDao userDao; //利用set进行动态实现值的注入！ public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void getUser() { userDao.getUser(); } } -
测试
@Test public void iocTset(){ UserServiceImpl userService = new UserServiceImpl(); //通过set方法把需要的对象传入，不需要程序去主动创建对象 userService.setUserDao(new UserDaoImpl()); userService.getUser(); }
改进后的UserServiceImpl类中程序员不在需要主动 new UserDaoImpl（）的实现类，而是通过set方法对 UserDao的引用 进行注入。这样可以实现解耦合。
2.3 两种方式对比
传统方式耦合度太高，用户需求变更有可能程序员要去修改程序源代码，这并不是一个好的办法。
而set方法通过参数向上转型，用户传入那个实现类的对象就可以调用正确的实现方法，程序员不用去修改源代码，只需要增加对应需求的代码即可。
**传统方式：**创建对象的主动权在程序员手上，程序员决定程序生成什么对象，调用什么方法
**set方式：**程序的主动权在用户手上，用户需要调用什么对象，就传入什么对象即可
- 之前，程序是主动创建对象！控制权在程序猿手上！
- 使用了set注入后，程序不再具有主动性，而是变成了被动的接收对象！
- 这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低~，可以更加专注的在业务的实现上！这是IOC的原型！
2.4 IOC 本质
- 控制反转IOC（Inversion of control）是一种设计思想，DI（依赖注入）是IOC的一种实现方式。没有IOC的程序中，面向对象对象编程，对象的创建和依赖关系都是硬编码在程序中的，对象的创建由程序控制，使用IOC后创建对象移交给第三方，通过DI的方式注入。控制反转就是获取对象的方式反转了
- 采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。 - 在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）。
3. HelloSpring
-
创建maven项目 编写实体类
package com.zdx.pojo; public class Hello { private String str; //通过set方式对属性注入 public void setStr(String str) { this.str = str; } @Override public String toString() { return "Hello{" + "str='" + str + '\'' + '}'; } } -
编写spring上下文applicationcontext.xml文件
<?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="hello" class="com.zdx.pojo.Hello"> <property name="str" value="helloSpring"></property> </bean> </beans> -
测试
public class SpringTest { @Test public void springTest(){ //获取spring上下文 ClassPathXmlApplicationContext 只是一种获取spring上下文的途径 ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml"); //从spring 的ioc容器中取出对象 Hello hello = context.getBean("hello", Hello.class); System.out.println(hello.toString()); } }
思考问题？
- Hello对象是谁创建的？
Hello对象是由Spring创建的。 - Hello对象的属性是怎么设置的？
Hello对象的属性是由Spring容器设置的。
这个过程就叫控制反转：
- 控制：传统模式为对象的创建为程序本身控制，使用spring后，对象由Spring的IOC容器创建。
- 反转：程序本身不在创建对象变成被动的接收对象
- 依赖注入：就是利用set方法来进行注入的。
IOC是一种编程思想，由主动的编程变成被动的接收。
可以通过new ClassPathXmlApplicationContext去浏览一下底层源码。
OK，到了现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！
4. IOC创建对象的方式
-
默认是无参构造创建对象
<bean id="user" class="com.zdx.pojo.User"></bean> -
有参构造创建对象
<!-- 方式一 参数下标赋值--> <bean id="user1" class="com.zdx.pojo.User"> <constructor-arg index="0" value="参数下标赋值"></constructor-arg> </bean> <!-- 方式二：通过参数类型赋值--> <bean id="user2" class="com.zdx.pojo.User"> <constructor-arg type="java.lang.String" value="参数类型赋值"></constructor-arg> </bean> <!-- 方式三：通过参数名称赋值--> <bean id="user3" class="com.zdx.pojo.User"> <constructor-arg name="name" value="参数名称赋值"></constructor-arg> </bean>总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！
5. Spring 配置
<!-- 别名设置 - 给类设置别名-->
<alias name="user" alias="user4"></alias>
<!-- bean配置
id：bean的唯一标识符，也就是相当于我们学的对象名
class：bean对象所对应的全限定名：包名+类名
name：也是别名，而且name可以同时取多个别名 分隔符可以是 空格 ， ；
-->
<bean id="userT" class="com.zdx.pojo.User" name="user5 user6,user7;user8">
<property name="name" value="zxd"></property>
</bean>
import 配置
这个import。一般用于团队开发使用，它可以将多个配置文件，导入合并为一个。
假设，现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！
<import resource="bean.xml"/>
<import resource="bean2.xml"/>
<import resource="bean3.xml"/>
6. 依赖注入
6.1 构造器注入
参考4.构造器创建对象
6.2 Set方式注入
- 依赖注入：Set注入
- 依赖：bean对象的创建依赖于容器！
- 注入：bean对象中的所有属性，由容器来注入！
构建环境
-
实体类
public class Address { private String address; //get set toString }public class Student { private String name; private Address address; private String[] books; private List<String> hobbies; private Map<String,String> card; private Set<String> games; private String wife; private Properties info; //get set toString } -
xml 文件
<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="address" class="com.zdx.pojo.Address"> <property name="address" value="bj"></property> </bean> <bean id="student" class="com.zdx.pojo.Student"> <!-- 基本类型注入--> <property name="name" value="zdx"/> <!-- 对象引用注入--> <property name="address" ref="address"/> <!-- 数组注入--> <property name="books"> <array> <value>红楼梦</value> <value>西游记</value> <value>spring</value> </array> </property> <!-- List集合注入--> <property name="hobbies"> <list> <value>篮球</value> <value>电影</value> <value>代码</value> </list> </property> <!-- Map集合注入--> <property name="card"> <map> <entry key="身份证" value="123456789987456321"></entry> <entry key="银行卡" value="123456789"/> </map> </property> <!-- Set 集合注入--> <property name="games"> <set> <value>LOL</value> <value>COC</value> </set> </property> <!-- NULL注入--> <property name="wife"> <null/> </property> <!-- properties文件注入--> <property name="info"> <props> <prop key="driver">20191029</prop> <prop key="url">102.0913.524.4585</prop> <prop key="user">zdx</prop> <prop key="password">123456</prop> </props> </property> </bean> </beans>
6.4 c\p 命名空间注入
-
导入xml约束
xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c" -
xml文件
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"> <!--c命名空间 调用的是有参构造进行注入属性 constructor-args--> <bean id="user" class="com.zdx.pojo.User" c:name="zxd"></bean> <!--p 命名空间 是property 的set方法方式直接注入属性--> <bean id="user1" class="com.zdx.pojo.User" p:name="zxd1"/> </beans> -
测试
@Test public void pcTest(){ ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); User user = context.getBean("user", User.class); User user1 = context.getBean("user1", User.class); System.out.println(user.toString()); System.out.println(user1.toString()); }
6.4 bean的作用域
-
单例模式(Spring默认机制）
<bean id="user" class="com.zdx.pojo.User" c:name="zxd" scope="singleton"/> -
原型模式:每次从容器中get的时候，都会产生一个新对象！
<bean id="user1" class="com.zdx.pojo.User" p:name="zxd1" scope="prototype"/>
7. Bean的自动装配
- 自动装配是Spring满足bean依赖一种方式！
- Spring会在上下文中自动寻找，并自动给bean装配属性！
在Spring中有三种装配的方式：
- 在xml中显式的配置；
- 在java中显式配置；
- 隐式的自动装配bean【重要】
7.1 测试环境搭建
-
实体类(一个人有两个宠物）
public class Dog { public void shout(){ System.out.println("wang~~~"); } } public class Cat { public void shout(){ System.out.println("miao~~~"); } } public class People { private String name; private Cat cat; private Dog dog; //有参构造、无参构造、set、get、toString }
7.2 autowire = byName 自动注入
<bean id="cat" class="com.zdx.pojo.Cat"/>
<bean id="dog" class="com.zdx.pojo.Dog"/>
<!-- byName 方式是根据 引用属性相对应的set方法名 set xxx与对应属性的bean id 相同，来找到属性注入-->
<!-- 其bean id必须是唯一的，否则无法注入成功-->
<bean id="people" class="com.zdx.pojo.People" autowire="byName">
<property name="name" value="zdxx"/>
</bean>
7.3 autowire = byType 自动注入
<bean id="cat" class="com.zdx.pojo.Cat"/>
<bean id="dog" class="com.zdx.pojo.Dog"/>
<!-- byType 是根据引用属性的类型和 bean 的class 相同，从而找到属性注入-->
<!-- 所以配置文件中只能有唯一的一个 class 才能注入成功-->
<bean id="people" class="com.zdx.pojo.People" autowire="byType">
<property name="name" value="zdxxx"></property>
</bean>
7.4 Autowired 注解
jdk1.5支持的注解，Spring2.5就支持注解了！
要使用注解须知：
-
导入约束
-
配置注解的支持
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <!--开启注解的支持 --> <context:annotation-config/> </beans>
环境搭建(一个人有两个宠物)
public class Dog {
public void shout(){
System.out.println("wang~~");
}
}
public class Cat {
public void shout(){
System.out.println("miao~~~");
}
}
public class People {
private String name;
private Cat cat;
private Dog dog;
//有参、无参构造、set、get、toString
}
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
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:annotation-config/>
<!--扫描包-->
<context:component-scan base-package="com.zdx.*"/>
<bean id="cat111" class="com.zdx.pojo.Cat"/>
<bean id="dog" class="com.zdx.pojo.Dog"/>
<bean id="people" class="com.zdx.pojo.People">
<property name="name" value="zdx"/>
</bean>
</beans>
使用@Autowired注解
直接在属性上使用即可！也可以在set方法上使用！
使用Autowired我们就可以不用编写set方法了，前提是你这个自动配置的属性在IOC（Spring）容器中存在
public class People {
private String name;
@Autowired
private Cat cat;
@Autowired
private Dog dog;
}
科普：
@Nullable 字段标记了了这个注解，说明这个字段可以为null;
public @interface Autowired {
boolean required() default true;
}
测试代码
public class People {
//如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
private String name;
}
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “xxx”) 指定一个bean id 去配置@Autowired的使用，指定一个唯一的bean对象注入！
public class People {
private String name;
@Autowired
@Qualifier("cat111")
private Cat cat;
@Autowired
private Dog dog;
}
@Resource 注解 是一个java注解 也可以自动装配bean
public class People {
private String name;
@Autowired
private Cat cat;
@Resource
private Dog dog;
}
小结：
@Resource和@Autowired的区别：
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】
- @Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
- 执行顺序不同：@Autowired通过byType的方式实现。
8. 注解开发
-
spring4 后使用注解开发必须导入Aop包
-
xml约束
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <!--开启注解的支持 --> <context:annotation-config/> <!--指定要扫描的包，这个包下的注解就会生效--> <context:component-scan base-package="com.zdx"/> </beans>
8.1 @Component 和 @Value注解
@component 注解的作用是在Spring容器中注册bean
@Value 注解的作用是为属性赋值 属性必须有set方法
@Component // <bean id = "user" class="org.zdx.pojo.User"/>
public class User {
@Value("zdx") //<property name="name" value="zdx" />
private String name;
}
8.2 @Conponent 注解的衍生
在web开发中使用MVC框架 框架每层都需要声明bean使用的注解不同,用来区分
dao @Repository
service @Service
controller @Controller
这三个注解的作用和@Conponent 的作用是一样的是不过是命名方式不同，都是代表将某个类注册到Spring中，装配Bean
8.3 自动装配
- @Autowired：自动装配通过类型，名字。如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "xxx")去配置。
- @Nullable 字段标记了了这个注解，说明这个字段可以为null;
- @Resource：自动装配通过名字，类型。
8.4 @Scope 作用域
@Scope(“singleton”)单例
@Component // <bean id = "user" class="org.zdx.pojo.User"/>
@Scope("singleton")
public class User {
@Value("zdx") //<property name="name" value="zdx" />
private String name;
}
小结
xml与注解：
xml更加万能，适用于任何场合！维护简单方便
注解不是自己类使用不了，维护相队复杂！
xml与注解最佳实践：
xml用来管理bean；
注解只负责完成属性的注入；
我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持
<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.zdx"/>
<!--开启注解的支持 -->
<context:annotation-config/>
9. 使用Java方式配置Spring
我们现在要完全不使用Spring的xml配置了，全权交给Java来做！
JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y7rPY35j-1625627023545)(C:\Users\OneAPM\AppData\Roaming\Typora\typora-user-images\image-20210701152555412.png)]
- 实体类
//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("zdx") //属性注入值
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
- javaConfig 配置类
package com.zdx.pojo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
// 这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Component
// @Configuration代表这是一个配置类，就和我们之前看的beans.xml
@Configuration
@ComponentScan("com.zdx.pojo") //扫描包注解
@Import(ZdxConfigTwo.class) // 导入其他配置类
public class ZdxConfig {
// 注册一个bean，就相当于我们之前写的一个bean标签
// 这个方法的名字，就相当于bean标签中id属性
// 这个方法的返回值，就相当于bean标签中的class属性
@Bean
public People people(){ // bean id
return new People(); //bean class
}
}
- 测试
@Test
public void javaConfigText(){
ApplicationContext context = new AnnotationConfigApplicationContext(ZdxConfig.class);
People people = context.getBean("people", People.class);
System.out.println(people);
}
这种纯Java的配置方式，在SpringBoot中随处可见！
10. 代理模式
为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】
代理模式的分类：
- 静态代理
- 动态代理
10.1 静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人！
环境搭建
-
抽象接口 代表租房这件事 Rent
public interface Rent { public void rent(); } -
真实角色也就是 执行抽象事件的房东
//真实角色通过实现接口来执行这个抽象事件 public class Host implements Rent{ @Override public void rent() { System.out.println("房东出租房子"); } } -
代理角色 帮真实角色执行抽象事件，同时代理类还可以执行一些附加操作，保证真实角色的类只专注于执行抽象事件
public class ZJ implements Rent{ private Host host; public ZJ(Host host) { this.host = host; } //房东找到中介帮着房东出租房子 @Override public void rent() { //中介还可以做一些附属操作 看房子，收钱 look(); host.rent(); money(); } public void look(){ System.out.println("看房子"); } public void money(){ System.out.println("签合同收钱"); } } -
客户角色，访问代理角色
public class Client { public static void main(String[] args) { //房东要出租房子 Host host = new Host(); //找到中介代理出租 ZJ zj = new ZJ(host); // 中介出租房子 zj.rent(); } }
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共角色就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
缺点：
- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低~
10.2 加深理解
-
接口
public interface UserService { public void add(); public void delete(); public void update(); public void query(); } -
真实角色
//真实角色 public class UserServiceImpl implements UserService{ public void add() { System.out.println("增加了一个用户！"); } public void delete() { System.out.println("删除了一个用户！"); } public void update() { System.out.println("修改了一个用户！"); } public void query() { System.out.println("查询了一个用户！"); } } -
代理角色
public class UserServiceProxy implements UserService{ private UserServiceImpl userService; public void setUserService(UserServiceImpl userService) { this.userService = userService; } public void add() { log("add"); userService.add(); } public void delete() { log("delete"); userService.delete(); } public void update() { log("update"); userService.update(); } public void query() { log("query"); userService.query(); } public void log(String msg){ System.out.println("[Debug] 使用了一个"+msg+"方法"); } } -
客户端访问代理角色
public class Client { public static void main(String[] args) { UserServiceImpl userService = new UserServiceImpl(); UserServiceProxy proxy = new UserServiceProxy(); proxy.setUserService(userService); proxy.delete(); } }
10.3 AOP
AOP 面向切面开发，当需要对业务做附加操作的时候我们可以不用去动源码，利用代理去做附加操作。这样可以横向开发。
10.4 动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的！
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口 — JDK动态代理【我们在这里使用】
- 基于类：cglib
- java字节码实现：javassist
动态代理核心
invocationHandler 接口 ， 动态代理中每一个动态代理实例都有一个处理程序类，这个处理程序类必须实现invocationHandler接口。实现了这个接口的处理程序类，在代理实例调用方法时，方法调用被编码分派到调用处理程序类的invoke方法。
看下官方文档对InvocationHandler接口的描述：
{@code InvocationHandler} is the interface implemented by
the <i>invocation handler</i> of a proxy instance.
<p>Each proxy instance has an associated invocation handler.
When a method is invoked on a proxy instance, the method
invocation is encoded and dispatched to the {@code invoke}
method of its invocation handler.
每一个动态代理类的调用处理程序都必须实现InvocationHandler接口，并且每个代理类的实例都关联到了实现该接口的动态代理类调用处理程序中，当我们通过动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现InvocationHandler接口类的invoke方法来调用，看如下invoke方法：
/**
* proxy:代理类代理的真实代理对象com.sun.proxy.$Proxy0
* method:我们所要调用某个对象真实的方法的Method对象
* args:指代代理对象方法传递的参数
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
Proxy 类，就是用来创建代理对象的类，它提供了很多方法，最常用的就是 newProxyinstance 方法。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
Returns an instance of a proxy class for the specified interfaces
that dispatches method invocations to the specified invocation
handler. This method is equivalent to:
这个方法的作用就是创建一个代理类对象，它接收三个参数，我们来看下几个参数的含义：
- 第一个参数是 一个classloader类加载器 表示用那个类生成代理类并加载
- 第二个参数是 interface接口数组，表示我们给代理类实现什么样的接口数组，也就是声明了代理类实现这些接口，代理类可以调用接口中所有的方法。
- 第三个参数是 invocationHandler 表示动态代理对象调用方法时关联到那个invocationHandler对象上，并最终尤其调用方法，当动态代理对象调用一个方法时候 就会转接到实现invocationHandler接口的类的invoke()方法上。
操作步骤
- 接口
public interface Rent {
public void rent();
}
-
真实角色
public class Host implements Rent{ public void rent() { System.out.println("房东要出租房子！"); } } -
ProxyInvocationHandler类
public class ProxyInvocationHandler implements InvocationHandler { //被代理的接口 private Rent rent; public ProxyInvocationHandler() { } public ProxyInvocationHandler(Rent rent) { this.rent = rent; } //获取代理对象 /* Proxy类可以生成代理对象，一般常用newProxyInstance 方法 * 第一个参数是 一个classloader类加载器 表示用那个类生成代理类并加载 * 第二个参数是 interface接口数组，表示我们给代理类实现什么样的接口数组，也就是声明了代理类实现这些接口，代理类可以调用接口中所有的方法。 * 第三个参数是 invocationHandler 表示动态代理对象调用方法时关联到那个invocationHandler对象上，并最终尤其调用方法。 * 当动态代理对象调用一个方法时候 就会转接到实现invocationHandler接口的类的invoke()方法上。 * */ public Object getProxy(){ return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object invoke = method.invoke(rent, args); return invoke; } } -
测试
public class Client { public static void main(String[] args) { //真实角色 Host host = new Host(); //加载代理类的invocationhandler ProxyInvocationHandler handler = new ProxyInvocationHandler(host); //生成代理对象 Rent proxy = (Rent) handler.getProxy(); //代理对象执行代理业务 proxy.rent(); } } -
工具类
public class ProxyInvocationHandler implements InvocationHandler { //被代理的接口 private Object target; public void setRent(Object target) { this.target = target; } //生成得到代理类 public Object getProxy(){ return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this); } //处理代理实例，并返回结果 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //动态代理的实质就是反射 log(method.getName()); Object result =method.invoke(target,args); return result; } public void log(String msg){ System.out.println("使用了一个"+msg+"方法"); } }
动态代理的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共角色就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可
11. AOP
11.1 什么是AOP
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
11.2 AOP在Spring 中的作用
提供声明式事务；允许用户自定义切面
横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的“地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。
SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：
即AOP在不改变原有代码的情况下，去增加新的功能。
11.3 使用Spring实现AOP
【重点】使用AOP织入，需要带入一个jar包
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
方式一：使用Spring的API接口
- 在service包下，定义UserService业务接口和UserServiceImpl实现类
public interface UserService {
public void add();
public void delete();
public void update();
public void select();
}
public class UserServiceImpl implements UserService {
@Override
public void add() {
System.out.println("增加一个用户");
}
@Override
public void delete() {
System.out.println("删除角色");
}
@Override
public void update() {
System.out.println("更新角色");
}
@Override
public void select() {
System.out.println("查询一个用户");
}
}
- 通知类
public class BeforeLog implements MethodBeforeAdvice {
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"方法");
}
}
public class AfterLog implements AfterReturningAdvice {
@Override
public void afterReturning(Object returnValue, Method method, Object[] objects, Object target) throws Throwable {
System.out.println("执行了"+method.getName()+"方法"+"返回结果为"+returnValue);
}
}
- xml 文件
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="com.zdx.service.UserServiceImpl" />
<bean id="beforelog" class="com.zdx.log.BeforeLog"/>
<bean id="afterlog" class="com.zdx.log.AfterLog"/>
<!-- 方式一：使用原生Spring API接口-->
<!-- 配置aop：需要导入aop约束-->
<aop:config>
<!-- 切入点 expression 表达式 execution(要执行的位置 (返回类型)* (包)* (类)* (方法名)* (参数)*) -->
<aop:pointcut id="pointcut" expression="execution(* com.zdx.service.UserServiceImpl.*(..))"/>
<!-- 执行环绕增加通知！-->
<aop:advisor advice-ref="beforelog" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
- 测试
@Test
public void aopTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
方式二：自定义切面类来实现AOP
-
自定义切面类和通知方法
package com.zdx.aspect; //自定义切面类 public class DiyAspect { //通知方法 public void before(){ System.out.println("方法前执行"); } //通知方法 public void after(){ System.out.println("方法后执行"); } } -
在xml文件中注册bean，并写入aop配置
<!-- 自定义切面类--> <bean id="aspect" class="com.zdx.aspect.DiyAspect"/> <aop:config> <!-- 要切入的切面--> <aop:aspect ref="aspect"> <!-- 切面要切入的切入点--> <aop:pointcut id="point" expression="execution(* com.zdx.service.UserServiceImpl.*(..))"/> <!-- 切入的通知--> <aop:before method="before" pointcut-ref="point"/> <aop:after method="after" pointcut-ref="point"/> </aop:aspect> </aop:config> -
测试
public class SpringAopTest { @Test public void aopTest(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserService userService = context.getBean("userService", UserService.class); userService.add(); } }
11.4 使用注解完成AOP
-
创建增强类
package com.zdx.aspect; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; //声明式事务 //标注这是一个切面类 @Aspect public class AnnotationAspect { //前置增强，已经增强的切入点 @Before("execution(* com.zdx.service.UserServiceImpl.*(..))") public void before(){ System.out.println("方法前执行"); } @After("execution(* com.zdx.service.UserServiceImpl.*(..))") public void after(){ System.out.println("方法后执行"); } //环绕增强 // ProceedingJoinPoint 对象是一个连接点，可以连接切入点，从切入点中拿到一些信息， // 可以类似看作切入点，但不是真正的切入点 @Around("execution(* com.zdx.service.UserServiceImpl.*(..))") public void around(ProceedingJoinPoint pj) throws Throwable { System.out.println("环绕前执行"); // 执行方法 Object proceed = pj.proceed(); //环绕后 System.out.println("环绕后"); System.out.println(proceed); } } -
xml文件开启注解
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> <!-- 开启aop注解支持--> <!-- JDK(默认是 proxy-target-class="false") cglib（proxy-target-class="true"）--> <aop:aspectj-autoproxy/> <!--注册对象--> <bean id="annotationAspect" class="com.zdx.aspect.AnnotationAspect"/> -
测试
public class SpringAopTest { @Test public void aopTest(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserService userService = context.getBean("userService", UserService.class); userService.add(); } } //out 环绕前执行 方法前执行 增加一个用户 环绕后 null 方法后执行
由输入可以看出执行顺序，
环绕前around–》方法执行前before----》方法执行-----》环绕后around–》方法执行后after
然而不同版本可能执行顺序会有不同，要格外注意。
12. 整合Mybatis
官方文档：http://mybatis.org/spring/zh/index.html
- 熟悉一下原生mybatis框架
方式一：xml文件整合mybatis
-
导入相关依赖，设置资源路径
junit
mybatis
mysql数据库
spring相关的
aop织入
mybatis-spring<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13</version> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.2</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.0.RELEASE</version> </dependency> <!--Spring操作数据库的话，还需要一个spring-jdbc--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.1.9.RELEASE</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> <version>1.8.13</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.2</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.16.10</version> </dependency> plugin <resources> <resource> <directory>src/main/resources</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> <resource> <directory>src/main/java</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>false</filtering> </resource> </resources> -
配置spring-dao.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 链接数据库信息--> <!--DataSource：使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid 我们这里使用Spring提供的JDBC：org.springframework.jdbc.datasource--> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=false&characterEncoding=utf-8"/> <property name="username" value="root"/> <property name="password" value="root"/> </bean> <!-- 创建sqlSessionFactory--> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <!-- 绑定mybatis配置文件--> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations" value="classpath:mapper/*.xml"/> </bean> <!-- 获取sqlSession--> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!--只能使用构造器注入sqlSessionFactory，因为没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean> </beans> -
配置mybatis.xml文件，进行mybatis配置
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!-- 开启别名--> <typeAliases> <package name="com.zdx.pojo"/> </typeAliases> </configuration> -
applicationContext.xml整合与注册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" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <import resource="spring-dao.xml"/> <bean id="userMapper" class="com.zdx.dao.UserMapperImpl"> <property name="sessionTemplate" ref="sqlSession"/> </bean> </beans> -
创建实体类
package com.zdx.pojo; public class User { private int id; private String name; private int pwd; //set、get、toString、构造 } -
userMapper\uesrMapper.xml
package com.zdx.dao; import com.zdx.pojo.User; import java.util.List; public interface UserMapper { public List<User> selectUser(); }<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.zdx.dao.UserMapper"> <select id="selectUser" resultType="user"> select * from user; </select> </mapper> -
userMapperImpl 用来创建sqlsession 来读取xml文件
package com.zdx.dao; import com.zdx.pojo.User; import org.mybatis.spring.SqlSessionTemplate; import java.util.List; public class UserMapperImpl implements UserMapper{ private SqlSessionTemplate sessionTemplate; public void setSessionTemplate(SqlSessionTemplate sessionTemplate) { this.sessionTemplate = sessionTemplate; } @Override public List<User> selectUser() { UserMapper mapper = sessionTemplate.getMapper(UserMapper.class); return mapper.selectUser(); } } -
测试
import com.zdx.dao.UserMapper; import com.zdx.pojo.User; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import java.util.List; public class MybatisTest { @Test public void mybatisTest(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserMapper userMapper = context.getBean("userMapper", UserMapper.class); List<User> users = userMapper.selectUser(); for (User user : users) { System.out.println(user.toString()); } } }
方式二：SqlSessionDaoSupport实现
SqlSessionDaoSupport
SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。调用 getSqlSession() 方法你会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法，就像下面这样:
package com.zdx.dao;
import com.zdx.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
/*
* 弊端：在java中只允许继承一个父类，通常情况下业务需要继承其他父类，就不能用此方式实现
* */
@Override
public List<User> selectUser() {
SqlSession sqlSession = getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
return mapper.selectUser();
}
}
测试
@Test
public void mybatisTest1(){
ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
List<User> users = userMapper.selectUser();
for (User user : users) {
System.out.println(user.toString());
}
}
13. 声明式事务
13.1 回顾事务
- 把一组业务当成一个业务来做；要么都成功，要么都失败！
- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
- 确保完整性和一致性。
事务ACID原则
- 原子性（atomicity）
- 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。
- 一致性（consistency）
- 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
- 隔离性（isolation）
- 可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏
- 持久性（durability）
- 事务一旦完成，无论系统发生什么错误，结果都不会受影响。通常情况下，事务的结果被写道初九话存储器中。
测试：
将上面的代码拷贝到一个新项目中
在之前的案例中，我们给userMapper接口新增两个方法，删除和增加用户；
//pojo
package com.zdx.pojo;
public class User {
private int id;
private String name;
private int pwd;
//set、get、toString、构造
}
UserMapper/UserMapper文件，我们故意把 deletes 写错，测试！
package com.zdx.dao;
import com.zdx.pojo.User;
import java.util.List;
public interface UserMapper {
//查询所有用户
public List<User> selectUser();
public int addUser(User user);
public int delete(int id);
}
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zdx.dao.UserMapper">
<select id="selectUser" resultType="user">
select * from user;
</select>
<insert id="addUser" parameterType="user">
insert into user(id,name,pwd) values (#{id},#{name},#{pwd})
</insert>
<delete id="delete" parameterType="int">
deletes from user where id=#{id}
</delete>
</mapper>
编写接口的UserMapperImpl实现类，在实现类中，我们去操作一波
package com.zdx.dao;
import com.zdx.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import java.util.List;
public class UserMapperImpl implements UserMapper{
private SqlSessionTemplate sessionTemplate;
public void setSessionTemplate(SqlSessionTemplate sessionTemplate) {
this.sessionTemplate = sessionTemplate;
}
@Override
public List<User> selectUser() {
UserMapper mapper = sessionTemplate.getMapper(UserMapper.class);
User user = new User(7, "aaa", 123123);
int i = mapper.addUser(user);
mapper.delete(7);
return mapper.selectUser();
}
@Override
public int addUser(User user) {
return sessionTemplate.getMapper(UserMapper.class).addUser(user);
}
@Override
public int delete(int id) {
return sessionTemplate.getMapper(UserMapper.class).delete(id);
}
}
测试
@Test
public void transTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
List<User> users = userMapper.selectUser();
for (User user : users) {
System.out.println(user.toString());
}
}
测试会报错，因为前边我们把delete 的sql写错了
但是现在查看数据库会发现id=7的数据已经插入数据库了，这样并不符合事务的ACID的原则**，一组业务当成一个业务执行时，要么都成功，要么都失败**，显然当前并不符合。
没有进行事务的管理；我们想让他们都成功才成功，有一个失败，就都失败，我们就应该需要事务！
以前我们都需要自己手动管理事务，十分麻烦！
但是Spring给我们提供了事务管理，我们只需要配置即可；
13.2 Spring的声明式事务
Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。
编程式事务管理
- 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
- 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码
声明式事务管理
- 一般情况下比编程式事务好用。
- 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
- 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。
- 使用Spring管理事务，注意头文件的约束导入 : tx
xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
-
JDBC事务
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> -
配置spring事务管理器
<!--结合AOP实现事务的织入--> <!--配置事务通知--> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <!--给那些方法配置事务--> <!--配置事务的传播特性： new --> <tx:attributes> <tx:method name="add" propagation="REQUIRED"/> <tx:method name="delete" propagation="REQUIRED"/> <tx:method name="update" propagation="REQUIRED"/> <tx:method name="query" read-only="true"/> <tx:method name="*" propagation="REQUIRED"/> </tx:attributes> </tx:advice>spring事务传播特性：
事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：- propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
- propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
- propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
- propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
- propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
- propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
- propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与
- propagation_required类似的操作。
- Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。
就好比，我们刚才的几个方法存在调用，所以会被放在一组事务当中！
-
配置aop切入
<!--配置事务切入--> <aop:config> <aop:pointcut id="txPointCut" expression="execution(* com.zdx.dao.*.*(..))"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/> </aop:config> -
测试
@Test public void transTest(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserMapper userMapper = context.getBean("userMapper", UserMapper.class); List<User> users = userMapper.selectUser(); for (User user : users) { System.out.println(user.toString()); } }思考：
为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况；
- 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
- 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！
扫一扫
907
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
