Spring_9_AspectJ-Advice定义及实例

=Advice定义及实例===================================================
Before advice

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MoocAspect {
 
 @Before("execution(* com.imooc.aop.aspectj.biz.*Biz.*(..))")//在执行com.imooc.aop.aspectj包下以Biz结尾的类所有方法时匹配Advice
 public void before() {
  System.out.println("Before.");
 } 
}

=============================================
After Returning advice

@Aspect
public class AfterReturningExample {
 @AfterReturning("com.xyz.myapp.SystemArchitecture.dateAccessOperation()")
 public void doAccessCheck() {
 //...
 }
}
·有时又需要在通知体内得到返回的实际值，可以使用@AfterReturning绑定返回值的形式
@Aspect
public class AfterReturningExample {
 @AfterReturning(
     pointcut="com.xyz.myapp.SystemArchitecture.dateAccessOperation()",
     returning="retVal")
 public void doAccessCheck(Object retVal) //不确定返回值类型，使用Object，确定时可使用相应类型
 {
 //...
 }
}
====================================================
After Throwing advice

@Aspect
public class AfterThrowingExample {
 @AfterThrowing("com.xyz.myapp.SystemArchitecture.dateAccessOperation()")
 public void doAccessCheck() {
 //...
 }
}
·有时又需要在通知体内得到返回的实际值，可以使用@AfterThrowing绑定返回值的形式
@Aspect
public class AfterThrowingExample {
 @AfterThrowing(
     pointcut="com.xyz.myapp.SystemArchitecture.dateAccessOperation()",
     throwing="ex")
 public void doAccessCheck(DateAccessException ex) //不确定返回值类型，使用Object，确定时可使用相应类型
 {
 //...
 }
}
====================================================
After (finally) advice
最终通知必须准备处理正常和异常两种返回情况，它通常用于释放资源
像是java的try catch finally代码块的finally 通常用于释放资源
@Aspect
public class AfterFinallyExample {
 @After("com.xyz.myapp.SystemArchitecture.dateAccessOperation()")
 public void doReleaseLock() {
 //...
 }
}
====================================================
Around advice
·环绕通知使用@Around注解来生命，通知方法的第一个参数必ProceedingJoinPoint类型
·在通知内部调用ProceedingJoinPoint的proceed()方法导致执行真正的方法，传到一个Object[]对象，
数组中的值将作为参数传递给方法 proceed[proʊˈsi:d]vi.进行;前进;尤指打断后）继续说 n收入获利
@Aspect
public class AroundExample {
 @Around("com.xyz.myapp.SystemArchitecture.dateAccessOperation()")
 public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Trowable {//pjp.proceed()可能会抛出异常处理方式1.throws 该exception2.catch该异常
 //start stopwatch
 Object retVal = pjp.proceed();//真正执行方法的步骤，不知道真正的方法是否有返回值，
 //所以用通用类型Object接收(void也是特殊类型的返回值)
 //stop  stopwatch
 }
}
==Advicer扩展==================================================
给advice传递参数
方式1 用来获取相应的参数进行判断或记录
@Before("com.xyz.myapp.SystemArchitecture.dateAccessOperation() && args(account,..)")//account与方法参数的名称一致
public void validateAccount(Account account) {
 System.out.println("Before.");
}
方式2(与方式1等效)
@Pointcut("com.xyz.myapp.SystemArchitecture.dateAccessOperation() && args(account,..)")//account与方法参数的名称一致
public void accountDataAccessPoeration(Account account) {}

@Before("accountDataAccessPoeration(account)")
public void validateAccount(Account account) {
 System.out.println("Before.");
}

方式3:作用1 记录 2 判断方法用了哪些注解或者注解的值，根据注解的不同或注解value的不同，可以做一些前置的操作
1）定义一个注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Auditable { 
 AuditCode value();
}
2）使用该注解
@Before("com.xyz.lib.Pointcuts.anyPublicMethod() && @annotation(auditable)")
public void auditAuditable auditable){
 AuditCode code = auditable.value();
 //System.out.println("Before.");
}

===Advice的参数及泛型=================================================
·Spring AOP可以处理泛型类的声明和使用方法的参数
public interface Sample<T> {
 void sampleGenericMethod(T param);
 void sampleGenericCollectionMethod(Collection<T> param);
}

@Before("execution(* ..Sample+.sampleGenericMethod(*)) && args(param)")
public void beforeSampleMethod(MyType param) {
 //advice implementation
}
@Before("execution(* ..Sample+.sampleGenericCollectionMethod(*)) && args(param)")
public void beforeSampleGenericCollectionMethod(Collection<MyType> param) {
 //advice implementation
}
===Advice参数名称=================================================
通知和切入点注解有一个额外的"argNames"属性,它可以用来指定所注解的方法的参数名

@Before(value = "com.xyz.lib.Pointcuts.anyPublicMethod() && target(bean) && @annotation(auditble)",
 argNames="bean,auditable")
public void audit(Object bean,Auditable auditable){
 AuditCode code = auditable.value();
 //...use code and bean
}
如果第一个参数是JoinPoint,ProceedingJoinPoint,JoinPoint.StaticPart,那么可以忽略它
@Before(value = "com.xyz.lib.Pointcuts.anyPublicMethod() && target(bean) && @annotation(auditble)",
 argNames="bean,auditable")
public void audit(JoinPoint jp,Object bean,Auditable auditable){
 AuditCode code = auditable.value();
 //...use code and bean
}
===Introductions=======================================================
·允许一个切面声明一个通知对象实现指定接口，并且提供了一个接口实现类来代表这些对象
·introduction使用@DeclareParents进行注解，这个注解用来定义匹配的类型拥有ige新的parent
例如：给定一个接口UsageTracked,并且该接口拥有DefaultUsageTracked的实现，
接下来的切面声明了所有service皆苦的实现都实现了UsageTracked接口

@Aspect
public class UsageTracking {
 @DeclareParents(value="com.xzy.myapp.service.*+",defaultImpl="DefaultUsageTracked.class")
 public static UsageTracked mixin;
 @Before("com.xyz.myapp.SystemArchitecture.bussinessService() && this(usageTracked)")
 public void recordUsage(UsageTracked usageTracked) {
  usageTracked.incrementUseCount();
 }
}
====切面实例化模型===================================
·这是一个高级主题
·"perthis"切面通过指定@Aspect注解perthis子句实现
·每个独立的service对象执行时都会创建一个切面实例
·service对象的每个方法在第一次执行的时候创捷切面实例，切面在service对象失效的同事失效

@Aspect("perthis(com.xyz.myapp.SystemArchitecture.businessService())")
public class MyAspect {

 private int someState;

 @Before("com.xyz.myapp.SystemArchitecture.bussinessService()")
 public void recordServiceUsage () {
  //...
 }
}

====================================================
====================================================

定义注解

package com.imooc.aop.aspectj;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MoocMethod {
 
 String value();
}

====================================================
例子

package com.imooc.aop.aspectj;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MoocAspect {
    
    //a    @Pointcut("execution(* com.imooc.aop.aspectj.biz.*Biz.*(..)) && @annotation(moocMethod)")
    //a    public void pointcut(MoocMethod moocMethod) {}
    @Pointcut("execution(* com.imooc.aop.aspectj.biz.*Biz.*(..))")
    public void pointcut() {}
    
    @Pointcut("within(com.imooc.aop.aspectj.biz.*)")
    public void bizPointcut() {}
    
    @Before("pointcut()")// pointcut()方法上面声明了一种类型的pointcut，此处可以使用代替@Before("execution(* com.imooc.aop.aspectj.biz.*Biz.*(..))")表达式
    public void before() {
        System.out.println("Before.");
    }
    
    @Before("pointcut() && args(arg)")
    public void beforeWithParam(String arg) {
        System.out.println("BeforeWithParam." + arg);
    }
    
    @Before("pointcut() && @annotation(moocMethod)")
    //a    @Before("pointcut(moocMethod)")
    public void beforeWithAnnotaion(MoocMethod moocMethod) {
        System.out.println("BeforeWithAnnotation." + moocMethod.value());
    }
    
    @AfterReturning(pointcut="bizPointcut()", returning="returnValue")
    public void afterReturning(Object returnValue) {
        System.out.println("AfterReturning : " + returnValue);
    }
    
    @AfterThrowing(pointcut="pointcut()", throwing="e")
    public void afterThrowing(RuntimeException e) {
        //e.printStackTrace();//调试时，可以打印出堆栈信息
        System.out.println("AfterThrowing : " + e.getMessage());
    }
    
    @After("pointcut()")
    public void after() {
        System.out.println("After.");
    }

    @Around("pointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("Around 1.");
        Object obj = pjp.proceed();
        System.out.println("Around 2.");
        System.out.println("Around : " + obj);
        return obj;
    }
    
}

 

==xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <context:component-scan base-package="com.imooc.aop.aspectj"/>
      <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
 </beans>

==biz

package com.imooc.aop.aspectj.biz;
import org.springframework.stereotype.Service;
import com.imooc.aop.aspectj.MoocMethod;
@Service
public class MoocBiz {
 
 @MoocMethod("MoocBiz save with MoocMethod.")//给注解赋值
 public String save(String arg) {
  System.out.println("MoocBiz save : " + arg);
//  throw new RuntimeException(" Save failed!");
  return " Save success!";
 }
}

==Test

package com.imooc.test.aop.aspectj;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;
import com.imooc.aop.aspectj.biz.MoocBiz;
import com.imooc.test.base.UnitTestBase;
@RunWith(BlockJUnit4ClassRunner.class)
public class TestAspectJ extends UnitTestBase {
 
 public TestAspectJ() {
  super("classpath:spring-aop-aspectj.xml");
 }
 
 @Test
 public void test() {
  MoocBiz biz = getBean("moocBiz");
  biz.save("This is test.");
 }
 
}