如何将对数据库两个表的操作处于用一个事物下？同一个连接对象+事物拦截

需求：
我要存储同时存储一个学生信息和这个学生购买的图书信息，当学生的信息存储失败了，图书信息也不存储了，反之也一样，当某本书的信息存储失败了，学生信息也不存储了。

正常情况下，如果两个表的信息分开存储代码如下

所以我们可以看到两个表是否存储成功的信息没有办法传递，图书存储情况不知道学生信息存储情况。

解决方法： 两个存储用同一个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层代码

本来想贴源代码的 太多了。整个项目的源代码。想要的私信我昊了