spring 配置 aop
<aop:config>
<aop:aspect id="asp1" ref="monitorApi">
<!-- 配置一个切入点,相当于@Pointcut -->
<aop:pointcut expression="execution(* com.xxx.xxx.impl.service.*.*(..))" id="simplePointcut"/>
<aop:before method="serviceBefore" pointcut-ref="simplePointcut" />
<aop:after method="release" pointcut-ref="simplePointcut" />
<aop:after-returning method="serviceAfter" pointcut-ref="simplePointcut" returning="rvt" />
<aop:around method="processTx" pointcut-ref="simplePointcut" />
<aop:after-throwing pointcut-ref="simplePointcut" method="afterThrow" throwing="ex"/>
</aop:aspect>
</aop:config>
切面类：
package com.changhang.urgoo.impl.utils;
import com.changhang.urgoo.impl.entity.result.MesResult;
import com.changhang.urgoo.impl.entity.result.SpResult;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
public class MonitorApi{
/**
* 通知前
* @date 2016年9月27日 上午9:18:10
* @Title before
* @Description
* @param jp void
* @throws
*/
public void serviceBefore(JoinPoint jp) {
// System.out.println("被代理方法名字："+jp.getSignature().getName());
// System.out.println("被代理方法参数："+jp.getArgs().toString());
// System.out.println("被代理对象："+jp.getTarget());
// System.out.println("模拟权限验证");
}
/**
*
* @date 2016年9月27日 上午9:18:29
* @Title log
* @Description
* @param jp
* @param rvt void
* @throws
*/
public void serviceAfter(JoinPoint jp, Object rvt){
long start= System.currentTimeMillis();
System.out.println("被代理方法名字："+jp.getSignature().getName());
System.out.println("被代理方法参数："+jp.getArgs());
System.out.println("被代理对象："+jp.getTarget());
System.out.println("被代理对象的返回值"+rvt);
System.out.println("现在调用的是日志管理");
long end= System.currentTimeMillis();
System.err.println(">>>>>>>>>>>日志处理时间共："+(end-start)+" 毫秒");
}
/**
*
* @date 2016年9月27日 上午9:18:53
* @Title processTx
* @Description
* @param pjp
* @return
* @throws Throwable Object
* @throws
*/
public Object processTx(ProceedingJoinPoint pjp) throws Throwable
{
long start= System.currentTimeMillis();
System.out.println("现在调用的是事务开启");
//得到业务方法的参数
Object[] args=pjp.getArgs();
System.out.println("业务方法的参数："+args.toString());
// Object result = pjp.proceed(args);
//被代理对象的业务方法
Object result = null;
try{
result=pjp.proceed(args);
System.out.println("现在调用的是事务提交或回滚");
long end= System.currentTimeMillis();
System.err.println(">>>>>>>>>>>事物处理时间共："+(end-start)+" 毫秒");
return result;
} catch (Exception e) {
// e.printStackTrace(); // 此处不进行打印，交由spring委托afterThrow进行打印
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
SpResult sr = new SpResult();
sr.setHeaderCode("400");
sr.setHeaderMessage(MesResult.messageInfo(MesResult.SERVER_BUSY, null));
sr.setBody(null);
return sr;
//throw e;
} finally {
;
}
}
/**
*
* @date 2016年9月27日 上午9:19:43
* @Title release
* @Description void
* @throws
*/
public void release(){
System.out.println("资源已经被释放！");
}
//配置抛出异常后通知,使用在方法aspect()上注册的切入点
public void afterThrow(JoinPoint jp, Exception ex){
long start= System.currentTimeMillis();
System.out.println("被代理方法名字："+jp.getSignature().getName());
System.out.println("被代理方法参数："+jp.getArgs());
System.out.println("被代理对象："+jp.getTarget());
System.out.println("被代理对象的返回值"+ex);
ex.printStackTrace();
System.out.println("现在调用的是异常管理");
long end= System.currentTimeMillis();
System.err.println(">>>>>>>>>>>异常处理时间共："+(end-start)+" 毫秒");
System.err.println("------------afterThrow---------------");
}
}
service：
@Service
@Transactional
public class TestService extends BaseService{
@Autowired
private TestAccessor testAccessor;
public SpResult aop(Map<String,String> map) {
SpResult sp = new SpResult();
testAccessor.insertTest(map);
testAccessor.selectTest();
return sp;
}
public SpResult withoutaop(Map<String,String> map) {
SpResult sp = new SpResult();
try{
testAccessor.insertTest(map);
testAccessor.selectTest();
} catch (Exception e) {
// e.printStackTrace();
//TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
throw new RuntimeException(e);
} finally {
;
}
return sp;
}
}
其中 insertTest正常，selectTest异常
函数aop完全不考虑异常，由Spring来全程捕捉处理，到了processTx中，集中处理
函数withoutaop则有try catch代码，扔出throw new RuntimeException(e);，效果等同于aop，如果此处没有扔出，则切面代理会走around -------- after-returning，因为spring不认为由异常发生，
扔出后，走around ------- after-throwing
注意，在catch中一般需要throw出异常，否则自行处理则spring认为没有异常在service发生，将不会回滚，当然也可以在catch中显式回滚：
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
但是这样所有函数代码变得冗长不好维护，不如不进行try catch操作，原则上service层不进行try catch，有必须释放的资源则finally throw return ，但仍然需注意将e抛出给spring，并且finally不能由任何返回，否则spring同样认为没有异常发生（finally throw return ）
processTx中，
result=pjp.proceed(args);
前后，Spring捕捉到异常，会进行一系列处理，回滚等等，原则上也不进行try catch，
但此处考虑到异常的返回值，此处显式回滚，并定义异常返回值，在集中处理器中自行处理异常