Spring Aop详解

Aop是面向切面编程，即把某一功能模块给抽出来对所有的方法都生效，如：权限控制，系统的每个功能方法都要校验权限，所以可以使用AOP，即把权限校验单独拿出来做一个切面，每次访问任意方法时都会经过切面，这就是AOP面向切面编程。采用动态代理实现。

术语

Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.

Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义（规定） 比如要拦截以delete开头的方法，这种规定称之为Pointcut

Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为

前置通知,:先执行通知在执行拦截地方法

后置通知：先执行拦截的方法在执行通知。抛异常不执行

异常通知：抛出异常后执行的通知

最终通知：不管出不出异常都要执行，如果不抛异常类似于后置通知

环绕通知：前后都要执行的通知(切面要完成的功能)

Target(目标对象):代理的目标对象(被拦截的对象)

Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.

spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入

Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类

Aspect(切面): 是切入点和通知的结合

AOP注解

l @Before 前置通知，相当于BeforeAdvice 

l @AfterReturning 后置通知，相当于AfterReturningAdvice  抛异常不执行

l @Around 环绕通知，相当于MethodInterceptor 

l @AfterThrowing抛出通知，相当于ThrowAdvice 

l @After 最终final通知，不管是否异常，该通知都会执行

连接点

  

@Repository
public class UserServer {

public UserServer(){
System.out.println("ddd");
}
public void getName(String name){
System.out.println("Hellow Word:"+name);
}

public int save() throws MyExecption {
System.out.println("Save Succcess");
//         if(1==1){ 为测试异常通知
//             throw new MyExecption("dd");
//         }
return 1;
}
}

切面(切入点+通知)

@Aspect
@Service
public class AopTest {

//把切点表达式一样的单独抽取出来，下面可以直复用
@Pointcut(value="execution(* com.test.*.*(..))")
public void myPointCut(){
}
//前置通知
@Before(value= "AopTest.myPointCut()")
public void before1(JoinPoint joinPonit){
System.out.println("前置通知,拦截到的方法名称为:"+joinPonit.getSignature());
}

//后置通知
@AfterReturning(value="AopTest.myPointCut()",returning="retunrnValue")
public void afterReturning(JoinPoint joinpoin,Object retunrnValue){
System.out.println("后置通知,并且方法返回值为:"+retunrnValue);
}

//环绕通知
@Around(value="AopTest.myPointCut()")
public Object around(ProceedingJoinPoint joinPoin) throws Throwable {
System.out.println("开启事务");
Object proceed =(Object)joinPoin.proceed();
System.out.println("关闭事务..");
return proceed;
}

//异常通知
@AfterThrowing(value="AopTest.myPointCut()",throwing="ex")
public void AfterThrowingTest(JoinPoint joinPoin,Exception ex){
System.out.println("方法:"+joinPoin.getSignature()+"抛出的异常为:"+ex.getMessage());
}

//最终通知
@After(value="AopTest.myPointCut()")
public void after(){
System.out.println("最终通知************************");
}
}

自定义异常类:

public class MyExecption extends Exception {

MyExecption(String test){
super(test);
}
}

Client:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-config.xml")
public class LocalTest{
@Resource
UserServer userServer;
@Test
public void localtest() throws MyExecption {
// userServer.getName("test");
int save = userServer.save();
System.out.println(save);
}
}

AOP XML的方式:

<!-- 切面 -->
<bean id="myAspect" class="com.test.MyAspect"/>
<!-- 基于xml配置切面 -->
<aop:config>
<aop:aspect ref="myAspect">
<!-- 定义一个切点表达式 -->
<aop:pointcut
expression="* com.test.*.*(..))"
id="myPointCut"/>
<!-- 前置通知 -->
<aop:before method="before1" pointcut-ref="myPointCut"/>
<!-- 后置通知 -->
<aop:after-returning returning="myReturn" method="afterReturning1" pointcut-ref="myPointCut"/>
<!-- 环绕通知 -->
<aop:around method="around1" pointcut-ref="myPointCut"/>
<!-- 异常通知 -->
<aop:after-throwing pointcut-ref="myPointCut" method="afterThrowing1" throwing="ex"/>
<!-- 最终通知 -->
<aop:after method="after1" pointcut-ref="myPointCut"/>
</aop:aspect>
</aop:config>