（四）SpringAOP和事务

最新推荐文章于 2023-01-26 21:44:41 发布
最新推荐文章于 2023-01-26 21:44:41 发布
阅读量145 收藏
点赞数
分类专栏： Spring 文章标签： spring java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cococonger_/article/details/115128348
版权

文章目录

一、AOP

1.1、概述

AOP：面向切面编程。通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP是OOP的延续

1.2、AOP在Spring中的应用

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

  • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与业务逻辑无关的，但是需要注意的部分就是横切关注点。如日志、安全、缓存、事务等
  • 切面：横切关注点被模块化的特殊对象，即一个类。如Log类
  • 通知：类中的方法，如Log中的方法
  • 目标：接口或者方法
  • 代理：向目标对象应用通知之后创建的对象。即生成的代理类
  • 切入点：切面通知执行的地点的定义。即method.invoke
  • 连接点：与切入点匹配的执行点

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

  • 前置通知：方法前
  • 后置通知：方法后
  • 环绕通知：方法前后
  • 异常抛出通知：方法抛出异常
  • 引介通知：类中增加新的方法属性

1.3、使用Spring实现AOP

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

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

1.3.1、方式一

使用Spring的API接口【主要是SpringAPI接口实现】

  1. 接口

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

  2. 实现类

    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("查询了一个用户");
    }
}

  3. 前置通知

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

  4. 后置通知

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

  5. 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.study09.service.UserServiceImpl"/>
    <bean id="log" class="com.study09.log.Log"/>
    <bean id="afterLog" class="com.study09.log.AfterLog"/>

    <!-- 方式一：使用原生SpringAPI接口 -->
    <!-- 配置AOP：需要导入AOP的约束 -->
    <aop:config>
        <!-- 切入点：expression表达式
                        execution(要执行的位置：* * * * *)
        -->
        <aop:pointcut id="pointcut" expression="execution(* com.study09.service.UserServiceImpl.*(..))"/>

        <!-- 执行环绕增加，把指定的类切入到指定的方法上面 -->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

  6. 测试

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

1.3.2、方式二

自定义来实现AOP【主要是切面定义】

  1. 自定义切入类

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

  2. xml配置

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

1.3.3、方式三

使用注解方式实现AOP

  1. 通知类

    // 标注这个类是一个切面
@Aspect
public class AnnotationPointCut {
    @Before("execution(* com.study09.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("==========方法执行前==========");
    }

    @After("execution(* com.study09.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("==========方法执行后==========");
    }

    // 在环绕增强中，可以给定一个参数，代表要获取处理的切入点
    @Around("execution(* com.study09.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("==========环绕前==========");
        // 执行方法，在这里才会去调用before和after
        Object proceed = jp.proceed();
        System.out.println("==========环绕后==========");
    }
}

  2. xml配置

    <!-- 方式三：使用注解 -->
<bean id="AnnotationPointCut" class="com.study09.diy.AnnotationPointCut"/>
<!-- 开启注解支持 -->
<aop:aspectj-autoproxy/>

二、整合Mybatis

步骤：

  1. 导入相关jar包
    • junit
    • mybatis
    • mysql-connector-java
    • spring
    • aop织入
    • mybatis-spring【新包】
  2. 编写配置文件
  3. 测试

要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个SqlSessionFactory和至少一个数据映射器类。
在 MyBatis-Spring 中，可使用SqlSessionFactoryBean来创建SqlSessionFactory。要配置这个工厂 bean，只需要把下面代码放在 Spring 的 XML 配置文件中：

<bean id="sqlSessionFactory"
class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource" />
</bean>

注意：SqlSessionFactory需要一个DataSource（数据源）。 这可以是任意的DataSource，只需要和配置其它 Spring 数据库连接一样配置它就可以了。

在基础的 MyBatis 用法中，是通过SqlSessionFactoryBuilder来创建SqlSessionFactory的。 而在 MyBatis-Spring 中，则使用SqlSessionFactoryBean来创建。

在 MyBatis 中，你可以使用SqlSessionFactory来创建SqlSession。一旦你获得一个session之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭session。
SqlSessionFactory有一个唯一的必要属性：用于 JDBC 的DataSource。这可以是任意的DataSource对象，它的配置方法和其它 Spring 数据库连接是一样的。

一个常用的属性是configLocation，它用来指定 MyBatis 的 XML 配置文件路径。它在需要修改MyBatis 的基础配置非常有用。通常，基础配置指的是 <settings> 或 <typeAliases> 元素。

需要注意的是，这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说，任何环境配置（<environments> ），数据源（ <DataSource> ）和 MyBatis 的事务管理器（<transactionManager>）都会被忽略。SqlSessionFactoryBean会创建它自有的 MyBatis环境配置（Environment），并按要求设置自定义环境的值。

SqlSessionTemplate是 MyBatis-Spring 的核心。作为SqlSession的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的SqlSession。

模板可以参与到 Spring 的事务管理中，并且由于其是线程安全的，可以供多个映射器类使用，你应该总是用SqlSessionTemplate来替换 MyBatis 默认的DefaultSqlSession实现。在同一应用程序中的不同类之间混杂使用可能会引起数据一致性的问题。

可以使用SqlSessionFactory作为构造方法的参数来创建SqlSessionTemplate对象。

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
	<constructor-arg index="0" ref="sqlSessionFactory" />
</bean>

现在，这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean 中添加一个 SqlSession
属性，就像下面这样：

public class UserDaoImpl implements UserDao {
	private SqlSession sqlSession;
	public void setSqlSession(SqlSession sqlSession) {
		this.sqlSession = sqlSession;
	}
	public User getUser(String userId) {
		return sqlSession.getMapper...;
	}
}

按下面这样，注入SqlSessionTemplate：

<bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl">
	<property name="sqlSession" ref="sqlSession" />
</bean>

2.1、整合实现一

  1. 引入Spring配置文件beans.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
http://www.springframework.org/schema/beans/spring-beans.xsd">

  2. 配置数据源替换mybaits的数据源

    <!--配置数据源：数据源有非常多，可以使用第三方的，也可使使用Spring的-->
<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&amp;useUnicode=true&amp;characterEncoding=utf8"/>
	<property name="username" value="root"/>
	<property name="password" value="root"/>
</bean>

  3. 配置SqlSessionFactory，关联MyBatis配置文件

    <!--配置SqlSessionFactory-->
<bean id="sqlSessionFactory"
class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource"/>
	<!--关联Mybatis-->
	<property name="configLocation" value="classpath:mybatisconfig.xml"/>
	<property name="mapperLocations" value="classpath:com/kuang/dao/*.xml"/>
</bean>

  4. 注册sqlSessionTemplate，关联sqlSessionFactory

    <!--注册sqlSessionTemplate , 关联sqlSessionFactory-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
	<!--利用构造器注入-->
	<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

  5. 增加Dao接口的实现类；私有化sqlSessionTemplate

    public class UserDaoImpl implements UserMapper {
	//sqlSession不用我们自己创建了，Spring来管理
	private SqlSessionTemplate sqlSession;
	public void setSqlSession(SqlSessionTemplate sqlSession) {
		this.sqlSession = sqlSession;
	}
	public List<User> selectUser() {
	UserMapper mapper = sqlSession.getMapper(UserMapper.class);
		return mapper.selectUser();
	}
}

  6. 注册bean实现

    <bean id="userDao" class="com.kuang.dao.UserDaoImpl">
	<property name="sqlSession" ref="sqlSession"/>
</bean>

  7. 测试

    @Test
public void test2(){
	ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
	UserMapper mapper = (UserMapper) context.getBean("userDao");
	List<User> user = mapper.selectUser();
	System.out.println(user);
}

2.2、整合实现二

dao层继承Support类，直接利用getSqlSession()获得，然后直接注入SqlSessionFactory。
比起方式1，不需要管理SqlSessionTemplate，而且对事物的支持更加友好。

  1. dao层实现类

    public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

  2. xml配置

<bean id="userMapper2" class="com.study10.mapper.UserMapperImpl2">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

  1. 测试

    @Test
public void test2(){
	ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
	UserMapper mapper = (UserMapper) context.getBean("userDao");
	List<User> user = mapper.selectUser();
	System.out.println(user);
}

三、声明式事务

1、回顾事务

  • 把一组业务当成一个业务来做，要么都成功，要么都失败
  • 事务在项目开发中十分重要，涉及到事物的一致性问题
  • 确保完整性和一致性

事物的ACID原则：

  • 原子性
  • 一致性
  • 隔离性
    • 多个业务可能操作同一个资源，防止数据损坏
  • 持久性
    • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，都会被持久化的写入到存储器中

2、Spring中事务管理

Spring支持编程式事务管理和声明式的事务管理。
编程式事务管理

  • 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
  • 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

  • 一般情况下比编程式事务好用。
  • 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
  • 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务
    管理。

代码：

  1. 实体类

    @Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
}

  2. 接口

    public interface UserMapper {
    List<User> selectUser();
    int addUser(User user);
    int deleteUser(int id);
}

  3. 实现类

    public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = new User(5, "小王", "2233123");
        mapper.addUser(user);
        mapper.deleteUser(4);

        return mapper.selectUser();
    }

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

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

  4. 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:tx="http://www.springframework.org/schema/tx"
       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/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- DataSource：使用Spring的数据源替换Mybatis的配置  c3p0、dbcp、druid
        这里使用Spring提供的JDBC
     -->
    <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&amp;useUnicode=true&amp;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:com/study11/mapper/*.xml"/>
    </bean>

    <bean id="userMapper" class="com.study11.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

    <!-- 配置声明式事务 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 结合AOP实现事务的织入 -->
    <!-- 配置事务通知：propagation -->
    <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>

    <!-- 配置事务切入 -->
    <aop:config>
        <aop:pointcut id="point" expression="execution(* com.study11.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="point"/>
    </aop:config>

</beans>

  5. Mapper.xml

    <mapper namespace="com.study11.mapper.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="deleteUser" parameterType="int">
        DELETE from user where id = #{id}
    </delete>

</mapper>

  6. 测试

    public static void main(String[] args) {
    ClassPathXmlApplicationContext 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);
    }
}

spring事务传播特性：
事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。
spring支持7种事务传播行为：

  • propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
  • propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
  • propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
  • propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
  • propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
  • propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
  • propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。
假设 ServiveX#methodX() 都工作在事务环境下（即都被 Spring 事务增强了），假设程序中存在如下的调用链：Service1#method1()->Service2#method2()->Service3#method3()，那么这 3 个服务类的 3个方法通过 Spring 的事务传播机制都工作在同一个事务中。
就好比，刚才的几个方法存在调用，所以会被放在一组事务当中

Clam.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP应用之事务
weixin_47742705的博客
04-24 588
Spring AOP应用之事务
spring aop (面向切面编程)实现事务管理(^_^^_^)
jaryle的专栏
03-23 2923
事务嵌套，不回滚的问题描述： 要想事务起作用，必须是主方法名上有@Transactional注解，方法体内不能用try catch；如果用try catch，则catch中必须用throw new RuntimeException(); @Transactional注解应该只被应用到public方法上，不要用在protected、private等方法上，即使用了也将被忽略，不起作用。这是由Sp...
spring笔记下(AOP、事务管理)
白豆五的博客
01-26 1354
todo
脏读、不可重复读、幻读
chengwai26的博客
08-08 329
1. 脏读 ：脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问 这个数据，然后使用了这个数据。 2. 不可重复读 ：是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两 次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务
5.1 Spring_AOP_事务
weixin_45813215的博客
05-03 325
AOP 1.1 AOP简介和作用【理解】 AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构 OOP(Object Oriented Programming)面向对象编程 作用：在不惊动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法源代码的基础上对方法进行功能增强。 Spring理念：无入侵式/无侵入式 面向对象(OOP)->面向切面(AOP) 面向切面(AOP): 是一种编程思想 动态代理 动态代理: 其实就
Spring AOP与事务
weixin_65440201的博客
09-02 472
AOP是在不改原有代码的前提下对其进行增强。面向切面编程，一种编程范式，指导开发者如何组织程序结构。AOP是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序。1.2AOP作用作用:在不惊动原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代理模式。1.3AOP核心概念为了能更好的理解AOP的相关概念，我们准备了一个环境，整个环境的内容我们暂时可以不用关注，最主要的类为://记录程序当前执行执行（开始时间）//业务执行万次i
spring aop和事务练习
03-18
spring中aop和Synchronized锁在Spring事务管理下，导致线程不安全。
线程池中使用spring aop事务增强
08-25
在Java开发中，Spring框架是...总之，Spring AOP在多线程环境中的使用，特别是结合线程池，需要特别注意事务管理和代理对象的正确使用。理解AOP的工作原理以及其与线程池的交互，对于构建健壮的并发应用程序至关重要。
Spring aop、jdbc和事务tx练习
11-08
通过这些练习，你可以深入理解Spring如何整合AOP、JDBC和事务管理，并提升你的实际开发技能。在实践中，你可能会遇到的问题包括事务传播行为、异常回滚规则、事务隔离级别等，这些都是进一步学习和研究的方向。
Spring AOP配置事务方法
11-09
Spring AOP 提供了一种灵活的方式来实现事务管理，通过配置事务特性和事务管理切面来实现事务管理。 配置事务管理切面： 在 Spring AOP 中，事务管理切面是通过 `<aop:config>` 元素来配置的。该元素用于定义一个...
Spring如何基于aop实现事务控制
08-24
Spring基于AOP实现事务控制 Spring框架中提供了多种方式来实现事务控制，基于AOP（Aspect-Oriented Programming，面向方面编程）是其中的一种常用方式。通过使用AOP，可以将事务控制逻辑从业务逻辑中分离出来，...
spring第二篇之AOP及其事物的管理
manba123456的博客
03-15 1045
概念： AOP是一种面向切面编程思想，是OOP的延续。其核心思想就是：横向重复，纵向抽取。Spring AOP中的动态代理很好的体现了这种思想。 如何去理解这种思想呢？如下图所示： AOP作用：不修改源码的情况下对程序进行增强。AOP可以进行权限校验、日志记录、性能监控、事务控制。 Spring底层AOP实现原理：动态代理(增强一个类中方法) 1，JDK动态代理(优先) 被代理对...
Spring二：AOP和事务
青衫忆笙的博客
12-03 2804
Spring AOP和事务的介绍以及代码实现，文末附源码，供入门者下载学习
Spring AOP与事务、日志的关系梳理
殷华隆的博客
10-10 932
很喜欢一句话：认清架构，才不容易在细节中迷失自我。 作为Springboot的初学者，我们都知道面向切面编程（AOP）常常用于事务管理、日志分析、等等，但是在实际的开发中，我只看到了@Transactional（事务相关注解）、@Slf4j（日志相关注解）与事务、日志相关的注解，好像都没到AOP的影子，难道这些注解对AOP做了封装？如果你也有这样的困惑，请往下看。 带着这个疑惑，我查看了很多别人写...
SpringAOP和事务
Mosqiote的博客
05-29 1871
AOP AOP简介 AOP(Aspect-Oriented Programming, 面向切面编程)：是一种新的方法论, 是对传统 OOP(Object-OrientedProgramming, 面向对象编程) 的补充.； AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点. 在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方...
SpringAOP与Spring事务处理总结
jordandandan的专栏
12-12 6619
spring用到的另外一项技术就是AOP(Aspect-Oriented Programming, 面向切面编程)，它是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程)的补充。AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点。在应用 AOP 编程时, 仍然需要在定义公共功能, 但可以明确的定义这个功能
Spring使用AOP实现统一事务处理
为天地立心，为生民立命，为往圣继绝学，为万世开太平
05-18 6719
我是使用XML配置开发AspectJ框架。 １、　所以！一点要在pom文件引入spring-aspects的配置。 版本自行选择 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId>...
数据库事务的四大特性、隔离级别以及Spring中如何利用AOP进行事务管理
c_w_d的博客
03-18 8314
首先，什么是事务？ 事务就是业务上的一个逻辑单元，它能够保证其中对数据所有的操作，要么成功，要么失败。 其次，事务的特性有哪些？ 1.原子性。 例如，转账，A账户减少，B账户增加。虽然是两条 DML语句，但是被当做是一个整体，一次事务。两条语句只能同时成功或者同时失败。 2.一致性。 账户A和B,要么都是转账前的状态，要么都是转账后的状态。(不能A账户的钱减少了但是B账户的钱没有增加)
关于spring aop和spring事务各种配置和一些注意事项
outsider
04-06 3594
关于spring事务和spring aop1. spring 事务默认只有抛出unchecked Exception才会回滚              UncheckedException包括error和runtimeException派生出的所有子类2.     什么时候才用事务?对数据库的数据进行批量或连表操作时，为了保证数据的一致性和正确性，我们需要添加事务管理机制进行管理。当对数据库的数据...
spring aop和事务
最新发布
08-09
Spring AOP (Aspect-...通过结合 Spring AOP 和事务，开发者可以在应用程序可以将事务管理逻辑抽象成切面，并将其应用到需要确保数据的一致性和完整性。 总结起来，Spring AOP 提供了通过使用 Spring AOP 和声明式

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值