Spring aop 事务

最新推荐文章于 2024-07-18 13:50:38 发布

哈哈哈537

最新推荐文章于 2024-07-18 13:50:38 发布

阅读量162

点赞数

文章标签： spring 代理模式 java

本文链接：https://blog.csdn.net/hai_man_/article/details/129295280

版权

Spring aop 事务

AOP
声明式事务控制

AOP

AOP是啥

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

aop优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
优势：减少重复代码，提高开发效率，并且便于维护

Spring AOP有两种代理模式：

JDK 动态代理（默认）
CGLIB 代理

代理技术描述
JDK 动态代理 Spring AOP 默认的动态代理方式，若目标对象实现了若干接口，Spring 使用 JDK 的 java.lang.reflect.Proxy 类进行代理。
CGLIB 动态代理若目标对象没有实现任何接口，Spring 则使用 CGLIB 库生成目标对象的子类，以实现对目标对象的代理。

aop相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。
在正式讲解 AOP 的操作之前，我们必须理解 AOP 的相关术语，常用的术语如下：

Target（目标对象）：代理的目标对象，也就是快捷方式后面的那个真正的应用程序；
Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类，也就是那个快捷方式；
Joinpoint（连接点）：所谓连接点是指那些被拦截到的点（方法，属性）。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点；
Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义；(可以理解为：查询条件)
Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知；
Aspect（切面）：是切入点和通知（引介）的结合；
Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入；

使用spring aop

第一步：导入依赖

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

第二步：创建目标接口和目标实现类

public interface TargetInterface {
    public void method();
}

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

第三步：创建切面

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

第四步:导入aop命名空间，配置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"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd">

    <!--    配置目标类   -->
    <bean id="target" class="com.zn.spring.aop.Target"/>
    <!--    配置切面类(增强类)   -->
    <bean id="aspect" class="com.zn.spring.aop.MyAspect"/>
    <aop:config>
<!--        这里配置的内容表示，目标对象com.zn.spring.aop.Target.method()方法执行时会在该方法执行前之调用aspect里的before方法 -->
        <aop:aspect ref="aspect">
<!--            配置切入点 execution就是切入条件(我要在那些点上做增强)  -->
            <!--配置目标对象Target的method方法执行时要进行myAspect的before方法前置增强-->
            <aop:before method="before"
                        pointcut="execution(
                        public void com.zn.spring.aop.Target.method())"/>
        </aop:aspect>
    </aop:config>

</beans>

第五步：测试

ClassPathXmlApplicationContext  applicationContext =
        new ClassPathXmlApplicationContext("spring.xml");
ITargetInterface target = (ITargetInterface) applicationContext.getBean("target");
target.method();
target.show();

切点表达式的写法

表达式语法：
execution([修饰符] 返回值类型包名.类名.方法名(参数))

访问修饰符可以省略
返回值类型、包名、类名、方法名可以使用星号* 代表任意
包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类
参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

execution(public void com.wanxi.aop.Target.method())    
execution(void com.wanxi.aop.Target.*(..))
execution(* com.wanxi.aop.*.*(..))
execution(* com.wanxi.aop..*.*(..))
execution(* *..*.*(..))

通知的类型

通知的配置语法：
<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>
在这里插入图片描述

使用注解 AOP

@Component("aspect")
@Aspect // 表示这是一个切面类
public class MyAspect {
    //前置增强方法.表示com.zn.spring.aop任何类下的任何方法都会在执行前切入before这个方法。
    @Before(value = "execution(* com.zn.spring.aop.*.*(..))")
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

<?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"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!--组件扫描-->
    <context:component-scan base-package="com.zn"></context:component-scan>
    <!--aop的自动代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

@RunWith(SpringJUnit4ClassRunner.class)
// 这里根据自己具体的情况书写正确的xml文件名。
@ContextConfiguration("classpath:applicationContext1.xml")
public class SpringAOPTest {
    @Autowired
    TargetInterface targetInterface;
    @Test
    public void test_target_aop() {
        targetInterface.method();
    }
}

声明式事务控制

什么是事务？

事务是指是程序中一系列严密的逻辑操作，而且所有操作必须全部成功完成，否则在每个操作中所作的所有更改都会被撤消。可以通俗理解为：就是把多件事情当做一件事情来处理，好比大家同在一条船上，要活一起活，要完一起完。

脏读：

某个事务已更新一份数据,另一个事务在此时读取了同一份数据,由于某些原因,前一个事务RollBack了操作,则后面那个事务所读取的数据就会是不正确的。

不可重复读：

在一个事务的前后多次读取，数据内容不一致,这可能是两次查询过程中间插入了个事务更新的原有的数据

幻读：

在一个事务的两次查询总数据笔数不一致，前后多次读取，数据总量不一致

怎么解决：对事务进行隔离

幻读和不可重复读的区别：

不可重复读指的是数据本身在一个事务里多次读取不一致。update
幻读是指的数据总量在一个事务里多次读取不一致。delete,insert.

Mysql的事务隔离级别

在这里插入图片描述
未授权读取，读未提交（Read Uncommitted）：允许脏读取，但不允许更新丢失。如果一个事务已经开始写数据，则另外一个事务则不允许同时进行写操作，但允许其他事务读此行数据。该隔离级别可以通过“排他写锁”实现。
授权读取，也称为读提交（Read Committed）：允许不可重复读取，但不允许脏读取。这可以通过“瞬间共享读锁”和“排他写锁”实现。读取数据的事务允许其他事务继续访问该行数据，但是未提交的写事务将会禁止其他事务访问该行。
可重复读取（Repeatable Read）：禁止不可重复读取和脏读取，但是有时可能出现幻读数据。这可以通过“共享读锁”和“排他写锁”实现。读取数据的事务将会禁止写事务（但允许读事务），写事务则禁止任何其他事务。