需求：轉賬功能中，使用springAOP管理事務，即在不改變原有邏輯代碼的情況下，加入事務管理的功能

注意

1. 事務管理起作用需要同一個connection，解決辦法是ThreadLocal的使用，并且單獨封裝一個工具類
2. 此文使用全注解的方式實現
3. 自定義一個注解，用以告知程序是否需要事務
4. 需要的jar包就不列出了，主要包括spring相關包，數據庫相關包（jdbc,c3p0,dbutils）

jdbc工具類

package com.qianfeng.account.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class JdbcUtils {

    private static ComboPooledDataSource dataSource =new ComboPooledDataSource();
//    用于存儲連接，保證同一個線程，同一個連接，這樣事務才有效果
    private static ThreadLocal<Connection> threadLocal=new ThreadLocal<>();

    public static DataSource getDataSource(){
        return dataSource;
    }

//    注意這個connection是import java.sql.Connection;不能是com.mysql.jdbc.Connection
//    因為這里從c3p0得到的鏈接，不能強轉為com.mysql.jdbc.Connection
    public static Connection getTransactionConnection() throws SQLException {

        Connection connection = threadLocal.get();
        if (connection==null){
            connection= dataSource.getConnection();
            threadLocal.set(connection);
        }
        return connection;
    }

//    開啟事務
    public static void startTransaction() throws SQLException {

        Connection connection = threadLocal.get();
        if (connection!=null){
            throw new SQLException("不要重復開啟事務");
        }
        connection=getTransactionConnection();
        connection.setAutoCommit(false);
    }
//提交事務
    public static void commitTransaction() throws SQLException {

        Connection connection = threadLocal.get();
        if (connection==null){
            throw new SQLException("無開啟的事務");
        }

        connection.commit();
        connection.close();
        threadLocal.remove();
    }
//回滾事務
    public static void rollbackTransaction() throws SQLException {

        Connection connection = threadLocal.get();
        if (connection==null){
            throw new SQLException("無開啟的事務");
        }

        connection.rollback();
        connection.close();
        threadLocal.remove();
    }
}

dao

package com.qianfeng.account.dao;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.qianfeng.account.utils.JdbcUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.stereotype.Repository;

import java.sql.Connection;
import java.sql.SQLException;

@Repository
public class AccountDao {

    QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());

    public void update(double money,Integer id) throws SQLException {
//        獲取連接
        Connection connection = JdbcUtils.getTransactionConnection();
        String sql ="update account set balance=balance+? where id=?";
        Object[] parms={money,id};
//        必須傳入連接保證是同一個連接，事務才有效
        queryRunner.update(connection,sql,parms);
    }
}

service

package com.qianfeng.account.service;

import com.qianfeng.account.annotation.IsTransactional;
import com.qianfeng.account.dao.AccountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.sql.SQLException;

@Service
public class AccountService {
    @Autowired
    private AccountDao accountDao;
    @IsTransactional//告知需要開啟事務
//    轉錢
    public void transfer() throws SQLException {
        accountDao.update(-1000,1);
//        System.out.println(1/0);
        accountDao.update(1000,2);
    }
}

自定義注解

package com.qianfeng.account.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 IsTransactional {
}

配置類

package com.qianfeng.account.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

//配置類
@Configuration
@ComponentScan(basePackages = {"com.qianfeng.account"})
@EnableAspectJAutoProxy
public class Config {
}

切面類

package com.qianfeng.account.aspect;

import com.qianfeng.account.annotation.IsTransactional;
import com.qianfeng.account.utils.JdbcUtils;
import org.aspectj.bridge.MessageWriter;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import sun.reflect.generics.tree.ClassSignature;

import java.lang.reflect.Method;

@Aspect
@Component
public class MyAspect {

    @Pointcut("execution(* com.qianfeng.account.service.*..*(..))")
    public void pointCut(){
    }

    //添加事務環繞，前提是同一個連接，要創建工具類
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

//        獲取方法簽名
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
//判斷是否需要開啟事務
        if (method.isAnnotationPresent(IsTransactional.class)){
            try {
//                開啟事務
                JdbcUtils.startTransaction();
//                執行原方法
                Object proceed = joinPoint.proceed(joinPoint.getArgs());
//                提交事務
                JdbcUtils.commitTransaction();
                return proceed;
            } catch (Exception e) {
//                遇到異常回滾事務
                JdbcUtils.rollbackTransaction();
                throw new Exception("交易過程出現異常，交易失敗");
            }
        }else {
            return joinPoint.proceed(joinPoint.getArgs());
        }
    }
}

測試類

package com.qianfeng.account.service;

import com.qianfeng.account.config.Config;
import junit.framework.TestCase;
import org.springframework.beans.factory.wiring.BeanWiringInfo;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.sql.SQLException;

public class AccountServiceTest extends TestCase {

    public void test01() throws SQLException {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        AccountService bean = context.getBean(AccountService.class);
        bean.transfer();
    }
}