【Spring】代理模式，AOP，声明式事务

最新推荐文章于 2024-06-09 16:06:06 发布
最新推荐文章于 2024-06-09 16:06:06 发布
阅读量233 收藏 1
点赞数 2
分类专栏： Spring 文章标签： java spring ssm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ladiez/article/details/118866487
版权

目录

1.代理模式

为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC很重要】

代理模式的分类：

  • 静态代理
  • 动态代理

在这里插入图片描述

1.1.静态代理

角色分析：

  • 抽象角色：一般会使用接口或抽象类来解决
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
  • 客户：访问代理对象的人！

代码步骤：

  1. 接口

    package com.adie.pojo.demo01;
//租房
public interface Rent {
    public void rent();
}

  2. 真实角色

    package com.adie.pojo.demo01;
//房东
public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房东要出租房子了");
    }
}

  3. 代理角色

    package com.adie.pojo.demo01;

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }

    //签合同
    public void hetong(){
        System.out.println("签租赁合同");
    }

    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

  4. 客户端访问代理角色

    package com.adie.pojo.demo01;

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，但是代理角色一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //你不用面对房东，直接找中介租房即可
        proxy.rent();
    }
}

代理模式的好处：

  • 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
  • 公共也就交给代理角色！实现了业务的分工！
  • 公共业务发生拓展的时候，方便集中管理！

缺点：

  • 一个真实角色就会产生一个代理角色；代码量会翻倍~开发效率会变低

1.2.静态代理加深理解

1.创建一个抽象角色，比如我们平时做的增删改查

package com.adie.pojo.demo02;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

2.需要一个真实对象来实现这些增删改查操作

package com.adie.pojo.demo02;

//真实对象
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 query() {
        System.out.println("查询了一个用户");
    }
}

3.这时候有一个需求，我们需要增加一个日志功能，如何实现？

方法一：在实现类上增加日志打印功能【如果实现类的方法很多，这样做很麻烦】

方法二：使用代理来做，在不改变原来的业务情况下，实现此功能

4.设置一个代理，来实现日志功能

package com.adie.pojo.demo02;

public class UserServiceProxy implements UserService{
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    //日志方法
    public void log(String msg){
        System.out.println("使用了"+msg+"方法");
    }
}

5.客户端来访问代理角色

package com.adie.pojo.demo02;

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy proxy=new UserServiceProxy();
        proxy.setUserService(userService);

        proxy.add();
    }
}

重要的是我们需要理解代理模式的一个思想

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想

纵向开发和横向开发

在这里插入图片描述

1.3.动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的，不是我们直接写好的！
  • 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
    • 基于接口—JDK动态代理【我们在这里使用】
    • 基于类：cglib
    • java字节码实现：javassist

需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序

【Proxy : 代理】

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//生成代理类
public Object getProxy(){
   return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                 rent.getClass().getInterfaces(),this);
}

【InvocationHandler：调用处理程序】
在这里插入图片描述

InvocationHandler接口只有一个方法

Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

代码实现

1.Rent 接口，即抽象角色

package com.adie.pojo.demo03;
//租房
public interface Rent {
    public void rent();
}

2.Host 真实角色

package com.adie.pojo.demo01;//房东public class Host implements Rent{    @Override    public void rent() {        System.out.println("房东要出租房子了");    }}

3.ProxyInvocationHandler. java 即代理角色

package com.adie.pojo.demo03;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//我们用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成得到代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

    //处理代理实例，并返回结果。proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质就是使用反射机制
        seeHouse();
         //核心：本质利用反射实现！
        Object invoke = method.invoke(rent, args);
        fare();
        return invoke;
    }

    public void seeHouse(){
        System.out.println("中介带看房子");
    }

    public void fare(){
        System.out.println("收中介费");
    }
}

4.Client.java

package com.adie.pojo.demo03;

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host=new Host();

        //代理角色:现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象！
        pih.setRent(host);

        Rent proxy = (Rent) pih.getProxy();//这里的proxy就是动态生成的，我们并没有写
        proxy.rent();
    }


}

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

1.4.动态代理加深理解

我们来使用动态代理实现代理我们后面写的UserService！

我们也可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！

package com.adie.pojo.demo04;

import com.adie.pojo.demo03.Rent;

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);
    }

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质就是使用反射机制
        log(method.getName());
        System.out.println(args);
//        这是反射的用法，通过放射调用target的方法，args是参数
        Object invoke = method.invoke(target, args);
        return invoke;
    }

    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

测试！

package com.adie.pojo.demo04;

import com.adie.pojo.demo02.UserService;
import com.adie.pojo.demo02.UserServiceImpl;

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService=new UserServiceImpl();
        //代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);//设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
    }
}

测试，增删改查，查看结果！

动态代理的好处：

  • 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务

  • 公共也就交给代理角色！实现了业务的分工！

  • 公共业务发生拓展的时候，方便集中管理！

  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务

  • 一个动态代理类可以代理多个类，只要是实现了同一个接口即可

2.AOP

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

在这里插入图片描述

Aop在Spring中的作用

提供声明式事务；允许用户自定义切面

以下名词需要了解下：

  • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
  • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
  • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
  • 目标（Target）：被通知对象。
  • 代理（Proxy）：向目标对象应用通知之后创建的对象。
  • 切入点（PointCut）：切面通知 执行的 “地点”的定义。
  • 连接点（JointPoint）：与切入点匹配的执行点。

在这里插入图片描述

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

在这里插入图片描述

即 Aop 在 不改变原有代码的情况下 , 去增加新的功能 .

2.1使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>
2.1.1第一种方式

通过 Spring API 实现

首先编写我们的业务接口和实现类

package com.adie.service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

package com.adie.service;

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 select() {
        System.out.println("查询了一个用户");
    }
}

然后去写我们的增强类 , 我们编写两个 , 一个前置增强 一个后置增强

前置增强

package com.adie.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {

    //method:要执行的目标对象的方法
    //args:参数
    //target:目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

后置增强

package com.adie.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    //returnValue:返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"返回结果为："+returnValue);
    }
}

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .

<?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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

   <!--注册bean-->
   <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
   <bean id="log" class="com.kuang.log.Log"/>
   <bean id="afterLog" class="com.kuang.log.AfterLog"/>

   <!--aop的配置-->
    <aop:config>
<!--        切入点:  expression:表达式  execution(修饰词  返回值  列名  方法名  参数)-->
        <aop:pointcut id="pointcut" expression="execution(* com.adie.service.UserServiceImpl.*(..))"/>

<!--        执行环绕增强-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

测试

import com.adie.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyText {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序员专注领域业务 , 其本质还是动态代理 。

2.1.2第二种方式

自定义类来实现Aop

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

public class DiyPointcut {

   public void before(){
       System.out.println("---------方法执行前---------");
  }
   public void after(){
       System.out.println("---------方法执行后---------");
  }
   
}

去spring中配置

<!--第二种方式自定义实现-->
<!--注册bean-->
    <bean id="diy" class="com.adie.diy.DiyPointCut"/>
    <aop:config>
<!--        自定义切面，ref要引用的类-->
        <aop:aspect ref="diy">
<!--            切入点-->
            <aop:pointcut id="point" expression="execution(* com.adie.service.UserServiceImpl.*(..))"/>
<!--            通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

测试：

import com.adie.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyText {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}
2.1.3第三种方式

使用注解实现

第一步：编写一个注解实现的增强类

package com.adie.diy;

//使用注解方式实现AOP

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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 AnnotationPointCut {
    @Before("execution(* com.adie.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("===方法执行前===");
    }
    @After("execution(* com.adie.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("===方法执行后===");
    }
    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.adie.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //执行方法
        Signature signature = jp.getSignature();//获得签名
        System.out.println("signature"+signature);
        jp.proceed();
        System.out.println("环绕后");

//        System.out.println(proceed);
    }
}

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<!--    方式三-->
    <bean id="AnnotationPointCut" class="com.adie.diy.AnnotationPointCut"/>
<!--    开启注解支持   代理模式有基于接口的，有基于类的  JDK（默认 proxy-target-class="false"）  cglibproxy-target-class="true"-->
    <aop:aspectj-autoproxy proxy-target-class="false"/>

执行结果
在这里插入图片描述

aop:aspectj-autoproxy：说明

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了

<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy  poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

3.声明式事务

3.1.事务简介

  • 事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎
  • 事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。

事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。

事务四个属性ACID

  • 原子性（atomicity）

    事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用

  • 一致性（consistency）

    一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中

  • 隔离性（isolation）

    可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏

  • 持久性（durability）

    事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中

3.2.实践

在之前的案例中，我们给userMapper接口新增两个方法，删除和增加用户；

package com.adie.mapper;

import com.adie.pojo.User;

import java.util.List;

public interface UserMapper {

    public List<User>selectUser();

//    添加一个用户
    public int addUser(User user);

//    删除一个用户
    public int deleteUser(int id);

}

UserMapper.xml的文件中，我们将delete的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.adie.mapper.UserMapper">

    <select id="selectUser" resultType="user">
        select * from mybatis.user
    </select>

    <insert id="addUser" parameterType="user">
        insert into mybatis.user(id, name, pwd)
        values (#{id},#{ name},#{pwd})
    </insert>

    <delete id="deleteUser" parameterType="Integer">
        deletes from mybatis.user where id=#{id};
    </delete>

</mapper>

修改实现类

可以看到我们在查询方法中，先添加了用户，然后删除了用户，可以知道，删除用户是肯定会出错的，那么我们的增加用户在这种情况下，根据事务的原子性，应该同样无法添加成功

package com.adie.mapper;

import com.adie.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{

    @Override
    public List<User> selectUser() {
        User user = new User(5, "c碟", "123456");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);

        mapper.addUser(user);
        mapper.deleteUser(5);
        return mapper.selectUser();
    }

    @Override
    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }

    @Override
    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}

测试

@Test
public void test1(){
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
    UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
    List<User> userList = userMapper.selectUser();
    for (User user : userList) {
        System.out.println(user);
    }
}

报错，sql异常，delete写错了

但是数据插入成功

没有进行事务的管理；我们想让他们都成功才成功，有一个失败，就都失败，我们就应该需要事务

以前我们都需要自己手动管理事务，十分麻烦。

但是Spring给我们提供了事务管理，我们只需要配置即可。

3.3.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">

事务管理器

  • 无论使用Spring的哪种事务管理策略（编程式或者声明式）事务管理器都是必须的。
  • 就是 Spring的核心事务管理抽象，管理封装了一组独立于技术的方法。
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

配置好事务管理器后我们需要去配置事务的通知

<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <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织入事务-->
    <aop:config>
        <aop:pointcut id="txPointcut" expression="execution(* com.adie.mapper.*.*(..))"/>

        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>

删掉刚才加入的数据，再次运行

可以发现，同样会报错，而且数据没有添加成功

a碟
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Spring框架-AOP和声明式事务
11-13
Spring框架-AOP和声明式事务
Spring事务五种不同的代理配置
07-19
Spring事务配置的五种方式 ,根据代理机制的不同，总结了五种Spring事务的配置方式.
SSM框架03-AOP和声明式事务控制
笔记|思路|总结
03-26 831
Spring的AOP简介 什么是AOP AOP(Aspect Oriented Programming)意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 动态代理：在不修改源码的情况下对目标方法进行增强，可以实现程序功能之间的松耦合。 AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的
Spring中AOP及事务管理详解
阿杰的博客
09-05 1059
AOP：Aspect Oriented Programming，面向切面编程。是通过预编译方式（aspectj）或者运行期动态代理（Spring）实现程序功能的统一维护的技术。AOP是OOP（面向对象编程）的技术延续，是软件开发中的一个热点，也是Spring中的一个重要内容。利用AOP可以实现对业务逻辑各个部分之间的隔离，从而使得业务逻辑各部分之间的耦合性降低，提高程序的可重用性，同时提高了开发效率。作用：不修改源码的情况下，进行功能增强，通过动态代理实现的优势：减少重复代码，提高开发效率，方便维护比如：给
Spring AOP之声明式事务@Transactional
诗人不写诗
05-04 714
本文基于Spring 5.2.7Spring声明式事务是我们使用颇多的一种功能。从整体上来讲，他的实现原理是生成一个代理类，将所有使用声明式事务的方法重写，重写的原则就是添加上开启事务，调用目标方法，提交事务的逻辑，就这样完成了声明式事务。事务的封装完全由Spring完成，因为JDBC层面的事务使用时步骤统一且繁琐，适合用AOP封装，Spring正是基于这个原因，专门提供了spring-tx来接管数据库事务功能，方便用户使用。使用Spring声明式注解的方式有2种，一种是普通Spring应用，一种是拥有自动
SpringIOC和AOP理解之深入浅出（建议收藏）
weixin_45105261的博客
01-13 6803
Spring框架介绍 概念：Spring是一个开源的框架，并且是一个轻量级的java开发框架 前身：interface21是他的前身 Spring理念：使现有的技术更加容易使用，本身就是一个大杂烩，整合了现有的主流技术框架 优点： 方便解耦，简化开发 （高内聚低耦合） Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理 spring工厂是用于生成bean AOP编程的支持 Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能 声明式事务的支
spring之AOP和声明式事务
qq_36116242的博客
02-22 477
1. AOP的基本概念 AOP（Aspect Oriented Programming），即面向切面编程。 (OOP：Object 面向对象编程) 比如去银行取款和查询余额 有了AOP，你写代码时不需要把这个验证用户步骤写进去，即完全不考虑验证用户。只写取款和显示余额的业务代码。而在另一个地方，写好验证用户的代码。这个验证用户的代码就是切面代码，以后在执行取款和显示余额的时候，利用代理模式。将验证用户的功能在执行取款和显示余额前调用。 代码在Spring容器中执行的时候，通过配置告诉Spring
浅入浅出代理模式与Spring事务管理
m0_69860228的博客
05-19 163
本文回顾了代理模式和Spring事务管理的原理。 前言 最近在开发业务代码的时候，犯了一个事务注解的错误：在同一个类的非事务方法中调用了另一个事务方法，导致事务没有生效，如下所示： public ConfirmOrderResultVO batchConfirmPurchaseOrders(Long taobaoUserId, List<String> bizOrderIds) throws TCException { ………………………………………………………………
SpringAOP(面向切面)
weixin_50485954的博客
04-04 118
SpringAOP(面向切面代理模式简单转账功能 代理模式 简单转账功能
aop基本概念和声明方式
lbl的博客
09-03 469
概念 advice/通知： 什么时候干什么事情 pointcut/切点： 什么地方可以干这个事情 advice与pointcut组成切面/aspect，在什么地方什么时候干什么事情 joinpoint：软件中的连接点，这些点可以织入切面。 五种通知类型 before after after-returning after-throwing around xml配置方式 &amp;lt...
Spring声明式事务配置管理方法
03-02
发布于2013-5-6项目使用SSH架构，现在要添加Spring事务管理功能，针对当前环境，只需要添加Spring2.0AOP类库即可。添加方法：点击项目右键->BuildPath->Addlibrarys:打开AddLibraries对话框，然后选定...
Spring ax/aop声明式事务配置实例
09-09
Spring ax/aop声明式事务配置实例
深入理解Spring声明式事务：源码分析与应用实践
12-13
Spring通过@Transactional注解以及底层的AOP和代理机制实现了声明式事务。这个机制允许开发者通过简单的注解就能控制事务的边界和规则，极大地简化了编程模型。在Spring中，事务管理是通过一系列的拦截器和事务管理...
设计模式-代理模式
武武武武武丶神的博客
08-05 91
代理模式 代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。在某些情况下，一个对象不合适或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 代理模式一般包含三种角色： 抽象主题角色（Subject）：抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类； 真实主题角色（RealSubject）：该类也被称为被代理类，该类定义了代理所表示的真实对象，是负责执行系统真正的逻辑业务对象； 代理
Spring中使用动态代理和AOP来实现事务的管理
weixin_44991304的博客
02-25 883
一.环境搭建 1）引入相关依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.14</version> </dependency> <dep
代理模式-----进行事务的注解
ZHL_blog
08-21 363
代理模式----能进行事务的注解 (做一个生成代理模式的工具类；把调用其中的getProxy(传入原型对像))；这时返回值就是一个代理后的对象 Transaction .java @Retention(RetentionPolicy.RUNTIME)//运行时环境 @Target(value=ElementType.METHOD)//指定该注解在哪里起作用 public @interfa
SpringAOP声明式事务
csdn_hmt的博客
06-20 584
文章目录SpringAOP声明式事务xml配置第一步配置数据源定义一个JdbcTemplate类型的bean,是Spring提供给我们做jdbc CRUD操作的类第二步初始化事务管理器第三步配置事务AOP通知第四步定义AOP配置（将上面的通知和表达式组装到一起）注解配置开启事务相关注解支持配置数据源bean定义JdbcTemplate对象，Spring给我们封装了所有的JDBC操作定义事务管理器b...
简单的项目部署脚本（转载）
最新发布
u010230019的博客
06-09 696
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
springaop声明式事务失效
09-07
Spring AOP声明式事务失效的主要原因有以下几种情况： 1. 非public方法失效：只有标注在public级别的方法上的@Transactional才会生效。因为Spring AOP不支持对private、protected方法进行拦截。声明@Transactional的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

a碟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值