AOP

pointcut testAll(Test.TestDerived derived,int x):call(*Test.TestDerived.testMethod(..))
             && target(derived)&& args(x)

pointcut testAll():call(*Test.TestDerived.testMethod(..)) && target(Test.TestDerived) &&args(int)是一样的

Object around(Test.TestDerived derived,int x):testAll(derived,x){
     System.out.println("     arg1=" + derived);
     System.out.println("     arg2=" + x);
      return proceed(derived,x); //注意，proceed就必须把所有参数传进去。
}

package com.androidaop.demo;
import android.util.Log;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.JoinPoint;
 
@Aspect   //必须使用@AspectJ标注，这样class DemoAspect就等同于 aspect DemoAspect了
public class DemoAspect {
    staticfinal String TAG = "DemoAspect";
/*
@Pointcut：pointcut也变成了一个注解，这个注解是针对一个函数的，比如此处的logForActivity()
其实它代表了这个pointcut的名字。如果是带参数的pointcut，则把参数类型和名字放到
代表pointcut名字的logForActivity中，然后在@Pointcut注解中使用参数名。
基本和以前一样，只是写起来比较奇特一点。后面我们会介绍带参数的例子
*/
@Pointcut("execution(* com.androidaop.demo.AopDemoActivity.onCreate(..)) ||"
        +"execution(* com.androidaop.demo.AopDemoActivity.onStart(..))")
public void logForActivity(){};  //注意，这个函数必须要有实现，否则Java编译器会报错
 
/*
@Before：这就是Before的advice，对于after，after -returning，和after-throwing。对于的注解格式为
@After，@AfterReturning，@AfterThrowing。Before后面跟的是pointcut名字，然后其代码块由一个函数来实现。比如此处的log。
*/
    @Before("logForActivity()")
    public void log(JoinPoint joinPoint){
       //对于使用Annotation的AspectJ而言，JoinPoint就不能直接在代码里得到多了，而需要通过
      //参数传递进来。
       Log.e(TAG, joinPoint.toShortString());
    }
}
 

@Pointcut("execution(* *..AopDemoActivity.on*(..))")
public void logForActivity(){};

package com.androidaop.demo;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
//第一个@Target表示这个注解只能给函数使用
//第二个@Retention表示注解内容需要包含的Class字节码里，属于运行时需要的。
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SecurityCheckAnnotation {//@interface用于定义一个注解。
    publicString declaredPermission();  //declarePermssion是一个函数，其实代表了注解里的参数
}
怎么使用注解呢？接着看代码：
//为checkPhoneState使用SecurityCheckAnnotation注解，并指明调用该函数的人需要声明的权限
   @SecurityCheckAnnotation(declaredPermission="android.permission.READ_PHONE_STATE")
   private void checkPhoneState(){
        //如果不使用AOP，就得自己来检查权限
       if(checkPermission("android.permission.READ_PHONE_STATE") ==false){
           Log.e(TAG,"have no permission to read phone state");
           return;
        }
       Log.e(TAG,"Read Phone State succeed");
       return;
    }

/*
来看这个Pointcut，首先，它在选择Jpoint的时候，把@SecurityCheckAnnotation使用上了，这表明所有那些public的，并且携带有这个注解的API都是目标JPoint
接着，由于我们希望在函数中获取注解的信息，所有这里的poincut函数有一个参数，参数类型是
SecurityCheckAnnotation，参数名为ann
这个参数我们需要在后面的advice里用上，所以pointcut还使用了@annotation(ann)这种方法来告诉
AspectJ，这个ann是一个注解
*/
  @Pointcut("execution(@SecurityCheckAnnotation public * *..*.*(..)) && @annotation(ann)")
  publicvoid checkPermssion(SecurityCheckAnnotationann){};
 
/*
接下来是advice，advice的真正功能由check函数来实现，这个check函数第二个参数就是我们想要
的注解。在实际运行过程中，AspectJ会把这个信息从JPoint中提出出来并传递给check函数。
*/
   @Before("checkPermssion(securityCheckAnnotation)")
    publicvoid check(JoinPoint joinPoint,SecurityCheckAnnotationsecurityCheckAnnotation){
        //从注解信息中获取声明的权限。
       String neededPermission = securityCheckAnnotation.declaredPermission();
       Log.e(TAG, joinPoint.toShortString());
       Log.e(TAG, "\tneeded permission is " + neededPermission);
       return;
    }

  @Before("checkPermssion(securityCheckAnnotation)")
    publicvoid check(JoinPoint joinPoint,SecurityCheckAnnotation securityCheckAnnotation){
       String neededPermission = securityCheckAnnotation.declaredPermission();
       Log.e(TAG, "\tneeded permission is " + neededPermission);
        SecurityCheckManager manager =SecurityCheckManager.getInstanc();
       if(manager.checkPermission(neededPermission) == false){
           throw new SecurityException("Need to declare permission:" + neededPermission);
        }
       return;
    }

//AndroidAopDemo.build.gradle
//此处是编译一个App，所以使用的applicationVariants变量，否则使用libraryVariants变量
//这是由Android插件引入的。所以，需要import com.android.build.gradle.AppPlugin;
android.applicationVariants.all { variant ->
   /*
     这段代码之意是：
     当app编译个每个variant之后，在javaCompile任务的最后添加一个action。此action
     调用ajc函数，对上一步生成的class文件进行aspectj处理。
   */
    AppPluginplugin = project.plugins.getPlugin(AppPlugin)
   JavaCompile javaCompile = variant.javaCompile
   javaCompile.doLast{
       String bootclasspath =plugin.project.android.bootClasspath.join(File.pathSeparator)
       //ajc是一个函数，位于utils.gradle中
        ajc(bootclasspath,javaCompile)
    }
}

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
 
def ajc(String androidbootClassFiles,JavaCompile javaCompile){
   String[] args = ["-showWeaveInfo",
                     "-1.8", //1.8是为了兼容java 8。请根据自己java的版本合理设置它
                     "-inpath",javaCompile.destinationDir.toString(),
                     "-aspectpath",javaCompile.classpath.asPath,
                     "-d",javaCompile.destinationDir.toString(),
                     "-classpath",javaCompile.classpath.asPath,
                    "-bootclasspath", androidbootClassFiles]
    MessageHandlerhandler = new MessageHandler(true);
    new Main().run(args,handler)
 
    deflog = project.logger
    for(IMessage message : handler.getMessages(null, true)) {
     switch (message.getKind()) {
       case IMessage.ABORT:
       case IMessage.ERROR:
       case IMessage.FAIL:
         log.error message.message, message.thrown
         throw message.thrown
         break;
       case IMessage.WARNING:
       case IMessage.INFO:
         log.info message.message, message.thrown
         break;
       case IMessage.DEBUG:
         log.debug message.message, message.thrown
         break;
      }
    }
  }