SSM之Spring 02 —— 动态代理、AOP、Spring-MyBatis、声明式事务

最新推荐文章于 2024-04-23 22:37:41 发布
最新推荐文章于 2024-04-23 22:37:41 发布
阅读量194 收藏 1
点赞数
分类专栏： # Spring 文章标签： spring java aop mybatis ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39763246/article/details/114066340
版权

系列文章

SSM之Spring 01 —— 第一个Spring程序、配置说明、IOC、DI、自动装配、注解/Java方式开发

SSM之Spring 02 —— 动态代理、AOP、Spring-MyBatis、声明式事务

文章目录

10、代理模式

为什么要学习代理模式？因为这是Spring AOC的底层【Spring AOP 和 Spring MVC】

代理模式的分类：

  • 静态代理
  • 动态代理

代理的概念就像房屋中介，它负责帮房东解决房屋出租的问题，房东只需要将钥匙给中介，其他的像广告宣传之类的都由代理完成，而租客则无法直接找到房东联系，也只能通过中介去完成租房。

1614149472034

 

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）：与切入点匹配的执行点
1614161334801

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&amp;characterEncoding=UTF-8&amp;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&amp;characterEncoding=UTF-8&amp;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&amp;characterEncoding=UTF-8&amp;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&amp;characterEncoding=UTF-8&amp;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中配置声明式事务，我们就需要在代码中手动去配置事务。
老板来碗小面加蛋~
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SSM框架教程Spring+SpringMVC+MyBatis全覆盖_Java热门框架视频教程
11-05
7、Spring的声明式事务控制 8、SpringMVC的介绍及其快速入门 9、SpringMVC的数据请求和响应 10、SpringMVC的异常处理及其拦截器 11、MyBatis简介及其入门 12、MyBatis的配置文件详解 13、MyBatis的多表操作 适用...
ssm框架之spring的动态代理，AOP，和声明式事务
殷志鹏的博客
03-10 247
目录1、动态代理什么是动态代理动态代理的好处如何实现动态代理通过JDK实现动态代理 1、动态代理 什么是动态代理 动态代理是一种设计模式（GOF23设计模式之一），在框架中使用居多，在spring中扩展出了AOP切面编程 动态代理可以这么理解，有一个类，它主要实现一些具体的逻辑操作，其中大量方法实现不同逻辑，现在想要为每一个方法都配置一个秘书（同一个人），当方法执行之前，做一些处理，比如当方...
spring aop怎么给Mybaits Mapper接口的代理实现类在进行代理
码农的世界你不懂
02-28 3306
不一定正确，哈哈哈，欢迎指正
【SSM】15-动态代理模式的使用总结
m0_50964976的博客
01-21 391
目录 一、代理模式 二、静态代理 （一）静态代理 （二）静态代理简单实现 三、动态代理 （一）动态代理 （二）动态代理简单实现 四、动态代理原理分析 五、InvocationHandler接口和Proxy类详解 六、JDK动态代理和CGLIB动态代理代码示例比较与总结 （一）定义创建用户管理接口 （二）用户管理实现类，实现用户管理接口(被代理的实现类) （三）采用JDK代理实现：JDK动态...
SpringAOP、动态代理、MyBatis原理
weixin_43890079的博客
09-27 125
SpringAOP Aspect Oriented Programming面向切面编程 ObjectOriented Programming面向对象编程 拦截器、过滤器都是基于代理模式 单例模式、简单工厂模式、代理模式 代理模式介绍： 静态代理： 让目标对象和代理类实现同一个接口，目的是让客户端访问的时候行为是一致。 这其实就是一种保护（对目标对象的保护），控制对具体目标对象的访问，这个时候就由代理说了算。 在代理对象里面转调目标对象之前和之后做...
Spring-activiti:转载测试通过--被人的SSM和ACTIVITI整合框架
05-09
项目技术架构(Spring+SpringMVC+Mybatis）MavenSpring（IOC DI AOP 声明式事务处理）SpringMVC（支持Restful风格）Hibernate Validator（参数校验）Mybatis（最少配置方案）shiro权限控制,结合ajax实现了异步认证与...
Spring.html
03-23
声明式事务管理 PlatFormTransactionManager:平台事务管理器:定义了commit/rollback Mybatis/jdbc:DataSourceTransactionManager Hibernater:HibernaterTransactionManager TransactionManagerDifinition ...
SSMM-Demo：实践出真知，相对于SSM-Demo项目，本项目是一个基于SSMM（SpringMVC + Spring + Mybatis + Redis + Maven）的练手Demo
02-03
Spring AOP的应用：日志模块的撤销，Redis查询缓存配置，声明式事务管理 春天声明式事务管理； Spring CharacterEncodingFilter过滤器； 使用Mybatis作持久层（ORM）框架：以面向对象的方式对PO类的操作映射成为...
积分管理系统java源码-ERP-ssm:这是一个SSM（Spring+SpringMVC+Mybatis）+jQueryEasyUI开发的E
06-06
声明式事务处理） SpringMVC（支持Restful风格） Hibernate Validator（参数校验） Mybatis（最少配置方案） shiro权限控制,结合ajax实现了异步认证与异步授权，同时实现了细粒度的权限动态分配（到按钮级别）；添加...
SpringBoot引入第三方jar包或本地jar包
zhourongxiang1的博客
04-23 270
在resources中新建jar目录，将第三方jar包fastjson2-2.0.47.jar放入其中。打完的war包在“D:\迅雷下载\snakerflow-master(1)\demoJar\target\demo-0.0.1-SNAPSHOT.war”中。),有两个Maven选择这一个。pom.xml中version改成2.5.10。pom.xml中添加configuration。pom.xml中添加dependence。pom.xml中再添加packaging。勾选Spring Web。
No spring.config.import property has been defined
一个写了10年bug的程序员日常笔记。
04-18 692
运行Springcloud项目出现下面错误：Description:No spring.config.import property has been definedAction:Add a spring.config.import=nacos: property to your configuration. If configuration is not required add spring.config.import=optional:nacos: instead. To disabl
mysql-connector-java和spring-boot-starter-jdbc和mybatis-spring-boot-start
xzy的博客
04-23 427
JDBC是使用java语言操作mysql数据库的规范，java语言必须按照这个规范写才可以操作mysql数据库。
javaweb-SpringBoot基础
kussm_的博客
04-20 1021
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
SpringBoot内容协商机制（就是接受数据的类型如json，xml）
gaoqiandr的博客
04-23 192
本文主要介绍的是SpringBoot中的内容协商机制，也就是接收参数的数据格式，如xml，json等等
怎么在 Spring 服务响应时控制响应时间？
Itmastergo的博客
04-18 756
在Spring应用程序中控制服务响应时间是确保系统性能和用户体验的关键方面之一。在处理请求时，响应时间是指从客户端发送请求到服务端返回响应所花费的时间。在某些情况下，需要对响应时间进行控制，以确保系统能够及时响应用户请求，并且不会因为响应时间过长而影响用户体验。
springcloud第4季 springcloud-alibaba之nacos篇-配置中心
健康平安的活着的专栏
04-20 259
namespace，group，dataid 之间的关系。
Ant Design Pro + springboot实现文件上传功能
ChenJin_2的博客
04-19 304
Ant Design Pro + springboot实现文件上传功能
Spring Security
最新发布
m0_66052129的博客
04-23 471
上面我们已经把准备工作做好了，包括搭建、代码、数据库。接下来我们会实现让security在认证的时候，根据我们数据库的用户和密码进行认证，也就是被security拦截业务接口，出现登录页面之后，我们需要通过输入数据库里的用户和密码来登录，而不是使用security默认的用户和密码进行登录思路: 只需要新建一个实现类，在这个实现类里面实现Security官方的UserDetailsService接口，然后重写里面的loadUserByUsername方法。
SSM框架相较于其他框架的优点
05-19
SSM（Spring + SpringMVC + MyBatis）框架相比于其他框架的优点主要包括： 1. 轻量级：SSM框架的核心都是轻量级框架，不像其他框架那样臃肿庞大，所以启动速度快，占用内存小，性能优越。 2. 易于学习：SSM框架的学习曲线相对较低，对于初学者来说容易上手，而且官方文档详尽，社区活跃，遇到问题能够很快得到解决。 3. 容易集成：SSM框架采用了分层架构，不同的层之间解耦，因此可以很容易地与其他框架进行集成，如Spring Boot、Spring Cloud等。 4. 事务管理：SSM框架提供了事务管理功能，支持编程式事务和声明式事务，可以很方便地控制数据的一致性和完整性。 5. 灵活性：SSM框架中的每个模块都可以独立使用，也可以组合使用，根据项目实际情况进行选择，具有很高的灵活性。 6. 较好的扩展性：SSM框架中的每个模块都可以通过扩展实现更多的功能，比如Spring可以通过AOP进行拦截、MyBatis可以通过插件进行扩展等。 综上所述，SSM框架具有轻量级、易于学习、容易集成、事务管理、灵活性和较好的扩展性等优点，因此在Java Web开发中得到了广泛的应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

老板来碗小面加蛋~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值