Spring的事務(wù)管理入門：編程式事務(wù)管理（TransactionTemplate）

liang1234_ 2019-02-25

展開全文

轉(zhuǎn)載：http://blog.csdn.net/zq9017197/article/details/6321391

Spring可以支持編程式事務(wù)和聲明式事務(wù)。

Spring使用事務(wù)管理器，每個不同平臺的事務(wù)管理器都實現(xiàn)了接口：PlatformTransactionManager

此接口是事務(wù)管理的核心，提供了三個需要實現(xiàn)的函數(shù)：

[java] view
 plaincopy

commit(TransactionStatus status) ;     

getTransaction(TransactionDefinition definition) ;     

rollback(TransactionStatus status) ;

如果我們使用的是JDBC來處理事務(wù)，那么這個事務(wù)管理器就是DataSourceTransactionManager。

通過Spring文檔查找到這個類，發(fā)現(xiàn)其需要DataSource這個類。也就是只要實現(xiàn)了javax.sql.DataSource這個接口的類，都可以作為參數(shù)傳入到DataSourceTransactionManager。

然后，找到包org.springframework.transaction.support中的 TransactionTemplate。

發(fā)現(xiàn)TransactionTemplate中有一個重要的方法：

[java] view
 plaincopy

execute(TransactionCallback action) ;

就是利用這個方法，我們可以在這個方法中添加事務(wù)。

這個方法需要傳入?yún)?shù) TransactionCallback。

TransactionCallback，顧名思義，就是事務(wù)回調(diào)然后查到TransactionCallback。

發(fā)現(xiàn)這是一個接口（這也必須是接口，因為任務(wù)都是自己具體定義的）

里面只有一個方法：

[java] view
 plaincopy

doInTransaction(TransactionStatus status) ;

很明顯，就是在一個事務(wù)中需要做的事情都包括這這個方法中了。

而這個doInTransaction 又傳入了一個參數(shù)，這次是 TransactionStatus，繼續(xù)顧名思義，也就是事務(wù)狀態(tài)。

查詢下去，這個 TransactionStatus 還是一個接口。看看這個接口定義了哪些服務(wù)（方法）：

[java] view
 plaincopy

hasSavepoint() ;  

isCompleted() ;    

isNewTransaction() ;  

setRollbackOnly() ;

當(dāng)需要回滾的時候，需要在調(diào)用 setRoolbackOnly(); 就OK了。

好了，走了這么久，現(xiàn)在就來簡單總結(jié)一下編程式事務(wù)管理。

首先：因為我們使用的是特定的平臺，所以，我們需要創(chuàng)建一個合適我們的平臺事務(wù)管理PlateformTransactionManager。如果使用的是JDBC的話，就用DataSourceTransactionManager。注意需要傳入一個DataSource，這樣，平臺才知道如何和數(shù)據(jù)庫打交道。

第二：為了使得平臺事務(wù)管理器對我們來說是透明的，就需要使用 TransactionTemplate。使用TransactionTemplat需要傳入一個 PlateformTransactionManager 進入，這樣，我們就得到了一個 TransactionTemplate，而不用關(guān)心到底使用的是什么平臺了。

第三： TransactionTemplate 的重要方法就是 execute 方法，此方法就是調(diào)用 TransactionCallback 進行處理。

也就是說，實際上我們需要處理的事情全部都是在 TransactionCallback 中編碼的。

第四：也就是 TransactionCallback 接口，我們可以定義一個類并實現(xiàn)此接口，然后作為 TransactionTemplate.execute 的參數(shù)。把需要完成的事情放到 doInTransaction中，并且傳入一個 TransactionStatus 參數(shù)。此參數(shù)是來調(diào)用回滾的。

也就是說，PlateformTransactionManager 和 TransactionTemplate 只需在程序中定義一次，而TransactionCallback 和 TransactionStatus 就要針對不同的任務(wù)多次定義了。

這就是Spring的編程式事務(wù)管理。下面貼出例子代碼：

TemplateUtils

[java] view
 plaincopy

import javax.naming.Context;  

import javax.naming.InitialContext;  

import javax.naming.NamingException;  

import javax.sql.DataSource;  

import org.apache.log4j.Logger;  

import org.springframework.jdbc.core.JdbcTemplate;  

import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;  

import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;  

import org.springframework.jdbc.datasource.DataSourceTransactionManager;  

import org.springframework.transaction.PlatformTransactionManager;  

import org.springframework.transaction.support.TransactionTemplate;  

public class TemplateUtils {  

    private static Logger logger = Logger.getLogger(TemplateUtils.class);  

    private static String oracleDS = "java:OracleDS";  

    private static DataSource dataSource = null;  

    static {  

        try {  

            Context context = new InitialContext();  

            dataSource = (DataSource) context.lookup(oracleDS);  

        } catch (NamingException e) {  

            logger.info("查找數(shù)據(jù)源失敗···", e);  

        }  

    }  

    public static TransactionTemplate getTransactionTemplate() {  

        PlatformTransactionManager txManager = new DataSourceTransactionManager(  

                dataSource);  

        return new TransactionTemplate(txManager);  

    }  

    public static JdbcTemplate getJdbcTemplate() {  

        return new JdbcTemplate(dataSource);  

    }  

    public static NamedParameterJdbcTemplate getNamedParameterJdbcTemplate() {  

        return new NamedParameterJdbcTemplate(dataSource);  

    }  

    public static SimpleJdbcTemplate getSimpleJdbcTemplate() {  

        return new SimpleJdbcTemplate(dataSource);  

    }  

}

Test

[java] view
 plaincopy

import javax.naming.Context;  

import javax.naming.InitialContext;  

import javax.sql.DataSource;  

import org.springframework.jdbc.core.JdbcTemplate;  

import org.springframework.jdbc.datasource.DataSourceTransactionManager;  

import org.springframework.transaction.PlatformTransactionManager;  

import org.springframework.transaction.TransactionStatus;  

import org.springframework.transaction.support.DefaultTransactionDefinition;  

import org.springframework.transaction.support.TransactionCallback;  

import org.springframework.transaction.support.TransactionCallbackWithoutResult;  

import org.springframework.transaction.support.TransactionTemplate;  

@SuppressWarnings("all")  

public class Test {  

    public void m1() throws Exception {  

        TransactionTemplate transactionTemplate = TemplateUtils  

                .getTransactionTemplate();  

        Object object = transactionTemplate.execute(new TransactionCallback() {  

            public Object doInTransaction(TransactionStatus status) {  

                try {  

                    // 數(shù)據(jù)庫操作1  

                    // 數(shù)據(jù)庫操作2  

                } catch (Exception e) {  

                    status.setRollbackOnly();  

                    e.printStackTrace();  

                }  

                return null;  

            }  

        });  

    }  

    public void m2() throws Exception {  

        TransactionTemplate transactionTemplate = TemplateUtils  

                .getTransactionTemplate();  

        transactionTemplate.execute(new TransactionCallbackWithoutResult() {  

            protected void doInTransactionWithoutResult(TransactionStatus s) {  

                try {  

                    // 數(shù)據(jù)庫操作1  

                    // 數(shù)據(jù)庫操作2  

                } catch (Exception e) {  

                    s.setRollbackOnly();  

                    e.printStackTrace();  

                }  

            }  

        });  

    }  

    public void m3() throws Exception {  

        Context ctx = new InitialContext();  

        DataSource ds = (DataSource) ctx.lookup("java:OracleDS");  

        JdbcTemplate jt = new JdbcTemplate(ds);  

        DefaultTransactionDefinition tf = new DefaultTransactionDefinition();  

        PlatformTransactionManager tm = new DataSourceTransactionManager(ds);  

        TransactionStatus ts = tm.getTransaction(tf);  

        try {  

            // 數(shù)據(jù)庫操作1  

            // 數(shù)據(jù)庫操作2  

            tm.commit(ts);  

        } catch (Exception e) {  

            tm.rollback(ts);  

            e.printStackTrace();  

        }  

    }  

}

JdbcUtils

[java] view
 plaincopy

import java.sql.CallableStatement;  

import java.sql.Connection;  

import java.sql.PreparedStatement;  

import java.sql.ResultSet;  

import java.sql.SQLException;  

import java.sql.Savepoint;  

import javax.naming.Context;  

import javax.naming.InitialContext;  

import javax.naming.NamingException;  

import javax.sql.DataSource;  

import org.apache.log4j.Logger;  

public class JdbcUtils {  

    private static Logger logger = Logger.getLogger(JdbcUtils.class);  

    private static String oracleDS = "java:OracleDS";  

    private static DataSource dataSource = null;  

    static {  

        try {  

            Context context = new InitialContext();  

            dataSource = (DataSource) context.lookup(oracleDS);  

        } catch (NamingException e) {  

            logger.info("查找數(shù)據(jù)源失敗···", e);  

        }  

    }  

    public static Connection getConnection() {  

        Connection conn = null;  

        try {  

            conn = dataSource.getConnection();  

        } catch (SQLException e) {  

            logger.info("獲取數(shù)據(jù)庫連接失敗···", e);  

        }  

        return conn;  

    }  

    public static void close(Connection conn) {  

        if (conn != null) {  

            try {  

                conn.close();  

            } catch (SQLException e) {  

                logger.info("釋放數(shù)據(jù)庫連接失敗···", e);  

            }  

        }  

    }  

    public static void close(CallableStatement cs) {  

        if (cs != null) {  

            try {  

                cs.close();  

            } catch (SQLException e) {  

                logger.info("關(guān)閉CallableStatement失敗···", e);  

            }  

        }  

    }  

    public static void close(PreparedStatement ps) {  

        if (ps != null) {  

            try {  

                ps.close();  

            } catch (SQLException e) {  

                logger.info("關(guān)閉PreparedStatement失敗···", e);  

            }  

        }  

    }  

    public static void close(ResultSet rs) {  

        if (rs != null) {  

            try {  

                rs.close();  

            } catch (SQLException e) {  

                logger.info("關(guān)閉ResultSet失敗···", e);  

            }  

        }  

    }  

    public static void setAutoCommit(Connection conn, boolean autoCommit) {  

        if (conn != null) {  

            try {  

                conn.setAutoCommit(autoCommit);  

            } catch (SQLException e) {  

                logger.info("設(shè)置事務(wù)提交方式失敗···", e);  

            }  

        }  

    }  

    public static void commit(Connection conn) {  

        if (conn != null) {  

            try {  

                conn.commit();  

            } catch (SQLException e) {  

                logger.info("提交事務(wù)失敗···", e);  

            }  

        }  

    }  

    public static void rollback(Connection conn) {  

        if (conn != null) {  

            try {  

                conn.rollback();  

            } catch (SQLException e) {  

                logger.info("回滾事務(wù)失敗···", e);  

            }  

        }  

    }  

    public static void rollback(Connection conn, Savepoint sp) {  

        if (conn != null) {  

            try {  

                conn.rollback(sp);  

            } catch (SQLException e) {  

                logger.info("回滾事務(wù)失敗···", e);  

            }  

        }  

    }  

}