Spring AOP和事务的相关陷阱
- 1、前言
- 2、嵌套方法拦截失效
- 2.1 问题场景
- 2.2 解决方案
- 2.3 原因分析
- 2.3.1 原理
- 2.3.2 源代码分析
- 3、Spring事务在多线程环境下失效
- 3.1 问题场景
- 3.2 解决方案
- 3.3 原因分析
- 4、总结
1、前言
Spring AOP在使用过程中需要注意一些问题,也就是平时我们说的陷阱,这些陷阱的出现是由于Spring AOP的实现方式造成的。对于这些缺陷本人坚持的观点是:一是每一样技术都或多或少有它的局限性,很难称得上完美,只要掌握其实现原理,在使用时不要掉进陷阱就行,也就是进行规避;二是更进一步讲,我们应该接受这就是技术本身的特点,也说不上什么缺陷,它本身就在“那里”,只是我们要的结果是“这样”,而它表现的是“那样”,恰好不是我们想要的而已。
对于Spring AOP的陷阱,我总结了以下两个方面,现在分别进行介绍。
2、嵌套方法拦截失效
2.1 问题场景
通过例子来讲解这样更好,首先加上注解配置:
- <!-- 启用注解式AOP -->
<aop:aspectj-autoproxy/>
然后定义一个切面,代码如下:
- @Aspect
- @Component
- public class AnnotationAspectTest {
- @Pointcut("execution(* *.action(*))")
- public void action() {
- }
- @Pointcut("execution(* *.work(*))")
- public void work() {
- }
- @Pointcut("action() || work())")
- public void compositePointcut() {
- }
- //前置通知
- @Before("compositePointcut()")
- public void beforeAdvice() {
- System.out.println("before advice.................");
- }
- //后置通知
- @After("compositePointcut()")
- public void doAfter() {
- System.out.println("after advice..................");
- }
- }
测试代码:
- //定义接口
- public interface IPersonService {
- String action(String msg);
- String work(String msg);
- }
- //编写实现类
- @Service
- public class PersonServiceImpl implements IPersonService {
- public String action(String msg) {
- System.out.println("FooService, method doing.");
- this.work(msg); // *** 代码 1 ***
- return "[" + msg + "]";
- }
- @Override
- public String work(String msg) {
- System.out.println("work: * " + msg + " *");
- return "* " + msg + " *";
- }
- }
- //单元测试
- @RunWith(SpringJUnit4ClassRunner.class)
- @ContextConfiguration(locations = {"classpath:applicationContext.xml"})
- public class FooServiceTest {
- @Autowired
- private IPersonService personService;
- @Test
- public void testAction() {
- personService.action("hello world.");
- }
- }
测试结果:
说明嵌套在action方法内部的work方法没有被进行切面增强,它没有被“切中”。
2.2 解决方案
在实现类中,如果注释掉代码1,将代码1改为:
- ((IPersonService) AopContext.currentProxy()).work(msg); // *** 代码 2 ***
并且在XML配置中加上expose-proxy="true",变为:<aop:aspectj-autoproxy expose-proxy="true"/>
运行结果为:
嵌套在action方法内部的work方法被进行了切面增强,它被“切中”。
2.3 原因分析
2.3.1 原理
以上结果的出现与Spring AOP的实现原理息息相关,由于Spring AOP采用了动态代理实现AOP,在Spring容器中的bean(也就是目标对象)会被代理对象代替,代理对象里加入了我们需要的增强逻辑,当调用代理对象的方法时,目标对象的方法就会被拦截。而上文中问题出现的症结也就是在这里,为了进一步说明这个问题,用图片说明最好:
通过调用代理对象的action方法,在其内部会经过切面增强,然后方法被发射到目标对象,在目标对象上执行原有逻辑,如果在原有逻辑中嵌套调用了work方法,则此时work方法并没有被进行切面增强,因为此时它已经在目标对象内部。
而解决方案很好地说明了,将嵌套方法发射到代理对象,这样就完成了切面增强。
2.3.2 源代码分析
接下来我们简单看一下源代码,Spring AOP的代码逻辑相当清晰:
- /**
- * Implementation of {@code InvocationHandler.invoke}.
- * <p>Callers will see exactly the exception thrown by the target,
- * unless a hook method throws an exception.
- */
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- ... ...
- Object retVal;
- //*** 代码3 ***
- if (this.advised.exposeProxy) {
- // Make invocation available if necessary.
- oldProxy = AopContext.setCurrentProxy(proxy);
- setProxyContext = true;
- }
- ... ...
- // Get the interception chain for this method.
- List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
- // Check whether we have any advice. If we don't, we can fallback on direct
- // reflective invocation of the target, and avoid creating a MethodInvocation.
- if (chain.isEmpty()) {
- // We can skip creating a MethodInvocation: just invoke the target directly
- // Note that the final invoker must be an InvokerInterceptor so we know it does
- // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
- retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
- }
- else {
- // We need to create a method invocation...
- invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
- // Proceed to the joinpoint through the interceptor chain.
- retVal = invocation.proceed();
- }
- ... ...
- }
在代码3处,如果配置了exposeProxy开关,则会将代理对象暴露在当前线程中,以供其它需要的地方使用。那么是怎么暴露的呢?答案很简单,通过使用静态的全局ThreadLocal变量就解决了问题。
3、Spring事务在多线程环境下失效
3.1 问题场景
沿用上面的代码稍作修改,加上事务配置:
- <!-- 数据库的事务管理器配置 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="meilvDataSource"/>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
代码如下所示:
- @Service
- @Transactional(propagation = Propagation.REQUIRED, timeout = 10000000)
- public class PersonServiceImpl implements IPersonService {
- @Autowired
- IUserDAO userDAO;
- @Override
- public String action(final String msg) {
- new Thread(new Runnable() {
- @Override
- public void run() {
- (getThis()).work(msg);
- }
- }).start();
- UserDO userDO = new UserDO();
- userDO.setName("lanlan");
- userDAO.insert(userDO);
- return "[" + msg + "]";
- }
- @Override
- public String work(String msg) {
- System.out.println("work: * " + msg + " *");
- UserDO userDO = new UserDO();
- userDO.setName("yanyan");
- userDAO.insert(userDO);
- throw new RuntimeException();
- }
- private IPersonService getThis() {
- try {
- return (IPersonService) AopContext.currentProxy();
- } catch (IllegalStateException e) {
- return this;
- }
- }
- }
结果:work方法中抛出异常,但是没有影响事务的回滚,说明事务在子线程中失效了。
3.2 解决方案
只需要将多线程中的方法提出来,或者作为另一个Service类中的方法即可。
- @Service
- @Transactional(propagation = Propagation.REQUIRED, timeout = 10000000)
- public class PersonServiceImpl implements IPersonService {
- @Autowired
- IUserDAO userDAO;
- @Override
- public String action(final String msg) {
- (getThis()).work(msg);
- UserDO userDO = new UserDO();
- userDO.setName("lanlan");
- userDAO.insert(userDO);
- return "[" + msg + "]";
- }
- @Override
- public String work(String msg) {
- System.out.println("work: * " + msg + " *");
- UserDO userDO = new UserDO();
- userDO.setName("yanyan");
- userDAO.insert(userDO);
- throw new RuntimeException();
- }
- private IPersonService getThis() {
- try {
- return (IPersonService) AopContext.currentProxy();
- } catch (IllegalStateException e) {
- return this;
- }
- }
- }
上面只是一个简单的例子,用于进行问题说明。
a、如果去掉多线程,将方法放在同一个类里,Spring则会根据事务的传播配置参数,是否重新启用新的事务。
b、如果将方法独立出来放在新的类里,并且该方法也配置了事务,则会重新启用新的事务。
3.3 原因分析
Spring的事务处理为了与数据访问解耦,它提供了一套处理数据资源的机制,而这个机制与上文中的原理相差无几,也是采用的ThreadLocal的方式。
在编程中,Service实例都是单例的无状态的,事务管理则需要加入事务控制的相关状态变量,使得Service实例不再是无状态线程安全的,解决这个问题的方式就是使用ThreadLocal。
通过使用ThreadLocal将数据源绑定在当前线程上,在当前线程的事务中,从设定的地方去取连接就会是同一个数据库连接,这样操作事务就会在同一个连接上进行。
如下图所示:
但是,ThreadLocal的特性是,绑定在当前线程中的变量不会自动传递到其它线程中(当然,InheritableThreadLocal可以在父子线程中间传递变量值,但是这需要特殊的使用场景),所以当开启子线程时,子线程并没有父线程的数据库连接资源。
对于上文提到的陷阱:如果另外开启线程,那么在新线程中将获取不到父线程的连接,事务要么失效,要么重新开启一个新的。
源代码如下:
- public abstract class DataSourceUtils {
- public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {
- try {
- return doGetConnection(dataSource);
- }
- catch (SQLException ex) {
- throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);
- }
- }
- public static Connection doGetConnection(DataSource dataSource) throws SQLException {
- ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
- if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
- conHolder.requested();
- if (!conHolder.hasConnection()) {
- logger.debug("Fetching resumed JDBC Connection from DataSource");
- conHolder.setConnection(dataSource.getConnection());
- }
- return conHolder.getConnection();
- }
- Connection con = dataSource.getConnection();
- ......
- return con;
- }
- }
- public abstract class TransactionSynchronizationManager {
- private static final ThreadLocal<Map<Object, Object>> resources =
- new NamedThreadLocal<Map<Object, Object>>("Transactional resources");
- /**
- * Retrieve a resource for the given key that is bound to the current thread.
- * @param key the key to check (usually the resource factory)
- * @return a value bound to the current thread (usually the active
- * resource object), or {@code null} if none
- * @see ResourceTransactionManager#getResourceFactory()
- */
- public static Object getResource(Object key) {
- Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
- Object value = doGetResource(actualKey);
- if (value != null && logger.isTraceEnabled()) {
- logger.trace("Retrieved value [" + value + "] for key [" + actualKey + "] bound to thread [" +
- Thread.currentThread().getName() + "]");
- }
- return value;
- }
- /**
- * Actually check the value of the resource that is bound for the given key.
- */
- private static Object doGetResource(Object actualKey) {
- Map<Object, Object> map = resources.get();
- if (map == null) {
- return null;
- }
- Object value = map.get(actualKey);
- // Transparently remove ResourceHolder that was marked as void...
- if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
- map.remove(actualKey);
- // Remove entire ThreadLocal if empty...
- if (map.isEmpty()) {
- resources.remove();
- }
- value = null;
- }
- return value;
- }
- }
4、总结
本文总结了Spring AOP和事务的两个陷阱,在平时的实际开发中经常与遇到,只有深入了解了其中的原理,才会在工作中能够有效应对。
Spring AOP和事务的相关陷阱的更多相关文章
- Web基础之Spring AOP与事务
Spring之AOP AOP 全程Aspect Oriented Programming,直译就是面向切面编程.和POP.OOP相似,它也是一种编程思想.OOP强调的是封装.继承.多态,也就是功能的模 ...
- Spring AOP及事务配置三种模式详解
Spring AOP简述 Spring AOP的设计思想,就是通过动态代理,在运行期对需要使用的业务逻辑方法进行增强. 使用场景如:日志打印.权限.事务控制等. 默认情况下,Spring会根据被代理的 ...
- 如何简单理解spring aop和事务
用比喻的方法理解吧: 初学者的理解,仅仅为了个人好记 aop:由三部分组成:工具箱,工人,为工人分配工具 tx事务:由四部分组成:管理者,制度,工人,向工人通知管理制度 为什么这样理解呢?个人觉得好 ...
- spring AOP 实现事务和主从读写分离
1 切面 是个类 2 切入点 3 连接点 4 通知 是个方法 5 配置文件 <?xml version="1.0" encoding="UTF-8"?&g ...
- Spring AOP (事务管理)
一.声明式事务管理的概括 声明式事务(declarative transaction management)是Spring提供的对程序事务管理的方式之一. Spring的声明式事务顾名思义就是采用声明 ...
- Spring AOP 面向切面编程相关注解
Aspect Oriented Programming 面向切面编程 在Spring中使用这些面向切面相关的注解可以结合使用aspectJ,aspectJ是专门搞动态代理技术的,所以比较专业. ...
- Java--通过Spring AOP进行事务管理
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sp ...
- Spring框架的事务管理相关的类和API
1. PlatformTransactionManager接口 -- 平台事务管理器.(真正管理事务的类).该接口有具体的实现类,根据不同的持久层框架,需要选择不同的实现类! 2. Transacti ...
- Spring AOP 管理事务
<aop:config proxy-target-class="true"> <aop:pointcut expression="execution(* ...
随机推荐
- 【C语言】22-枚举
上一讲介绍了结构体类型,这讲就介绍C语言中的另一种数据类型---枚举类型.枚举类型在iOS中也是很常用的,用法跟Java中的枚举类似. 一.枚举的概念 枚举是C语言中的一种基本数据类型,并不是构造类型 ...
- SAP ECC6安装系列五:安装后 License 的处理
原作者博客 http://www.cnblogs.com/Michael_z/ ======================================== 我发现我确实比较懒,先和各位说声抱歉了 ...
- response.setHeader各种用法
一秒刷新页面一次 response.setHeader("refresh","1"); 二秒跳到其他页面 (登陆跳转) response.setHeader(& ...
- java中高并发和高响应解决方法
并发不高.任务执行时间长的业务要区分开看: 假如是业务时间长集中在I/O操作上,也就是I/O密集型的任务,因为I/O操作并不占用CPU,所以不要让所有的CPU闲下来,可以加大线程池中的线程数目,让CP ...
- PHP——0128练习相关2——js点击button按钮跳转到另一个新页面
js点击button按钮跳转到另一个新页面 投稿:whsnow 字体:[增加 减小] 类型:转载 时间:2014-10-10我要评论 点击按钮怎么跳转到另外一个页面呢?点击图片要跳转到新的页面时,怎么 ...
- catch signal
捕抓信号 如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,称为捕抓信号. 除了SIGSTOP和SIGKILL进程能够忽略或捕获其他的全部信号. 注:信号可从两个不同分类角度对信号进行分 ...
- 百度JS模板引擎
1. 应用场景 前端使用的模板系统 或 后端Javascript环境发布页面 2. 功能描述 提供一套模板语法,用户可以写一个模板区块,每次根据传入的数据,生成对应数据产生的HTML片段,渲染不同 ...
- 常见的装包的三种宝,包 bao-devel bao-utils bao-agent ,包 开发包 工具包 客户端
常见的装包的三种宝,包 bao-devel bao-utils bao-agent ,包 开发包 工具包 客户端
- ASP.NET MVC 使用 Datatables (1)
具体步骤: 1.建立实体类 public class Asset { public System.Guid AssetID { get; set; } [Display(Name = "Ba ...
- 假设A.jsp内设定一个<jsp:useBean>元素:
假设A.jsp内设定一个<jsp:useBean>元素: <jsp:useBean id=”bean1” class=”myBean” /> 下列哪一个为真?(选择1项) A. ...