Spring 의 사무 관리 입문:프로 그래 밍 식 사무 관리(TransactionTemplate)

Oracle 임시 표 에 적용 할 수 있 는 insert 와 select
 
Spring 은 프로 그래 밍 식 사무 와 성명 식 사 무 를 지원 할 수 있 습 니 다.
Spring 은 사무 관리 자 를 사용 하여 모든 플랫폼 의 사무 관리 자 는 인 터 페 이 스 를 실현 합 니 다:PlatformTransactionManager
이 인 터 페 이 스 는 사무 관리의 핵심 으로 세 가지 실현 해 야 할 함 수 를 제공 합 니 다.
 
[java] 
view plain
copy
print
?
 
commit(TransactionStatus status) ;     
getTransaction(TransactionDefinition definition) ;     
rollback(TransactionStatus status) ;  
 
만약 우리 가 JDBC 를 사용 하여 업 무 를 처리한다 면,이 사무 관리 자 는 DataSourceTransactionManager 입 니 다.
Spring 문 서 를 통 해 이 종 류 를 찾 았 는데 DataSource 라 는 종류 가 필요 합 니 다.즉,javax.sql.dataSource 라 는 인터페이스의 클래스 를 실현 하면 DataSourceTransactionManager 에 매개 변수 로 전송 할 수 있 습 니 다.
 그리고 패키지 org.springframework.transaction.support 의 TransactionTemplate 를 찾 습 니 다.
TransactionTemplate 에서 중요 한 방법 이 있 습 니 다.
 
[java] 
view plain
copy
print
?
 
execute(TransactionCallback action) ;  
 
바로 이 방법 을 이용 하여 우 리 는 이 방법 에 사 무 를 추가 할 수 있다.
이 방법 은 인자 TransactionCallback 을 입력 해 야 합 니 다.
TransactionCallback 은 말 그대로 트 랜 잭 션 Callback 을 찾 아 낸 것 이다.
이것 은 인터페이스 임 을 발견 했다.
안에 한 가지 방법 만 있다.
 
[java] 
view plain
copy
print
?
 
doInTransaction(TransactionStatus status) ;   
 
한 가지 일 에 해 야 할 일이 모두 이 방법 에 포함 되 어 있 음 이 분명 하 다.
이 doInTransaction 은 또 하나의 인자 가 들 어 왔 습 니 다.이번 에는 TransactionStatus 입 니 다.말 그대로 업무 상태 입 니 다.
이 TransactionStatus 는 인터페이스 입 니 다. 이 인터페이스 가 어떤 서 비 스 를 정의 하 는 지 보 세 요.
 
[java] 
view plain
copy
print
?
 
hasSavepoint() ;  
isCompleted() ;    
isNewTransaction() ;  
setRollbackOnly() ;  
 
스크롤 백 이 필요 할 때 setRoolback Only()를 호출 해 야 합 니 다.오케이 야.
자,이렇게 오래 걸 었 으 니 이제 프로 그래 밍 식 사무 관 리 를 간단하게 정리 하 겠 습 니 다.
우선: 저 희 는 특정한 플랫폼 을 사용 하기 때문에 저 희 는 저희 에 게 적합 한 플랫폼 사무 관리 PlateformTransactionManager 를 만들어 야 합 니 다.JDBC 를 사용 했다 면 DataSourceTransactionManager 를 사용 하 세 요.데이터 소스 를 전송 해 야 플랫폼 이 데이터 베 이 스 를 어떻게 만 나 는 지 알 수 있 습 니 다.
두 번 째: 플랫폼 사무 관리 자 를 우리 에 게 투명 하 게 하기 위해 서 는 TransactionTemplate 를 사용 해 야 합 니 다.TransactionTemplate 를 사용 하려 면 PlateformTransactionManager 가 들 어 와 야 합 니 다.그러면 우 리 는 어떤 플랫폼 을 사용 하 는 지 신경 쓰 지 않 고 TransactionTemplate 를 얻 을 수 있 습 니 다.
세 번 째: TransactionTemplate 의 중요 한 방법 은 execute 방법 입 니 다.이 방법 은 TransactionCallback 을 호출 하여 처리 하 는 것 입 니 다.
실제로 우리 가 처리 해 야 할 일 은 모두 TransactionCallback 에서 인 코딩 된 것 이다.
넷 째: 즉,TransactionCallback 인터페이스 입 니 다.우 리 는 이 인 터 페 이 스 를 정의 하고 실현 한 다음 에 TransactionTemplate.execute 의 매개 변수 로 사용 할 수 있 습 니 다.완성 해 야 할 일 을 doInTransaction 에 넣 고 TransactionStatus 인 자 를 전달 합 니 다.이 매개 변 수 는 스크롤 백 을 호출 하 러 왔 습 니 다.
그 러 니까 ，PlateformTransactionManager 와 TransactionTemplate 는 프로그램 에서 한 번 만 정의 하고 TransactionCallback 과 TransactionStatus 는 서로 다른 작업 에 대해 여러 번 정의 해 야 합 니 다.
이것 이 바로 Spring 의 프로 그래 밍 식 사무 관리 입 니 다.다음 에 예 코드 를 붙 입 니 다:
TemplateUtils

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("       ···", 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

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 {
					//      1
					//      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 {
					//      1
					//      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 {
			//      1
			//      2
			tm.commit(ts);
		} catch (Exception e) {
			tm.rollback(ts);
			e.printStackTrace();
		}
	}
}

 JdbcUtils

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("       ···", e);
		}
	}
	public static Connection getConnection() {
		Connection conn = null;
		try {
			conn = dataSource.getConnection();
		} catch (SQLException e) {
			logger.info("         ···", e);
		}
		return conn;
	}
	public static void close(Connection conn) {
		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
				logger.info("         ···", e);
			}
		}
	}
	public static void close(CallableStatement cs) {
		if (cs != null) {
			try {
				cs.close();
			} catch (SQLException e) {
				logger.info("  CallableStatement  ···", e);
			}
		}
	}
	public static void close(PreparedStatement ps) {
		if (ps != null) {
			try {
				ps.close();
			} catch (SQLException e) {
				logger.info("  PreparedStatement  ···", e);
			}
		}
	}
	public static void close(ResultSet rs) {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				logger.info("  ResultSet  ···", e);
			}
		}
	}
	public static void setAutoCommit(Connection conn, boolean autoCommit) {
		if (conn != null) {
			try {
				conn.setAutoCommit(autoCommit);
			} catch (SQLException e) {
				logger.info("          ···", e);
			}
		}
	}
	public static void commit(Connection conn) {
		if (conn != null) {
			try {
				conn.commit();
			} catch (SQLException e) {
				logger.info("      ···", e);
			}
		}
	}
	public static void rollback(Connection conn) {
		if (conn != null) {
			try {
				conn.rollback();
			} catch (SQLException e) {
				logger.info("      ···", e);
			}
		}
	}
	public static void rollback(Connection conn, Savepoint sp) {
		if (conn != null) {
			try {
				conn.rollback(sp);
			} catch (SQLException e) {
				logger.info("      ···", e);
			}
		}
	}
}

 
등급:http://blog.csdn.net/zq9017197/article/details/6321391