系列文章
SSM之Spring 01 —— 第一个Spring程序、配置说明、IOC、DI、自动装配、注解/Java方式开发
SSM之Spring 02 —— 动态代理、AOP、Spring-MyBatis、声明式事务
文章目录
10、代理模式
为什么要学习代理模式?因为这是Spring AOC的底层【Spring AOP 和 Spring MVC】
代理模式的分类:
- 静态代理
- 动态代理
代理的概念就像房屋中介,它负责帮房东解决房屋出租的问题,房东只需要将钥匙给中介,其他的像广告宣传之类的都由代理完成,而租客则无法直接找到房东联系,也只能通过中介去完成租房。
10.1、静态代理
角色分析:
- 抽象角色:一般用接口或抽象类实现,例如房屋出租接口
- 真实角色:被代理的角色,例如房东
- 代理角色:代理真实角色,在代理过程中会做一些附属操作
- 客户:访问代理对象的人,例如租客
下面用房屋出租为例:
1、出租房屋操作的接口
public interface Rent {
public void rent();
}
2、真实角色—房东
public class Landlord implements Rent {
public void rent() {
System.out.println("房东要出租房子了!");
}
}
3、代理角色—房屋中介
public class Proxy implements Rent {
Landlord landlord;
public Proxy(Landlord landlord) {
this.landlord = landlord;
}
public void rent() {
seeHouse();
landlord.rent();
sign();
charge();
}
public void seeHouse(){
System.out.println("中介带你看房~");
}
public void charge(){
System.out.println("收中介费~");
}
public void sign(){
System.out.println("签合同~");
}
}
4、客户联系代理角色
public class Client {
public static void main(String[] args) {
//房东准备出租房子
Landlord landlord = new Landlord();
//中介替房东出租房子,并带上附属操作
Proxy proxy = new Proxy(landlord);
//你直接找中介
proxy.charge();
}
}
代理模式优点:
- 可以使真实角色的操作更加纯粹,无需去关注一些公共业务,例如房东只需要出租房
- 公共操作统一交给代理角色,实现了业务的分工
- 公共业务发生扩展时方便管理,例如中介需要增加其他操作时,无需修改房东
代理模式缺点:
- 一个真实角色就会产生一个代理角色,代码量翻倍,开发效率变低。
10.2、加深理解代理
这里再举一个例子,说明代理的必要性!假如我们有一堆业务代码,实现用户增删改查,现在希望在不改动原有代码的基础上,实现对增删改查的日志。这就可以用代理实现!
//用户业务层接口
public interface UserService {
public void addUser();
public void deleteUser();
public void updateUser();
public void queryUser();
}
//用户业务层实现类
public class UserServiceImpl implements UserService{
public void addUser() {
System.out.println("增加了一个用户");
}
public void deleteUser() {
System.out.println("删除了一个用户");
}
public void updateUser() {
System.out.println("更新了一个用户");
}
public void queryUser() {
System.out.println("查询了一个用户");
}
}
//用户业务层代理
public class UserServiceProxy implements UserService {
//Spring不适用new创建对象,而是通过set注入
UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
public void addUser() {
log("addUser");
userService.addUser();
}
public void deleteUser() {
log("deleteUser");
userService.deleteUser();
}
public void updateUser() {
log("updateUser");
userService.updateUser();
}
public void queryUser() {
log("queryUser");
userService.queryUser();
}
public void log(String message){
System.out.println("执行了"+message+"操作");
}
}
通过代理,我们可以实现横向开发,即在不改变原有业务的情况下,实现新的操作。
10.3、动态代理
- 动态代理和静态代理的角色一样,但克服了静态代理的缺陷(每个真实角色都要写一个代理)
- 动态代理的代理类是动态生成的,所以不需要每个不同的真实角色都去写代理类
- 动态代理分为两大类:基于接口和基于类
- 基于接口:JDK动态代理(我们现在使用这个)
- 基于类:cglib
- Java字节码也能实现:Javassist
基于接口的动态代理需要先了解:Proxy 代理类 和 InvocationHandler 调用处理接口
- Proxy:提供创建动态代理类的静态方法
- InvocationHandler:调用处理程序接口,需要实现invoke方法
现在我们修改上一个Service层加日志的代码,UserService和UserServiceImpl不变,使用动态代理:
package com.zcy.demo03;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;//被代理的角色
//设置被代理的角色
public void setTarget(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;
}
//设置UserServiceImpl日志
public void log(String message){
System.out.println("执行了"+message+"方法");
}
}
测试:
@Test
public void test(){
//真实角色
UserService userService = new UserServiceImpl();
//代理角色
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//设置要代理的角色为 userService
pih.setTarget(userService);
//动态生成代理类
UserService proxy = (UserService) pih.getProxy();
//执行操作
proxy.queryUser();
proxy.addUser();
proxy.deleteUser();
proxy.updateUser();
}
结果:
代理操作基本是死的模板,只需要修改log方法以及invoke里的操作,由于是基于反射实现的,所以非常灵活!
动态代理优点:
- 一个动态代理类,代理的是一个接口,一般直接就是一类业务,相当于一个模板。
- 一个动态代理类可以实现了相同接口的多个类。
11、AOP
一句化概括:在不改变原有业务类的情况下,实现动态增强,比如增加些附属操作。
11.1、什么是AOP
AOP(Aspect Oriented Programming)即:面向切面编程,通过预编译方式以及动态代理来统一维护程序功能的一种技术。AOP是OOP的延续,是Spring框架的重要内容。利用AOP可以对业务逻辑的各个部分进行隔离,从而降低业务逻辑各部分间的耦合度,提高程序可用性以及开发效率。
11.2、Aop在Spring中的作用
提供声明式事务:允许用户自定义切面
- 横切关注点:跨越应用程序多个模块的方法或功能。即,与我们业务逻辑无关的,但又需要我们关注的那部分。例如:日志、缓存…
- 切面(aspect):横切关注点被模块化后的特殊对象。即,横切关注点的类。
- 通知(advice):切面必须完成的动作。即,横切关注点类的一个方法。
- 目标(target):被通知的对象。
- 代理(proxy):向目标对象应用通知后创建的对象
- 切入点(point cut):切面通知 执行的 ”地点“
- 连接点(joint point):与切入点匹配的执行点
Spring AOP中,通过Advice定义横切逻辑,Spring中支持5中类型的Advice:
11.3、使用Srping实现AOP
【注意】使用Spring AOP需要导入包aop织入
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
导入XML约束
xmlns:aop="http://www.springframework.org/schema/aop"
//放在xsi:schemaLocation里
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
方式一:使用Spring的API接口
还是用前面的UserService接口和UserServiceImpl实现类,但新增两个日志通知类。
public class BeforeLog implements MethodBeforeAdvice {
/**
*
* @param method 要执行的目标对象的方法
* @param args 目标对象的参数
* @param target 目标对象
* @throws Throwable
*/
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行前");
}
}
public class AfterLog implements AfterReturningAdvice {
//returnValue:目标对象方法执行完后的返回值
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行后");
}
}
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"
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 -->
<bean id="userService" class="com.zcy.service.UserServiceImpl"/>
<bean id="beforeLog" class="com.zcy.log.BeforeLog"/>
<bean id="afterLog" class="com.zcy.log.AfterLog"/>
<!-- 方式一:使用原生Spring API接口 -->
<!-- 配置AOP:需要先导入AOP约束 -->
<aop:config>
<!-- 切入点:表明要切入的位置,id是该切入点名字 -->
<!-- expression就是位置,其值是一个表达式(第一个*表明修饰符任意,第二个*表明方法任意,(..)表明参数不限) -->
<aop:pointcut id="pointcut" expression="execution(* com.zcy.service.UserServiceImpl.*(..))"/>
<!-- 通知:把beforeLog和afterLog(bean的id)这两个类切入到pointcut切入点上 -->
<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.addUser();
}
结果:
方式二:使用自定义类实现(主要是切面方式)
public class DiyPointCut {
public void before(){
System.out.println("======方法执行前=====");
}
public void after(){
System.out.println("======方法执行后======");
}
}
<!-- 注册bean -->
<bean id="userService" class="com.zcy.service.UserServiceImpl"/>
<!-- 方式二:自定义类 -->
<!-- 注册自定义类 -->
<bean id="diy" class="com.zcy.log.DiyPointCut"/>
<aop:config>
<!-- 自定义切面,ref是要引入的类 -->
<aop:aspect ref="diy">
<!-- 切入点,切入com.zcy.service.UserServiceImpl下的所有方法且不限参数 -->
<aop:pointcut id="point" expression="execution(* com.zcy.service.UserServiceImpl.*(..))"/>
<!-- 通知:方法前、方法后 -->
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
测试结果:
方式三:使用注解实现
package com.zcy.log;
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 DiyPointCut {
//注意这里的@Before和@After是aspectj包下的,junit包里也有这个
@Before("execution(* com.zcy.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("======方法执行前=====");
}
@After("execution(* com.zcy.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("======方法执行后======");
}
//环绕:我们可以给定一个参数,代表我们要获取处理切入的点
@Around("execution(* com.zcy.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("环绕前");
Object proceed = joinPoint.proceed();//调用后,才开始执行方法
System.out.println("环绕后");
}
}
applicationContext.xml
<!-- 方式三:注解实现AOP -->
<bean id="diy" class="com.zcy.log.DiyPointCut"/>
<!-- 开启AOP注解支持 -->
<aop:aspectj-autoproxy/>
测试结果:
12、整合MyBatis
中文文档:http://mybatis.org/spring/zh/index.html
相关jar包
<!-- Junit测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<!-- Lombok 简化实体类代码 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
<!-- Spring核心框 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.3</version>
</dependency>
<!-- Spring AOP -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
<!-- 数据库驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!-- MyBatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<!-- Spring整合MyBatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.6</version>
</dependency>
<!-- Spring 操作数据库 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.3</version>
</dependency>
12.1、MyBatis回顾
正常使用MyBatis的流程:
1、编写核心配置文件mybatis-config.xml
<?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.zcy.pojo"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8&useSSL=false"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<package name="com.zcy.dao"/>
</mappers>
</configuration>
2、根据数据库字段创建实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
private String password;
}
3、编写接口
public interface UserMapper {
public List<User> getUser();
}
4、编写mapper.xml并实现接口的SQL
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zcy.dao.UserMapper">
<select id="getUser" resultType="user">
select * from user
</select>
</mapper>
5、测试
@Test
public void testMyBatis() throws IOException {
//MyBatis核心配置文件路径
String resource = "mybatis-config.xml";
//加载核心配置文件
InputStream is = Resources.getResourceAsStream(resource);
//获取SqlSession工厂
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
//通过工厂获得SqlSession,打开数据库连接
SqlSession sqlSession = build.openSession(true);
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.getUser();
for (User user : userList) {
System.out.println(user);
}
}
6、结果
12.2、MyBatis-Spring
使用Spring整合MyBatis,
1、根据数据库字段编写实体类User(和前面一样的)
2、编写UserMapper接口以及UserMapper.xml(和前面一样的)
3、UserMapperImpl实现类
之所以要写实现类,是因为MyBatis仅靠mapper是无法实现Spring注入的,因为没有set方法,这个实现类就是Spring和MyBatis的关联。
public class UserMapperImpl implements UserMapper {
//SqlSessionTemplate是Spring中对SqlSession的替代,操作是一样的
private SqlSessionTemplate sqlSessionTemplate;
//由于Spring通过注入方式赋值,所以必须实现set方法
public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
this.sqlSessionTemplate = sqlSessionTemplate;
}
//实现接口的方法
public List<User> getUser() {
//获得Mapper,依然通过Mapper执行接口方法
UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
return mapper.getUser();
}
}
4、编写Spring配置文件和MyBatis配置文件
MyBatis配置文件:mybatis-config.xml,一般只写setting和别名
<?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>
<settings>
<setting name="cacheEnabled" value="true"/>
<setting name="logImpl" value="LOG4J"/>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<typeAliases>
<package name="com.zcy.pojo"/>
</typeAliases>
</configuration>
Spring配置文件:固定模板,用于关联MyBatis的
<?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">
<!-- 数据源,替代了mybatis-config.xml中的environment -->
<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?useUnicode=true&characterEncoding=UTF-8&useSSL=false"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
<!-- 获得SqlSessionFactory的bean,可在这里设置mybatis-config.xml中的各种参数配置 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 加载数据源 -->
<property name="dataSource" ref="dataSource"/>
<!-- 可绑定MyBatis核心配置文件 -->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<!-- 注册Mapper -->
<property name="mapperLocations" value="classpath:com/zcy/mapper/*.xml"/>
<!-- 别名(但一般别名和set标签还是留在mybatis-config.xml中设置,以便查看)-->
<property name="typeAliasesPackage" value="com.zcy.pojo"/>
</bean>
<!-- 替代了SqlSession,并实现注入 -->
<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
<!-- SqlSessionTemplate没有set方法,所以只能使用构造方法注入 -->
<!-- 通过SqlSessionFactory获得SqlSessionTemplate -->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
</beans>
Spring配置文件:真正的配置文件,同时需要导入上一个配置文件,并注册UserMapper接口。
<?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">
<import resource="spring-dao.xml"/>
<bean id="userMapper" class="com.zcy.mapper.UserMapperImpl">
<property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
</bean>
</beans>
5、测试:通过Spring方式使用MyBatis
@Test
public void testSpringMyBatis(){
//获得Spring容器,通过该容器获取Mapper
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取Mapper后,正常使用MyBatis
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
for (User user : userMapper.getUser()) {
System.out.println(user);
}
}
结果:
12.3、MyBatis-Spring简化版
根据官方文档,我们可以让接口的实现类去继承 SqlSessionDaoSupport
,然后就能直接通过getSqlSession()
获得 SqlSessionTemplate
。
如此我们便可以省略注入SqlSessionTemplate
。(但需要注入sqlSessionFactory,因为继承的父类SqlSessionDaoSupport
需要)
UserMapperImpl2.java
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
public List<User> getUser() {
return getSqlSession().getMapper(UserMapper.class).getUser();
}
}
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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<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?useUnicode=true&characterEncoding=UTF-8&useSSL=false"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/zcy/mapper/*.xml"/>
</bean>
<!-- 省略了sqlSessionTemplate注入 -->
</beans>
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="userMapper2" class="com.zcy.mapper.UserMapperImpl2">
<!-- 无需注入sqlSessionTemplate,但需要给它的父类注入sqlSessionFactory -->
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
</beans>
13、声明式事务
13.1、回顾事务
- 把一组业务当成一个业务来做,要么都成功,要么都失败
- 事务在项目开发中十分重要,涉及到数据的一致性问题!
- 事务ACID原则:
- 原子性 atomicity :事务是一个整体,必须一起完成,不能只执行一部分
- 一致性 consistency :一个事务执行前后,数据库都必须处于一致状态,即某些未完成的事务不能写入数据库,否则数据库会不一致。
- 隔离性 isolation :并发的事务相互隔离,一个事务执行时不被其他事务干扰
- 脏读:一个事务读取了另一个事务还未提交的数据
- 非重复读:在一个事务内读取表中的某一行数据,但多次读取的结果不同
- 幻读:在一个事务内读取到其他事务插入的数据,导致前后读取不一致
- 持久性 durability :事务一旦提交,数据一定会被写入数据库,无论系统发生声明问题。
13.2、没配置事务的情况
考虑下面情况,一组动作中添加用户、删除用户、查询用户,但删除用户出现错误,所以不应该写入数据库,而由于没有配置事务,虽然最后报错了,不过添加用户依然成功执行。
public interface UserMapper {
public List<User> getUser();
public int addUser(User user);
public int deleteUser(int id);
}
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
public List<User> getUser() {
addUser(new User(3,"老王", "333333"));
deleteUser(3);
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
return mapper.getUser();
}
public int addUser(User user) {
return getSqlSession().getMapper(UserMapper.class).addUser(user);
}
public int deleteUser(int id) {
return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
}
}
UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zcy.mapper.UserMapper">
<select id="getUser" resultType="user">
select * from user
</select>
<insert id="addUser" parameterType="user">
insert into user (id, name, password) values (#{id}, #{name}, #{password})
</insert>
<!-- 故意写错 deletesss -->
<delete id="deleteUser" parameterType="int">
deletesss from user where id = #{id}
</delete>
</mapper>
结果:
13.3、AOP 事务
Spring中写事务有两种方式,但主要还是横向切入,通过AOP的方式写事务,这样可以不用改变原有代码。
只需要修改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:tx="http://www.springframework.org/schema/tx"
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/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<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?useUnicode=true&characterEncoding=UTF-8&useSSL=false"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/zcy/mapper/*.xml"/>
</bean>
<!-- =========== 下面代码几乎就是一个模板!!========== -->
<!-- 配置声明式事务 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<constructor-arg ref="dataSource" />
</bean>
<!-- 结合AOP,实现事务的织入 -->
<!-- 配置事务通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!-- 给哪些方法配置事务 -->
<tx:attributes>
<!-- 设置查询用户为只读 -->
<tx:method name="getUser" read-only="true"/>
<!-- 所有方法开启事务:propagation(传播)=REQUIRED 如果当前没有事务就创建事务 -->
<!-- 这个配置的意思是:当我调用Service层的方法时,会开启一个事务。而当我们在这个Service层的方法里调用其他方法
或者其他Service层的方法时,会直接用当前方法的事务。如果当前方法没有事务,就会创建事务。
-->
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 配置事务切入 -->
<aop:config>
<aop:pointcut id="txPoint" expression="execution(* com.zcy.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
</aop:config>
</beans>
思考:为什么需要事务?
- 如果不配置事务,可能存在数据不一致的情况。
- 如果我们不在Spring中配置声明式事务,我们就需要在代码中手动去配置事务。