`
lushuaiyin
  • 浏览: 705046 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

java架构搭建（四）--spring事务

 
阅读更多

此篇接上篇（java架构搭建（三））继续http://blog.csdn.net/lushuaiyin/article/details/8589938

先看一下applicationContext.xml的内容：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	    <property name="locations">
			<list>
				<value>classpath:configure.properties</value>
			</list>
	     </property>		
	</bean>
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.query.substitutions">true=1,false=0</prop>
				<prop key="hibernate.jdbc.batch_size">25</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">false</prop>
				<prop key="hibernate.generate_statistics">false</prop>
				<prop key="hibernate.cache.use_query_cache">false</prop>
				<prop key="hibernate.cache.region_prefix">direct</prop>
				<prop key="hibernate.cache.use_structured_entries">false</prop> 
				<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
				<prop key="hibernate.query.factory_class">org.hibernate.hql.ast.ASTQueryTranslatorFactory</prop> 
				<prop key="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</prop>				
			</props>
		</property>
		<property name="dataSource"       ref="dataSource"/>
		<property name="mappingDirectoryLocations">
	       <list>
	         <value>classpath:/org/first/config/</value>
	         <value>classpath:/org/second/config/</value>
	       </list>
        </property>
	</bean>
	
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
		<property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
		<property name="minPoolSize" value="${c3p0.minPoolSize}"/>
		<property name="maxIdleTime" value="${c3p0.maxIdleTime}"/>
		<property name="maxStatements" value="${c3p0.maxStatements}"/>
		<property name="acquireIncrement" value="${c3p0.acquireIncrement}"/>
		<property name="idleConnectionTestPeriod" value="${c3p0.idleConnectionTestPeriod}"/>
		<property name="driverClass" value="${jdbc.driverClassName}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource">
        	<ref bean="dataSource"/>
        </property>
    </bean>
    	
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
	
	<bean id="transactionProxyTemplate" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
		<property name="transactionManager" ref="transactionManager"/>
		<property name="transactionAttributes">
			<props>
				<prop key="query*">PROPAGATION_REQUIRED</prop>
				<prop key="*">PROPAGATION_REQUIRED</prop>
			</props>
		</property>
	</bean>	
	
	<!-- 功能模块的引入 -->
	<import resource="classpath:/org/first/config/context_first.xml"/>
	<import resource="classpath:/org/second/config/context_second.xml"/>
</beans>

其中 

	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>

即是对事务的配置，他需要注入sessionFactory。

下面还有配置一个事务代理：

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

这个事务代理模板是干嘛用的呢？先看看源码吧：

org.springframework.transaction.interceptor.TransactionProxyFactoryBean

/*jadclipse*/// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.

package org.springframework.transaction.interceptor;

import java.util.Properties;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.AbstractSingletonProxyFactoryBean;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.transaction.PlatformTransactionManager;

// Referenced classes of package org.springframework.transaction.interceptor:
//            TransactionInterceptor, TransactionAttributeSourceAdvisor, TransactionAttributeSource

public class TransactionProxyFactoryBean extends AbstractSingletonProxyFactoryBean
    implements BeanFactoryAware
{

    public TransactionProxyFactoryBean()
    {
    }

    public void setTransactionManager(PlatformTransactionManager transactionManager)
    {
        transactionInterceptor.setTransactionManager(transactionManager);
    }

    public void setTransactionAttributes(Properties transactionAttributes)
    {
        transactionInterceptor.setTransactionAttributes(transactionAttributes);
    }

    public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource)
    {
        transactionInterceptor.setTransactionAttributeSource(transactionAttributeSource);
    }

    public void setPointcut(Pointcut pointcut)
    {
        this.pointcut = pointcut;
    }

    public void setBeanFactory(BeanFactory beanFactory)
    {
        transactionInterceptor.setBeanFactory(beanFactory);
    }

    protected Object createMainInterceptor()
    {
        transactionInterceptor.afterPropertiesSet();
        if(pointcut != null)
            return new DefaultPointcutAdvisor(pointcut, transactionInterceptor);
        else
            return new TransactionAttributeSourceAdvisor(transactionInterceptor);
    }

    private final TransactionInterceptor transactionInterceptor = new TransactionInterceptor();
    private Pointcut pointcut;
}


/*
	DECOMPILATION REPORT

	Decompiled from: D:\ChinaDevelopmentBankJBPM\workSpace\frame\webapp\WEB-INF\lib\spring-tx-3.0.3.RELEASE.jar
	Total time: 151 ms
	Jad reported messages/errors:
	Exit status: 0
	Caught exceptions:
*/

通过set方法我们就知道它需呀注入的属性：

setTransactionManager，setTransactionAttributes，setTransactionAttributeSource，setBeanFactory

对比上次对HibernateTemplete，我们可以简单的理解这个类进一步对transactionManager进行了管理。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------


事务的使用

context_first.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

	<bean id="firstDao" parent="transactionProxyTemplate">
		<property name="target">
			<bean class=" org.first.dao.impl.FirstDaoImpl">
				<property name="sessionFactory">
					<ref bean="sessionFactory"/>
				</property>
			</bean>
		</property>
		<property name="proxyInterfaces">
			<value> org.first.dao.FirstDao</value>
		</property>
	</bean>
</beans>

对涉及事务的api要定义接口和实现类。

FirstDao

package org.first.dao;

import java.util.List;

public interface FirstDao {
	
	public List queryUsers(String realName);

}
FirstDaoImpl
package org.first.dao.impl;

import java.util.List;

import org.base.MyHibernateDao;
import org.first.dao.FirstDao;

public class FirstDaoImpl extends MyHibernateDao implements FirstDao{
	
	public List queryUsers(String realName){
		List list=null;
		if(realName==null||realName.trim().equals("")){
			System.out.println("参数realName为空，查询所有值。");
			String hql="select u from LsyUser u ";
			list=this.queryListHql(hql);
		}else{
			String hql="select u from LsyUser u where u.real_name like '%"+realName.trim()+"%'";
			list=this.queryListHql(hql);
		}
		return list;
	}
}

然后再spring的配置文件中，如上，把接口类在spring中注册一个bean，class是：parent="transactionProxyTemplate"。

配置属性proxyInterfaces（接口类），target（接口的实现类）。

而接口的实现类需要注入sessionFactory。


上面的文件这样写更清楚：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

    <bean id="firstDaoTarget" class="org.first.dao.impl.FirstDaoImpl">
		<property name="sessionFactory">
			<ref bean="sessionFactory"/>
		</property>
	</bean>
	<bean id="firstDao" parent="transactionProxyTemplate">
		<property name="target" ref="firstDaoTarget" />
		<property name="proxyInterfaces">
			<value> org.first.dao.FirstDao</value>
		</property>
	</bean>
</beans>


再说些废话，上面用到了<bean id="firstDao" parent="transactionProxyTemplate">

这个parent简单说就是继承，如果你再配置一些属性，这些属性就会覆盖默认的属性值。

这样配置：

<bean id="transactionProxyTemplate" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
		<property name="transactionManager" ref="transactionManager"/>
		<property name="transactionAttributes">
			<props>
				<prop key="query*">PROPAGATION_REQUIRED</prop>
				<prop key="*">PROPAGATION_REQUIRED</prop>
			</props>
		</property>
	</bean>
<bean id="firstDao" parent="transactionProxyTemplate">
		<property name="target" ref="firstDaoTarget" />
		<property name="proxyInterfaces">
			<value> org.first.dao.FirstDao</value>
		</property>
	</bean>


相当于：

<bean id="firstDao" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
		<property name="transactionManager" ref="transactionManager"/>
		<property name="transactionAttributes">
			<props>
				<prop key="query*">PROPAGATION_REQUIRED</prop>
				<prop key="*">PROPAGATION_REQUIRED</prop>
			</props>
		</property>
		<property name="target" ref="firstDaoTarget" />
		<property name="proxyInterfaces">
			<value> org.first.dao.FirstDao</value>
		</property>
	</bean>

简单理解成继承就可以了，使用parent的好处也就是继承的好处，不用每个bean都去配置属性transactionManager，transactionAttributes。

有了继承，只需要配置一次即可。


----------------------------------------------------------------------------------------------

关于spring事务有哪几种方式，有篇文章介绍的很好。

Spring事务配置的五种方式http://www.blogjava.net/robbie/archive/2009/04/05/264003.html


----------------------------------------------------------------------------------------------


分享到：
| java架构搭建（三）--测试模块编写
评论
发表评论

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

相关推荐

    精通Java EE项目案例--基于Eclipse Spring Struts Hibernate (源程序2)

    《精通Java EE项目案例--基于Eclipse Spring Struts Hibernate (源程序2)》是一个深入学习Java企业级开发的实践教程，特别关注于Eclipse集成开发环境、Spring框架、Struts和Hibernate这四大核心技术的整合应用。...

    精通Java EE项目案例-基于Eclipse Spring Struts Hibernate

    总之，《精通Java EE项目案例-基于Eclipse Spring Struts Hibernate》通过实际的MyStuMan系统，帮助学习者掌握如何利用这些主流技术搭建功能完善的Web应用，理解Java EE开发的全貌，为日后的软件开发工作打下坚实的...

    tuling-vip-spring-master.zip

    Spring Boot简化了Spring应用的初始搭建和配置，它默认配置了许多常见功能，使开发者能快速启动项目。 通过分析“tuling-vip-spring-master.zip”中的样例代码，我们可以逐步了解并掌握Spring的使用。例如，从XML...

    D:\Java\Framework\Spring\Code_Spring

    6. **Spring Boot**：为简化Spring应用的初始搭建和运行过程，Spring Boot应运而生，它提供了预配置的starter，可以快速启动基于Spring的应用。 7. **Spring Cloud**：对于微服务架构，Spring Cloud提供了一整套...

    【Java-框架-Spring】(01) - 文件

    7. **Spring Boot**：随着微服务架构的流行，Spring Boot应运而生，它简化了Spring应用的初始搭建和配置，提供了一种快速开发独立运行的Spring应用的方式。 创建并使用Spring框架通常涉及以下步骤： 1. **引入依赖...

    JAX-RS+spring

    JAX-RS是Java平台上的标准，用于构建RESTful Web服务，而Spring则是一个全面的后端框架，提供了包括依赖注入、事务管理、AOP（面向切面编程）在内的多种功能。 **JAX-RS 知识点** 1. **定义**: JAX-RS 是JSR 339...

    JAVA-ACE-架构师系列视频教程在线观看地址- RocketMQ（订单实战上下全集）

    JAVA-ACE-架构师系列视频教程RocketMQ订单实战上目录介绍： 1001_RocketMQ_简介 2002_RocketMQ_核心概念详解 3003_RocketMQ_集群构建模型详解（一） 4004_RocketMQ_集群构建模型详解（二） 5005_RocketMQ_双主模式...

    JAVAspring-使用javaspring开发的猜数字游戏.zip

    在本项目中，"JAVAspring-使用javaspring开发的猜数字游戏.zip" 提供了一个使用Java Spring框架开发的猜数字小游戏。这个项目旨在帮助开发者熟悉Spring框架的运用，以及增强对Web应用程序开发的理解。以下是这个项目...

    基于Spring Boot的民宿租赁系统的设计与实现论文-java-文档-论文-基于Spring Boot的民宿租赁系统-文档

    - **简介**：`Spring Boot`是`Spring`家族中的一个新成员，旨在简化`Spring`应用的初始搭建以及开发过程。 - **特点**：通过约定优于配置的原则，减少配置量，提供了一系列默认配置来简化开发工作。 #### 2. ...

    SpringCloud微服务架构笔记-共四部分四个PDF文件

    SpringBoot简化了Spring应用的初始搭建以及开发过程，它集成了大量常用的Java库，提供了一种“开箱即用”的体验。主要特性包括自动配置、内嵌Servlet容器、健康检查、应用指标等。SpringBoot使得开发者能够快速地...

    基于Spring-Boot和Spring-Cloud实现微服务架构学习

    Spring-Boot和Spring-Cloud是两个关键的Java框架，它们共同为企业构建高效、可扩展的微服务提供了强大的支持。本文将深入探讨如何利用这两个框架来实现微服务架构。 首先，Spring-Boot是由Pivotal团队提供的一个...

    spring-spring-spring

    Spring Boot简化了Spring应用的初始搭建和配置，提供了一系列默认设置，让开发者可以快速启动项目。它还集成了许多常用的第三方库，如Tomcat、JDBC等，使得微服务开发更加便捷。 5. Spring Security: 这是Spring的...

    搭建SSH框架需要引入的Struts2包(log4j，spring-web，struts2-spring-plugin)

    SSH框架，全称为Struts2、Spring和Hibernate的组合，是Java Web开发中常见的三大开源框架集成。在构建SSH框架时，每个框架都扮演着不同的角色，以提供一个高效、可扩展的后端架构。现在我们来详细了解一下搭建SSH...

    JAVA-SSH三层架构搭建学习笔记

    ### JAVA-SSH三层架构搭建学习笔记 #### 一、概述 本学习笔记基于浪曦老师的教学视频进行整理，旨在帮助读者理解如何搭建完整的Struts2 + Hibernate + Spring（简称SSH）三层架构。通过本笔记，读者能够掌握如何从...

    spring技术内幕-深入解析spring架构与设计原理

    《Spring技术内幕——深入解析Spring架构与设计原理》是一本深度剖析Spring框架核心机制与设计理念的专业书籍。本书旨在帮助读者全面理解Spring的内部工作原理，从而更好地应用和优化Spring框架在实际开发中的使用。...

    spring-mybatis-spring-2.0.2.zip

    在Java Web开发中，Spring框架以其强大的功能和灵活的架构，成为企业级应用的首选。而MyBatis作为轻量级的持久层框架，以其简洁的SQL映射和易于理解的API，深受开发者喜爱。当Spring与MyBatis相结合时，可以实现数据...

    dynamic-datasource-spring-boot-starter-master.zip

    "dynamic-datasource-spring-boot-starter-master"项目则进一步简化了这一过程，让开发者可以更专注于业务逻辑的实现，而非底层基础设施的搭建。无论是初学者还是经验丰富的开发者，都能从中受益。

    angular-bootsrtrap-spring-mybatis-master框架搭建

    "angular-bootsrtrap-spring-mybatis-master"框架搭建是一个集成现代前端技术Angular与后端Spring和持久层Mybatis的项目。这个项目旨在提供一个完整的、开箱即用的开发环境，适合快速构建Web应用程序。下面我们将...

    struts-hibernate-spring最全jar包.rar

    这个压缩包"struts-hibernate-spring最全jar包.rar"包含了这三个框架的核心库文件，使得开发者可以快速搭建一个基于这些技术的Java应用。 **Struts** 是一个用于构建MVC（Model-View-Controller）架构的Java Web...

    2017年最新JAVA-ACE-架构师系列视频课程- RocketMQ（上下集）

    适用人群： 高级java工程师、java架构师 共23课时共9小时33分钟更新时间：2017-04-05 课程目标 RocketMQ（下）订单实战主要讲解rmq的分布式实战项目，围绕着订单模块等进行讲解，实现补偿等 课程目录 101_rocketmq...

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