如何將對數據庫兩個表的操作處於用一個事物下？同一個連接對象+事物攔截

需求：
我要存儲同時存儲一個學生信息和這個學生購買的圖書信息，當學生的信息存儲失敗了，圖書信息也不存儲了，反之也一樣，當某本書的信息存儲失敗了，學生信息也不存儲了。

正常情況下，如果兩個表的信息分開存儲代碼如下

所以我們可以看到兩個表是否存儲成功的信息沒有辦法傳遞，圖書存儲情況不知道學生信息存儲情況。

解決方法： 兩個存儲用同一個Connection對象。同時在Serivce事物層完成。
第一個問題：如何控制讓兩個表拿的是同一個Connection對象。
數據庫連接池來實現：

ThreadLocal<Connection>：

ThreadLocal 是一個HashMap,Key是當前線程，value是Object. 因此只要是同一個線程在存學生信息和圖書信息，就可以拿到同一個連接對象。
貼上數據庫連接詞代碼

import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;
//////該版本相比第4版引入了ThreadLocal線程管理對象,以實現同一線程獲得的con對象是同一個///////////
public class Conn5Utils {
    //聲明一個單例的池
    private static List<Connection> pool = new ArrayList<Connection>();
    private static final int MAX=3;

    //線程管理對象
    private static ThreadLocal<Connection> t = new ThreadLocal<Connection>();

    static{
        try {
            Properties p = new Properties();
            p.load( Conn5Utils.class.getClassLoader().getResourceAsStream("jdbc.properties"));

            String driver = p.getProperty("driver");
            String url = p.getProperty("url");
            String user = p.getProperty("username");
            String pwd = p.getProperty("password");

            Class.forName(driver);
            for (int i = 0; i < MAX; i++) {

                final Connection conn = DriverManager.getConnection(url, user, pwd);

                //使用動態代理,實現對con.close()方法的攔截
                Object proxiedObj = Proxy.newProxyInstance(
                        Conn5Utils.class.getClassLoader(),
                        new Class[]{Connection.class},//注意，jdbc包中con的類加載器應該不是AppClassLoader,所以此處採用“conn.getClass().getInterfaces()”方式不行
                        //上面一個參數，用將要把代理後對象強轉的接口類型，是最保險的!

                        new InvocationHandler() {
                            @Override //proxy參數就是代理後的對象，如果在invoke()方法中使用代理後對象就用這個，如果在外面就用proxiedObj
                            public Object invoke(Object proxy, Method method, Object[] args)
                                    throws Throwable {
                                if(method.getName().equals("close")){//指定只攔截close()方法
                                    System.out.println("往池中還回來一個連接....");
                                    pool.add((Connection) proxy);

                                    t.set(null);//清空t池中的本地線程對象

                                    return null;
                                }else{//其它方法，放行!
                                    return method.invoke(conn, args);
                                }
                            }
                        });

                pool.add((Connection) proxiedObj); //必須使用代理後的對象，纔有攔截功能
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private Conn5Utils(){
    }

    public static synchronized Connection getConn() throws Exception{
        //直接先從線程管理池t中去拿，若有就拿出來，若沒有就重新從pool中獲取一個並放入t中
        Connection con = t.get();

        if(con==null){
            if(pool.size()<=0){
                System.out.println("池中暫時沒了，請稍後...");
                Thread.sleep(1000);
                return getConn();
            }else{
                con= pool.remove(0);
                t.set(con);
            }
        }

        return con;
    }

}

同時把事物處理放到service層來了

同時我們發現一個新的問題。。。這個Service層的Save寫的太複雜。—通過攔截代理來完成，

package cn.hncu.utils;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;

public class TxProxy implements InvocationHandler {
    private Object srcObject;

    private TxProxy(Object srcObject) {
        this.srcObject = srcObject;
    }

    /*
     * public static Object getProxy(Object srcObject){ Object proxiedObj =
     * Proxy.newProxyInstance( TxProxy.class.getClassLoader(),
     * srcObject.getClass().getInterfaces(), new TxProxy(srcObject));
     * 
     * return proxiedObj; }
     */

    @SuppressWarnings("unchecked")
    public static <T> T getProxy(T srcObject) {
        Object proxiedObj = Proxy.newProxyInstance(TxProxy.class
                .getClassLoader(), srcObject.getClass().getInterfaces(),
                new TxProxy(srcObject));

        return (T) proxiedObj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // 有@Transaction就進行攔截(進行事務處理),否則直接放行

        if (method.isAnnotationPresent(Transaction.class)) {
            Connection con = null;
            try {
                con = Conn5Utils.getConn();
                con.setAutoCommit(false);
                System.out.println("事務開啓了...");

                Object res = method.invoke(srcObject, args); // 業務代碼//放行

                con.commit();
                System.out.println("事務提交了....");

                return res;
            } catch (Exception e) {
                try {
                    con.rollback();
                    System.out.println("事務回滾了...");
                } catch (SQLException e1) {
                    throw new RuntimeException("數據庫回滾失敗!", e1);
                }
            } finally {
                try {
                    con.setAutoCommit(true);
                    con.close();
                } catch (SQLException e) {
                    throw new RuntimeException("數據庫關閉失敗!", e);
                }
            }

            return null;
        } else {
            return method.invoke(srcObject, args);
        }

    }
}

加了事物攔截之後 Service層代碼

本來想貼源代碼的 太多了。整個項目的源代碼。想要的私信我昊了