参考文章：
    image.png

    1. package csdn;
    3. import java.io.PrintWriter;
    4. import java.lang.annotation.Documented;
    5. import java.lang.annotation.ElementType;
    6. import java.lang.annotation.Inherited;
    7. import java.lang.annotation.Retention;
    8. import java.lang.annotation.RetentionPolicy;
    9. import java.lang.annotation.Target;
    10. import java.lang.reflect.InvocationHandler;
    11. import java.lang.reflect.InvocationTargetException;
    12. import java.lang.reflect.Method;
    13. import java.lang.reflect.Proxy;
    14. import java.sql.Connection;
    15. import java.sql.DriverManager;
    16. import java.sql.PreparedStatement;
    17. import java.sql.SQLException;
    18. import java.sql.SQLFeatureNotSupportedException;
    19. import java.util.logging.Logger;
    21. import javax.sql.DataSource;
    23. /**
    24.  * 手写事务管理器
    25.  */
    26. public class TranscationalManager {
    28.     /**
    29.      * 开启事务
    30.      */
    31.     final static ThreadLocal<Boolean> transcational = new ThreadLocal<Boolean>();
    33.     /**
    34.      * 数据库连接
    35.      */
    36.     final static ThreadLocal<Connection> currentConnection = new ThreadLocal<Connection>();
    38.     static DataSource dataSource=new DataSource() {
    40.         @Override
    41.         public <T> T unwrap(Class<T> iface) throws SQLException {
    42.             // TODO Auto-generated method stub
    43.             return null;
    44.         }
    46.         @Override
    47.         public boolean isWrapperFor(Class<?> iface) throws SQLException {
    48.             // TODO Auto-generated method stub
    49.             return false;
    50.         }
    52.         @Override
    53.         public void setLoginTimeout(int seconds) throws SQLException {
    54.             // TODO Auto-generated method stub
    56.         }
    58.         @Override
    59.         public void setLogWriter(PrintWriter out) throws SQLException {
    60.             // TODO Auto-generated method stub
    62.         }
    64.         @Override
    65.         public Logger getParentLogger() throws SQLFeatureNotSupportedException {
    66.             // TODO Auto-generated method stub
    67.             return null;
    68.         }
    70.         @Override
    71.         public int getLoginTimeout() throws SQLException {
    72.             // TODO Auto-generated method stub
    73.             return 0;
    74.         }
    76.         @Override
    77.         public PrintWriter getLogWriter() throws SQLException {
    78.             // TODO Auto-generated method stub
    79.             return null;
    80.         }
    82.         @Override
    83.         public Connection getConnection(String username, String password) throws SQLException {
    84.             // TODO Auto-generated method stub
    85.             return null;
    86.         }
    88.         @Override
    89.         public Connection getConnection() throws SQLException {
    90.             Connection conn = null;
    91.             String driverClass = "com.mysql.jdbc.Driver";
    92.             String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8";
    93.             String user = "root";
    94.             String password = "denglintao";
    95.             try {
    96.                 Class.forName(driverClass);
    97.             } catch (ClassNotFoundException e) {
    98.                 // TODO Auto-generated catch block
    99.                 e.printStackTrace();
    100.             }
    101.             conn = DriverManager.getConnection(url, user, password);
    102.             return conn;
    103.         }
    104.     };
    106.     static class ConnectionProxy implements InvocationHandler {
    107.         Connection targetConn;
    109.         public Connection proxyConnection(Connection targetConn) {
    110.             this.targetConn = targetConn;
    111.             Connection proxyConn = (Connection) Proxy.newProxyInstance(targetConn.getClass().getClassLoader(),
    112.                     new Class[] { Connection.class }, this);
    113.             return proxyConn;
    114.         }
    116.         @Override
    117.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    118.             if (method.getName().equals("close")) {
    119.                 // 清除当前的数据库连接
    120.                 if (isOpenTranscational()) {
    121.                     // 若开启事务的 连接将不做操作
    122.                     return null;
    123.                 }
    124.                 targetConn.setAutoCommit(true);
    125.                 targetConn.close();
    126.                 return null;
    127.             }
    129.             Object result = method.invoke(targetConn, args);
    130.             return result;
    132.         }
    134.         public Connection getTargetConn() {
    135.             return targetConn;
    136.         }
    137.     }
    139.     @Target({ ElementType.METHOD, ElementType.TYPE })
    140.     @Retention(RetentionPolicy.RUNTIME)
    141.     @Inherited
    142.     @Documented
    143.     public @interface Transactional {
    144.         String value() default "";
    145.     }
    147.     static class TranscationalInvocationHandler implements InvocationHandler {
    148.         public static Object proxyTranscational(Object service) throws InstantiationException, IllegalAccessException {
    149.             // 此处若有 @Transactional 代理
    150.             Class<? extends Object> clazz = service.getClass();
    151.             Class<?>[] interfaces = clazz.getInterfaces();
    152.             boolean isProxy = false;
    153.             for (Method method : clazz.getDeclaredMethods()) {
    154.                 if (method.isAnnotationPresent(Transactional.class)) {
    155.                     isProxy = true;
    156.                     break;
    157.                 }
    158.             }
    159.             if (isProxy) {
    160.                 return Proxy.newProxyInstance(clazz.getClassLoader(), interfaces,
    161.                         new TranscationalInvocationHandler(service));
    162.             } else {
    163.                 return service;
    164.             }
    165.         }
    167.         Object traget;
    169.         public TranscationalInvocationHandler(Object bean) {
    170.             this.traget = bean;
    171.         }
    173.         public Object getTraget() {
    174.             return traget;
    175.         }
    177.         @Override
    178.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    180.             Object invoke = null;
    182.             Method declaredMethod = traget.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());
    184.             // 不需要事务
    185.             if (!declaredMethod.isAnnotationPresent(Transactional.class)) {
    186.                 try {
    187.                     return method.invoke(traget, args);
    188.                 } catch (InvocationTargetException e) {
    189.                     throw e.getTargetException();
    190.                 } finally {
    191.                     // 原本不存在事务时候 才释放资源
    192.                     if (!TranscationalManager.isOpenTranscational()) {
    193.                         TranscationalManager.closeConnection();// 防止开发者在dao层面拿取数据库连接 没有关闭导致连接泄漏
    194.                         TranscationalManager.release();
    195.                     }
    196.                 }
    197.             }
    199.             // 如果原本存在事务，那么加入事务
    200.             if (TranscationalManager.isOpenTranscational()) {
    201.                 try {
    202.                     // 数据库连接处理
    203.                     return invoke = method.invoke(traget, args);
    204.                 } catch (InvocationTargetException e) {
    205.                     TranscationalManager.rollback();
    206.                     throw e.getTargetException();
    207.                 }
    208.             }
    210.             // 需要开启事务
    211.             try {
    212.                 // 有事务注解的开启事务
    213.                 TranscationalManager.openTranscational();
    214.                 // 数据库连接处理
    215.                 invoke = method.invoke(traget, args);
    216.                 TranscationalManager.commit();
    217.             } catch (InvocationTargetException e) {
    218.                 TranscationalManager.rollback();
    219.                 throw e.getTargetException();
    220.             } finally {
    221.                 // 关闭连接 释放资源
    222.                 TranscationalManager.closeConnection();
    223.                 TranscationalManager.release();
    224.             }
    225.             return invoke;
    226.         }
    228.     }
    230.     /**
    231.      * 代理service层的事务控制
    232.      */
    233.     @SuppressWarnings("unchecked")
    234.     public static <T> T proxyTranscationalService(T serviceBean) {
    235.         try {
    236.             return (T) TranscationalInvocationHandler.proxyTranscational(serviceBean);
    237.         } catch (Exception e) {
    238.             throw new RuntimeException(e);
    239.         }
    240.     }
    242.     /**
    243.      * 测试接口类
    244.     * @Description:</p>  
    245.     * @author 邓霖涛  
    246.     * @date 2020年12月23日
    247.      */
    248.     public interface UserService{
    249.         void modifyUsers() throws Exception;
    250.     }
    252.     public static class UserServiceImpl implements UserService{
    254.         /**
    255.          * 加上事务注解
    256.          */
    257.         @Transactional
    258.         @Override
    259.         public void modifyUsers() throws Exception {
    261.             //操作1与操作2 同属于一个事务，
    262.             //模拟dao操作1
    263.             Connection conn = TranscationalManager.getConnection();
    264.             PreparedStatement pst = conn.prepareStatement(" insert into user(user_name,password) values('姓名1','123' ) ");
    265.             pst.executeUpdate();
    266.             pst.close();
    267.             conn.close();
    268.             if(true) {
    269. //                throw new RuntimeException("强制异常，让后面的执行不了，会发现前者并没有插入到数据库库中");
    270.             }
    271.             //模拟dao操作2
    272.             Connection conn1 = getConnection();
    273.             PreparedStatement pst1 = conn1.prepareStatement(" insert into user(user_name,password) values('姓名2','123' ) ");
    274.             pst1.executeUpdate();
    275.             pst1.close();
    276.             conn1.close();
    278.             if(true) {
    279.                 throw new RuntimeException("强制异常，让后面的执行不了，会发现前者并没有插入到数据库库中");
    280.             }
    281.         }
    282.     }
    284.     /**
    285.      * 主函数测试
    286.      */
    287.     public static void main(String[] args) {
    289.         //原本的service层的
    290.         UserService userService = new UserServiceImpl();
    292.         //事务管理代理
    293.         userService = proxyTranscationalService(userService);
    295.         try {
    296.             //执行更新
    297.             userService.modifyUsers();
    298.         } catch (Exception e) {
    299.             e.printStackTrace();
    300.         }
    301.     }
    304.     /**
    305.      * 获取数据库连接
    306.      */
    307.     public static Connection getConnection() throws SQLException {
    308.         if (currentConnection.get() != null) {
    309.             return currentConnection.get();
    310.         }
    311.         Connection conn = dataSource.getConnection();
    312.         ConnectionProxy connectionProxy = new ConnectionProxy();
    313.         Connection proxyConnection = connectionProxy.proxyConnection(conn);
    314.         currentConnection.set(proxyConnection);
    316.         if(TranscationalManager.isOpenTranscational()){
    317.             conn.setAutoCommit(false);
    318.         }else{
    319.             conn.setAutoCommit(true);
    320.         }
    322.         return proxyConnection;
    323.     }
    325.     /**
    326.      * 事务开启
    327.      */
    328.     static void openTranscational() {
    329.         transcational.set(true);
    330.     }
    332.     /**
    333.      * 是否开启事务 true开启/false未开启
    334.      */
    335.     static boolean isOpenTranscational() {
    336.         boolean result = false;
    337.         if (transcational.get() == null) {
    338.             result = false;
    339.         } else {
    340.             result = transcational.get();
    341.         }
    342.         return result;
    343.     }
    345.     /**
    346.      * 事务关闭
    347.      */
    348.     static void closeTranscational() {
    349.         transcational.set(false);
    350.     }
    352.     /**
    353.      * 事务提交
    354.      */
    355.     static void commit() throws SQLException {
    356.         Connection conn = currentConnection.get();
    357.         if (conn != null) {
    358.             conn.commit();
    359.         }
    360.     }
    362.     /**
    363.      * 回滚
    364.      */
    365.     static void rollback() throws SQLException {
    366.         Connection conn = currentConnection.get();
    367.         if (conn != null) {
    368.             conn.rollback();
    369.         }
    370.     }
    372.     /**
    373.      * 关闭连接，需要先关闭事务在调用此方法
    374.      */
    375.     static void closeConnection() throws SQLException {
    376.         closeTranscational();
    377.         Connection conn = currentConnection.get();
    378.         if (conn != null) {
    379.             conn.close();
    380.         }
    381.     }
    383.     /**
    384.      * 释放资源
    385.      */
    386.     static void release() {
    387.         transcational.remove();
    388.         currentConnection.remove();
    389.     }
    390. }