spring使用基于注解的AOP事务管理
掌握常用框架的基本用法与应用场景
掌握常用框架的基本用法与应用场景常用框架的基本用法和应用场景可以根据具体的框架来进行讨论。
以下是几个常用框架的基本用法和应用场景。
1. Spring框架：Spring是一个轻量级的Java开发框架，提供了一站式的解决方案，包括依赖注入、AOP、事务管理、Web开发等。
在Spring框架中，可以通过注解或XML配置来管理各个组件之间的依赖关系，并利用Spring的IOC容器来管理对象的生命周期。
应用场景包括Web应用开发、企业应用开发、中小型项目开发等。
2. Hibernate框架：Hibernate是一个Java持久化框架，它提供了将Java对象映射到数据库表的解决方案。
通过Hibernate，开发人员可以简化数据库操作，使用面向对象的方式来进行数据库访问，提高开发效率。
应用场景包括ORM映射、事务管理、性能优化等。
3. Django框架：Django是一个基于Python的Web开发框架，致力于提供高效的、安全的Web应用程序开发解决方案。
它采用了MTV （Model-Template-View）的设计模式，通过模型（Model）与数据库交互，通过模板（Template）生成HTML页面，通过视图（View）处理用户请求。
应用场景包括Web应用开发、数据分析平台搭建等。
4. React框架：React是一个用于构建用户界面的JavaScript库，它提供了高效的组件化开发方式，通过虚拟DOM的技术实现了高性能的界面渲染。
React可以与其他框架或库（如Redux、React Router）结合使用，用于构建单页应用、移动应用等。
应用场景包括前端开发、跨平台移动应用开发等。
除了以上几个框架，还有许多其他常用框架，如Angular、Vue.js、Express等，它们都有各自的特点和适用场景。
掌握这些常用框架的基本用法和应用场景，可以帮助开发人员更高效地进行软件开发，提高开发质量和效率。
此外，不仅要掌握框架的基本用法，还要提升自己的拓展能力，如深入学习框架的源码、参与开源社区、阅读相关的技术文章和书籍等，才能更好地应对各种应用场景和解决复杂问题。
基于SpringBootAOP与自定义注解转义字典值
基于SpringBootAOP与自定义注解转义字典值要基于SpringBoot、AOP和自定义注解来转义字典值，可以按照以下步骤进行：1.创建一个字典表，存储字典值和对应的转义值。
例如，可以创建一个数据库表或者在配置文件中定义一个字典映射关系。
4.在切面方法中，获取需要转义的字段的值，然后根据字典表中的映射关系，找到对应的转义值，并将转义值设置回字段。
5.在需要使用转义值的地方，直接使用被转义后的字段值即可。
下面是一个简单的示例代码：1.创建字典表，例如在配置文件中定义：```yamldict.mapping:gender:0:男1:女``````javaString value( default "";```3.创建AOP切面类：```javapublic class DictTransAspectprivate DictMapping dictMapping;public Object dictTrans(ProceedingJoinPoint joinPoint) throws ThrowableObject result = joinPoint.proceed(;//获取被标记的字段或方法Field field =ReflectionUtils.findField(joinPoint.getTarget(.getClass(, ((MethodSignature) joinPoint.getSignature().getName();DictTrans dictTrans = field.getAnnotation(DictTrans.class);if (dictTrans != null)//获取字段值Object value = field.get(joinPoint.getTarget();//获取字段的字典映射关系Map<String, String> mapping =dictMapping.getMapping(dictTrans.value();//根据字典映射关系转义字段值String transValue = mapping.get(value.toString();//设置转义值回字段field.set(joinPoint.getTarget(, transValue);}return result;}``````javapublic class Userprivate Integer gender;// getter and setter```5.在业务中使用转义后的字段值：```javapublic class UserService// 注入 UserMapper 或者其他数据访问层public User getUserById(String id)User user = userMapper.findById(id);System.out.println(user.getGender(); // 输出转义后的值，例如输出 "男"return user;}```这样，就实现了基于 SpringBoot、AOP 和自定义注解来转义字典值的功能。
关于Spring事务的原理,以及在事务内开启线程,连接池耗尽问题.
关于Spring事务的原理,以及在事务内开启线程,连接池耗尽问题.主要以结果为导向解释Spring 事务原理,连接池的消耗,以及事务内开启事务线程要注意的问题.Spring 事务原理这⾥不多说,⽹上⼀搜⼀⼤堆,也就是基于AOP配合ThreadLocal实现.这⾥强调⼀下Spring Aop 以及Spring 注解式注⼊在⾮Spring容器管理的类中是⽆效的.因为Spring Aop是在运⾏时实现字节码增强,字节码增强有多种实现⽅法,请⾃⾏了解,原⽣AspectJ是编译时织⼊,但是需要特定的编译器.语法并没有Spring Aop好理解.先看下Spring的事务传播⾏为类型事务传播⾏为类型说明PROPAGATION_REQUIRED如果当前没有事务，就新建⼀个事务，如果已经存在⼀个事务中，加⼊到这个事务中。
这是最常见的选择。
PROPAGATION_SUPPORTS⽀持当前事务，如果当前没有事务，就以⾮事务⽅式执⾏。
PROPAGATION_MANDATORY使⽤当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED以⾮事务⽅式执⾏操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER以⾮事务⽅式执⾏，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED如果当前存在事务，则在嵌套事务内执⾏。
如果当前没有事务，则执⾏与 PROPAGATION_REQUIRED类似的操作。
打开⽇记debug模式,留意控制台输出以下测试为了可读性以及更容易理解全是基于Spring注解式事务,⽽没有配置声明式事务.测试1:可以看见只创建了⼀个SqlSession以及⼀个事务,在⽅法内所有操作都使⽤同⼀个连接,同⼀个事务@RequestMapping(value="/testThreadTx",method = RequestMethod.GET)@Transactional(propagation = Propagation.REQUIRED)public void testThreadTx(){//此⽅法没有事务(当前⽅法是 Propagation.REQUIRED)Quotation quotation = quotationService.findEntityById(new String("1"));//此⽅法没有事务(当前⽅法是 Propagation.REQUIRED)quotationService.updateEntity(quotation);}//查看控制台输出(红字关键部分,第三个查询是更新⽅法内部需要先查询⼀次再更新,可以⽆视)Creating a new SqlSessionRegistering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@230376b4]ansaction(line/:54) -JDBC Connection [1068277098(com.mysql.jdbc.JDBC4Connection@5d92bace)] will be managed by SpringotationMapper.findEntityById(line/:54) -==> Preparing: SELECT * FROM table WHERE id = 1otationMapper.findEntityById(line/:54) -==> Parameters:otationMapper.findEntityById(line/:54) -<== Total: 1Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@230376b4]Fetched SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@230376b4] from current transactionReleasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@230376b4]Fetched SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@230376b4] from current transactionotationMapper.updateEntity(line/:54) -==> Preparing: update ….. where id = 1otationMapper.updateEntity(line/:54) -==> Parameters:otationMapper.updateEntity(line/:54) -<== Updates: 1Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@230376b4]erOperationLogServiceImpl(line/:41) -请求所⽤时间:207erOperationLogServiceImpl(line/:42) -请求结束*******************************************************************************Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@230376b4]Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@230376b4]Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@230376b4]测试2:不使⽤事务可以看出在⾮事务操作数据库,会使⽤多个连接,⾮常不环保,这⾥给稍微多线程插⼊埋下⼀个陷阱@RequestMapping(value="/testThreadTx",method = RequestMethod.GET)// @Transactional(propagation = Propagation.REQUIRED)public void testThreadTx(){Quotation quotation = quotationService.findEntityById(new String("1"));quotationService.updateEntity(quotation);}//查看控制台输出(红字关键部分,第三个查询是更新⽅法内部需要先查询⼀次再更新,可以⽆视)Creating a new SqlSessionSqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7f7b94f] was not registered for synchronization because synchronizationansaction(line/:54) -JDBC Connection [352410768(com.mysql.jdbc.JDBC4Connection@c63fcb6)] will not be managed by SpringotationMapper.findEntityById(line/:54) -==> Preparing: SELECT * FROM table WHERE id = 1otationMapper.findEntityById(line/:54) -==> Parameters:otationMapper.findEntityById(line/:54) -<== Total: 1Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7f7b94f]Creating a new SqlSessionSqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7a41785a] was not registered for synchronization because synchronizationansaction(line/:54) -JDBC Connection [1615108970(com.mysql.jdbc.JDBC4Connection@38377d86)] will not be managed by SpringotationMapper.findEntityById(line/:54) -==> Preparing: SELECT * FROM table WHERE id = 1otationMapper.findEntityById(line/:54) -==> Parameters:otationMapper.findEntityById(line/:54) -<== Total: 1Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7a41785a]Creating a new SqlSessionSqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@181e5a22] was not registered for synchronization because synchronizationansaction(line/:54) -JDBC Connection [2096339748(com.mysql.jdbc.JDBC4Connection@5d4e9892)] will not be managed by SpringotationMapper.updateEntity(line/:54) -==> Preparing: update …. where id = 1otationMapper.updateEntity(line/:54) -==> Parameters:otationMapper.updateEntity(line/:54) -<== Updates: 1Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@181e5a22]erOperationLogServiceImpl(line/:41) -请求所⽤时间:614erOperationLogServiceImpl(line/:42) -请求结束*******************************************************************************测试3:@RequestMapping(value="/testThreadTx",method = RequestMethod.GET)@Transactional(propagation = Propagation.REQUIRED)public void testThreadTx(){final ExecutorService executorService = Executors.newFixedThreadPool(3);Quotation quotation = quotationService.findEntityById(new String("1"));quotationService.updateEntity(quotation);List<Future<Integer>> futures = new ArrayList<Future<Integer>>(3);for(int i=0;i<3;i++){Callable<Integer> task = new Callable<Integer>() {@Overridepublic Integer call() throws Exception {Quotation quotation = quotationService.findEntityById(new String("1"));quotationService.updateEntity(quotation);return null;}};futures.add(executorService.submit(task));}executorService.shutdown();}//查看控制台输出(红字关键部分,第三个查询是更新⽅法内部需要先查询⼀次再更新,可以⽆视)为了节篇幅,这⾥不贴出控制台数据⼤概就是输出了10个Creating a new SqlSession(⼤概有些同学使⽤了多线程,把线程池耗完了也没弄明⽩原因)外层⽅法启动⼀个,内部3个线程,每个线程3个.⼀共是使⽤了10个连接.为什么?这涉及到ThreadLocal以及线程私有栈的概念.如果Spring 事务使⽤InhertableThreadLocal就可以把连接传到⼦线程,但是为什么Spring不那么⼲呢?因为这样毫⽆意义,如果把同⼀个连接传到⼦线程,那就是SQL操作会串⾏执⾏,那何必还多线程呢?有关于ThreadLocal,InhertableThreadLocal配合线程池的⼀些陷阱请看我另⼀篇⽂章:测试4:既然使⽤同⼀个事务,不能实现并发操作,那么只能折中,在每⼀个线程开启⼀个事务,减少创建更多的连接,执⾏完毕以后可以返回操作成功失败结果,反馈给⽤户@RequestMapping(value="/testThreadTx",method = RequestMethod.GET)// @Transactional(propagation = Propagation.REQUIRED)public void testThreadTx(){ExecutorService executorService = Executors.newFixedThreadPool(3);List<Future<Integer>> futures = new ArrayList<Future<Integer>>(3);for(int i=0;i<3;i++){Callable<Integer> task = new Callable<Integer>() {@Overridepublic Integer call() throws Exception {quotationService.doSomeThing();return null;}};futures.add(executorService.submit(task));}executorService.shutdown();}//封装⼀下@Override@Transactional(propagation =Propagation.REQUIRED)public void doSomeThing(){Quotation quotation = this.findEntityById(new String("1"));this.updateEntity(quotation);}//查看控制台输出,只会创建3个连接,为节省篇幅,这⾥不贴出控制台所有数据Creating a new SqlSessionCreating a new SqlSessionCreating a new SqlSession最后⼩技巧PROPAGATION_NOT_SUPPORTED(仅仅为了让Spring能获取ThreadLocal的connection),如果不使⽤事务,但是同⼀个⽅法多个对数据库操作,那么使⽤这个传播⾏为可以减少消耗数据库连接@RequestMapping(value="/testThreadTx",method = RequestMethod.GET)@Transactional(propagation = Propagation.NOT_SUPPORTED)public void testThreadTx(){Quotation quotation = quotationService.findEntityById(new String("1"));quotation.setStatus(ClassDataManager.STATE_N);quotationService.updateEntity(quotation);}//这样只会创建⼀个SqlSession。
SpringAOP的原理和应用场景
SpringAOP的原理和应用场景SpringAOP（Aspect-Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种通过预定义的方式，将横切关注点（Cross-cutting Concerns）与业务逻辑进行解耦的机制。
本文将介绍SpringAOP的原理及其在实际应用场景中的应用。
一、SpringAOP的原理SpringAOP基于代理模式（Proxy Pattern）实现。
在SpringAOP中，通过生成与原始类（被代理类）具有相同接口的代理类，将横切逻辑编织到业务逻辑中。
在运行时，当调用代理类的方法时，会在方法执行前、后或异常抛出时插入相应的横切逻辑代码。
具体而言，SpringAOP使用了以下几个核心概念：1. 切面（Aspect）：切面是横切逻辑的模块化单元，它包含了一组通知（Advice）和切点（Pointcut）。
2. 通知（Advice）：通知定义了实际的横切逻辑代码，并规定了何时执行该代码。
SpringAOP提供了五种类型的通知：前置通知（Before）、后置通知（After）、返回通知（After-returning）、异常通知（After-throwing）和环绕通知（Around）。
3. 切点（Pointcut）：切点指定了在哪些连接点（Join Point）上执行通知。
连接点可以是方法调用、属性访问等程序执行的点。
4. 连接点（Join Point）：连接点是程序执行过程中的一个特定点，如方法调用前、方法调用后等。
通知通过切点来选择连接点。
5. 织入（Weaving）：织入是将切面应用到目标对象，并创建代理对象的过程。
织入可以在编译时、类加载时或运行时进行。
二、SpringAOP的应用场景SpringAOP可应用于各种场景，用于解决跨越多个模块或类的横切关注点问题。
以下是一些常见的SpringAOP应用场景：1. 日志记录：通过在关键方法的前后插入日志代码，实现对系统运行状态的监控和记录。
aop的原理应用
AOP的原理应用1. 什么是AOPAOP（Aspect-Oriented Programming）是面向切面编程的缩写，它是一种能够通过解耦的方式将横切性关注点模块化的编程范式。
传统的面向对象编程（OOP）主要是通过类和对象来划分和组织代码，但当系统变得复杂时，代码中常常散布着一些与主要业务逻辑无关的、可复用的逻辑（比如日志记录、安全控制、事务管理等），这就导致了代码的重复和耦合度的增加。
而AOP可以通过将这些横切逻辑（称为切面）与主要业务逻辑分离，从而提高代码的可维护性、可测试性和可复用性。
2. AOP的原理AOP的核心原理是在编译期、加载期或运行期利用动态代理技术来实现切面的织入。
具体来说，AOP框架会在目标对象的方法调用前后或者异常抛出时，插入横切逻辑（切面），从而实现对目标对象的增强。
其中，横切逻辑通过切面由切点和增强组成。
•切点：定义了在何处插入切面的准则，比如可以根据类名、方法名或注解等进行精确定位。
•增强：指的是横切逻辑的实现，比如可以在方法调用前后执行某些操作。
织入过程可以通过前置织入、后置织入等方式来实现。
3. AOP的应用场景AOP的特点使得它在很多场景下都能够发挥作用，以下列举了几个常见的应用场景：•日志记录：AOP可以很方便地将日志记录逻辑与主要业务逻辑分离，从而使得代码更加清晰、易于维护。
例如，可以利用AOP在方法调用前后记录方法的输入参数和返回结果。
•安全控制：通过AOP可以在方法调用前进行身份验证、权限检查等安全控制逻辑，从而确保系统的安全性。
•事务管理：AOP可以在方法调用前后添加事务管理逻辑，保证数据的一致性和完整性。
例如，可以在方法调用前开启事务，在方法调用后提交或回滚事务。
•性能监控：利用AOP可以在方法调用前后统计方法的执行时间、请求次数等，通过监控这些性能指标可以优化系统的性能。
•异常处理：AOP可以在方法抛出异常时进行异常处理逻辑，并且可以根据异常类型进行不同的处理。
spring事务原理
spring事务原理数据库系统内，事务指一系列连续的操作，这系列操作被看作一个整体，要么完全执行，要么完全不执行，不会出现执行部分的情况，这是数据库系统的基本特征之一。
在传统数据库系统中，事务的管理是由数据库系统自身提供的一种功能，然而随着数据库系统的复杂性的增加，数据库中的事务管理越来越复杂，对数据库操作有更多的要求，这样就催生了应用层事务管理技术，而当前最流行的事务管理技术是Spring事务。
Spring事务是一种基于AOP（面向切面编程）的分布式事务管理技术，它能够帮助系统更好的控制事务的处理过程，从而使系统内的数据更加有效率的共享，降低数据库事务的管理复杂度，提高数据库系统的可用性及性能。
Spring事务原理包括几个要素：事务模型、分布式事务处理框架、事务实现机制以及事务管理工具等。
一、事务模型Spring事务原理的核心是事务模型，即它把事务分为两种：提交成功事务和失败事务，在Spring提供的事务模型中，每个事务都只有两种结果，要么提交成功，要么提交失败，而不存在半提交的状态。
在Spring的事务模型中，事务的分类还要求事务的原子性，它要求一旦提交事务，事务就不会再次改变，或者改变的程度会很小。
原子性还表明事务的执行要么完全成功，要么完全失败，不会出现半成功半失败的情况。
二、分布式事务处理框架Spring提供了基于AOP技术的分布式事务处理框架，这种分布式事务处理框架能够有效地支持不同数据库之间的事务处理，它包括三个部分：事务管理器（TransactionManager）、事务拦截器（TransactionInterceptor）和事务事件监听器（TransactionListener）。
事务管理器是Spring对分布式事务的抽象，它可以处理不同类型的事务，它的实现通常会涉及到一些事务拦截器。
事务拦截器是Spring提供的一种安全机制，它能够在事务处理过程中，根据配置的规则，来拦截事务的执行，以便能够在事务处理过程中发现任何可能存在的问题，并对其进行调整，使得事务能够顺利的提交。
MyBatis-Spring-TransactionManager事务管理
</property>
</bean>
编程式事务管理
MyBatis 的 SqlSession 提供指定的方法来处理编程式的事务。 但是当使用 MyBatis-Spring 时, bean 将会使用 Spring 管理的 SqlSession 或映射器来注入。 那就是说 Spring 通常是处理 事务的。
一旦事务创建之后,MyBatis-Spring 将会透明的管理事务。在你的 DAO 类中就不需要额 外的代码了。
标准配置
要 开 启 Spring 的 事 务 处 理 , 在 Spring 的 XML 配 置 文 件 中 简 单 创 建 一 个 DataSourceTransactionManager 对象:
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
TransactionStatus status = txManager.getTransaction(def);
</bean>
指定的 DataSource 一般可以是你使用 Spring 的任意 JDBC DataSource。这包含了连接 池和通过 JNDI 查找获得的 DataSource。
要注意, 为事务管理器指定的 DataSource 必须和用来创建 SqlSessionFactoryBean 的 是同一个数据源,否则事务管理器就无法工作了。
transactional注解的实现原理
transactional注解的实现原理
Transaction注解的实现原理是使用AOP技术，实现对方法的增强，对加上注解的方法进行事务管理。
实现过程如下：
1. 首先在spring的配置文件中声明一个事务管理器(TransactionManager)，这个管理器会在Spring容器启动时初始化。
2. 在需要进行事务管理的方法上加上@Transactional注解，这
个注解就代表这个方法需要进行事务管理。
3. Spring在扫描带有@Transactional注解的方法时，会使用AOP技术生成一个代理对象，这个代理对象增强了原始方法的功能。
4. 代理对象会在方法前后执行一些特定的操作，主要包括在方
法执行前开启事务，方法执行完成后根据方法执行结果决定是否提交
或回滚事务。
5. 如果方法执行成功，代理对象会提交事务。
如果方法执行失败，则代理对象会回滚事务。
如果出现异常，代理对象也会回滚事务。
6. 最后，代理对象调用完方法后，会被销毁，原始方法依然存在。
通过这种方式，@Transactional注解提供了简单易用的事务管理方式。
在实际应用中，我们只需要在需要事务的方法上加上注解，就
可以实现事务管理，非常方便。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
spring使用基于注解的AOP事务管理
16.6 AOP事务管理
AOP事务管理利用了Spring AOP的基础设施，在大多数情况下，Spring AOP会创建一个JDK代理以拦截方法调用。
你可以使用装载时编织以在装载期编织切面，这样就不需要代理了（如果你记不清什么是装载时编织，请参看第6章）。
你有两种方式来配置Spring AOP 事务管理，基于注解的配置以及XML配置。
16.6.1 使用基于注解的AOP事务管理
你可以借助于AOP的自动代理，通过注解将事务性行为引入到现有的bean中。
让我们以代码清单16-21开始吧，它展示了类DeclarativeTxBankService。
代码清单16-21 DeclarativeTxBankService实现
请注意@Transactional属性，为了让Spring的事务管理基础设施可以利用该属性创建恰当的切入点和通知，我们需要使用AOP的自动代理和注解驱动的事务支持。
代码清单16-22展示了与该注解相对应的XML配置。
代码清单16-22 基于注解的事务管理的配置文件
该XML配置文件展示了标准的bankService bean声明，紧跟其后的是
<tx:annotation-driven/>和<aop:aspectj-autoproxy/>标签。
<tx:annotation-driven/>标签使用@Transactional注解创建恰当的事务管理切面。
接下来由<aop:aspectj-autoproxy/>通知匹配的bean。
1．探索tx:annotation-driven标签
<tx:annotation-driven/>标签是注解驱动的事务管理支持的核心。
表16-3列出了
<tx:annotation- driven/>标签的所有属性。
表16-3 <tx:annotation-driven/>标签的属性
属性说明
transactionManager 指定到现有的PlatformTransaction Manager bean的引用，通知会使用该引用
mode 指定Spring事务管理框架创建通知bean的方式。
可用的值有proxy和aspectj。
前者是默认值，
表示通知对象是个JDK代理；后者表示
Spring AOP会使用AspectJ创建代理
order 指定创建的切面的顺序。
只要目标对象有多个通知就可以使用该属性
proxy-target-class 该属性如果为true就表示你想要代理目标类而不是bean所实现的所有接口
2．探索@Transactional注解
凭借@Transactional注解我们就可以控制通知将要创建的事务定义的方方面面。
就像使用transactionAttributes属性表达式一样，你可以指定传播、隔离级别、超时以及允许和不允许的异常。
表16-4列出了@Transactional注解的所有属性。
表16-4 @Transactional注解的属性
属性类型说明
propagation org.springframework.
annotaion.transaction.Propagation 指定事务定义中使用的传播
isolation org.springframework.
annotation.
transaction.Isolation
设定事务的隔离级别
timeout int 指定事务的超时
（单位为秒）readOnly boolean 如果为true，事务
就被标识为只读
noRollbackF or Class<? extends Throwable>[] 目标方法可抛出的
异常所构成的数组，
但通知仍会提交事务
rollbackFor Class<? extends Throwable>[] 异常所构成的数组，
如果目标方法抛出了
这些异常，通知就会回滚事务3．基于注解的事务管理小结
通过@Transactional注解，我们可以轻松地为一个方法声明事务。
其好处在于你可以很直观地看到哪些方法带有事务，因为方法上面有该注解修饰。
其缺点是你不得不为每个需要事务的方法都加上@Transactional注解。
如果你使用的是默认的事务属性，这就不算什么问题，但当你需要设置其他的事务属性时，这就变得很乏味了，因为你要不停的复制、粘贴。
另一种方式就是用@Transactional注解去修饰类。
这会将事务应用到该类中的所有方法。
这种方式的问题在于所有的方法，包括简单的读取方法和设置方法也都运行在事务中了，尽管根本不需要这么做。
XML AOP事务管理能更好地处理这种情况。
说明虽然说通过使用@Transactional注解会使所有方法运行在事务中，但我还要再多说几句：其实准确的说法应该是如果某个类被@Transactional注解所修饰，那么该类实例化的Spring bean的所有方法都是事务性的。