本篇文章为你整理了Spring学习笔记（spring教程 csdn）的详细内容，包含有spring入门教程 spring教程 csdn spring详细教程 spring 教程 Spring学习笔记，希望能帮助你了解 Spring学习笔记。
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void priv.dandelion.dao.BookDao.*te())")
private void pt() {
@Around("pt()")
public void around(ProceedingJoinPoint pjp) throws Throwable {
//记录程序当前执行执行（开始时间）
Long startTime = System.currentTimeMillis();
//业务执行万次
for (int i = 0;i 10000;i++) {
// 表示对原始操作的调用
pjp.proceed();
//记录程序当前执行时间（结束时间）
Long endTime = System.currentTimeMillis();
//计算时间差
Long totalTime = endTime-startTime;
//输出信息
System.out.println("执行万次消耗时间：" + totalTime + "ms");
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
bookDao.save();
// bookDao.update();
// bookDao.delete();
// bookDao.select();
连接点：在 AOP 中，将所以原始方法称为连接点（如右侧的 save,update,delete和select 方法）。
切入点：在上述四个方法中，除 save 方法之外，仅 update 和 delete 方法执行了万次，即追加了功能。这些追加了同一种功能的方法（可以是一个也可以是多个，此处为两个）称为一个切入点，反之，如 save, select 方法就不是切入点。
通知：共性功能，即左边的方法。
通知类：通知是一个方法，必须写在一个类中。
切面：通知与切入点的关系，一个通知对应一个切入点，称为一个切面。
连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等
在SpringAOP中，理解为方法的执行
一个具体的方法:如priv.dandelion.dao包下的BookDao接口中的无形参无返回值的save方法
匹配多个方法:所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。
打印save方法的时候，因为方法中有打印系统时间，所以运行的时候是可以看到系统时间
对于update方法来说，就没有该功能
System.out.println(System.currentTimeMillis());
System.out.println("book dao save ...");
public void update(){
System.out.println("book dao update ...");
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
bookDao.save();
Spring 有自己的 AOP 实现，但是相比于 AspectJ 来说比较麻烦，所以我们直接采用Spring 整合 ApsectJ 的方式进行 AOP 开发
!-- 因为spring-context依赖aop，aop的包已经导入 --
!-- 此处我们额外导入aspectjweaver包 --
dependency
groupId org.aspectj /groupId
artifactId aspectjweaver /artifactId
version 1.9.4 /version
/dependency
切入点定义依托一个不具有实际意义的方法进行，即无参数、无返回值、方法体无实际逻辑
execution及后面编写的内容，将在后续的章节中详细介绍
// 定义切入点，注解中execution后面的内容即为对切入点的描述（即当执行到这个方法的时候）
@Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
private void pt(){}
public void method(){
System.out.println(System.currentTimeMillis());
// 定义执行时间（在运行到哪一个切入点的什么时间执行，如此处使用Before就是在运行pt()切入点前执行）
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
AOP 是基于 Spring 容器管理的 bean 做的增强，所以整个工作过程需要从 Spring 加载 bean 说起
读取所有切面配置中的切入点（仅包含已经被使用到了的切入点，具体案例如下）
@Component
@Aspect
public class MyAdvice {
// ptx()未被使用到，不会被读取
@Pointcut("execution(void priv.dandelion.dao.BookDao.save())")
private void ptx(){}
// pt()被使用到，会被读取
@Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
private void pt(){}
// 仅使用了pt()
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
获取 bean 调用方法并执行，完成操作
获取的 bean 是代理对象时，根据代理对象的运行模式运行原始方法与增强内容，完成操作
不能直接打印对象，直接打印对象走的是对象的toString方法，不管是不是代理对象打印的结果都是一样的，原因是内部对toString方法进行了重写
此处使用getClass()方法
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
System.out.println(bookDao.getClass());
// Dao中无该方法，bean中的方法匹配不到当前切入点
@Pointcut("execution(void priv.dandelion.dao.BookDao.update1())")
private void pt(){}
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
* 控制台输出为原始对象：
* class priv.dandelion.dao.impl.BookDaoImpl
目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
简单来说，目标对象就是要增强的类 [如:BookServiceImpl 类] 对应的对象，也叫原始对象，不能说它不能运行，只能说它在运行的过程中对于要增强的内容是缺失的。
代理(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现
SpringAOP是在不改变原有设计 (代码) 的前提下对其进行增强的，它的底层采用的是代理模式实现的，所以要对原始对象进行增强，就需要对原始对象创建代理对象，在代理对象中的方法把通知 [如:MyAdvice 中的 method 方法] 内容加进去，就实现了增强,这就是我们所说的代理 (Proxy)
切入点表达式在上面的章节出现过，即@Pointcut中的内容
@Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
private void pt(){}
对于AOP中的切入点表达式，本文将详细说明三个内容，分别是语法格式、通配符和书写技巧
因为调用接口方法的时候最终运行的还是其实现类的方法，所以下面两种描述方式都是可以的。
执行接口中的方法（按接口描述）
execution(void priv.dandelion.dao.BookDao.update())
执行实现类中的方法（按实现类描述）
execution(void priv.dandelion.dao.impl.BookDaoImpl.update())
execution：动作关键字，描述切入点的行为动作，例如 execution 表示执行到指定切入点
public:访问修饰符，还可以是 public，private 等（可以省略，默认 public）
User：返回值，写返回值类型
priv.dandelion.service：包名，多级包使用点连接
UserService:类/接口名称
findById：方法名
int:参数，直接写参数的类型，多个类型用逗号隔开
异常名：方法定义中抛出指定异常（可以省略）
匹配 priv.dandelion 包下的任意包中的 UserService 类或接口中所有 find 开头的带有一个参数的方法
execution（public * priv.dandelion.*.UserService.find*(*))
这个使用率较低，描述子类的，做JavaEE开发，继承机会就一次，使用都很慎重，所以很少用它。*Service+，表示所有以Service结尾的接口的子类。
execution(* *..*Service+.*(..))
System.out.println(System.currentTimeMillis());
System.out.println("book dao save ...");
public void update(){
System.out.println("book dao update ...");
// 匹配接口，能匹配到
execution(void priv.dandelion.dao.BookDao.update())
// 匹配实现类，能匹配到
execution(void priv.dandelion.dao.impl.BookDaoImpl.update())
// 返回值任意，能匹配到
execution(* priv.dandelion.dao.impl.BookDaoImpl.update())
// 返回值任意，但是update方法必须要有一个参数，无法匹配，要想匹配需要在update接口和实现类添加参数
execution(* priv.dandelion.dao.impl.BookDaoImpl.update(*))
// 返回值为void,priv包下的任意包三层包下的任意类的update方法，匹配到的是实现类，能匹配
execution(void priv.*.*.*.*.update())
// 返回值为void,priv包下的任意两层包下的任意类的update方法，匹配到的是接口，能匹配
execution(void priv.*.*.*.update())
// 返回值为void，方法名是update的任意包下的任意类，能匹配
execution(void *..update())
// 匹配项目中任意类的任意方法，能匹配，但是不建议使用这种方式，影响范围广
execution(* *..*(..))
// 匹配项目中任意包任意类下只要以u开头的方法，update方法能满足，能匹配
execution(* *..u*(..))
// 匹配项目中任意包任意类下只要以e结尾的方法，update和save方法能满足，能匹配
execution(* *..*e(..))
// 返回值为void，priv包下的任意包任意类任意方法，能匹配，*代表的是方法
execution(void priv..*())
// 将项目中所有业务层方法的以find开头的方法匹配
execution(* priv.dandelion.*.*Service.find*(..))
// 将项目中所有业务层方法的以save开头的方法匹配
execution(* priv.dandelion.*.*Service.save*(..))
所有代码按照标准规范开发，否则以下技巧全部失效
描述切入点通常描述接口，而不描述实现类,如果描述到实现类，就出现紧耦合了
访问控制修饰符针对接口开发均采用 public 描述（可省略访问控制修饰符描述）
返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述
包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配
接口名/类名书写名称与模块相关的采用*匹配，例如 UserService 书写成 *Service ，绑定业务层接口名
方法名书写以动词进行精准匹配，名词采用*匹配，例如 getById 书写成 getBy*，selectAll 就书写成 selectAll 即可
参数规则较为复杂，根据业务方法灵活调整
通常不使用异常作为匹配规则
4.2 AOP 通知类型
前面的案例中，涉及到如下内容：
@Before("pt()")
其代表的含义是将通知添加到切入点方法执行的前面
4.2.1 类型介绍
AOP 通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置
AOP 代码加入位置演示
// 环绕通知功能比较强大，它可以追加功能到方法执行的前后，是比较常用的方式，它可以实现其他四种通知类型的功能，具体的实现方式将在下面进行说明
public int methodName() {
// 前置通知追加位置1，即方法执行前
try {
// 前置通知追加位置2，即方法执行前
// code，原始的业务操作，即要被增强的方法本体
return;
// 返回后通知追加位置，即方法执行后（只有方法正常执行结束后才进行,如果方法执行抛出异常，返回后通知将不会被添加）
} catch (Exception e) {
// 抛出异常后通知追加位置，即抛出异常后（只有方法抛出异常后才会被添加）
// 后置通知追加位置，在方法执行后（不管方法执行的过程中有没有抛出异常都会执行）
public class MyAdvice {
@Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
private void pt(){}
public void before() {
System.out.println("before advice ...");
public void after() {
System.out.println("after advice ...");
public void around(){
System.out.println("around before advice ...");
System.out.println("around after advice ...");
public void afterReturning() {
System.out.println("afterReturning advice ...");
public void afterThrowing() {
System.out.println("afterThrowing advice ...");
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
bookDao.update();
@Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
private void pt() {
@Pointcut("execution(int priv.dandelion.dao.BookDao.select())")
private void pt2() {
// 环绕通知方法需要有一个ProceedingJoinPoint类型的参数，用于调用原始对象
@Around("pt()")
public void around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("around before advice ...");
// 表示对原始操作的调用，环绕通知必须手动调用原始方法
pjp.proceed();
System.out.println("around after advice ...");
// 有返回值的方法在增强时，环绕通知方法必须要有Object的返回值
@Around("pt2()")
public Object around2(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("around before advice ...");
// 表示对原始操作的调用，并接收返回值
Object proceed = pjp.proceed();
System.out.println("around after advice ...");
return proceed;
环绕通知方法需要有一个 ProceedingJoinPoint 类型的参数，用于调用原始对象，其中，可以使用pjp.proceed()来调用原始方法。
环绕通知不手动调用原始方法时，会自动跳过原始方法（利用这一特性可完成权限校验与内容分配等功能）
由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须要处理 Throwable 异常
有返回值的方法在增强时，环绕通知方法必须要有 Object 的返回值
无返回值的原始方法对应的通知类一般返回 void，但也可以写返回值，正常获取并返回后得到的结果为null，通常会返回 Object
设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法正常执行完毕后执行
设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行名称
环绕通知方法需要有一个 ProceedingJoinPoint 类型的参数，用于调用原始对象，其中，可以使用pjp.proceed()来调用原始方法。
环绕通知不手动调用原始方法时，会自动跳过原始方法（利用这一特性可完成权限校验与内容分配等功能）
由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须要处理 Throwable 异常
有返回值的方法在增强时，环绕通知方法必须要有 Object 的返回值
无返回值的原始方法对应的通知类可以返回 void，但也可以写返回值，正常获取并返回后得到的结果为null，通常会返回 Object
@Insert("insert into tbl_account(name,money)values(#{name},#{money})")
void save(Account account);
@Delete("delete from tbl_account where id = #{id} ")
void delete(Integer id);
@Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
void update(Account account);
@Select("select * from tbl_account")
List Account findAll();
@Select("select * from tbl_account where id = #{id} ")
Account findById(Integer id);
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=123456
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
ssfb.setTypeAliasesPackage("priv.dandelion.entity");
ssfb.setDataSource(dataSource);
return ssfb;
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("priv.dandelion.dao");
return msc;
@Pointcut("execution(* priv.dandelion.service.*Service.*(..))")
private void servicePt(){}
@Around("servicePt()")
public Object runSpeed(ProceedingJoinPoint pjp) throws Throwable {
Signature signature = pjp.getSignature();
String className = signature.getDeclaringTypeName();
String methodName = signature.getName();
long start = System.currentTimeMillis();
Object proceed = null;
for (int i = 0; i 10000; i++) {
proceed = pjp.proceed();
long end = System.currentTimeMillis();
System.out.println("万次执行：" + className + "." + methodName + "----- " + (end - start) + "ms");
return proceed;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
@Autowired
private AccountService accountService;
@Test
public void testFindById(){
Account ac = accountService.findById(2);
System.out.println(ac);
@Test
public void testFindAll(){
List Account all = accountService.findAll();
System.out.println(all);
获取异常信息（获取切入点方法运行异常信息，前置和返回后通知不会有，后置通知可有可无，所以不做研究）
抛出异常后通知
public class MyAdvice {
@Pointcut("execution(* priv.dandelion.dao.BookDao.findName(..))")
private void pt(){}
@Before("pt()")
public void before() {
System.out.println("before advice ..." );
@After("pt()")
public void after() {
System.out.println("after advice ...");
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
Object ret = pjp.proceed();
return ret;
@AfterReturning("pt()")
public void afterReturning() {
System.out.println("afterReturning advice ...");
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
String name = bookDao.findName(100);
System.out.println(name);
public Object around(ProceedingJoinPoint pjp) throws Throwable{
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
Object ret = pjp.proceed();
return ret;
ProceedingJoinPoint 的 proceed() 方法用于调用原始方法，但是该方法除了空参的形式还包括有参形式 proceed(Object[] args)，二者本质区别不大，后者用于手动传入参数
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
// 假设原始方法被调用时传入的参数有问题，此处进行处理
args[0] = 666;
// 手动传入参数，执行原始方法时将使用被手动传入的参数
Object ret = pjp.proceed(args);
return ret;
环绕通知获取返回值时，在调用原始方法时接收返回值，并且为通知方法定义返回值类型 Object，如果有需要可以进行修改
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
// 假设原始方法被调用时传入的参数有问题，此处进行处理
args[0] = 666;
// 手动传入参数，执行原始方法时将使用被手动传入的参数
Object ret = pjp.proceed(args);
return ret;
4.4.3.2 非环绕通知获取返回值
@AfterReturning(value = "pt()", returning = "ret")
public void afterReturning(Object ret) {
System.out.println("afterReturning advice ..." + ret);
@AfterReturning(value = "pt()", returning = "ret")
public void afterReturning(JoinPoint jp, Object ret) {
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("afterReturning advice ..." + ret);
对于获取抛出的异常，只有抛出异常后AfterThrowing和环绕Around这两个通知类型可以获取
public Object around(ProceedingJoinPoint pjp) throws Throwable{
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
// 假设原始方法被调用时传入的参数有问题，此处进行处理
args[0] = 666;
Object ret = null;
try {
// 手动传入参数，执行原始方法时将使用被手动传入的参数
ret = pjp.proceed(args);
} catch (Throwable t) {
// 捕获异常
t.printStackTrace();
return ret;
4.4.4.2 抛出异常后通知获取异常
@AfterThrowing(value = "pt()", throwing = "t")
public void afterThrowing(Throwable t) {
System.out.println("afterThrowing advice ..." + t);
4.5 百度网盘密码数据兼容处理
4.5.1 需求分析
百度网盘选取分享密码时会多带一个空格，影响正常使用
在业务方法执行之前对所有的输入参数使用trim()进行格式处理
后续类似的操作可能很多，故此处采用 AOP 进行统一处理
需要先处理参数再调用原始方法，故此处采用环绕通知
4.5.2 环境准备
public boolean openURL(String url, String password) {
return resourcesDao.readResources(url,password);
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root");
System.out.println(flag);
// 定义切入点，假设对业务层任意包含字符串的参数都进行处理
@Pointcut("execution(boolean priv.dandelion.service.*Service.*(..))")
private void servicePt(){}
@Around("servicePt()")
public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
// 获取参数，若参数为字符串类型，则去除空格
Object[] args = pjp.getArgs();
for (int i = 0; i args.length; i++) {
if (args[i].getClass().equals(String.class))
args[i] = args[i].toString().trim();
// 调用原始方法，手动传入修改后的参数
Object proceed = pjp.proceed(args);
return proceed;
代理（Proxy）：SpringAOP 的核心本质是采用代理模式实现的
连接点（JoinPoint）：在 SpringAOP 中，理解为任意方法的执行
切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
切面（Aspect）：描述通知与切入点的对应绑定关系
目标对象（Target）：被代理的原始对象成为目标对象
减少使用..的形式描述包
对接口进行描述，使用*表示模块名，例如UserService的匹配描述为*Service
方法名书写保留动词，例如get，使用*表示名词，例如getById匹配描述为getBy*
参数根据实际情况灵活调整
环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
环绕通知可以隔离原始方法的调用执行
环绕通知返回值设置为Object类型
环绕通知中可以对原始方法调用过程中出现的异常进行处理
获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究
返回后通知
获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究
抛出异常后通知
Spring 提供了接口 PlatformTransactionManager 以及其简单实现类 DataSourceTransactionManager（内部使用 JDBC 事务）
public interface PlatformTransactionManager {
void commit(TransactionStatus status) throws TransactionException;
void rollback(TransactionStatus status) throws TransactionException;
insert into tbl_account values(1,Tom,1000);
insert into tbl_account values(2,Jerry,1000);
@Update("update tbl_account set money = money + #{money} where name = #{name}")
void inMoney(@Param("name") String name, @Param("money") Double money);
@Update("update tbl_account set money = money - #{money} where name = #{name}")
void outMoney(@Param("name") String name, @Param("money") Double money);
public void transfer(String out,String in ,Double money) {
accountDao.outMoney(out,money);
accountDao.inMoney(in,money);
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=123456
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
ssfb.setTypeAliasesPackage("priv.dandelion.entity");
ssfb.setDataSource(dataSource);
return ssfb;
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("priv.dandelion.dao");
return msc;
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer() throws IOException {
accountService.transfer("Tom","Jerry",100D);
再需要被事务管理的方法上添加@Transactional注解（一般加在接口而非实现类中）
public interface AccountService {
* 转账操作
* @param out 传出方
* @param in 转入方
* @param money 金额
@Transactional
public void transfer(String out,String in ,Double money);
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
// 需要其他的Bean，直接写参数，详见Bean的注入
transactionManager.setDataSource(dataSource);
return transactionManager;
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
为当前业务层方法添加事务（如果设置在类或接口上方则类或接口中所有方法均添加事务）名称
事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法
public void transfer(String out,String in ,Double money) {
accountDao.outMoney(out,money);
accountDao.inMoney(in,money);
Dao 接口中的方法 （事务协调员）
@Update("update tbl_account set money = money + #{money} where name = #{name}")
void inMoney(@Param("name") String name, @Param("money") Double money);
@Update("update tbl_account set money = money - #{money} where name = #{name}")
void outMoney(@Param("name") String name, @Param("money") Double money);
Service 中运行到 outMoney() 时，调用Dao，操作数据库，该步骤是一个完整的事务
Service 中运行到 inMoney() 时，调用Dao，操作数据库，该步骤是一个完整的事务
outMoney() 和 inMoney() 之间没有事务关系
Service 中运行到 outMoney() 时，调用Dao，操作数据库，该步骤是一个完整的事务
Service 中运行到 inMoney() 时，调用Dao，操作数据库，该步骤是一个完整的事务
开启 Spring 的事务管理后，Service 的 transfer() 方法成为一个独立事务，此时其下事务将进行事务合并，outMoney() 和 inMoney() 都加入到了transfer()事务中，合并成了完整的事务
事务仅在发生 Error 和 运行时异常 时才能正常回滚
此外的异常若想正常回滚需要设置 rollbackFor 属性
public interface LogDao {
@Insert("insert into tbl_log (info,createDate) values(#{info},now())")
void log(String info);
public void log(String out,String in,Double money ) {
logDao.log("转账操作由"+out+"到"+in+",金额："+money);
代码中，outMoney()、inMoney()、三个为独立事务，但是都加入了事务管理者transfer()开启的事务中，合并为一个整体，出现异常时全部回滚，无法记录日志
@Transactional
public void transfer(String out,String in ,Double money) {
try{
accountDao.outMoney(out,money);
accountDao.inMoney(in,money);
}finally {
logService.log(out,in,money);
可以将log()对应的事务独立出来，不参与与事务管理者transfer()开启的的事务合并，自然可以不随之而回滚，可在任何时候完成事务
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void log(String out,String in,Double money ) {
logDao.log("转账操作由"+out+"到"+in+",金额："+money);
6.3.3.2 事务传播行为的可选值
以上就是Spring学习笔记（spring教程 csdn）的详细内容，想要了解更多 Spring学习笔记的内容，请持续关注盛行IT软件开发工作室。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。