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

正常情況下，如果兩個表的資訊分開儲存程式碼如下

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

解決方法： 兩個儲存用同一個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層程式碼

本來想貼原始碼的 太多了。整個專案的原始碼。想要的私信我昊了