spring事物管理是怎么实现的

Spring框架简介

Spring框架是一个2003年2月才出现的开源项目，该开源项目起源自Rod Johnson在2002年末出版的《Expert One-on-One J2EE Design and Development》一书中的基础性代码。在该书中，Rod Johnson倡导J2EE实用主义的设计思想，而Spring框架正是这一思想的更全面和具体的实现。Spring框架由一个容器，一个配置和组织组件 的框架，和一组内置的为事务、持久化和Web用户接口提供的服务组成。作为一种轻量级的J2EE框架，Spring提供了一种有效的方式来建立和组织 J2EE应用程序。

Spring特性

IoC(Inversion of Control；控制反转)；又称DI(Dependency Injection；依赖注入)；是面向对象领域新兴的编程思想；也是Spring的精髓所在。简单地说；IoC就是指程序之间的关系由容器来控制；而不 是传统实现中由程序代码直接 *** 控。这也就是所谓“控制反转”的概念所在：控制权由应用代码转到外部容器，控制权的转移，也就是所谓的反转。IoC将控制创 建的职责搬进了框架中；并把它从应用代码脱离开来。当使用Spring的IoC容器时只需指出组件需要的对象，在运行时Spring的IoC容器会根据 XML配置数据提供给它。

Spring IoC，借助于依赖注入设计模式，使得开发者不用理会对象自身的生命周期及其关系，而且能够改善开发者对模式的使用。对于一个对象的管理不是什么困难，难 就难在对整个对象群的管理。依赖注入可以让容器管理对象，即“Don’t call me, I will call you”。这样对象本身的生命周期以及对象之间的关系就不再让开发者费神了。

Spring AOP，借助于Spring实现拦截器，开发者能够实现以声名方式使用企业级服务，比如安全性服务、事务服务。AOP 合理的补充了OOP，借助于Spring AOP，开发者能够高效的使用J2EE服务。

Spring服务抽象，借助于各种J2EE API抽象，使得开发者能够一致地使用J2EE 技术，而不管具体是使用什么J2EE API，借助于Spring服务抽象，使代码大大减少，满足“更少代码，更少BUG”的软件设计原则。

Spring IoC+Spring AOP+Spring服务抽象，一起形成Spring，这样一个有机体，使构建轻量级J2EE成为可能。

Spring事务管理

Spring事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活方便。

1传统使用JDBC的事务管理

以往使用JDBC进行数据 *** 作，使用DataSource，从数据源中得到Connection，我们知道数据源是线程安全的，而连接不是线程安全 的，所以对每个请求都是从数据源中重新取出一个连接。一般的数据源由容器进行管理，包括连接池。例如TOMCAT，WEBSPHERE，WEBLOGIC 等这些J2EE商业容器都提供了这个功能。

以往的我们使用JDBC在写代码时，事务管理可能会是这样：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

Connection conn = null;

try{

conn = DBConnectionFactorygetConnection;

connsetAutoCommit(false);

//do something

conncommit(); //commit transcation

}catch(Exception e)

finally catch(SQLException se){ //do sth}

//close ResultSet,PreparedStatement,Connection

//notice:Maybe ocurr Exception when u close rs,pstmt,conn

}

按照以往的思路来写代码，代码量比较长，而且容易疏忽，忘掉一些try/catch，引发一些异常无法catch，虽然有时候我们会写DBTool类，来关闭这些资源，并且保证在关闭这些资源时，不向外抛异常，但是这样做会导致额外的麻烦。

2Spring事务管理提供的编程式

Spring提供了几个关于事务处理的类：

TransactionDefinition //事务属性定义

TranscationStatus //代表了当前的事务，可以提交

Spring+Hibernate的实质：

就是把Hibernate用到的数据源Datasource，Hibernate的SessionFactory实例，事务管理器HibernateTransactionManager，都交给Spring管理。

那么再没整合之前Hibernate是如何实现事务管理的呢？

通过ServletFilter实现数据库事务的管理，这样就避免了在数据库 *** 作中每次都要进行数据库事务处理。

一事务的4个特性：

原子性：一个事务中所有对数据库的 *** 作是一个不可分割的 *** 作序列，要么全做，要么全部做。

一致性：数据不会因为事务的执行而遭到破坏。

隔离性：一个事务的执行，不受其他事务（进程）的干扰。既并发执行的个事务之间互不干扰。

持久性：一个事务一旦提交，它对数据库的改变将是永久的。

二事务的实现方式：

实现方式共有两种：编码方式；声明式事务管理方式。

基于AOP技术实现的声明式事务管理，实质就是：在方法执行前后进行拦截，然后在目标方法开始之前创建并加入事务，执行完目标方法后根据执行情况提交或回滚事务。

声明式事务管理又有两种方式：基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中。

三创建事务的时机：

是否需要创建事务，是由事务传播行为控制的。读数据不需要或只为其指定只读事务，而数据的插入，修改，删除就需要事务管理了。

一种常见的事务管理配置：事务拦截器TransactionInterceptor和事务自动代理BeanNameAutoProxyCreator相结合的方式

<!--定义Hibernate的事务管理器HibernateTransactionManager -->

<bean id="transactionManager"

class="orgspringframeworkormhibernate3HibernateTransactionManager">

<!-- 依赖注入上面定义的sessionFactory -->

<property name="sessionFactory" ref="sessionFactory"/>

</bean>

<!--定义Spring的事务拦截器TransactionInterceptor -->

<bean id="transactionInterceptor" class="orgspringframeworktransactioninterceptorTransactionInterceptor">

<!-- 依赖注入上面定义的事务管理器transactionManager -->

<property name="transactionManager" ref="transactionManager"/>

<!-- 定义需要进行事务拦截的方法及所采用的事务控制类型 -->

<property name="transactionAttributes">

<props>

<!-- 以browse、list、load、get及is开头的所有方法采用只读型事务控制类型 -->

<prop key="browse">PROPAGATION_REQUIRED,readOnly</prop>

<prop key="list">PROPAGATION_REQUIRED,readOnly</prop>

<prop key="load">PROPAGATION_REQUIRED,readOnly</prop>

<prop key="get">PROPAGATION_REQUIRED,readOnly</prop>

<prop key="is">PROPAGATION_REQUIRED,readOnly</prop>

<!-- 所有方法均进行事务控制，如果当前没有事务，则新建一个事务 -->

<prop key="">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

<!-- 定义BeanNameAutoProxyCreatorf进行Spring的事务处理-->

<bean class="orgspringframeworkaopframeworkautoproxyBeanNameAutoProxyCreator">

<!-- 针对指定的bean自动生成业务代理 -->

<property name="beanNames">

<list>

<value>adminService</value>

<value>columnsService</value>

<value>newsService</value>

<value>crawlService</value>

<value>memberLevelService</value>

<value>memberService</value>

<value>categoryService</value>

<value>merService</value>

<value>cartService</value>

<value>ordersService</value>

<value>trafficService</value>

</list>

</property>

<!-- 这个属性为true时，表示被代理的是目标类本身而不是目标类的接口 -->

<property name="proxyTargetClass">

<value>true</value>

</property>

<!-- 依赖注入上面定义的事务拦截器transactionInterceptor -->

<property name="interceptorNames">

<list>

<value>transactionInterceptor</value>

</list>

</property>

</bean>

aop原理：

AOP将业务逻辑组件和切面类都加入到容器中，负责在业务逻辑运行的时候将日志进行打印，切面类负责动态感知MathCalculatordiv运行到哪里然后执行。通过＠Aspect通知注解给切面类的目标方法标注何时何地运行。

在程序创建之前会根据切入点表达式对增强器进行一一匹配，最终拿到所有的增强器。创建代理对象过程中，会先创建一个代理工厂，获取到所有的增强器（通知方法），将这些增强器和目标类注入代理工厂，再用代理工厂创建对象。

AOP的组成：

1、方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的Advisor或拦截器实现。

2、连接点（Joinpoint）：程序执行过程中明确的点，如方法的调用或特定的异常被抛出。

3、通知（Advice）：在特定的连接点，AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。

首先将sessionFactory注入到HibernateTransactionManager中，再将HibernateTransactionManager对象注入到TransactionProxyFactoryBean对象中~应该还有一段对sessionFactory的定义

AOP就是面向代理的模式，本来一个应用程序要对某个对象进行 *** 作的，但是这个对象中包含了很多与他本身不相关的业务逻辑，不如日志、锁等等。所以就要想办法把这些无关的东西全部抽离出来。被抽离过的对象就是被代理对象。

此时应用程序再调用的时候，会去调用代理对象，这个对象中包含了对被代理对象的调用以及被抽离出来的无关的业务逻辑方法。被代理对象则是纯粹的业务逻辑。

至于触发的话因为在容器起来的时候，比如tomcat或者jboss，会定义到指定的xml文件然后这些谁注入到谁的东西会被自动识别的。

第一种：注解配置AOP

注解配置AOP（使用 AspectJ 类库实现的），大致分为三步：

1 使用注解@Aspect来定义一个切面，在切面中定义切入点(@Pointcut),通知类型(@Before, @AfterReturning,@After,@AfterThrowing,@Around)

2 开发需要被拦截的类。

3 将切面配置到xml中，当然，我们也可以使用自动扫描Bean的方式。这样的话，那就交由Spring AoP容器管理。

另外需要引用 aspectJ 的 jar 包： aspectjweaverjar aspectjrtjar

首先说下HibernateTemplate是spring的辅助类

事务的处理是使用了动态代理的设计模式，将事务处理作为一个独立的切面抽取出来，如果一个功能需要用到事务处理那么就在这个功能的基础上插入这个切面

因为要进行访问修改才生效

访问修饰符 public修饰的方法入口才能生效,否则springAop不切入,private 方法, final 方法 和 static 方法不能添加事务,加了也不生效。

楼上两位说的都很对，你的方式是将AOP的切点设置在DAO层中，但如此事务必然会回滚你的DAO同时回滚你的AOP方法；

而你这样的需求应该将两个过程解耦，DAO应该处于最底层，将AOP的切点移到DAO层之上。

事务、日志、分布式锁。

1、在软件业springaop可以使用的应用场景有事务，在标注Transactional注解的方法上，可以实现自动开启、提交、回滚事务。

2、日志，记录方法执行前的入参和执行后的结果。

3、分布式锁，由于大型软件架构都是分布式服务，当需要实现分布式锁时，可以利用AOP和自定义注解的方式，在Service执行前上锁，执行结束后解锁。

以上就是关于spring事物管理是怎么实现的全部的内容，包括:spring事物管理是怎么实现的、aop原理是什么、使用Spring AOP代理方式实现声明式事务的原理等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！