`
winneryj
  • 浏览: 129650 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Spring事务简化配置

Spring配置管理BeaniBATISlog4j 
阅读更多
Java代码 复制代码

 

<beans>
	<!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
    <bean id="transactionManager"
          class="org.springframework.orm.hibernate3.HibernateTransactionManager">
          <property name="sessionFactory">
              <ref bean="sessionFactory"/>
          </property>
    </bean>	
	
	<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
    	<property name="transactionManager" ref="transactionManager"/>
		<property name="transactionAttributeSource">
		  <value>
			com.skyon.user.manager.UserManager.*=PROPAGATION_REQUIRED
			#Add new defines here ->
		  </value>
		</property>
	</bean>
	
	<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
		<property name="interceptorNames">
			<list>
				<value>transactionInterceptor</value>
				<!--
				增加新的 Interceptor
				-->
			</list>
		</property>
	</bean>

	<bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
	  <property name="transactionInterceptor" ref="transactionInterceptor"/>
	</bean>
		
</beans>



这里利用 DefaultAdvisorAutoProxyCreator 实现了对容器中所有 bean 的自动代理,  增加一个需要事务的业务 bean 时只要在 transactionInterceptor 增加一行即可,  增加别的 interceptor 也非常方便，
极大减少了配置量

使得bean注入简捷的autowire，使得创建proxy简捷的autoproxy（实现有两个，一个是DefaultAdvisorAutoProxyCreator,BeanNameAutoProxyCreator）.
另外一些奇技淫巧可以查下实现了BeanPostProcessor接口的类．

 

配置Spring，针对Service层的bean做事务处理，以往的做法是这样：

Java代码 复制代码

 

<bean id="txProxyTemplate" abstract="true" 
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
    <property name="transactionManager">
        <ref bean="transactionManager"/>
    </property> 
    <property name="transactionAttributes"> 
        <props>
            <prop key="find*">PROPAGATION_REQUIRED, readOnly</prop> 
            <prop key="*">PROPAGATION_REQUIRED</prop> 
        </props> 
    </property> 
</bean> 

<bean id="userManager" parent="txProxyTemplate"> 
    <property name="target"> 
        <bean class="some.package.UserManagerImpl"> 
            <property name="userDAO"><ref bean="userDAO"/></property> 
        </bean> 
    </property> 
</bean>



以后，如果增加新的Service/Manager，则XML配置的增量是这一段：

Java代码 复制代码

 

<bean id="someOtherManager" parent="txProxyTemplate"> 
    <property name="target"> 
        <bean class="some.package.someOtherManagerImpl"> 
        </bean> 
    </property> 
</bean>



上面说的是老的做法，比较传统。缺点是增量比较大，配置起来copy&paste让人觉得不太爽，比较臃肿。

下面的是Feiing给出的更好的方案，我有一些修改：

Java代码 复制代码

 

<beans> 
        <!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA); --> 
    <bean id="transactionManager"           class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
          <property name="sessionFactory"> 
              <ref bean="sessionFactory"/> 
          </property> 
    </bean>        
        
        <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
            <property name="transactionManager" ref="transactionManager"/> 
            <property name="transactionAttributes">
                <props>
                    <prop key="*">PROPAGATION_REQUIRED</prop>
                    <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
                </props>
            </property>
        </bean> 
        
        <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> 
                <property name="beanNames">
                    <value>*Service,*Manager</value>
                </property>
                <property name="interceptorNames"> 
                        <list> 
                                <value>transactionInterceptor</value> 
                                <!-- 
                                此处增加新的Interceptor
                                --> 
                        </list> 
                </property> 
        </bean> 

        <bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor"> 
          <property name="transactionInterceptor" ref="transactionInterceptor"/> 
        </bean> 


        <bean id="userManager" class="some.package.UserManagerImpl" autoWire="byName"/>
                
</beans>



以后每次的增量是这一段：

Java代码 复制代码

 

        <bean id="userManager" class="some.package.UserManagerImpl" autoWire="byName"/>



跟配置普通bean的方法一样，非常简洁、直观。对现有的Service接口也无须任何修改

我把Feiing的transactionAttributesSource改成叻transactionAttributes，并且将DefaultAdvisorAutoProxyCreator改成了BeanNameAutoProxyCreator，我觉得毕竟不是context下的每个bean都需要事务，只要在Service层做AOP就可以叻。

和Robbin一致认为，Feiing的做法非常可取，因为它分离了XML配置文件关注点

 

以下是spring+iBatis的配置

作为开源的Orm对象映射框架，ibatis是一个线程安全，学习容易，但是开发相对于hibernate来说的话，就要繁锁些，没有很好的工具支持ibatis所有的配置几乎是通过手写，这样增加了开发者的难度、、好啦，言归正转。下面编写实现。

一、引入spring,ibatis jar包.

二、编写log4j.properties日志文件

      log4j.rootLogger=DEBUG,stdout

      log4j.appender.stdout=org.apache.log4j.ConsoleAppender
      log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
      log4j.appender.stdout.layout.ConversionPattern=%c{1}% - %m%n

      log4j.logger.java.sql.PreparedStatement=DEBUG

      

 

 

三、建立Student.java类映象属性

package org.terry.ibatis.pojo;

public class Student {
 private Long id;

 private String name;

 private String subject;

 private Long score;

 public Long getId() {
  return id;
 }

 public void setId(Long id) {
  this.id = id;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public Long getScore() {
  return score;
 }

 public void setScore(Long score) {
  this.score = score;
 }

 public String getSubject() {
  return subject;
 }

 public void setSubject(String subject) {
  this.subject = subject;
 }
}

 

 

 

四、编写 student.xml 映象文件

<?xml version="1.0" encoding="utf-8" ?>

<!DOCTYPE sqlMap      
    PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"      
    "http://ibatis.apache.org/dtd/sql-map-2.dtd">
    
<sqlMap namespace="student">
 <typeAlias alias="student" type="org.terry.ibatis.pojo.Student"/>
 <resultMap class="student" id="studentResult">
  <result property="id" column="id" jdbcType="number" javaType="java.lang.Long"/>
  <result property="name" column="name"/>
  <result property="subject" column="subject"/>
  <result property="score" column="score"/>
 </resultMap>
 
 <select id="selectAll" resultMap="studentResult">
  select * from student
 </select>
 
 <select id="findbyId" parameterClass="java.lang.Long" resultClass="student">
  select * from student where id=#id#
 </select>
 <insert id="insert" parameterClass="student">
  insert into student(id,name,subject,score) values(#id#,#name#,#subject#,#score#)
 </insert>
 <update id="update" parameterClass="student">
  update student set name=#name#,subject=#subject#,score=#score# where id=#id#
 </update>
 <delete id="delete" parameterClass="java.lang.Long">
  delete from student where id=#id#
 </delete>
</sqlMap>

 

 

五、编写 SqlMapConfig.xml文件

<?xml version="1.0" encoding="utf-8" ?>

<!DOCTYPE sqlMapConfig      
    PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"      
    "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
    
<sqlMapConfig>
 <sqlMap resource="org/terry/ibatis/pojo/student.xml"/>
</sqlMapConfig>

 

 

六、编写 StudentDao.java(实现类)

package org.terry.ibatis.dao;

import java.io.IOException;
import java.sql.SQLException;
import java.util.List;

import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.orm.ibatis.SqlMapClientCallback;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
import org.terry.ibatis.pojo.Student;

import com.ibatis.sqlmap.client.SqlMapExecutor;

public class StudentDao extends SqlMapClientDaoSupport implements Idao{

 public void delete(Long id) {
  this.getSqlMapClientTemplate().delete("delete", id);
 }

 public Object findbyId(Long id) {
  return this.getSqlMapClientTemplate().queryForObject("findbyId", id);
 }

 public List getAll() {
  return (List)this.getSqlMapClientTemplate().execute(new SqlMapClientCallback(){

   public Object doInSqlMapClient(SqlMapExecutor sqlMapper) throws SQLException {
    return sqlMapper.queryForList("selectAll");
   }
   
  });
 }

 public void save(Object o) {
  this.getSqlMapClientTemplate().insert("insert", o);
 }

 public void update(Object o) {
  this.getSqlMapClientTemplate().update("update", o);
 }
 
 public static void main(String[] args) throws IOException {
   Resource re=new ClassPathResource("Ibatis-Context.xml");
   XmlBeanFactory xml=new XmlBeanFactory(re);
   StudentDao student=(StudentDao)xml.getBean("studentDao");
   Student stu=new Student();
   stu.setId(Long.valueOf(16));
   stu.setName("terry");
   stu.setScore(Long.valueOf(99));
   stu.setSubject("数学");
   student.delete(Long.valueOf(16));
 }
}

 

 

七、配置 ApplicationContext.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="dataSource"
  class="org.apache.commons.dbcp.BasicDataSource">
  <property name="driverClassName">
   <value>oracle.jdbc.driver.OracleDriver</value>
  </property>
  <property name="url">
   <value>jdbc:oracle:thin:@localhost:1521:orcl</value>
  </property>
  <property name="username">
   <value>terry</value>
  </property>
  <property name="password">
   <value>terry</value>
  </property>
 </bean>
 
 <bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
  <property name="configLocation" value="SqlMapConfig.xml"/>
  <property name="dataSource" ref="dataSource"></property>
 </bean>
 
 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"></property>
 </bean>
  <!-- 配置事务拦截器 -->
   <bean id="transactionIterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
    <!-- 事务拦截器需要注入一个事务管理器 -->
    <property name="transactionManager" ref="transactionManager"></property>
    <property name="transactionAttributes">
     <props>
      <prop key="insert*">PROPAGATION_REQUIRED</prop>
      <prop key="find*,get*">PROPAGATION_REQUIRED,readOnly</prop>
      <prop key="*">PROPAGATION_REQUIRED</prop>
     </props>
    </property>
   </bean>
   
   <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
    <property name="beanNames">
     <list>
      <value>*Dao</value>
     </list>
    </property>
    <property name="interceptorNames">
     <list>
      <value>transactionIterceptor</value>
     </list>
    </property>
   </bean>
 <bean id="studentDao" class="org.terry.ibatis.dao.StudentDao">
  <property name="sqlMapClient" ref="sqlMapClient"></property>
 </bean>
</beans>

 

 

这样Ibatis 集成 Spring就实现啦

分享到：
| Axis实践入门
评论
1 楼 geek87 2010-01-30  
很好，，不错
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring事务配置的五种方式

    ### Spring事务配置的五种方式详解 #### 一、引言 在企业级应用开发中，事务处理是非常重要的一部分，特别是在涉及多个数据库操作时。Spring框架提供了强大的事务管理功能，支持编程式和声明式两种事务处理方式。...

    Spring 事务代理配置

    最后，需要将事务拦截器应用到具体的目标类上，通常是在`aop:config`标签下配置切入点和增强，或者通过`@Transactional`注解来简化配置。 ```xml (* com.example.service.*.*(..))"/&gt; ``` 或者使用`@...

    Spring事务管理开发必备jar包

    本资源包提供了进行Spring事务管理开发所需的所有关键库，包括框架基础、核心组件、AOP（面向切面编程）支持、日志处理、编译工具以及与数据库交互的相关jar包。下面将对这些知识点进行详细解释： 1. **Spring框架*...

    spring事务案例分析.zip

    7. **案例分析**："SPRING事务管理案例分析.docx"很可能包含了具体的项目实例，详细讲解了如何在Spring项目中配置和使用事务管理，以及如何解决实践中遇到的问题。而"studyspring"可能是源代码目录，包含了实现这些...

    spring 事务传播 demo

    在Java后端开发中，Spring的事务管理机制大大简化了事务控制，使得开发者可以更专注于业务逻辑，而不用关心底层事务的管理。通过声明式事务管理，我们只需在方法上添加@Transactional注解，而无需编写手动的try-...

    spring声明事务的配置

    此外，Spring Boot简化了Spring应用的启动和配置，包括事务管理，使得在现代项目中使用声明式事务更加便捷。 总的来说，Spring声明式事务管理提供了一种强大且灵活的方式来控制事务的边界，使得事务管理与业务逻辑...

    spring事务详解

    在实际应用中，Spring事务管理的配置和使用需要注意以下几个方面： - 事务传播行为：定义了事务在遇到已有事务时的行为模式，例如是否加入当前事务、新建一个事务等。 - 事务隔离级别：定义了事务的隔离水平，例如...

    Spring事务管理配置

    在深入探讨Spring事务管理配置之前，我们先简要回顾一下Spring框架的核心概念。Spring是一个开源的Java平台，它提供了一套全面的编程和配置模型，旨在简化企业级应用的开发。其中，事务管理是Spring框架中的一个重要...

    实验 spring 声明事务

    Spring 提供了声明式事务管理，允许开发者在不编写事务管理代码的情况下实现事务控制，极大地简化了事务处理。 实验环境主要包括 Eclipse 或 MyEclipse 开发工具，以及 Spring 4.0 及以上版本，JDK 1.7 及以上版本...

    Spring事务五种不同的代理配置

    第一种方式需要手动配置事务规则，而第二、三种方式通过注解简化了配置，第四种方式适用于不依赖接口的情况，第五种方式则提供了最大的灵活性。在实际开发中，我们通常会选择基于注解的声明式事务管理，因为它既简洁...

    Spring事务配置的五种方式

    这种方式的优点是可以简化配置文件，但是缺点是需要了解 AOP 的机制和实现。 第三种方式：使用代理工厂 这种方式使用了 Spring 的代理工厂机制，可以将事务管理器注入到 Bean 中。这种方式的优点是可以灵活地控制...

    Spring基于XML方式配置事务

    结合上述配置，Spring会自动管理事务的开始、提交、回滚等操作，大大简化了事务管理的代码。在实际项目中，根据业务需求，我们可以灵活调整这些配置，以实现高效、安全的事务处理。 在提供的压缩包文件`Spring-JDBC...

    spring 事务基于注解模式

    Spring事务管理分为编程式和声明式两种。编程式事务管理通过编程的方式（如使用`TransactionTemplate`或直接调用`PlatformTransactionManager`）来控制事务的开始、提交、回滚等操作。而声明式事务管理则是在配置...

    Spring事务优缺点及使用详解.docx

    Spring事务管理提供了统一的事务处理模型，使得开发者无需关注具体数据库访问技术的事务细节，简化了事务控制代码，提高了代码的可读性和可维护性。无论是使用注解还是AOP配置，都能有效地管理和协调事务，确保应用...

    Spring事务详解

    本文将深入探讨Spring事务管理的概念、类型、配置方式以及在实际开发中的应用。 首先，我们要理解什么是事务。事务是数据库操作的基本单元，它确保一组数据库操作要么全部成功，要么全部失败。事务有四大特性，即...

    Spring的事务管理小案例

    在本文中，我们将深入探讨Spring框架中的事务管理。Spring是一个广泛应用的Java企业级应用开发框架，它提供...如果你想要深入了解，可以参考提供的博客链接或其他相关资料，进一步学习Spring事务管理的细节和最佳实践。

    spring声明式事务配置

    根据提供的信息，我们可以深入探讨Spring框架中的声明式事务配置及其多种实现方式。声明式事务管理是一种简化事务管理的方式，它允许开发人员通过配置而非编程来指定事务边界，从而减少了代码的复杂性并提高了可维护...

    Spring 事务配置详解(多种配置方法)

    Spring 2.5引入了注解事务管理，可以直接在Service层的方法上添加@Transactional注解，简化配置。例如： ```java @Service public class UserService { @Transactional public void addUser(User user) { // ...

    spring事务管理5种方法

    本篇文章将深入探讨Spring事务管理的五种方法，旨在帮助开发者更好地理解和运用这一核心特性。 首先，我们来了解什么是事务。在数据库操作中，事务是一组逻辑操作，这些操作要么全部成功，要么全部失败，确保数据的...

Magicbox
Global site tag (gtag.js) - Google Analytics