spring 四种配置方法
spring事务配置
Spring事务配置的五种方法事务就是对一系列的数据库操作(比如插入多条数据)进行统一的提交或回滚操作,如果插入成功,那么一起成功,如果中间有一条出现异常,那么回滚之前的所有操作。
这样可以防止出现脏数据,防止数据库数据出现问题。
开发中为了避免这种情况一般都会进行事务管理。
在JDBC中是通过Connection对象进行事务管理的,默认是自动提交事务,可以手工将自动提交关闭,通过commit方法进行提交,rollback方法进行回滚,如果不提交,则数据不会真正的插入到数据库中。
Hibernate中是通过Transaction进行事务管理,处理方法与JDBC中类似。
Spring不会直接去管理事务,它提供了很多可供选择的事务管理器,将事务委托给JTA或某些特定的平台事务实现. Spring一般是使用TransactionMananger进行管理,可以通过Spring的注入来完成此功能。
针对Spring事务管理总结如下:要想用Spring的事务管理机制,就需要把数据库的连接交给Spring来管理,(JDBC,SESSION道理一样),如果使用Hibernate框架,要把Session交给Spring管理。
在整个Service方法调用中,虽然Sevice调用了多个Dao,但是整个过程中Session只有一个。
也就是说你对数据库的DML操作,都会先保存在这个Session中,包括update,insert,delete。
当发生异常(这个异常可以是数据库的,也可以是程序的),Spring会把这个Session中对应的DML操作回滚。
Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用Hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为HibernateTransactionManager。
bean的几种装配方式的基本用法
bean的几种装配方式的基本用法Bean的装配方式是Spring框架中用于实现对象依赖注入的一种机制。
Spring提供了多种装配方式,包括XML配置、注解配置和Java代码配置。
下面将分别介绍这几种装配方式的基本用法。
1.XML配置方式XML配置方式是Spring最早的装配方式之一,需要在XML文件中明确描述Bean的定义和依赖关系。
以下是XML配置的基本用法:- 在XML文件中使用`<bean>`元素定义Bean,可以指定Bean的类名、属性值、构造函数参数等。
- 使用`<property>`元素设置Bean的属性值,可以通过`ref`属性引用其他Bean。
- 使用`<constructor-arg>`元素设置Bean的构造函数参数,同样可以通过`ref`属性引用其他Bean。
2.注解配置方式注解配置方式是Spring 2.5引入的一种装配方式。
通过在Bean的类或者方法上添加注解,Spring能够自动完成对象的创建和依赖注入。
以下是注解配置的基本用法:3. Java代码配置方式Java代码配置方式是从Spring 3.0开始引入的,通过编写Java代码来配置Bean和依赖关系。
以下是Java代码配置的基本用法:- 在方法体中可以进行复杂的逻辑处理来创建Bean,并可以通过参数注入其他Bean。
以上是XML配置、注解配置和Java代码配置这三种装配方式的基本用法。
根据实际的需求和项目的规模,可以选择相应的装配方式来完成对象的管理和依赖注入。
在实际开发中,通常会结合使用这三种方式来完实现Bean的装配。
五种配置bean方式
Spring事务配置的五种方式前段时间对Spring的事务配置做了比较深入的研究,在此之间对Spring的事务配置虽说也配置过,但是一直没有一个清楚的认识。
通过这次的学习发觉Spring的事务配置只要把思路理清,还是比较好掌握的。
总结如下:Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用Hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为HibernateTransactionManager。
具体如下图:根据代理机制的不同,总结了五种Spring事务的配置方式,配置文件如下:第一种方式:每个Bean都有一个代理<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"/></bean><!-- 配置DAO --><bean id="userDaoTarget" class="erDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDao"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <!-- 配置事务管理器--><property name="transactionManager" ref="transactionManager"/> <property name="target" ref="userDaoTarget"/><property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao"/><!-- 配置事务属性--><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>第二种方式:所有Bean共享一个代理基类<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"/></bean><bean id="transactionBase"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"lazy-init="true" abstract="true"><!-- 配置事务管理器--><property name="transactionManager" ref="transactionManager"/><!-- 配置事务属性--><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><!-- 配置DAO --><bean id="userDaoTarget" class="erDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDao" parent="transactionBase"><property name="target" ref="userDaoTarget"/></bean></beans>第三种方式:使用拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"/></bean><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterceptor"><property name="transactionManager" ref="transactionManager"/><!-- 配置事务属性--><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><beanclass="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"><property name="beanNames"><list><value>*Dao</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><!-- 配置DAO --><bean id="userDao" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory"/></bean></beans>第四种方式:使用tx标签配置的拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"/></bean><tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes><tx:method name="*" propagation="REQUIRED"/></tx:attributes></tx:advice><aop:config><aop:pointcut id="interceptorPointCuts"expression="execution(* com.bluesky.spring.dao.*.*(..))"/><aop:advisor advice-ref="txAdvice"pointcut-ref="interceptorPointCuts"/></aop:config></beans>第五种方式:全注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky"/><tx:annotation-driven transaction-manager="transactionManager"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"/></bean></beans>此时在DAO上需加上@Transactional注解,如下:package com.bluesky.spring.dao;import java.util.List;import org.hibernate.SessionFactory;importorg.springframework.beans.factory.annotation.Autowired;importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;importponent;import er;@Transactional@Component("userDao")public class UserDaoImpl extends HibernateDaoSupport implements UserDao {public List<User> listUsers() {return this.getSession().createQuery("from User").list();}}。
Spring的并发问题——有状态Bean和无状态Bean
Spring的并发问题——有状态Bean和⽆状态Bean⼀、有状态和⽆状态有状态会话bean :每个⽤户有⾃⼰特有的⼀个实例,在⽤户的⽣存期内,bean保持了⽤户的信息,即“有状态”;⼀旦⽤户灭亡(调⽤结束或实例结束),bean的⽣命期也告结束。
即每个⽤户最初都会得到⼀个初始的bean。
简单来说,有状态就是有数据存储功能。
有状态对象(Stateful Bean),就是有实例变量的对象,可以保存数据,是⾮线程安全的。
⽆状态会话bean :bean⼀旦实例化就被加进会话池中,各个⽤户都可以共⽤。
即使⽤户已经消亡,bean 的⽣命期也不⼀定结束,它可能依然存在于会话池中,供其他⽤户调⽤。
由于没有特定的⽤户,那么也就不能保持某⼀⽤户的状态,所以叫⽆状态bean。
但⽆状态会话bean 并⾮没有状态,如果它有⾃⼰的属性(变量),那么这些变量就会受到所有调⽤它的⽤户的影响,这是在实际应⽤中必须注意的。
简单来说,⽆状态就是⼀次操作,不能保存数据。
⽆状态对象(Stateless Bean),就是没有实例变量的对象 .不能保存数据,是不变类,是线程安全的。
package com.sw;public class TestManagerImpl implements TestManager{private User user; //有⼀个记录信息的实例public void deleteUser(User e) throws Exception {user = e ; //1prepareData(e);}public void prepareData(User e) throws Exception {user = getUserByID(e.getId()); //2.....//使⽤user.getId(); //3..........}}⼀个有状态的bean⼆、解决有状态bean的线程安全问题Spring对bean的配置中有四种配置⽅式,我们只说其中两种:singleton单例模式、prototype原型模式。
Spring事务五种不同的代理配置
Spring事务配置的五种方式前段时间对Spring的事务配置做了比较深入的研究,在此之间对Spring的事务配置虽说也配置过,但是一直没有一个清楚的认识。
通过这次的学习发觉Spring的事务配置只要把思路理清,还是比较好掌握的。
总结如下:Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用Hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为 HibernateTransactionManager。
具体如下图:根据代理机制的不同,总结了五种Spring事务的配置方式,配置文件如下:第一种方式:每个Bean都有一个代理<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务) --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><!-- 配置DAO --><bean id="userDaoTarget" class="erDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDao"class="org.springframework.transaction.interceptor.TransactionProxyFactoryB ean"><!-- 配置事务管理器 --><property name="transactionManager" ref="transactionManager"/> <property name="target" ref="userDaoTarget"/><property name="proxyInterfaces"value="com.bluesky.spring.dao.GeneratorDao"/><!-- 配置事务属性 --><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>第二种方式:所有Bean共享一个代理基类<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务) --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="transactionBase"class="org.springframework.transaction.interceptor.TransactionP roxyFact oryBean"lazy-init="true" abstract="true"><!-- 配置事务管理器 --><property name="transactionManager" ref="transactionManager"/><!-- 配置事务属性 --><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><!-- 配置DAO --><bean id="userDaoTarget" class="erDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="userDao" parent="transactionBase"><property name="target" ref="userDaoTarget"/></bean></beans>第三种方式:使用拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务) --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterceptor"><property name="transactionManager" ref="transactionManager"/><!-- 配置事务属性 --><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><beanclass="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="beanNames"><list><value>*Dao</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><!-- 配置DAO --><bean id="userDao" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory"/></bean></beans>第四种方式:使用tx标签配置的拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务) --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes><tx:method name="*" propagation="REQUIRED"/></tx:attributes></tx:advice><aop:config><aop:pointcut id="interceptorPointCuts"expression="execution(* com.bluesky.spring.dao.*.*(..))"/> <aop:advisor advice-ref="txAdvice"pointcut-ref="interceptorPointCuts"/></aop:config></beans>第五种方式:全注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky"/><tx:annotation-driven transaction-manager="transactionManager"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/><property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/></bean><!-- 定义事务管理器(声明式的事务) --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean></beans>此时在DAO上需加上@Transactional注解,如下:package com.bluesky.spring.dao;import java.util.List;import org.hibernate.SessionFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;import ponent;import er;@Transactional@Component("userDao")public class UserDaoImpl extends HibernateDaoSupport implements UserDao {public List<User> listUsers() {return this.getSession().createQuery("from User").list();}}。
spring的4种事物管理
spring的4种事物管理Spring 2009-04-08 19:59:51 阅读241 评论0字号:大中小订阅Spring中的四种声明式事务的配置Spring容器中有两种思想很重要,也就是我们常用的Ioc和Aop,如果理解了这两种思想,对于我们学习设计模式和编程有很大的帮助,美国四人帮(GOF)写的设计模式中,有很多都用到了Ioc的思想。
简单的说就是依赖注入的思想。
常见的一种情况:如果一个类中要复用另外一个类中的功能时,我们可能会首先想到继承,如果你知道Ioc这种思想的话,我想你不会用继承,你会马上想到把要用到功能抽取出来,在我们要用到的类中只需通过set方法简单的注入就可以了,其实这里用到了对象的组合代替继承,这样不仅避免了单一继承,还很好的实现了松耦合。
同时也遵循了面向对象的编程的设计原则:多用组合,少用继承。
在这里对于Ioc和Aop这两种思想的好处。
我就不介绍了。
接下来我要说的是Spring 中几种常见的事务配置,是Aop和Ioc的充分体现。
在说点题外话,以前EJB在J2EE中开发中可是大名鼎鼎的了。
就是因为EJB提供了很多服务,而不需要我们去开发了,其中用到最多的算是它提供的声明式事务了。
在Spring 没有出现之前,EJB在J2EE开发中扮演着非常重要的角色。
同时也是很多项目失败的罪魁祸首。
其中的原因就是因为它是重量级,强侵入性收费的框架。
需要昂贵的服务器支持,在加上它的测试更是让人头痛。
而Spring恰恰与它相反。
Spring是一个轻量级的,非侵入性的开源框架。
它提供的声明式事务的功能更是强大,不需要容器的支持。
这一点吸引力很多人愿意放弃EJB而使用Spring。
让我们言归正传吧。
以下两个bean的配置是下面要用到的。
<!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"<property name="sessionFactory"><ref local="sessionFactory" /></property></bean><!-- *******业务逻辑层(是对各个DAO层的正面封装)主要用到<<门面模式>>****** --><bean id="fundService"<property name="operdao"><ref bean="operatorDAO" /></property><property name="producedao"><ref bean="fundProduceDAO" /></property></bean>可能还有其他很多模块。
Spring事务配置的五种方式
Spring事务原理统观spring事务,围绕着两个核心PlatformTransactionManager和TransactionStatusspring提供了几个关于事务处理的类:TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务,可以提交,回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口,其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。
一般事务定义步骤:TransactionDefinition td = new TransactionDefinition();TransactionStatus ts = transactionManager.getTransaction(td);try{ //do sthmit(ts);}catch(Exception e){transactionManager.rollback(ts);}spring提供的事务管理可以分为两类:编程式的和声明式的。
编程式的,比较灵活,但是代码量大,存在重复的代码比较多;声明式的比编程式的更灵活。
编程式主要使用transactionTemplate。
省略了部分的提交,回滚,一系列的事务对象定义,需注入事务管理对象.void add(){transactionTemplate.execute( new TransactionCallback(){pulic Object doInTransaction(TransactionStatus ts){ //do sth}}}声明式:使用TransactionProxyFactoryBean:<bean id="userManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"><property name="transactionManager"><ref bean="transactionManager"/></property><property name="target"><ref local="userManagerTarget"/></property><property name="transactionAttributes"><props><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="*">PROPAGATION_REQUIRED,readOnly</prop></props></property></bean>围绕Poxy的动态代理能够自动的提交和回滚事务org.springframework.transaction.interceptor.TransactionProxyFactoryBeanPROPAGATION_REQUIRED--支持当前事务,如果当前没有事务,就新建一个事务。
spring配置文件详解
spring配置文件详解Spring是一个轻量级的开源Java框架,它提供了一种简化Java应用开发的方式。
在Spring框架中,配置文件起着非常重要的作用,它用于配置应用程序中的各种组件和对象。
Spring配置文件通常使用XML格式,但也可以使用注解或Java代码进行配置。
在配置文件中,我们可以定义Bean(对象)、依赖关系、AOP(面向切面编程)等等。
下面将详细介绍Spring配置文件的各个部分。
1. 命名空间和约束在Spring配置文件的开头,我们需要声明命名空间和约束。
命名空间用于引入Spring的命名空间,以便我们可以使用Spring提供的各种功能。
约束用于验证配置文件的正确性。
2. Bean定义在Spring配置文件中,我们可以定义多个Bean。
每个Bean都有一个唯一的ID和一个类名或接口名。
我们可以使用构造函数或工厂方法来创建Bean,并指定Bean的属性值。
3. 依赖注入依赖注入是Spring框架的核心特性之一。
通过依赖注入,我们可以将一个Bean的依赖关系委托给Spring容器来管理。
在配置文件中,我们可以使用<property>元素来设置Bean的属性值,也可以使用<constructor-arg>元素来设置构造函数的参数。
4. 别名和引用在配置文件中,我们可以为Bean定义别名,以便在其他地方使用更简洁的名称来引用Bean。
我们还可以使用<ref>元素来引用其他Bean。
5. 集合和数组Spring配置文件还支持定义集合和数组类型的属性。
我们可以使用<list>、<set>、<map>和<props>元素来定义不同类型的集合。
6. 自动装配自动装配是Spring框架的另一个重要特性。
通过自动装配,Spring容器可以根据Bean之间的依赖关系自动将它们连接起来。
在配置文件中,我们可以使用autowire属性来指定自动装配的方式。
spring配置的五种方式
Spring事务配置的五种方式前段时间对Spring的事务配置做了比较深入的研究,在此之间对Spring的事务配置虽说也配置过,但是一直没有一个清楚的认识。
通过这次的学习发觉Spring的事务配置只要把思路理清,还是比较好掌握的。
总结如下:Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用Hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为HibernateTransactionManager。
具体如下图:根据代理机制的不同,总结了五种Spring事务的配置方式,配置文件如下:第一种方式:每个Bean都有一个代理<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><!-- 配置DAO --><bean id="userDaoTarget" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="userDao"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <!-- 配置事务管理器--><property name="transactionManager" ref="transactionManager" /><property name="target" ref="userDaoTarget" /><property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" /><!-- 配置事务属性--><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>第二种方式:所有Bean共享一个代理基类<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="transactionBase"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"lazy-init="true" abstract="true"><!-- 配置事务管理器--><property name="transactionManager" ref="transactionManager" /><!-- 配置事务属性--><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><!-- 配置DAO --><bean id="userDaoTarget" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="userDao" parent="transactionBase" ><property name="target" ref="userDaoTarget" /></bean></beans>第三种方式:使用拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterceptor"><property name="transactionManager" ref="transactionManager" /><!-- 配置事务属性--><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><beanclass="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="beanNames"><list><value>*Dao</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><!-- 配置DAO --><bean id="userDao" class="erDaoImpl"><property name="sessionFactory" ref="sessionFactory" /></bean></beans>第四种方式:使用tx标签配置的拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky" /><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="*" propagation="REQUIRED" /></tx:attributes></tx:advice><aop:config><aop:pointcut id="interceptorPointCuts"expression="execution(* com.bluesky.spring.dao.*.*(..))" /><aop:advisor advice-ref="txAdvice"pointcut-ref="interceptorPointCuts" /></aop:config></beans>第五种方式:全注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd"><context:annotation-config /><context:component-scan base-package="com.bluesky" /><tx:annotation-driven transaction-manager="transactionManager"/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml" /><property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" /></bean><!-- 定义事务管理器(声明式的事务)--><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean></beans>此时在DAO上需加上@Transactional注解,如下:package com.bluesky.spring.dao;import java.util.List;import org.hibernate.SessionFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;import ponent;import er;@Transactional@Component("userDao")public class UserDaoImpl extends HibernateDaoSupport implements UserDao {public List<User> listUsers() {return this.getSession().createQuery("from User").list();}}。
SpringMVC目录结构配置
SpringMVC目录结构配置SpringMVC是一种常见的Java Web框架,它遵循MVC(Model-View-Controller)设计模式,用于构建灵活可扩展的Web应用程序。
SpringMVC的目录结构对于项目的开发和维护非常重要,下面会详细介绍SpringMVC的标准目录结构以及配置方式。
1.标准目录结构1.1 src/main/java:主要用于存放Java源代码。
1.2 src/main/resources:主要用于存放配置文件和资源文件。
1.3 src/main/webapp:主要用于存放Web应用的静态资源。
1.4 src/test/java:主要用于存放测试用例的Java源代码。
1.5 src/test/resources:主要用于存放测试用例的配置文件和资源文件。
2.详细解析2.1 src/main/java目录src/main/java目录是存放Java源代码的默认目录,它包括以下几个子目录:- config:用于存放Spring配置类,如配置数据库连接、配置事务管理等。
- interceptor:用于存放SpringMVC的拦截器。
- model:用于存放数据模型相关的实体类。
- util:用于存放工具类。
- web:用于存放SpringMVC的控制器。
2.2 src/main/resources目录src/main/resources目录是存放配置文件和资源文件的默认目录,它包括以下几个子目录:- static:用于存放静态资源文件,如CSS、JavaScript、图片等。
- templates:用于存放模板文件,如HTML、Thymeleaf模板等。
- application.properties:存放项目的配置信息,如数据库配置、端口配置等。
- logback.xml:存放日志配置,如日志级别、输出路径等。
- mapper:存放MyBatis的Mapper.xml文件。
Spring配置数据源的四种方式
Spring配置数据源的四种方式Spring框架支持四种数据源的配置:1.自带数据源(DriverManagerDataSource)2.DBCP数据源3.C3P0数据源4.JNDI数据源准备:2.Spring-config.xml中引入配置文件(注册JDBC属性配置文件)方式二:(需要添加context约束)第二种方式:DBCP数据源便Spring容器关闭时,数据源能够正常关闭。
除以上必须的数据源属性外,还有一些常用的属性:defaultAutoCommit:设置从数据源中返回的连接是否采用自动提交机制,默认值为true;defaultReadOnly:设置数据源是否仅能执行只读操作,默认值为false;maxActive:最大连接数据库连接数,设置为0时,表示没有限制;maxIdle:最大等待连接中的数量,设置为0时,表示没有限制;maxWait:最大等待秒数,单位为毫秒,超过时间会报出错误信息;validationQuery:用于验证连接是否成功的查询SQL语句,SQL语句必须至少要返回一行数据,如你可以简单地设置为:“select count(*) from user”;removeAbandoned:是否自我中断,默认是false ;removeAbandonedTimeout:几秒后数据连接会自动断开,在removeAbandoned为true,提供该值;logAbandoned:是否记录中断事件,默认为false;第三种方式:C3P0数据源们就可以保证Spring容器关闭时数据源能够成功释放。
acquireIncrement:当连接池中的连接用完时,C3P0一次性创建新连接的数目;acquireRetryAttempts:定义在从数据库获取新连接失败后重复尝试获取的次数,默认为30;acquireRetryDelay:两次连接中间隔时间,单位毫秒,默认为1000;autoCommitOnClose:连接关闭时默认将所有未提交的操作回滚。
Spring中bean的四种注入方式
Spring 中bean 的四种注⼊⽅式⼀、前⾔ 最近在复习的相关内容,这篇博客就来记录⼀下为的属性注⼊值的四种⽅式。
这篇博客主要讲解在⽂件中,如何为的属性注⼊值,最后也会简单提⼀下使⽤注解的⽅式。
废话不多说,直接开始吧。
⼆、正⽂2.1 注⼊⽅式 在中,共有四种⽅式为的属性注⼊值,分别是:set ⽅法注⼊构造器注⼊静态⼯⼚注⼊实例⼯⼚注⼊ 下⾯我就分别演⽰⼀下,如何使⽤这四种⽅式进⾏属性的注⼊。
2.2 set ⽅法注⼊ 在演⽰前,我们需要准备⼏个类,我使⽤下⾯两个类来进⾏注⼊的演⽰,这两个类分别是和类:Spring Spring bean xml bean Spring bean User Car public class Car {// 只包含基本数据类型的属性private int speed;private double price;public Car() {}public Car(int speed, double price) {this.speed = speed;this.price = price;}public int getSpeed() {return speed;}public void setSpeed(int speed) { this.speed = speed;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}@Overridepublic String toString() {return "Car{" +"speed=" + speed + ", price=" + price + '}';}}public class User {private String name;private int age;// 除了上⾯两个基本数据类型的属性,User 还依赖Carprivate Car car;public User() {}public User(String name, int age, Car car) { = name;this.age = age;this.car = car;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Car getCar() { 有了上⾯两个类,我们就可以演⽰注⼊了。
spring配置详解
spring配置详解1.前⾔公司⽼项⽬的后台,均是基于spring框架搭建,其中还⽤到了log4j.jar等开源架包。
在新项⽬中,则是spring和hibernate框架均有使⽤,利⽤了hibernate框架,来实现持久化,简化sql操作等。
Hibernate配置⽂件可以有两种格式,⼀种是 hibernate.properties,另⼀种是hibernate.cfg.xml。
后者稍微⽅便⼀些,当增加hbm映射⽂件的时候,可以直接在 hibernate.cfg.xml ⾥⾯增加,不必像 hibernate.properties 必须在初始化代码中加⼊。
我们新项⽬中使⽤的是hibernate.cfg.xml格式。
不过在本⽂中不将细述,后续有机会再补上。
公司项⽬中,中间件主要有tomcat,webshpere,WebLogic。
以下,将对项⽬中spring基本配置,log4j的配置,还有中间件的相关参数配置做⼀个初步的介绍。
2.spring配置——以⽼GIS项⽬为例⼦GISV13中的配置涉及到了SpringMVC,IOC,AOP, Quartz⽅⾯的配置。
配置的实现是通过注记配置和XML配置来合作实现。
这⾥,我将按照Spring的配置流程,将其他⼏个⽅⾯的配置融合其中,来进⾏全⾯解析。
2.1SpringMVC的配置2.1.1.web.xml的配置Web程序中,当中间件启动时,中间件会⾸先读取web.xml中的配置。
在web.xml中可以配置监听器,过滤器,servlet映射等等。
在Spring 框架中,我们主要需配置容器初始化时读取的spring容器配置⽂件的路径以及springMVC中的分发器DispatcherServlet。
在GISV13的web.xml中,我们定义了如下内容:InitGISConfigServlet定义了容器启动时,⾸先要运⾏这个⽅法。
然后servletname为MVC的这部分便是定义了springMVC的分发器以及此servlet所对应的加载配置⽂件的路径。
spring的5中事务配置方式
Spring事务配置的五种方式这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用Hibernate 进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为HibernateTransactionManager。
具体如下图:Spring事务配置根据代理机制的不同,总结了五种Spring事务的配置方式,配置文件如下:第一种方式:每个Bean都有一个代理1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/context9. /schema/context/spring-context-2.5.xsd10. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">11.12.<bean id="sessionFactory"13.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">14.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>15.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>16.</bean>17.18.<!-- 定义事务管理器(声明式的事务) -->19.<bean id="transactionManager"20.class="org.springframework.orm.hibernate3.HibernateTransactionManager">21.<property name="sessionFactory"ref="sessionFactory"/>22.</bean>23.24.<!-- 配置DAO -->25.<bean id="userDaoTarget"class="erDaoImpl">26.<property name="sessionFactory"ref="sessionFactory"/>27.</bean>28.29.<bean id="userDao"30.class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">31.<!-- 配置事务管理器 -->32.<property name="transactionManager"ref="transactionManager"/>33.<property name="target"ref="userDaoTarget"/>34.<property name="proxyInterfaces"value="com.bluesky.spring.dao.GeneratorDao"/>35.<!-- 配置事务属性 -->36.<property name="transactionAttributes">37.<props>38.<prop key="*">PROPAGATION_REQUIRED</prop>39.</props>40.</property>41.</bean>42.</beans>第二种方式:所有Bean共享一个代理基类1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/context9. /schema/context/spring-context-2.5.xsd10. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">11.12.<bean id="sessionFactory"13.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">14.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>15.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>16.</bean>17.18.<!-- 定义事务管理器(声明式的事务) -->19.<bean id="transactionManager"20.class="org.springframework.orm.hibernate3.HibernateTransactionManager">21.<property name="sessionFactory"ref="sessionFactory"/>22.</bean>23.24.<bean id="transactionBase"25.class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"zy-init="true"abstract="true">27.<!-- 配置事务管理器 -->28.<property name="transactionManager"ref="transactionManager"/>29.<!-- 配置事务属性 -->30.<property name="transactionAttributes">31.<props>32.<prop key="*">PROPAGATION_REQUIRED</prop>33.</props>34.</property>35.</bean>36.37.<!-- 配置DAO -->38.<bean id="userDaoTarget"class="erDaoImpl">39.<property name="sessionFactory"ref="sessionFactory"/>40.</bean>41.42.<bean id="userDao"parent="transactionBase">43.<property name="target"ref="userDaoTarget"/>44.</bean>45.</beans>第三种方式:使用拦截器1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/context9. /schema/context/spring-context-2.5.xsd10. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">11.12.<bean id="sessionFactory"13.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">14.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>15.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>16.</bean>17.18.<!-- 定义事务管理器(声明式的事务) -->19.<bean id="transactionManager"20.class="org.springframework.orm.hibernate3.HibernateTransactionManager">21.<property name="sessionFactory"ref="sessionFactory"/>22.</bean>23.24.<bean id="transactionInterceptor"25.class="org.springframework.transaction.interceptor.TransactionInterceptor">26.<property name="transactionManager"ref="transactionManager"/>27.<!-- 配置事务属性 -->28.<property name="transactionAttributes">29.<props>30.<prop key="*">PROPAGATION_REQUIRED</prop>31.</props>32.</property>33.</bean>34.35.<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">36.<property name="beanNames">37.<list>38.<value>*Dao</value>39.</list>40.</property>41.<property name="interceptorNames">42.<list>43.<value>transactionInterceptor</value>44.</list>45.</property>46.</bean>47.48.<!-- 配置DAO -->49.<bean id="userDao"class="erDaoImpl">50.<property name="sessionFactory"ref="sessionFactory"/>51.</bean>52.</beans>第四种方式:使用tx标签配置的拦截器1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xmlns:tx="/schema/tx"7.xsi:schemaLocation="/schema/beans8. /schema/beans/spring-beans-2.5.xsd9. /schema/context10. /schema/context/spring-context-2.5.xsd11. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd12. /schema/tx /schema/tx/spring-tx-2.5.xsd">13.14.<context:annotation-config/>15.<context:component-scan base-package="com.bluesky"/>16.17.<bean id="sessionFactory"18.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">19.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>20.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>21.</bean>22.23.<!-- 定义事务管理器(声明式的事务) -->24.<bean id="transactionManager"25.class="org.springframework.orm.hibernate3.HibernateTransactionManager">26.<property name="sessionFactory"ref="sessionFactory"/>27.</bean>28.29.<tx:advice id="txAdvice"transaction-manager="transactionManager">30.<tx:attributes>31.<tx:method name="*"propagation="REQUIRED"/>32.</tx:attributes>33.</tx:advice>34.35.<aop:config>36.<aop:pointcut id="interceptorPointCuts"37.expression="execution(* com.bluesky.spring.dao.*.*(..))"/>38.<aop:advisor advice-ref="txAdvice"39.pointcut-ref="interceptorPointCuts"/>40.</aop:config>41.</beans>第五种方式:全注解1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xmlns:tx="/schema/tx"7.xsi:schemaLocation="/schema/beans8. /schema/beans/spring-beans-2.5.xsd9. /schema/context10. /schema/context/spring-context-2.5.xsd11. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd12. /schema/tx /schema/tx/spring-tx-2.5.xsd">13.14.<context:annotation-config/>15.<context:component-scan base-package="com.bluesky"/>16.17.<tx:annotation-driven transaction-manager="transactionManager"/>18.19.<bean id="sessionFactory"20.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">21.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>22.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>23.</bean>24.25.<!-- 定义事务管理器(声明式的事务) -->26.<bean id="transactionManager"27.class="org.springframework.orm.hibernate3.HibernateTransactionManager">28.<property name="sessionFactory"ref="sessionFactory"/>29.</bean>30.31.</beans>此时在DAO上需加上@Transactional注解,如下:1.package com.dawnsky.spring.dao;2.3.import java.util.List;4.5.import org.hibernate.SessionFactory;6.import org.springframework.beans.factory.annotation.Autowired;7.import org.springframework.orm.hibernate3.support.HibernateDaoSupport;8.import ponent;9.10.import er;11.12.@Transactional13.@Component("userDao")14.public class UserDaoImpl extends HibernateDaoSupport implements UserDao {15.16.public List<User> listUsers() {17.return this.getSession().createQuery("from User").list();18. }19.}。
SpringBean几种注入方式——setter(常用),构造器,注入内部Bean,注入集。。。
SpringBean⼏种注⼊⽅式——setter(常⽤),构造器,注⼊内部Bean,注⼊集。
依赖注⼊分为三种⽅式:1.1构造器注⼊ 构造器通过构造⽅法实现,构造⽅法有⽆参数都可以。
在⼤部分情况下我们都是通过类的构造器来创建对象,Spring也可以采⽤反射机制通过构造器完成注⼊,这就是构造器注⼊的原理。
代码清单:构造器注⼊1package com.spring.chapter3;23public class Role {45private long id;6private String roleName;78public Role(long id,String roleName){9this.id=id;10this.roleName=roleName;1112 }13public void getCount(){14 System.out.println("Role已被调⽤"+"\n"+"id:"+id+"\n"+"roleName:"+roleName);1516 }1718 } 代码清单:构造器配置1<bean id="Role" class="com.spring.chapter3.Role">2<constructor-arg index="0" value="007"></constructor-arg>3<constructor-arg index="1" value="zhangqiang"></constructor-arg>4</bean>元素名作⽤优缺点constructor-arg元素⽤于定义类构造⽅法的参数注⼊简单,不宜参数过多index⽤于定义对应类构造⽅法的参数位置value设置值1.2使⽤setter注⼊ setter注⼊是Spring中最主流的注⼊⽅法(常⽤),好处就不⽤多说了。
Spring中XML配置文件的十二个最佳方法
本文介绍Spring中XML配置文件的十二个最佳方法中的前六个,包括使用简洁形式,使用命名约定等。
1。
避免使用自动绑定(autowiring)功能Spring 可以通过bean类的自省自动绑定依赖性,所以不必显式指明bean的属性和构造函数。
Bean属性可以通过属性名称或类型匹配来实现自动绑定。
构造函数通过类型匹配来实现自动绑定。
甚至可以指定自动检测autowiring模式,它可以引导Spring选择一种适当的运行机制。
先来看看下面的一个例子:1.<bean id="orderService"2.class="com.lizjason.spring.OrderService"3.autowire="byName"/>OrderService 类的属性名在容器中用于匹配bean实例。
自动绑定可能会节省一些键入工作量并减少混乱。
但是在现实项目中不应该使用这种方式,因为它牺牲了配置的可读性和可维护性。
许多指南和介绍中大肆吹捧自动绑定是Spring的一项极好的特性,而没有提到这一特性所带来的牺牲。
依我来看,这就像Spring中的对象池(object-pooling),更大程度上只是宣传的噱头。
对于精简XML配置文件来说,它是一个好办法,但它实际上增加了复杂性,尤其是在运行包含大量类声明的项目时。
虽然Spring允许混合使用自动绑定和显式绑定,但这会使XML配置更加晦涩难懂。
2.使用命名约定该原则对于Java编码也一样适用。
在项目中使用清晰的、描述性的、一致的命名约定将非常有利于开发人员理解XML配置。
例如,对于bean ID,可以按照Java类字段名约定来命名它。
OrderServiceDAO实例的bean ID应该命名为orderServiceDAO。
对于大型项目,可以在bean ID前面加上包名作为前缀。
3. 使用简洁形式简洁形式避免了冗长,因为它将属性值和引用从子元素中移入属性中。
Spring中自动装配的4种方式
Spring中⾃动装配的4种⽅式Spring容器可以在不使⽤<constructor-arg>和<property>元素的情况下⾃动装配相互协作的bean之间的关系,助于减少编写⼀个⼤的基于Spring的应⽤程序的XML配置的数量使⽤<bean>元素的autowire属性为⼀个bean定义指定⾃动装配模式。
在Spring中,我们有4种⽅式可以装配Bean的属性。
1,byName通过byName⽅式⾃动装配属性时,是在定义Bean的时候,在property标签中设置autowire属性为byName,那么Spring会⾃动寻找⼀个与该属性名称相同或id相同的Bean,注⼊进来。
2,byType通过byType⽅式⾃动注⼊属性时,是在定义Bean的时候,在property标签中设置autowire属性为byType,那么Spring会⾃动寻找⼀个与该属性类型相同的Bean,注⼊进来。
3,constructor通过构造器⾃动注⼊。
在定义Bean时,在bean标签中,设置autowire属性为constructor,那么,Spring会寻找与该Bean的构造函数各个参数类型相匹配的Bean,通过构造函数注⼊进来。
4,autodetect⾃动装配。
如果想进⾏⾃动装配,但不知道使⽤哪种类型的⾃动装配,那么就可以使⽤autodetect,让容器⾃⼰决定。
这是通过在定义Bean时,设置bean标签的autowire属性为autodetect来实现的。
设置为autodetect时,Spring容器会⾸先尝试构造器注⼊,然后尝试按类型注⼊。
默认情况下,Spring是不进⾏⾃动装配的。
我们可以在xml中,设置beans标签的default-autowire属性为byName,byType 等,来设置所有bean都进⾏⾃动装配。
总结以上就是这篇⽂章的全部内容了,希望本⽂的内容对⼤家的学习或者⼯作具有⼀定的参考学习价值,谢谢⼤家对的⽀持。
Spring@Configuration注解及配置方法
Spring@Configuration注解及配置⽅法Spring @Configuration注解Spring3.0开始,@Configuration⽤于定义配置类,定义的配置类可以替换xml⽂件,⼀般和@Bean注解联合使⽤。
@Configuration注解主要标注在某个类上,相当于xml配置⽂件中的<beans>@Bean注解主要标注在某个⽅法上,相当于xml配置⽂件中的<bean>等价于注意:@Configuration注解的配置类有如下要求:@Configuration不可以是final类型;@Configuration不可以是匿名类;嵌套的configuration必须是静态类。
Configuration⾥⾯有⼀个component组件来标识,说明此类也是⼀个bean,可以被调⽤,来看看哪些主要的注解含有component:Annotation 的装配 Spring 中,尽管使⽤ XML 配置⽂件可以实现 Bean 的装配⼯作,但如果应⽤中有很多 Bean 时,会导致 XML 配置⽂件过于靡肿,给后续的维护和升级⼯作带来⼀定的困难为此, Spring 提供了对 Annotation (注解)技术的全⾯⽀持 Spring 中定义了⼀系列的注解,常⽤的注解如下所⽰• @Component: 可以使⽤此注解描述 Spring 中的 Bean ,但它是⼀个泛化的概念,仅仅表⽰⼀个组件 (Bean ,并且可以作⽤在任何层次使⽤时只需将该注解标注在相应类上即可• @Repository: ⽤于将数据访问层( DAO 层)的类标识为 Spring 中的 Bean ,其功能与 @Component 相同• @Service: 通常作⽤在业务层( Service ,⽤于将业务层的类标识为 Spring 中的 Bean 其功能与@Component 相同• @Controller: 通常作⽤在控制层(如 Spring MVC Controller ,⽤于将控制层的类标识 Spring 中的 Bean ,其功能与@Component 相同• @Autowired: ⽤于对 Bean 的属性变量、属性的 setter ⽅法及构造⽅法进⾏标注,配合对应的注解处理器完成 Bean 的⾃动配置⼯作默认按照 Bean 的类型进⾏装配• @Resource: 其作⽤与 Autowired ⼀样其区别在于@Autowired 默认按照 Bean 类型装配,⽽@Resource 默认按照 Bean 实例名称进⾏装配 @Resource 中有两个重要属性: name type Spring name 属性解析为 Bean 实例名称, type 属性解析为 Bean 实例类型如果指定 name 属性,贝IJ 按实例名称进⾏装配;如果指定 type 属性,则按 Bean 类型进⾏装配;如果都不指定,则先按 Bean 实例名称装配,如果不能匹配,再按照 Bean 类型进⾏装⾃⼰;如果都⽆法匹配,则抛出NoSuchBeanDefinitionException 异常• @Qualifier: @Autowired 注解配合使⽤,会将默认的按 Bean 类型装配修改为接 Bean 的实例名称装配, Bean 的实例名称由 @Qualifier 注解的参数指定在上⾯⼏个注解中,虽然@Repository @Service @Controller 功能与@Component 注解的功能相同,但为了使标注类本⾝⽤途更加清晰,建议在实际开发中使⽤@Repository @Service @Controller 分别对实现类进⾏标注下⾯。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
如果在项目里面能看到下面的库文件,说明已经安装成功。
image
事务配置
首先在/WEB-INF/applicationContext.xml添加以下内容:
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="mySessionFactory"/>
</property>
</bean>
注:这是作为公共使用的事务管理器Bean。这个会是事先配置好的,不需各个模块各自去配。
下面就开始配置各个模块所必须的部分,在各自的applicationContext-XXX-beans.xml配置的对于事务管理的详细信息。
项目使用SSH架构,现在要添加Spring事务管理功能,针对当前环境,只需要添加Spring 2.0 AOP类库即可。添加方法:
点击项目右键->Build Path->Add librarys:
9(V[673_ZRWHP65{U81tes>
</tx:advice>
<!-- 配置参与事务的类 -->
<aop:config>
<aop:pointcut id="allTestServiceMethod" expression="execution(* com.test.testAda.test.model.service.*.*(..))"/>
打开Add Libraries对话框,然后选定 MyEclipse Libraries:
image
点击Next,找到Spring 2.0 aop Libraries并勾选上,点击finsh即可。
图解:
image
下面附上配置声明式事务的一些相关的资料,以下资料均来源于互联网:
附一、Spring事务类型详解
附二、对spring事务类型详解的一点补充(关于嵌套事务)
附三、Transaction后缀给声明式事务管理带来的好处
附四、Spring中的四种声明式事务的配置
propagation="REQUIRED"代表支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
(3) aop:pointcut标签配置参与事务的类,由于是在Service中进行数据库业务操作,配的应该是包含那些作为事务的方法的Service类。
首先应该特别注意的是id的命名,同样由于每个模块都有自己事务切面,所以我觉得初步的命名规则因为 all+模块名+ServiceMethod。而且每个模块之间不同之处还在于以下一句:
一旦你有这样的要求那嵌套事务类型就非常适合你!我们可以这样理解,
一:将“从A用户帐户里面减去100元钱” 和 “往B用户帐户里面增加100元钱”我们暂时认为是一级事务操作
二:将从A用户的3个帐户的任意一个帐户里面减钱看做是“从A用户帐户里面减去100元钱”这个一级事务的子事务(二级事务),同样把后面存钱的看成是另一个的二级事务。
<tx:method name="find*" propagation="REQUIRED"/>
<tx:method name="get*" propagation="REQUIRED"/>
<tx:method name="apply*" propagation="REQUIRED"/>
首先就是配置事务的传播特性,如下:
<!-- 配置事务传播特性 -->
<tx:advice id="TestAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
问题一:当二级事务被rollback一级事务会不会被rollback?
答案是不会的,二级事务的rollback只针对自己。
问题二:什么时候这个一级事务会commit,什么时候会被rollback呢?
我们主要看二级里面出现的情况,当所有的二级事务被commit了并且一级事务没有失败的操作,那整个事务就算是一个成功的事务,这种情况整个事务会被commit。
Spring中常用事务类型:
PROPAGATION_REQUIRED--支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS--支持当前事务,如果当前没有事务,就以非事务方式执行。
PROPAGATION_MANDATORY--支持当前事务,如果当前没有事务,就抛出异常。
· PROPAGATION_SUPPORTS--支持当前事务,如果当前没有事务,就以非事务方式执行。
· PROPAGATION_MANDATORY--支持当前事务,如果当前没有事务,就抛出异常。
· PROPAGATION_REQUIRES_NEW--新建事务,如果当前存在事务,把当前事务挂起。
expression="execution(* com.test.testAda.test.model.service.*.*(..))"
其中第一个*代表返回值,第二*代表service下子包,第三个*代表方法名,“(..)”代表方法参数。
(4) aop:advisor标签就是把上面我们所配置的事务管理两部分属性整合起来作为整个事务管理。
PROPAGATION_REQUIRES_NEW--新建事务,如果当前存在事务,把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行,如果当前存在事务,则抛出异常。
PROPAGATION_NESTED--如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则进行与PROPAGATION_REQUIRED类似的操作。
附二、对spring事务类型详解的一点补充(关于嵌套事务)
· PROPAGATION_REQUIRED--支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
看了一下觉得上面的例子好像不是很深刻,看这个情况(A用户的3个帐户都是有信用额度的,也就是说可以超支,但是超支有金额限制)。不过原理是一样的,简单点也好说明一点,祝你好运!^_^
附三、Transaction后缀给声明式事务管理带来的好处
良好的面向对象的程序,一般都使用接口和实现分离的模式。我在《事务管理最佳实践全面解析》一文中提出,用*Transaction和*Dao后缀这样的形式,区分方法的不同用途。
附一、Spring事务类型详解
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop><prop key="store*">PROPAGATION_REQUIRED</prop>
估计有好多朋友还没有弄清楚里面的值的意思,仔细看完下面应该知道自己什么情况下面应该使用什么样的声明。^_^
(2) tx:attribute标签所配置的是作为事务的方法的命名类型。
如<tx:method name="save*" propagation="REQUIRED"/>
其中*为通配符,即代表以save为开头的所有方法,即表示符合此命名规则的方法作为一个事务。
<prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="modify*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
这样,可以提醒接口的实现者和方法的使用者注意到它们对于数据库连接和事务的依赖。
实际上,使用*Transaction后缀这样的命名方式,对于声明式事务管理也是很有用处的。如,Spring的事务管理中,我们一般使用方法名的匹配来应用声明式事务。
一、请看下面的Spring配置:
<bean id="txProxyTemplate" abstract="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
PROPAGATION_NESTED: 嵌套事务类型,是相对上面提到的六种情况(上面的六种应该称为平面事务类型),打个比方我现在有一个事务主要有一下几部分: