Spring事务配置的五种方式
spring MVC原理及配置
spring MVC原理及配置springmvc原理及配置springmvc原理及配置1.springmvc详述:springmvc就是spring提供更多的一个强悍而有效率的web框架。
借助注释,springmvc提供更多了几乎就是pojo的研发模式,使控制器的研发和测试更加直观。
这些控制器通常不轻易处置命令,而是将其委托给spring上下文中的其他bean,通过spring的倚赖转化成功能,这些bean被转化成至控制器中。
springmvc主要由dispatcherservlet、处理器映射、处理器(控制器)、视图解析器、视图组成。
他的两个核心是两个核心:处理器映射:选择使用哪个控制器来处理请求视图解析器:选择结果应该如何渲染通过以上两点,springmvc确保了如何挑选掌控处置命令和如何挑选视图展现出输入之间的松耦合。
2.springmvc运行原理这里写图片描述(2)找寻处理器:由dispatcherservlet控制器查阅一个或多个handlermapping,找出处置命令的controller。
(3)调用处理器:dispatcherservlet将请求提交到controller。
(4)(5)调用业务处置和回到结果:controller调用业务逻辑处置后,回到modelandview。
3.springmvc接口解释(1)dispatcherservlet接口:spring提供的前端控制器,所有的请求都有经过它来统一分发。
在dispatcherservlet将请求分发给springcontroller 之前,需要借助于spring提供的handlermapping定位到具体的controller。
(2)handlermappingUSB:能够完成客户请求到controller映射。
(3)controller接口:须要为mammalian用户处置上述命令,因此同时实现controllerUSB时,必须确保线程安全并且可以器重。
Spring核心技术详解
Spring核⼼技术详解⼀、Sring简介Spring是⼀个分层的Java SE/EE应⽤⼀站式的轻量级开源框架。
Spring核⼼是IOC和AOP。
Spring主要优点包括:⽅便解耦,简化开发,通过Spring提供的IoC容器,我们可以将对象之间的依赖关系交由Spring进⾏控制,避免硬编码造成的程序耦合度⾼。
AOP编程的⽀持,通过Spring提供的AOP功能,⽅便进⾏⾯向切⾯编程。
声明式事务的⽀持,在Spring中,我们可以从单调烦闷的事务管理代码中解脱出来,通过声明式⽅式灵活地进⾏事务的管理,提⾼开发效率和质量。
⽅便程序的测试,可以⽤⾮容器依赖的编程⽅式进⾏⼏乎所有的测试⼯作。
⽅便集成各种优秀框架,Spring提供了对各种优秀框架的直接⽀持。
⼆、Spring体系结构如下图所⽰,整个spring框架按其所属功能可以划分为五个主要模块,这五个模块⼏乎为企业应⽤提供了所需的⼀切,从持久层、业务层到表现层都拥有相应的⽀持,这就是为什么称Spring是⼀站式框架的原因。
核⼼模块(Core Container) Spring的核⼼模块实现了IoC的功能,它将类和类之间的依赖从代码中脱离出来,⽤配置的⽅式进⾏依赖关系描述。
由IoC容器负责类的创建,管理,获取等。
BeanFactory接⼝是Spring框架的核⼼接⼝,实现了容器很多核⼼的功能。
Context模块构建于核⼼模块之上,扩展了BeanFactory的功能,包括国际化,资源加载,邮件服务,任务调度等多项功能。
ApplicationContext是Context模块的核⼼接⼝。
表达式语⾔(Expression Language)是统⼀表达式语⾔(EL)的⼀个扩展,⽀持设置和获取对象属性,调⽤对象⽅法,操作数组、集合等。
使⽤它可以很⽅便的通过表达式和Spring IoC容器进⾏交互。
AOP模块Spring AOP模块提供了满⾜AOP Alliance规范的实现,还整合了AspectJ这种AOP语⾔级的框架。
springboot之手动控制事务
springboot之⼿动控制事务 ⼀、事务的重要性,相信在实际开发过程中,都有很深的了解了。
但是存在⼀个问题我们经常在开发的时候⼀般情况下都是⽤的注解的⽅式来进⾏事务的控制,说⽩了基于spring的7种事务控制⽅式来进⾏事务的之间的协调。
⼆、spring的7中事务传播⾏为Propagation.REQUIRED代表当前⽅法⽀持当前的事务,且与调⽤者处于同⼀事务上下⽂中,回滚统⼀回滚(如果当前⽅法是被其他⽅法调⽤的时候,且调⽤者本⾝即有事务),如果没有事务,则⾃⼰新建事务,Propagation.SUPPORTS代表当前⽅法⽀持当前的事务,且与调⽤者处于同⼀事务上下⽂中,回滚统⼀回滚(如果当前⽅法是被其他⽅法调⽤的时候,且调⽤者本⾝即有事务),如果没有事务,则该⽅法在⾮事务的上下⽂中执⾏Propagation.MANDATORY代表当前⽅法⽀持当前的事务,且与调⽤者处于同⼀事务上下⽂中,回滚统⼀回滚(如果当前⽅法是被其他⽅法调⽤的时候,且调⽤者本⾝即有事务),如果没有事务,则抛出异常Propagation.REQUIRES_NEW创建⼀个新的事务上下⽂,如果当前⽅法的调⽤者已经有了事务,则挂起调⽤者的事务,这两个事务不处于同⼀上下⽂,如果各⾃发⽣异常,各⾃回滚Propagation.NOT_SUPPORTED该⽅法以⾮事务的状态执⾏,如果调⽤该⽅法的调⽤者有事务则先挂起调⽤者的事务Propagation.NEVER该⽅法以⾮事务的状态执⾏,如果调⽤者存在事务,则抛出异常Propagation.NESTED如果当前上下⽂中存在事务,则以嵌套事务执⾏该⽅法,也就说,这部分⽅法是外部⽅法的⼀部分,调⽤者回滚,则该⽅法回滚,但如果该⽅法⾃⼰发⽣异常,则⾃⼰回滚,不会影响外部事务,如果不存在事务,则与PROPAGATION_REQUIRED⼀样 三、数据库四⼤特性和MySQL事务的隔离级别 1)四⼤特性 a、原⼦性(Atomicity) 原⼦性是指事务包含的所有操作要么全部成功,要么全部失败回滚。
实验一Spring环境配置
<beansxmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance"
xsi:schemaLocation="/schema/beans
传统J2EE应用的开发效率低,应用服务器厂商对各种技术的支持并没有真正统一,导致J2EE的应用没有真正实现Write Once及Run Anywhere的承诺。Spring作为开源的中间件,独立于各种应用服务器,甚至无须应用服务器的支持,也能提供应用服务器的功能,如声明式事务、事务处理等。
Spring致力于J2EE应用的各层的解决方案,而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择,并贯穿表现层、业务层及持久层。然而,Spring并不想取代那些已有的框架,而是与它们无缝地整合。
}
publicvoidrecharge(){
System.out.println("您好"+user.getAccount()+"用户,你的账户充值成功!");
System.out.println("充值金额为:"+user.getMoney());
}
publicvoidread(){
try(BufferedReader reader =newBufferedReader(
(三)Spring由哪些模块组成?它们分别有些什么作用?
Spring 框架是一个分层架构,由 7 个定义良好的模块组成。Spring模块构建在核心容器之上,核心容器定义了创建、配置和管理 bean 的方式,如图所示:
高级Java工程师面试题及答案
高级Java工程师面试题选择题各2分共44分1.下列说法正确的是A. Java语言不区分大小写B. Java程序以类为基本单位C. JVM为Java虚拟机JVM的英文缩写D. 运行Java程序需要先安装JDK答案:B,C,D2.下列说法中错误的是A. Java语言是编译执行的B. Java中使用了多进程技术C. Java的单行注视以//开头D. Java语言具有很高的安全性答案:A,B3.下面不属于Java语言特点的一项是A. 安全性B. 分布式C. 移植性D. 编译执行答案:D4.下列语句中,正确的项是A . int $ e,a,b=10;B. char c,d=’a’;C. float e=0.0d;D. double c=0.0f;答案ABD5.一个int 类型的常量和一个byte类型常量做减法,结果的类型是A. intB. byteC. charD. float答案A6.下列程序段的输出结果是public class Expressions{void printExpr(){int x=3,y=4,z=5;System.out.println(x+y+z);}}A. xyzB. x+y+zC. 12D. 9答案C7.下列关于for循环和while循环的说法中哪些是不正确的?A. for循环能实现的操作,while循环也都能实现B. for循环判断条件一般是非程序结果C. while循环判断条件一般是程序结果D. 两种循环结构中都必须有循环体,循环体不能为空答案ABC8.以下程序段执行后的K值为int x=10; y=34;k=(x<y)?y:x;A. 10B. 34C. 10D. 44答案B9.下列不属于Java语言流程控制结构是A.分支语句B.条转语句C.循环语句D.赋值语句E.答案D10.设定义语句:int a[ ]={43,44,45};则下面对此语句的叙述正确的是A.定义一个名为a的一维数组B.a数组有3个元素C.a数组的元素的下标为1~3D.数组中的每一个元素都是整型E.答案ABD11.运行以下代码public class Person{int array[]=new int[10];public static void main(String args[]){System.out.println(array [1]);}}正确的是A.编译时将产生错误B.编译时正确,运行时将产生错误C.输出零D.输出空答案A12.执行完下面语句int[ ]x = new int[20]; 后,说法正确的是A.x[19]为0B.x[19]未定义C.x[20]为0D.x[0]为空答案A13.设tmp是一个数组类成员,以下声明并初始化一个4个元素的数组选项A.int tmp[]={1,2,3,4};B.int tmp[]=new int[5];C.int tmp[]=new int(5);D.int tmp[];答案A14.设定义:String s=”cake”,下面不合法的有A.s=s. toUpperCase();B.char c=s[1];C.int len=s.length;D.s=s.trim();答案BC15.设String s1=”Hello”;String s2=”World”;以下方法用来得到字符串“Hello World”有A.s2+s1;B.s1.concat(s2);C.s1.append(s2);D.s1.concate(s2);答案B16.下面哪一个是Java最基本的元素A. 接口B. 方法C. 包D. 对象答案:D17.如果Cake.java、Ball.java这两个类总共包含有8个方法,则编译后会产生多少个字节码文件A. 12B. 10C. 2D. 1答案:C18.下面关于抽象类的理解,错误的是A. 构造方法可以声明为抽象类型B. 抽象方法必须被子类的方法覆盖C. 不允许实现抽象方法D. 方法声明中,static 和abstract不能同时存在答案:A19.编译Java程序时编译器提示找不到要编译的代码,这种错误通常可能是A. 文件名拼写错误B. 没有导入相应的包C. 文件名不是.javaD. 源文件不在Java搜索路径中答案:A,C,D20.捕获异常应该使用下列哪个子句A. throwB. catchC. finallyD. throws答案:B21.下列哪一项不属于finally语句的工作A. 关闭数据库B. 释放资源C. 关闭文件D.分配资源答案:D22.下面哪些需要异常处理机制A. 编译出错B. 方法、类中抛出的异常C. 使系统从故障中恢复D. 程序因不可避免的原因产生错误答案:B,C,D简述题每题3分共18分(1)用final声明属性、方法和类时,被声明的属性、方法和类表现出哪些特性?下面的实例正确吗?如果不正确,请说明原因?实例:final Test t = new Test();t.setName(“Jack”);答:final 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。
【SpringFramework】Spring入门教程(三)使用注解配置
【SpringFramework】Spring⼊门教程(三)使⽤注解配置本⽂主要介绍四个⽅⾯:(1) 注解版本IOC和DI(2) Spring纯注解(3) Spring测试(4) SpringJDBC - Spring对数据库的操作使⽤注解配置Spring⼊门说在前⾯学习基于注解的IoC配置,⼤家脑海⾥⾸先得有⼀个认知,即注解配置和xml配置要实现的功能都是⼀样的,都是要降低模块间的耦合度。
仅仅只是配置的形式不⼀样。
关于实际的开发中到底使⽤xml还是注解,每家公司有着不同的使⽤习惯。
所以这两种配置⽅式我们都需要掌握。
基于注解配置的⽅式也已经逐渐代替xml配置。
所以我们必须要掌握使⽤注解的⽅式配置Spring。
配置步骤注意:如果使⽤Eclipse需要先安装了STS插件,或者使⽤STS开发⼯具创建项⽬。
本⽂使⽤IDEA进⾏演⽰。
1.2.1. 第⼀步:拷贝必备jar包到⼯程的lib⽬录。
注意:在基于注解的配置中,我们还要多拷贝⼀个aop的jar包。
如下图:1.2.2. 第⼆步:在类的根路径下创建⼀个任意名称的xml⽂件(不能是中⽂)注意:基于注解整合时,Spring配置⽂件导⼊约束时需要多导⼊⼀个context命名空间下的约束。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"></beans>1.2.3. 第⼆步:创建⼀个服务类创建⼀个测试的服务类,并且加⼊使⽤@Component注解,声明该类允许注⼊到Spring容器package org.cjw.service;import ponent;/*使⽤注解配置时,需要将Spring框架启动就创建对象的类表⽰为组件类表⽰组件类使⽤@Component注解*/@Componentpublic class CustomerService {public void save() {System.out.println("-保存数据-");}}1.2.4. 第四步在spring的配置⽂件加⼊扫描注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"><!-- 声明扫描包及其⼦包的类,如果发现有组件注解的类,就创建对象并加⼊到容器中去 --><context:component-scan base-package="org.cjw" /></beans>1.2.5. 第五步:测试调⽤代码package org.cjw.test;import org.cjw.service.CustomerService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class CustomerServiceTest {@Testpublic void testSave() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");CustomerService customerService = context.getBean(CustomerService.class);customerService.save();}}--测试结果,如果可以调⽤服务⽅法,测试成功。
《Java EE企业级应用开发教程(Spring+Spring MVC+MyBatis)》_课后习题
第一章【思考题】1、请简述Spring框架的优点。
2、请简述什么是Spring的IoC和DI。
【答案】1、Spring框架的优点如下:(1)非侵入式设计:Spring是一种非侵入式(non-invasive)框架,它可以使应用程序代码对框架的依赖最小化。
(2)方便解耦、简化开发:Spring就是一个大工厂,可以将所有对象的创建和依赖关系的维护工作都交给Spring容器管理,大大的降低了组件之间的耦合性。
(3)支持AOP:Spring提供了对AOP的支持,它允许将一些通用任务,如安全、事务、日志等进行集中式处理,从而提高了程序的复用性。
(4)支持声明式事务处理:只需要通过配置就可以完成对事务的管理,而无需手动编程。
(5)方便程序的测试:Spring提供了对Junit4的支持,可以通过注解方便的测试Spring 程序。
(6)方便集成各种优秀框架:Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接支持。
(7)降低了Java EE API的使用难度:Spring对Java EE开发中非常难用的一些API (如:JDBC、JavaMail等),都提供了封装,使这些API应用难度大大降低。
2、IoC的全称是Inversion of Control,中文名称为控制反转。
控制反转就是指在使用Spring框架之后,对象的实例不再由调用者来创建,而是由Spring容器来创建,Spring 容器会负责控制程序之间的关系,而不是由调用者的程序代码直接控制。
这样,控制权由应用代码转移到了Spring容器,控制权发生了反转。
DI的全称是Dependency Injection,中文称之为依赖注入。
它与控制反转(IoC)的含义相同,只不过这两个称呼是从两个角度描述的同一个概念。
从Spring容器的角度来看,Spring容器负责将被依赖对象赋值给调用者的成员变量,这相当于为调用者注入了它依赖的实例,这就是Spring的依赖注入。
springboot在controller中添加事务
springboot在controller中添加事务在开发过程中,碰到了一个问题,一个接口中需要插入三条数据,需要保证三条数据全部成功或者三条数据全部失败,由于使用的是MytbatisPlus,所以没有考虑在service层进行处理,通过网上找资料,找到了如下解决办法:实体类:@Data@TableName(value = "student")@KeySequence(value = "seq_student", clazz = Integer.class) public class Student implements Serializable {@TableId(value = "id", type = IdType.INPUT)private Integer id;private String nam;private String cla;}mapper层、service层、serviceImpl层都是继承了mybatisPlus 的公共类,这里就不详细介绍了,我其他博客里有这些类的写法,下面直接上controller层:@RestController@RequestMapping("/student")public class StudentController {@Autowiredprivate StudentService studentService;//添加事务第一步引入platformTransactionManager对象@Autowiredprivate PlatformTransactionManager platformTransactionManager;@RequestMapping(value = "/insert" , method = RequestMethod.POST)public Object insert(@RequestBody Map<String,Object> map){//第二步不太理解都是什么方法但是需要添加到方法中DefaultTransactionDefinition definition = new DefaultTransactionDefinition();definition.setPropagationBehavior(TransactionDefinition.PR OPAGATION_REQUIRED);TransactionStatus status = platformTransactionManager.getTransaction(definition);//第三步加入try catch语句块try{String nam = map.get("nam").toString();String cla = map.get("cla").toString();Student s = new Student();s.setNam(nam);s.setCla(cla);//第一次调用保存studentService.insert(s);s.setNam("会当凌绝顶一览众山小写代码真开心");s.setCla("故意");//第二次手动加入错误数据因为数据库中该字段最多可输入五个字符当前nam值过大会导致插入报错studentService.insert(s);//mit(status);return "添加成功";}catch (Exception e){//第二次插入报错后会被try catch捕获,捕获后执行rollback操作,第一条数据回滚platformTransactionManager.rollback(status);}return "添加失败";}}并不是太理解代码的原理,但是这样做实现了需求,找机会在深入研究。
事务管理的五种方法
前段时间对Spring的事务配置做了比较深入的研究,在此之间对Spring的事务配置虽说也配置过,但是一直没有一个清楚的认识。
通过这次的学习发觉Spring的事务配置只要把思路理清,还是比较好掌握的。
总结如下:Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource、TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化,比如使用Hibernate进行数据访问时,DataSource实际为SessionFactory,TransactionManager的实现为HibernateTransactionManager。
具体如下图:根据代理机制的不同,总结了五种Spring事务的配置方式,配置文件如下:第一种方式:每个Bean都有一个代理<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/beans"xmlns:xsi="/XMLSchema-instance"xmlns:context="/context"xmlns:aop="/aop"xsi:schemaLocation="/beans/beans/spring-beans-/context/context/spring-context-/aop /aop/spring-aop-"><bean id="sessionFactory"class=""><property name="configLocation"value="classpath:"/><property name="configurationClass"value=""/></bean><!--定义事务管理器(声明式的事务)--><bean id="transactionManager"class=""><property name="sessionFactory"ref="sessionFactory"/> </bean><!--配置DAO--><bean id="userDaoTarget"class=""><property name="sessionFactory"ref="sessionFactory"/> </bean><bean id="userDao"class=""><!--配置事务管理器--><property name="transactionManager"ref="transactionManager"/> <property name="target"ref="userDaoTarget"/><property name="proxyInterfaces"value=""/><!--配置事务属性--><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>第二种方式:所有Bean共享一个代理基类<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/beans"xmlns:xsi="/XMLSchema-instance"xmlns:context="/context"xmlns:aop="/aop"xsi:schemaLocation="/beans/beans/spring-beans-/context/context/spring-context-/aop /aop/spring-aop-"><bean id="sessionFactory"class=""><property name="configLocation"value="classpath:"/><property name="configurationClass"value=""/></bean><!--定义事务管理器(声明式的事务)--><bean id="transactionManager"class=""><property name="sessionFactory"ref="sessionFactory"/></bean><bean id="transactionBase"class=""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=""><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="/beans"xmlns:xsi="/XMLSchema-instance"xmlns:context="/context"xmlns:aop="/aop"xsi:schemaLocation="/beans/beans/spring-beans-/context/context/spring-context-/aop /aop/spring-aop-"><bean id="sessionFactory"class=""><property name="configLocation"value="classpath:"/><property name="configurationClass"value=""/></bean><!--定义事务管理器(声明式的事务)--><bean id="transactionManager"class=""><property name="sessionFactory"ref="sessionFactory"/></bean><bean id="transactionInterceptor"class=""><property name="transactionManager"ref="transactionManager"/> <!--配置事务属性--><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean><bean class=""><property name="beanNames"><list><value>*Dao</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><!--配置DAO--><bean id="userDao"class=""><property name="sessionFactory"ref="sessionFactory"/> </bean></beans>第四种方式:使用tx标签配置的拦截器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/beans"xmlns:xsi="/XMLSchema-instance"xmlns:context="/context"xmlns:aop="/aop"xmlns:tx="/tx"xsi:schemaLocation="/beans/beans/spring-beans-/context/context/spring-context-/aop /aop/spring-aop-/tx /tx/spring-tx-"><context:annotation-config/><context:component-scan base-package="com.bluesky"/><bean id="sessionFactory"class=""><property name="configLocation"value="classpath:"/><property name="configurationClass"value=""/></bean><!--定义事务管理器(声明式的事务)--><bean id="transactionManager"class=""><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(* "/><aop:advisor advice-ref="txAdvice"pointcut-ref="interceptorPointCuts"/></aop:config></beans>第五种方式:全注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/beans"xmlns:xsi="/XMLSchema-instance"xmlns:context="/context"xmlns:aop="/aop"xmlns:tx="/tx"xsi:schemaLocation="/beans/beans/spring-beans-/context/context/spring-context-/aop /aop/spring-aop-/tx /tx/spring-tx-"><context:annotation-config/><context:component-scan base-package="com.bluesky"/><tx:annotation-driven transaction-manager="transactionManager"/><bean id="sessionFactory"class=""><property name="configLocation"value="classpath:"/><property name="configurationClass"value=""/></bean><!--定义事务管理器(声明式的事务)--><bean id="transactionManager"class=""><property name="sessionFactory"ref="sessionFactory"/></bean></beans>package;import;import;import;import;import;import;@Transactional@Component("userDao")public class UserDaoImpl extends HibernateDaoSupport implements UserDao {public List<User>listUsers() {return this.getSession().createQuery("from User").list();}}注意的几点:1、@Transactional只能被应用到public方法上,对于其他非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能。
Spring声明式事务注解之@EnableTransactionManagement解析
Spring声明式事务注解之@EnableTransactionManagement解析Spring声明式事务注解之@EnableTransactionManagement1. 说明@EnableTransactionManagement声明在主配置类上,表⽰开启声明式事务,其原理是通过@Import导⼊TransactionManagementConfigurationSelector组件,然后⼜通过TransactionManagementConfigurationSelector导⼊组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration;2. 原理分析@EnableTransactionManagement代码实现如下:@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented// 通过@Import导⼊TransactionManagementConfigurationSelector组件@Import(TransactionManagementConfigurationSelector.class)public @interface EnableTransactionManagement {boolean proxyTargetClass() default false;AdviceMode mode() default AdviceMode.PROXY;int order() default Ordered.LOWEST_PRECEDENCE;}@EnableTransactionManagement通过@Import导⼊TransactionManagementConfigurationSelector;TransactionManagementConfigurationSelector的实现如下:public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {/*** {@inheritDoc}* @return {@link ProxyTransactionManagementConfiguration} or* {@code AspectJTransactionManagementConfiguration} for {@code PROXY} and* {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()}, respectively*/@Overrideprotected String[] selectImports(AdviceMode adviceMode) {switch (adviceMode) {case PROXY:// 根据@EnableTransactionManagement的固定值PROXY,这⾥会导⼊AutoProxyRegistrar组件和ProxyTransactionManagementConfiguration组件 return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};case ASPECTJ:return new String[] {TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};default:return null;}}}所以TransactionManagementConfigurationSelector⼜导⼊了组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration;3. AutoProxyRegistrar分析3.1 AutoProxyRegistrar继承关系InfrastructureAdvisorAutoProxyCreator--AbstractAdvisorAutoProxyCreator--AbstractAdvisorAutoProxyCreator--ProxyProcessorSupport--SmartInstantiationAwareBeanPostProcessor // 跟AOP是原理是⼀样的--InstantiationAwareBeanPostProcessor--BeanPostProcessor--BeanFactoryAware3.2 AutoProxyRegistrar的所⽤AutoProxyRegistrar的作⽤跟AOP中的AnnotationAwareAspectJAutoProxyCreator是⼀样的,利⽤后置处理器机制在对象创建以后,包装对象,返回⼀个代理对象(增强器),代理对象执⾏⽅法利⽤拦截器链进⾏调⽤;InfrastructureAdvisorAutoProxyCreator继承SmartInstantiationAwareBeanPostProcessor,跟AOP的原理是⼀样的,也是通过@Transactional作为⽅法拦截的标记,把有事务管理的类作为⽬标类,⽣成代理对象,然后增强@Transactional标记的⽅法,在使⽤⽬标⽅法的时候,从IOC容器中获取的其实是被增强的代理类,且事务⽅法会被代理,跟AOP原理⼀样的;4. ProxyTransactionManagementConfiguration分析ProxyTransactionManagementConfiguration是⼀个配置类,想IOC容器中导⼊事务增强器(BeanFactoryTransactionAttributeSourceAdvisor),事务注解@Transactional的解析器(AnnotationTransactionAttributeSource)和事务⽅法拦截器(TransactionInterceptor);package org.springframework.transaction.annotation;import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Role;import org.springframework.transaction.config.TransactionManagementConfigUtils;import org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor;import org.springframework.transaction.interceptor.TransactionAttributeSource;import org.springframework.transaction.interceptor.TransactionInterceptor;@Configurationpublic class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {/**事务增强器(Advisor),在事务类创建的时候,被AutoProxyRegistrar导⼊的组件InfrastructureAdvisorAutoProxyCreator拦截,InfrastructureAdvisorAutoProxyCreator拦截的逻就是增强事务类的事务⽅法,⽽BeanFactoryTransactionAttributeSourceAdvisor作为增强器,与需要增强的⽅法(这⾥是指被@Transactional标记的⽅法)进⾏匹配,匹配成功的增强器,最后转成拦截器(MethodInterceptor,就是下⾯的TransactionInterceptor),然后与⽬标⽅法⼀起在拦截器链中被执⾏,达到⽅法增强的效果;BeanFactoryTransactionAttributeSourceAdvisor的继承关系如下:BeanFactoryTransactionAttributeSourceAdvisor--AbstractBeanFactoryPointcutAdvisor--AbstractPointcutAdvisor--PointcutAdvisor--AdvisorAOP中AspectJPointcutAdvisor的继承关系如下,与AbstractPointcutAdvisor⼀样,都实现PointcutAdvisor--AspectJPointcutAdvisor--PointcutAdvisor--Advisor*/@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();advisor.setTransactionAttributeSource(transactionAttributeSource());advisor.setAdvice(transactionInterceptor());advisor.setOrder(this.enableTx.<Integer>getNumber("order"));return advisor;}/**@Transactional注解的解析类;负责解析事务⽅法上@Transactional中的各个参数配置,解析的时机是在创建事务类之后被增强的时候,匹配事务⽅法的时候⼀起被解析了AnnotationTransactionAttributeSource的继承关系如下:AnnotationTransactionAttributeSource--AbstractFallbackTransactionAttributeSource--TransactionAttributeSource通过⽅法org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource.getTransactionAttribute(Method, Class<?>)解析出事务信息TransactionAttribute;AnnotationTransactionAttributeSource在⽅法findTransactionAttribute(Class<?>)中依赖于SpringTransactionAnnotationParser在解析事务类时,绑定事务⽅法与增强器的时候进⾏@Transactional注解解析;*/@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionAttributeSource transactionAttributeSource() {return new AnnotationTransactionAttributeSource();}/**被@Transactional标记的事务⽅法的拦截器,实际是⼀个MethodInterceptor保存了事务属性信息,事务管理器;在⽬标⽅法执⾏的时候;执⾏拦截器链;*/@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionInterceptor transactionInterceptor() {TransactionInterceptor interceptor = new TransactionInterceptor();interceptor.setTransactionAttributeSource(transactionAttributeSource());if (this.txManager != null) {interceptor.setTransactionManager(this.txManager);}return interceptor;}}在SpringTransactionAnnotationParser中parseTransactionAnnotation⽅法来解析@Transactional中的各个参数,其具体代码如下:protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();Propagation propagation = attributes.getEnum("propagation");rbta.setPropagationBehavior(propagation.value());Isolation isolation = attributes.getEnum("isolation");rbta.setIsolationLevel(isolation.value());rbta.setTimeout(attributes.getNumber("timeout").intValue());rbta.setReadOnly(attributes.getBoolean("readOnly"));rbta.setQualifier(attributes.getString("value"));ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<RollbackRuleAttribute>();Class<?>[] rbf = attributes.getClassArray("rollbackFor");for (Class<?> rbRule : rbf) {RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);rollBackRules.add(rule);}String[] rbfc = attributes.getStringArray("rollbackForClassName");for (String rbRule : rbfc) {RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);rollBackRules.add(rule);}Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");for (Class<?> rbRule : nrbf) {NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);rollBackRules.add(rule);}String[] nrbfc = attributes.getStringArray("noRollbackForClassName");for (String rbRule : nrbfc) {NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);rollBackRules.add(rule);}rbta.getRollbackRules().addAll(rollBackRules);return rbta;}spring 事务 @EnableTransactionManagement原理@EnableXXX原理:注解上有个XXXRegistrar,或通过XXXSelector引⼊XXXRegistrar,XXXRegistrar实现了ImportBeanDefinitionRegistrar的registerBeanDefinitions⽅法,给容器注册XXXCreator。
Spring声明式事务@Transactional详解,事务隔离级别和传播行为
Spring声明式事务@Transactional详解,事务隔离级别和传播⾏为@Transactional注解⽀持9个属性的设置,这⾥只讲解其中使⽤较多的三个属性:readOnly、propagation、isolation。
其中propagation属性⽤来枚举事务的传播⾏为,isolation⽤来设置事务隔离级别,readOnly进⾏读写事务控制。
@Service@Transactional(readOnly = true)public class AppTradeRec2Service extends BaseService {@Autowiredprivate AppTradeRecDao appTradeRecDao;@Autowiredprivate ConsInfoDao consInfoDao;@Transactional(readOnly = false)public void payCharge(TradeRec tradeRec) {User usr = UserUtils.getUser();ConsInfo cons = consInfoDao.getByUser(usr.getId());//修改交易记录tradeRec.setPayBefore(cons.getAccountAmt());tradeRec.setPayAfter(cons.getAccountAmt() - tradeRec.getRcvAmt());tradeRec.setIsPay("99");appTradeRecDao.save(tradeRec);//修改账户余额cons.setAccountAmt(cons.getAccountAmt() - tradeRec.getRcvAmt());consInfoDao.save(cons);}}⼀、readOnly读写事务控制readOnly=true表明所注解的⽅法或类只是读取数据。
Spring的常见问题及答案
Spring的常见问题及答案⽬录Spring 概述依赖注⼊Spring beansSpring注解Spring数据访问Spring⾯向切⾯编程(AOP)Spring MVCSpring 概述1. 什么是spring?Spring 是个java企业级应⽤的开源开发框架。
Spring主要⽤来开发Java应⽤,但是有些扩展是针对构建J2EE平台的web应⽤。
Spring 框架⽬标是简化Java企业级应⽤开发,并通过POJO为基础的编程模型促进良好的编程习惯。
2. 使⽤Spring框架的好处是什么?轻量:Spring 是轻量的,基本的版本⼤约2MB。
控制反转:Spring通过控制反转实现了松散耦合,对象们给出它们的依赖,⽽不是创建或查找依赖的对象们。
⾯向切⾯的编程(AOP):Spring⽀持⾯向切⾯的编程,并且把应⽤业务逻辑和系统服务分开。
容器:Spring 包含并管理应⽤中对象的⽣命周期和配置。
MVC框架:Spring的WEB框架是个精⼼设计的框架,是Web框架的⼀个很好的替代品。
事务管理:Spring 提供⼀个持续的事务管理接⼝,可以扩展到上⾄本地事务下⾄全局事务(JTA)。
异常处理:Spring 提供⽅便的API把具体技术相关的异常(⽐如由JDBC,Hibernate or JDO抛出的)转化为⼀致的unchecked 异常。
3. Spring由哪些模块组成 ?以下是Spring 框架的基本模块:Core moduleBean moduleContext moduleExpression Language moduleJDBC moduleORM moduleOXM moduleJava Messaging Service(JMS) moduleTransaction moduleWeb moduleWeb-Servlet moduleWeb-Struts moduleWeb-Portlet module4. 核⼼容器(应⽤上下⽂) 模块。
SpringCloud五大组件及其功能
SpringCloud五大组件及其功能Spring Cloud是一个分布式系统的开发工具集,它基于Spring Boot 来快速构建分布式系统的应用程序。
Spring Cloud提供了一系列的工具和组件,用于简化分布式系统的开发和部署。
下面将介绍Spring Cloud 的五大组件及其功能。
1. 服务注册与发现(Service Discovery):服务注册与发现是Spring Cloud的核心组件之一,用于实现服务治理。
在分布式系统中,由于服务的动态性和不确定性,需要一个机制来将服务注册到注册中心,并可以动态地发现和调用其他服务。
Spring Cloud 中常用的服务注册与发现组件是Eureka和Consul。
它们可以帮助开发人员轻松地实现服务注册与发现的功能,提供服务的自动注册和发现,以及负载均衡和故障恢复。
2. 服务调用(Service Invocation):服务调用是分布式系统中不可或缺的组件之一、在分布式系统中,不同的服务之间需要相互调用。
Spring Cloud提供了一个统一的服务调用方式,可以使用HTTP或RPC来调用其他服务。
常用的服务调用组件是Feign和Ribbon。
Feign是一个声明式的REST客户端,内部集成了Ribbon来实现负载均衡。
Ribbon是一个客户端负载均衡器,可以根据自定义的规则来调用不同的实例。
3. 服务熔断与降级(Circuit Breaker & Fallback):服务熔断与降级是分布式系统中常用的解决方案之一、当一个服务在高负载或异常情况下无法正常工作时,为了保证系统的稳定性和可用性,可以使用服务熔断和降级功能。
Spring Cloud提供了Hystrix来实现服务熔断和降级。
Hystrix是一个容错和延迟容忍库,可以分离服务的请求处理和熔断逻辑。
它可以通过断路器来阻止对失败服务的调用,并提供一个回退机制,以保障系统的稳定性。
4. 配置管理(Configuration Management):配置管理是分布式系统中必不可少的组件之一、在分布式系统中,不同的服务可能有不同的配置项,而且这些配置项可能需要动态地修改和管理。
spring,mybatis事务管理配置与@Transactional注解使用[转]
spring,mybatis事务管理配置与@Transactional注解使用[转]spring,mybatis事务管理配置与@Transactional注解使用概述事务管理对于企业应用来说是至关重要的,即使出现异常情况,它也可以保证数据的一致性。
Spring Framework对事务管理提供了一致的抽象,其特点如下:为不同的事务API提供一致的编程模型,比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理,特别是基于注解的声明式事务管理,简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成事务管理方式spring支持编程式事务管理和声明式事务管理两种方式。
编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。
对于编程式事务管理,spring推荐使用TransactionTemplate。
声明式事务管理建立在AOP之上的。
其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务。
声明式事务最大的优点就是不需要通过编程的方式管理事务,这样就不需要在业务逻辑代码中掺杂事务管理的代码,只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式),便可以将事务规则应用到业务逻辑中。
显然声明式事务管理要优于编程式事务管理,这正是spring 倡导的非侵入式的开发方式。
声明式事务管理使业务代码不受污染,一个普通的POJO对象,只要加上注解就可以获得完全的事务支持。
和编程式事务相比,声明式事务唯一不足地方是,后者的最细粒度只能作用到方法级别,无法做到像编程式事务那样可以作用到代码块级别。
springMVC配置文件详解
web.xml的配置web.xml应该是整个项目最重要的配置文件了,不过servlet3.0中已经支持注解配置方式了。
在servlet3.0以前每个servlet必须要在web.xml中配置servlet及其映射关系。
但是在spring框架中就不用了,因为Spring中是依赖注入(Dependency Injection)的也叫控制反转(Inversion of Control)。
但是也要配置一个重要的servlet,就是前端控制器(DispatcherServlet)。
配置方式与普通的servlet基本相似。
配置内容如下:<!-- 配置前端控制器--><servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><!-- ContextconfigLocation配置springmvc加载的配置文件适配器、处理映射器等--><param-name>contextConfigLocation</param-name><param-value>WEB-INF/classes/spring/springmvc.xml</param-value></init-param></servlet><servlet-mapping><servlet-name>spring</servlet-name><!-- 1、.action访问以.action结尾的由DispatcherServlet进行解析2、/,所有访问都由DispatcherServlet进行解析--><url-pattern>/</url-pattern></servlet-mapping>这里需要注意,springmvc.xml是spring配置文件,将在后面讨论。
SpringBoot事务注解@Transactional
SpringBoot事务注解@TransactionalSpringBoot提供了⾮常⽅便的事务操作,通过注解就可以实现事务的回滚,⾮常⽅便快捷,下⾯我们就说⼀下如何进⾏事务操作。
1. 事务说明在Spring中,事务有两种实现⽅式,分别是编程式事务管理和声明式事务管理两种⽅式。
编程式事务管理:编程式事务管理使⽤TransactionTemplate或者直接使⽤底层的PlatformTransactionManager。
对于编程式事务管理,spring推荐使⽤TransactionTemplate。
声明式事务管理:建⽴在AOP之上的。
其本质是对⽅法前后进⾏拦截,然后在⽬标⽅法开始之前创建或者加⼊⼀个事务,在执⾏完⽬标⽅法之后根据执⾏情况提交或者回滚事务。
声明式事务管理不需要⼊侵代码,通过@Transactional就可以进⾏事务操作,更快捷⽽且简单。
推荐使⽤2. 如何使⽤在Mybatis中使⽤事务,⾮常简单,只需要在函数增加注解@Transactional,⽆需任何配置。
我们通过在controller层增加事务例⼦看下:@AutowiredOrderServiceorderService; //order操作的Service层@ApiOperation(value = "增加OrderCustomer")@RequestMapping(value = "", method = RequestMethod.POST)@ResponseBody@Transactionalpublic JsonBean<Order> insertOrder(@RequestParam(value = "order") String order) {try {//创建订单Order order = orderService.insert(user.getId(),is_company,fk_want_company_id);return new JsonBean(SUCCESS, orderCustomer);}catch (ErrorCodeException e){TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();return new JsonBean(e.getErrorCode());}}@Transactional可以作⽤于接⼝、接⼝⽅法、类以及类⽅法上。
jdbctemplate 注解
JdbcTemplate是Spring框架中的一个重要组件,它提供了简单且灵活的方式来访问数据库。
在实际开发中,我们经常会使用JdbcTemplate来执行SQL查询、插入、更新和删除操作。
而注解则是在Spring框架中用来简化配置和管理依赖的重要工具。
本文将详细介绍JdbcTemplate注解的使用方法和场景。
一、Autowired注解在使用JdbcTemplate时,首先需要创建JdbcTemplate的实例。
通常情况下,我们会使用Autowired注解来自动注入JdbcTemplate实例,而不需要手动创建实例并配置数据源。
Autowired注解能够帮助我们更加便捷地获取JdbcTemplate实例,同时也减少了配置的工作量。
二、Repository注解在DAO(Data Access Object)层中,我们通常会使用Repository 注解来标识数据访问对象。
在结合JdbcTemplate使用时,Repository注解可以让Spring框架自动扫描并识别DAO层的类,并将其实例化为bean。
这样一来,我们就可以在DAO层的类中方便地使用JdbcTemplate进行数据库操作。
三、Transactional注解在进行数据库操作时,事务管理是一个非常重要的问题。
Spring框架提供了Transactional注解来简化事务管理的配置。
在使用JdbcTemplate执行数据库操作时,我们可以通过在方法上添加Transactional注解来开启事务管理。
这样可以确保在一组数据库操作中,要么全部执行成功,要么全部执行失败,从而确保数据的一致性和完整性。
四、Value注解在实际开发中,我们经常需要将数据库连接的信息进行配置,比如数据库位置区域、用户名、密码等。
这时,我们可以使用Value注解将这些配置信息注入到JdbcTemplate中,而不需要在代码中硬编码这些信息。
通过Value注解,我们可以将配置信息集中管理,从而方便后续的维护和修改。
Spring事务管理及与mybatis整合的事务管理
数据访问事务处理in Spring+Mybatis3.0事务---保证了用户的每一次操作都是可靠的,即使出现了异常的访问,也不至于破坏后台数据的完整性;Java事务简介事务必须符合ISO/IEC所定制的ACID原则1)A(atomicity):原子性在事务执行的过程中,任何的失败就将导致事务的任何修改失效,2)C(consistency):一致性事务回滚时,事务所执行的内容必须恢复到初始状态,即事务执行前的状态3)I(isolation):隔离性事务执行过程中对数据的修改,在提交之前的数据对其他事务不可见4)D(durability):持久性已经提交的数据在事务执行失败时,数据的状态都是正确的.事务分类:全局事务(分布式事务):由应用服务器来管理(如JTA),同时可以用于多个事务性的资源;本地事务本地事务和资源相关,主要通过JDBC来实现在实际应用中,存在一种容器管理事务,容器事务主要是由javaEE应用服务器提供,容器事务大多给予JTA完成,事实上这是在容器中覆盖了JDBC和JTA事务.事务特性分析(use spring)TransactionDefinition 接口来定义事务属性。
Code:public interface TransactionDefinition{int getIsolationLevel();int getPropagationBehavior();int getTimeout();boolean isReadOnly();}事务机制a)事务隔离级别隔离级别是指若干个并发的事务之间的隔离程度。
TransactionDefinition 接口中定义了五个表示隔离级别的常量:TransactionDefinition.ISOLATION_DEFAULT(默认值):表示使用底层数据库的默认隔离级别。
对大部分数据库而言,通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。
Spring七种事务传播行为与五种事务隔离级别
Spring七种事务传播⾏为与五种事务隔离级别⼀、事务的传播⾏为:通过Propagation定义:<!-- 配置事务通知 --><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><!-- 以⽅法为单位,指定⽅法应⽤什么事务属性:isolation:隔离级别 propagation:传播⾏为 read-only:是否只读--><tx:method name="transfer" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/><!--上⾯的⽅式只适⽤单个⽅法,当我们业务有很多个⽅法都要操作事务时,则要配置很多个,可以使⽤下⾯的通配符配置⽅式--><tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>省略update.. detele.....</tx:attributes></tx:advice>readOnly:事务属性中的readOnly标志表⽰对应的事务应该被最优化为只读事务。
这是⼀个最优化提⽰。
在⼀些情况下,⼀些事务策略能够起到显著的最优化效果,例如在使⽤Object/Relational映射⼯具(如:或TopLink)时避免dirty checking(试图“刷新”)。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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--支持当前事务,如果当前没有事务,就新建一个事务。
这是最常见的选择。
PROPAGATION_SUPPORTS--支持当前事务,如果当前没有事务,就以非事务方式执行。
PROPAGATION_MANDATORY--支持当前事务,如果当前没有事务,就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务,如果当前存在事务,把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行,如果当前存在事务,则抛出异常。
PROPAGATION_NESTED--如果当前存在事务,则在嵌套事务内执行。
如果当前没有事务,则进行与PROPAGATION_REQUIRED类似的操作。
Spring 事务管理创造性的解决了很多以前要用重量级的应用服务器才能解决的事务问题,那么其实现原理一定很深奥吧?可是如果读者仔细研究了Spring事务管理的代码以后就会发现,事务管理其实也是如此简单的事情。
这也印证了在本书开头的一句话“重剑无锋、大巧不工”,Spring并没有使用什么特殊的API,它运行的原理就是事务的原理。
下面是DataSourceTransactionManager的启动事务用的代码(经简化):protected void doBegin(Object transaction, TransactionDefinition definition){DataSourceTransactionObject txObject =(DataSourceTransactionObject) transaction;Connection con = null;try{if (txObject.getConnectionHolder() == null){Connection newCon = this.dataSource.getConnection();txObject.setConnectionHolder(new ConnectionHolder(newCon), true);}txObject.getConnectionHolder().setSynchronizedWithTransaction(true);con = txObject.getConnectionHolder().getConnection();Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);txObject.setPreviousIsolationLevel(previousIsolationLevel);if (con.getAutoCommit()){txObject.setMustRestoreAutoCommit(true);con.setAutoCommit(false);}txObject.getConnectionHolder().setTransactionActive(true);// Bind the session holder to the thread.if (txObject.isNewConnectionHolder()){TransactionSynchronizationManager.bindResource(getDataSource(),txObject.getConnectionHolder());}}catch (SQLException ex){DataSourceUtils.releaseConnection(con, this.dataSource);throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);}}本文出自:在调用一个需要事务的组件的时候,管理器首先判断当前调用(即当前线程)有没有一个事务,如果没有事务则启动一个事务,并把事务与当前线程绑定。
Spring使用TransactionSynchronizationManager的bindResource方法将当前线程与一个事务绑定,采用的方式就是ThreadLocal,这可以从TransactionSynchronizationManager类的代码看出。
public abstract class TransactionSynchronizationManager{……private static final ThreadLocal currentTransactionName = new ThreadLocal();private static final ThreadLocal currentTransactionReadOnly = new ThreadLocal();private static final ThreadLocal actualTransactionActive = new ThreadLocal(); ……}从doBegin的代码中可以看到在启动事务的时候,如果Connection是的自动提交的(也就是getAutoCommit()方法返回true)则事务管理就会失效,所以首先要调用setAutoCommit(false)方法将其改为非自动提交的。
setAutoCommit(false)这个动作在有的JDBC驱动中会非常耗时,所以最好在配置数据源的时候就将“autoCommit”属性配置为true。
首先,为什么要进行事务,接下来说说spring是怎样进行事务管理的.①Spring事务策略Spring事务策略,也就是spring事务管理的实现方式.它有一个统一的抽象是由实现下面这个接口完成的.org.springframework.transaction.PlatformTransactionManager此接口的内容如下:Public interfacePlatformTransactionManager()...{TransactionStatue getTransaction(TransactionDefinition definition) throws TransactionException;Void commit(TransactionStatus status) throws TransactionException;Void rollback(TransactionStatus status) throws TransactionException;}不管是声明式的还是编程式的事务管理都需要此抽象来完成.解释一下这个接口,这样可以更好的理解spring的事务控制的原理.getTransaction()根据类型为TransactionDefinition的参数返回一个TransactionStatus 对象.返回的TransactionStatus对象可能代表一个新的或已经存在的事务(如果在当前调用堆栈有一个符合条件的事务).如同J2EE事务上下文,一个TransactionStatus也是和执行的线程关联的.同时,在框架中还存在TransactionDefinition接口,即上边的参数类型.此接口指定了事务隔离程度、事务传播、事务超时、只读状态。