【 Spring 源码分析 】- 2 手写 Spring 事务框架

最新推荐文章于 2024-03-16 21:09:02 发布
最新推荐文章于 2024-03-16 21:09:02 发布
阅读量166 收藏
点赞数
分类专栏： 🌟🌟🌟源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42112635/article/details/104446374
版权

0 环境准备

1、创建 maven 工程，导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.snow</groupId>
    <artifactId>ssm</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 引入Spring-AOP等相关Jar -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>3.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.5.3</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>
    </dependencies>

</project>

2、创建 spring 的配置文件

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

	<!-- 扫包范围 -->
	<context:component-scan base-package="com.snow"></context:component-scan>

	<!-- 开启事物注解 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

	<!-- 1. 数据源对象: C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://120.78.134.111:3306/test"></property>
		<property name="user" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>

	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

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

</beans>

3、创建数据库

CREATE DATABASE test;
USE test;

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `age` int(3) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

SET FOREIGN_KEY_CHECKS = 1;

4、dao 层

package com.snow.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class UserDao {

	@Autowired
	private JdbcTemplate jdbcTemplate;

	public void add(String name, Integer age) {
		String sql = "INSERT INTO user(name, age) VALUES(?, ?);";
		int updateResult = jdbcTemplate.update(sql, name, age);
		System.out.println("updateResult:" + updateResult);
	}

}

5、service 层

package com.snow.service;

public interface UserService {

	public void add();
}


package com.snow.service.impl;

import com.snow.dao.UserDao;
import com.snow.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserDao userDao;

	public void add() {

		userDao.add("test001", 20);
		System.out.println("################");
		userDao.add("test002", 21);
		
	}

}

6、切面类

package com.snow.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

// 切面类
@Component
@Aspect
public class AopLog {

    // aop 编程里面有几个通知： 前置通知 后置通知 运行通知 异常通知 环绕通知
    @Before("execution(* com.snow.service.UserService.add(..))")
    public void before() {
        System.out.println("前置通知 在方法之前执行...");
    }

    // 后置通知 在方法运行后执行
    @After("execution(* com.snow.service.UserService.add(..))")
    public void after() {
        System.out.println("后置通知 在方法之后执行...");
    }

    // 运行通知
    @AfterReturning("execution(* com.snow.service.UserService.add(..))")
    public void returning() {
        System.out.println("运行通知...");
    }

    // 异常通知
    @AfterThrowing("execution(* com.snow.service.UserService.add(..))")
    public void afterThrowing() {
        System.out.println("异常通知...");
    }

    // 环绕通知 在方法之前和之后处理事情
    @Around("execution(* com.snow.service.UserService.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

        // 调用方法之前执行
        System.out.println("环绕通知 调用方法之前执行");

        // 代理调用方法 注意点： 如果调用方法抛出溢出不会执行后面代码
        proceedingJoinPoint.proceed();

        // 调用方法之后执行
        System.out.println("环绕通知 调用方法之后执行");
    }

}

7、测试类

package com.snow;

import com.snow.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test001 {

	public static void main(String[] args) {

		ClassPathXmlApplicationContext applicationContext =
				new ClassPathXmlApplicationContext("spring.xml");

		UserService userService = (UserService) applicationContext.getBean("userServiceImpl");
		userService.add();
	}

}

8、测试

控制台打印：

前置通知 在方法之前执行...
环绕通知 调用方法之前执行
updateResult:1
################
updateResult:1
后置通知 在方法之后执行...
运行通知...
环绕通知 调用方法之后执行

数据库：
在这里插入图片描述

9、测试异常

修改 service 层

package com.snow.service.impl;

import com.snow.dao.UserDao;
import com.snow.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserDao userDao;

	public void add() {

		userDao.add("test001", 20);
		int i = 1 / 0;
		System.out.println("################");
		userDao.add("test002", 21);

	}

}

在这里插入图片描述

测试，控制台打印：

前置通知 在方法之前执行...
环绕通知 调用方法之前执行
updateResult:1
后置通知 在方法之后执行...
异常通知...
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.snow.service.impl.UserServiceImpl.add(UserServiceImpl.java:17)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:309)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:183)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:150)
	at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:42)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:55)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:50)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:80)
	at com.snow.aop.AopLog.around(AopLog.java:44)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:621)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:610)
	at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:65)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:50)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:90)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:202)
	at com.sun.proxy.$Proxy15.add(Unknown Source)
	at com.snow.Test001.main(Test001.java:14)

1 编程事务实现

概述

所谓编程式事务指的是通过编码方式实现事务，即类似于 JDBC 编程实现事务管理。管理使用 TransactionTemplate 或者直接使用底层的 PlatformTransactionManager。对于编程式事务管理，spring 推荐使用 TransactionTemplate。

1⃣️ 使用编程事务实现手动事务

使用编程事务实现，手动事务 begin、commit、rollback

创建事务工具类：

package com.snow.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;

/**
 *
 * 编程事务（需要手动begin 手动回滚  手都提交）
 *
 */
@Component
public class TransactionUtils {

	// 获取事务源
	@Autowired
	private DataSourceTransactionManager dataSourceTransactionManager;

	// 开启事务
	public TransactionStatus begin() {
		TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
		return transaction;
	}

	// 提交事务
	public void commit(TransactionStatus transaction) {
		dataSourceTransactionManager.commit(transaction);
	}

	// 回滚事务
	public void rollback(TransactionStatus transaction) {
		dataSourceTransactionManager.rollback(transaction);
	}

}

修改 service 层：

package com.snow.service.impl;

import com.snow.dao.UserDao;
import com.snow.service.UserService;
import com.snow.transaction.TransactionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserDao userDao;

	@Autowired
	private TransactionUtils transactionUtils;

	public void add() {

		TransactionStatus transactionStatus = null;
		try {
			transactionStatus = transactionUtils.begin();
			userDao.add("wangmazi", 27);
			int i = 1 / 0;
			System.out.println("我是add方法");
			userDao.add("zhangsan", 16);
			transactionUtils.commit(transactionStatus);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (transactionStatus != null) {
				transactionStatus.rollbackToSavepoint(transactionStatus);
			}
		}
	}

}

2⃣️ AOP 技术封装手动事务

创建切面类，基于手手动事务封装：

package com.snow.aop;

import com.snow.transaction.TransactionUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

/**
 *
 * 切面类,基于手手动事务封装
 *
 */
@Component
@Aspect
public class AopTransaction {

	@Autowired
	private TransactionUtils transactionUtils;

	/**
	 * 异常通知
	 * TransactionUtils 不要实现为单例子： 如果为单例子的话可能会发生线程安全问题
	 *
	 */
	@AfterThrowing("execution(* com.snow.service.UserService.add(..))")
	public void afterThrowing() {
		System.out.println("回滚事务");
		// 获取当前事务 直接回滚
		TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
	}

	/**
	 * 环绕通知 在方法之前和之后处理事情
	 *
	 * @param proceedingJoinPoint
	 * @throws Throwable
	 */
	@Around("execution(* com.snow.service.UserService.add(..))")
	public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

		// 调用方法之前执行
		System.out.println("开启事务");
		TransactionStatus transactionStatus = transactionUtils.begin();
		proceedingJoinPoint.proceed();// 代理调用方法 注意点： 如果调用方法抛出溢出不会执行后面代码
		// 调用方法之后执行
		System.out.println("提交事务");
		transactionUtils.commit(transactionStatus);
	}
}

修改 service 层：

package com.snow.service.impl;

import com.snow.dao.UserDao;
import com.snow.service.UserService;
import com.snow.transaction.TransactionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserDao userDao;

	@Autowired
	private TransactionUtils transactionUtils;

	public void add() {

		// 注意事项： 在使用spring事务的时候，service 不要try 最将异常抛出给外层aop 异常通知接受回滚
		try {
			userDao.add("test001", 20);
			int i = 1 / 0;
			System.out.println("################");
			userDao.add("test002", 21);
		} catch (Exception e) {
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
		}
	}

}

重点：使用事务注意事项

事务是程序运行如果没有错误，会自动提交事物，如果程序运行发生异常，则会自动回滚。

如果使用了 try 捕获异常时，一定要在 catch 里面手动回滚。

  • 事务手动回滚代码
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

在这里插入图片描述

如果在使用事务时，同时 try...catch 捕获了异常，那么 aop 就拿不到异常通知了，就不会回滚事务。
注意：begin 后面必须要有 commit 或者 rollback，否则对数据库表的操作拿到的锁就不会释放，会发生 死锁 现象。

2 声明事务实现

2.1 概述

管理建立在 AOP 之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于 @Transactional 注解的方式)，便可以将事务规则应用到业务逻辑中。

显然声明式事务管理要优于编程式事务管理，这正是 spring 倡导的非侵入式的开发方式。

声明式事务管理使业务代码不受污染，一个普通的 POJO 对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。

2.2 XML实现声明

2.3 注解版本声明

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans.xsd
     	 http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">


	<!-- 开启注解 -->
	<context:component-scan base-package="com.snow"></context:component-scan>
	<!-- 1. 数据源对象: C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://120.78.134.111:3306/test"></property>
		<property name="user" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>

	<!-- 2. JdbcTemplate工具类实例 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	<!-- 配置事物 -->
	<bean id="dataSourceTransactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 开启注解事物 -->
	<tx:annotation-driven transaction-manager="dataSourceTransactionManager" />
</beans>

用法

	@Transactional
	public void add() {
		userDao.add("wangmazi", 27);
		int i = 1 / 0;
		System.out.println("我是add方法");
		userDao.add("zhangsan", 16);
	}

3 手写 Spring 注解版本事务

3.1 注解

Jdk1.5 新增新技术，注解。很多框架为了简化代码，都会提供有些注解。可以理解为插件，是代码级别的插件，在类的方法上写：@XXX，就是在代码上插入了一个插件。

注解不会也 不能影响代码的实际逻辑，仅仅起到辅助性的作用。

注解分类：内置注解(也成为元注解 jdk 自带注解)、自定义注解（Spring 框架）

3.1.1 什么是内置注解

  • @SuppressWarnings 再程序前面加上可以在 javac 编译中去除警告–阶段是SOURCE
  • @Deprecated 带有标记的包，方法，字段说明其过时----阶段是SOURCE
  • @Overricle 打上这个标记说明该方法是将父类的方法重写–阶段是SOURCE
@Overricle 案例演示
	@Override
	public String toString() {
		return null;
	}
@Deprecated 案例演示
	new Date().parse("");
@SuppressWarnings 案例演示
	@SuppressWarnings({ "all" })
	public void save() {
		java.util.List list = new ArrayList();
	}

3.1.2 实现自定义注解

元注解的作用就是负责注解其他注解。Java5.0 定义了4个标准的 meta-annotation 类型，它们被用来提供对其它 annotation 类型作说明。Java5.0 定义的元注解：

1、@Target

@Target 说明了 Annotation 所修饰的对象范围：Annotation 可被用于 packages、types（类、接口、枚举、Annotation 类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch 参数）。在 Annotation 类型的声明中使用了 target 可更加明晰其修饰的目标。

  1. CONSTRUCTOR：用于描述构造器
  2. FIELD：用于描述域
  3. LOCAL_VARIABLE：用于描述局部变量
  4. METHOD：用于描述方法
  5. PACKAGE：用于描述包
  6. PARAMETER：用于描述参数
  7. TYPE：用于描述类、接口(包括注解类型) 或enum声明

2、@Retention
表示需要在什么级别保存该注释信息，用于描述注解的生命周期（即：被描述的注解在什么范围内有效）

3、@Documented

4、@Inherited

使用 @interface 定义注解。

自定义注解：

package com.snow.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Target(value = ElementType.METHOD) 设置注解权限<br>
 * @author
 *
 */
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AddAnnotation { // @interface 定义注解

	// 手写Spring事务注解
	int userId() default 0;

	String userName() default "默认名称";

	String[] arrays();
}

测试类：

package com.snow.annotation;

import java.lang.reflect.Method;

public class User {

	@AddAnnotation(userName = "张三", userId = 18, arrays = { "1" })
	public void add() {

	}

	public void del() {

	}

	/**
	 * 反射读取注解信息
	 *
	 * @param args
	 * @throws ClassNotFoundException
	 */
	public static void main(String[] args) throws ClassNotFoundException {
		// 怎么样获取到方法上注解信息 反射机制
		Class<?> forName = Class.forName("com.snow.annotation.User");
		// 获取到当前类（不包含继承）所有的方法
		Method[] declaredMethods = forName.getDeclaredMethods();
		for (Method method : declaredMethods) {
			// 获取该方法上是否存在注解
			System.out.println("#### 方法名称 " + method.getName());
			AddAnnotation addAnnotation = method.getDeclaredAnnotation(AddAnnotation.class);
			if (addAnnotation == null) {
				// 该方法上没有注解
				System.out.println("该方法上没有加注解...");
				continue;
			}
			// 在该方法上查找到该注解
			System.out.println("userId:" + addAnnotation.userId());
			System.out.println("userName:" + addAnnotation.userName());
			System.out.println("arrays:" + addAnnotation.arrays());
			System.out.println();
		}
	}

}

运行测试类，控制台打印：

#### 方法名称 main
该方法上没有加注解...
#### 方法名称 add
userId:18
userName:张三
arrays:[Ljava.lang.String;@3f99bd52

#### 方法名称 del
该方法上没有加注解...

3.2 自定义事务注解

1⃣️ 定义事务注解

package com.snow.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 *
 * 事务注解 设置传播行为
 *
 */
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtTransaction {

}

2⃣️ 封装手动事务

package com.snow.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;

/**
 *
 * 编程事务（需要手动begin 手动回滚  手都提交）
 *
 */
@Component
@Scope("prototype") // 设置成原型解决线程安全
public class TransactionUtils {

    private TransactionStatus transactionStatus;

	// 获取事务源
	@Autowired
	private DataSourceTransactionManager dataSourceTransactionManager;

	// 开启事务
	public TransactionStatus begin() {
        System.out.println("开启事务");
        transactionStatus = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
        return transactionStatus;
	}

    // 提交事务
    public void commit(TransactionStatus transaction) {
        dataSourceTransactionManager.commit(transaction);
    }

    // 回滚事务
    public void rollback() {
        System.out.println("rollback");
        dataSourceTransactionManager.rollback(transactionStatus);
    }

}

3⃣️ 定义一个事务扫包的 AOP

4⃣️ 判断是否有注解

拦截方法的时候，使用反射技术判断该方法上是否有事务注解。如果有的话，就开启事务；没有，就不开启事务。

package com.snow.aop;

import java.lang.reflect.Method;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import com.snow.annotation.ExtTransaction;
import com.snow.transaction.TransactionUtils;

//  自定义事务注解具体实现
@Aspect
@Component
public class AopExtTransaction {

	// 一个事务实例子 针对一个事务
	@Autowired
	private TransactionUtils transactionUtils;

	// 使用异常通知进行 回滚事务
	@AfterThrowing("execution(* com.snow.service.*.*.*(..))")
	public void afterThrowing() {
		// 获取当前事务进行回滚
		// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
		transactionUtils.rollback();
	}

    /**
     * 环绕通知 在方法之前和之后处理事情
     *
     * @param pjp
     * @throws Throwable
     */
	@Around("execution(* com.snow.service.*.*.*(..))")
	public void around(ProceedingJoinPoint pjp) throws Throwable {

		// 1.获取该方法上是否加上注解
		ExtTransaction extTransaction = getMethodExtTransaction(pjp);
		TransactionStatus transactionStatus = begin(extTransaction);
		// 2.调用目标代理对象方法
		pjp.proceed();
		// 3.判断该方法上是否就上注解
		commit(transactionStatus);
	}

	private TransactionStatus begin(ExtTransaction extTransaction) {
		if (extTransaction == null) {
			return null;
		}
		// 2.如果存在事务注解,开启事务
		return transactionUtils.begin();
	}

	private void commit(TransactionStatus transactionStatus) {
		if (transactionStatus != null) {
			// 5.如果存在注解,提交事务
			transactionUtils.commit(transactionStatus);
		}

	}

    /**
     * 获取方法上是否存在事务注解
     *
     * @param pjp
     * @return
     * @throws NoSuchMethodException
     * @throws SecurityException
     */
	private ExtTransaction getMethodExtTransaction(ProceedingJoinPoint pjp)
			throws NoSuchMethodException, SecurityException {

	    // 获取方法的名称
		String methodName = pjp.getSignature().getName();
		// 获取目标对象
		Class<?> classTarget = pjp.getTarget().getClass();
		// 获取目标对象类型
		Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
		// 获取目标对象方法
		Method objMethod = classTarget.getMethod(methodName, par);
		ExtTransaction extTransaction = objMethod.getDeclaredAnnotation(ExtTransaction.class);
		return extTransaction;
	}

}

在 service 层的方法上面使用：

@ExtTransaction
public void add() {
	// 注意事项： 在使用spring事务的时候，service 不要 try 最将异常抛出给外层aop 异常通知接受回滚
	try {
		userDao.add("test001", 20);
		int i = 1 / 0;
		System.out.println("################");
		userDao.add("test002", 21);
	} catch (Exception e) {
		e.printStackTrace();
		TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
	}
}

注意：需要删除 spring 配置文件中的 开启注解事物

<!-- 开启注解事物 -->
<tx:annotation-driven transaction-manager="dataSourceTransactionManager" />

4 Spring 事物传播行为

4.1 Spring 中事务的定义

Propagation（key 属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。）有以下选项可供使用：

  • PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
  • PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。
  • PROPAGATION_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。
  • PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。
  • PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  • PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

4.2 例子

1、创建日志 dao 层

package com.snow.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class LogDao {
	@Autowired
	private JdbcTemplate jdbcTemplate;

	public void add(String name) {
		String sql = "INSERT INTO t_log(log_name) VALUES(?);";
		int updateResult = jdbcTemplate.update(sql, name);
		System.out.println("updateResult:" + updateResult);
	}

}

2、创建日志 service 层

package com.snow.service;

public interface LogService {

	public void addLog();

}


package com.snow.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.snow.service.LogService;
import com.snow.dao.LogDao;

@Service
public class LogServiceImpl implements LogService {

	@Autowired
	private LogDao logDao;

	public void addLog() {
		logDao.add("log_" + System.currentTimeMillis());
	}

}

3、修改 user 的 service 层

package com.snow.service.impl;

import com.snow.dao.UserDao;
import com.snow.service.LogService;
import com.snow.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserDao userDao;

	@Autowired
	private LogService logService;

	@Transactional
	public void add() {

		logService.addLog(); // 日志记录每次都会插入的，后面代码发生错误，不会回滚
		userDao.add("test001", 20);
		int i = 1 / 0;
		System.out.println("################");
		userDao.add("test002", 21);

	}

}

需求：日志记录每次都会插入的，后面代码发生错误，不会回滚

4、修改 log 的 service 层

修改 Spring 事物传播行为为 PROPAGATION_REQUIRES_NEW

package com.snow.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.snow.service.LogService;
import com.snow.dao.LogDao;

@Service
public class LogServiceImpl implements LogService {
	@Autowired
	private LogDao logDao;

	@Transactional(propagation = Propagation.REQUIRES_NEW)
	public void addLog() {
		logDao.add("log_" + System.currentTimeMillis());
	}

}

测试：

用户表无记录，日志表有记录
在这里插入图片描述
在这里插入图片描述

不知所起 一往而深
关注
专栏目录
Spring源码解析：Spring 事务
Java技术攻略的博客
04-23 301
我们再⼩节⼀下，⽂章先介绍了事务的使⽤示例，以及事务的执⾏流程。先匹配出 model 对象所有关于事务的切⾯列表，并将匹配成功的事务属性保存到缓存；从缓存取出事务属性，然后创建、启动事务，执⾏业务逻辑，最后提交或者回滚事务。
Spring 事务源码分析-上
wangjiangwkq的博客
08-29 62
本章节对Spring 事务源码详细解析，Spring 事务是基于Spring AOP实现，但是也离不开Spring IOC，对于Spring事务源码的学习，首先立一个明确的目标，那就是从整个Spring 源码进行解读分析。
spring源码分析-事务的底层源码-1
java_lyvee的专栏
03-16 1463
其实这属于AOP的知识，也就是springAOP在完成代理的时候会进行切面当中的连接点信息判断是否需要增强；上图所示当调用inventoryService的save方法的时候，假设inventoryService没有实例化，那么spring容器会实例化这个bean，会走他的生命周期，当走到BeanPostProcessor的postProcessAfterInitialization方法的时候会从容器当中拿出所有的后置处理器依次执行他们的postProcessAfterInitialization方法；
Spring框架及源码学习---手写IOC和AOP
weixin_43811057的博客
03-18 922
Spring 是分层的 full-stack（全栈） 轻量级开源框架，以 IoC 和 AOP 为内核，提供了展现层 Spring MVC 和业务层事务管理等众多的企业级应⽤技术，还能整合开源世界众多著名的第三⽅框架和类库，已 经成为使⽤最多的 Java EE 企业应⽤开源框架。我们经常说的 Spring 其实指的是Spring Framework（spring 框架）。==IoC Inversion of Control (控制反转/反转控制)，注意它是⼀个技术思想，不是⼀个技术实现 ==
【框架源码篇 01】Spring源码-手写IOC
10-21
通过分析和手写Spring的IOC源码，我们可以更好地理解Spring的工作原理，从而更有效地利用它来构建我们的应用程序。在01-手写IoC源码-spring-v1.zip文件中，你将找到逐步实现这个过程的代码示例，这将帮助你加深对...
spring源码合集spring源码合集
04-09
《Spring源码合集：揭示Java后端开发的基石》 Spring框架作为Java后端开发的核心，其源码的研究对于提升开发者对系统架构理解和优化能力至关重要。本合集深入剖析了Spring的诸多关键特性，包括依赖注入、配置类解析...
手写Spring源码.rar
10-27
本压缩包"手写Spring源码.rar"可能包含了一份详尽的、逐步实现Spring核心功能的源代码分析，这对于理解Spring的工作原理和提升开发者技能非常有帮助。下面，我们将深入探讨Spring框架的一些关键知识点。 1. **依赖...
用300行代码手写Spring V1.0版本
05-29
本文将通过分析标题"用300行代码手写Spring V1.0版本"和描述，探讨Spring的基本设计理念和实现机制。 首先，Spring的核心是IoC容器，它负责管理对象的生命周期和依赖关系。在300行代码的简化版本中，我们将看到如何...
第四周实践课-课堂笔记.pdf
09-16
第四周实践课-课堂笔记
第5周玩转案例分析(2).pdf
09-16
第5周玩转案例分析(2)
第7周实践课安排.pdf
09-16
第7周实践课安排
基于MATLAB m编程的发动机最优工作曲线计算程序（OOL），在此工作曲线下，发动机燃油消耗最小 文件内含：1、发动机最优工
09-16
基于MATLAB m编程的发动机最优工作曲线计算程序（OOL），在此工作曲线下，发动机燃油消耗最小。 文件内含：1、发动机最优工作曲线计算程序m文件；2、发动机万有特性数据excel文件 注：附赠电机效率map绘制程序（m程序）与对应电机效率map数据（excel ）
前端监控SDK，可用来收集并上报：代码报错、性能数据、页面录屏、用户行为、白屏检测等个性化指标数据_web-see.zip
最新发布
09-16
前端监控SDK，可用来收集并上报：代码报错、性能数据、页面录屏、用户行为、白屏检测等个性化指标数据_web-see
财务报表分析与内部控制.ppt
09-16
财务报表分析与内部控制.ppt
河南开封科技传媒学院在河北2021-2024各专业最低录取分数及位次表.pdf
09-16
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
武汉纺织大学外经贸学院在河北2021-2024各专业最低录取分数及位次表.pdf
09-16
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
智能优化算法-SMA黏菌优化算法Matlab程序
09-16
智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序 智能优化算法|SMA黏菌优化算法Matlab程序
第4周玩转案例分析.pdf
09-16
第4周玩转案例分析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不知所起 一往而深

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

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

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

打赏作者

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

抵扣说明：

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

余额充值