Android Aop基本知识和使用

最强反击!程序员注册996.ICU域名炮轰“996”工作制
在互联网公司之中,实行“996 工作制”几乎成为默认标配,在去年的年会中,有赞 CEO 白鸦将这种企业文化公开的在公司年会提出、并被广泛地传播出来,撕掉了互联网企业因焦虑而追赶的遮羞布。
因不满最近各个 IT 公司的工作 996 制度,这次程序员终于忍不了啦。昨天,一个域名为 996.ICU 的网站突然出现,控诉“工作 996,生病 ICU”,并且还发在了 GitHub 上,一个小时后就获得了上千个标星。
github地址

1.最近重温了一下Aop的知识,发现之前不懂的都一下明白了。这个东西还挺好玩的。然后....先普及一下概念性的东西

AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

Aop思想可以说成插桩,在类的编译期间中干一些东西,下图看一个图就明白了,主要关注一下AspectJ插入时机

image.png

2.了解基本概念性的东西开始引入AspectJ

apply plugin: 'com.android.application'
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
android {
  ...
}

final def log = project.logger
final def variants = project.android.applicationVariants
variants.all { variant ->
    if (!variant.buildType.isDebuggable()) {
        log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
        return;
    }

    JavaCompile javaCompile = variant.javaCompile
    javaCompile.doLast {
        String[] args = ["-showWeaveInfo",
                         "-1.8",
                         "-inpath", javaCompile.destinationDir.toString(),
                         "-aspectpath", javaCompile.classpath.asPath,
                         "-d", javaCompile.destinationDir.toString(),
                         "-classpath", javaCompile.classpath.asPath,
                         "-bootclasspath", project.android.bootClasspath.join(File.pathSeparator)]
        log.debug "ajc args: " + Arrays.toString(args)

        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler);
        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
                    break;
                case IMessage.WARNING:
                    log.warn message.message, message.thrown
                    break;
                case IMessage.INFO:
                    log.info message.message, message.thrown
                    break;
                case IMessage.DEBUG:
                    log.debug message.message, message.thrown
                    break;
            }
        }
    }
}


dependencies {
    ...
    implementation 'org.aspectj:aspectjrt:1.8.9'
}

3.切换到project的build.gradle

buildscript {
    
    repositories {
        google()
        jcenter()
    }
    dependencies {
        ....
        classpath 'org.aspectj:aspectjtools:1.8.9'
        classpath 'org.aspectj:aspectjweaver:1.8.9'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

4.在动手之前,要大概知道Aspectj语法详细说明,下面就列一些比较常用的注解关键字

@Aspect:声明切面,标记类,使用下面注解之前一定要在类使用@Aspec

@Aspect
public class AnnAopTestExample {
}

然后先说一下切入的表达式,通配符看上面的超链接Aspectj语法详细说明
execution(<修饰符模式>? <返回类型模式> <方法名模式>(<参数模式>) <异常模式>?)

/*执行的activity的on系列的方法*/
execution(* android.app.Activity.on**(..))

@Pointcut(切点表达式):定义切点,标记切入方法

/*标记切入执行的activity的on系列的方法*/
@Pointcut("execution(* android.app.Activity.on**(..))")

@Before(切点表达式):切点之前执行,
@After(切点表达式):切点之后执行,和before相反。
随便说说两种使用方法,个人比较喜欢第一种

  /*第一种*/
  @Pointcut("execution(* android.app.Activity.on**(..))")
    public void executionActivityOn(){

    }

    @Before("executionActivityOn()")
    public void executionActivityOnBefore(JoinPoint joinPoint){
        Log.d(TAG, "executionActivityOnBefore: ");
    }
/*第二种*/
   @Before("execution(* android.app.Activity.on**(..))")
    public void executionActivityOnBefore(JoinPoint joinPoint){
        Log.d(TAG, "executionActivityOnBefore: ");
    }

运行一下看看效果


image.png

@AfterReturning(切点表达式):返回通知,切点方法返回结果之后执行
@AfterThrowing(切点表达式):异常通知,切点抛出异常时执行

@Around 切点前后执行

  @Pointcut("execution(* com.example.aop.MainActivity.testAop())")
    public void executionTestAop(){ }

    @Around("executionTestAop()")
    public void executionTestAopAround(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.d(TAG, "MainActivity executionTestAopAround: before");
        /*执行MainActivity中的testAop()方法---执行原方法*/
        joinPoint.proceed();
        Log.d(TAG, "MainActivity executionTestAopAround: After");
    }

效果如下:


image.png

在使用了注解@Around,@Before方法中的参数ProceedingJoinPoint,JoinPoint。JoinPoint是ProceedingJoinPoint的父类
在JoinPoint接口中方法说明
1.String toString(); //连接点所在位置的相关信息
2.String toShortString(); //连接点所在位置的简短相关信息
3.String toLongString(); //连接点所在位置的全部相关信息
4.Object getThis(); //返回AOP代理对象
5.Object getTarget(); //返回目标对象
6.Object[] getArgs(); //返回被通知方法参数列表
7.Signature getSignature(); //返回当前连接点签名
8.SourceLocation getSourceLocation();//返回连接点方法所在类文件中的位置
9.String getKind(); //连接点类型
10.StaticPart getStaticPart(); //返回连接点静态部分

在ProceedingJoinPoint接口中方法说明
1.Object proceed(),Object proceed(Object[] args)//执行切入点的原方法

关于Aop中的运用的实际场景,一开始的图来源于这个博客,差不多要动手写一个小Demo来练习并加深理解--防止View被连续点击触发多次事件

创建注解SingleClick,默认800millisecond之内重复点击拦截,对java注解不了解可以自行百度一下哦


@Retention(RetentionPolicy.CLASS)
@Target(ElementType.METHOD)
public @interface SingleClick {
    long clickIntervals() default 800;
}

切面类SingleClickAop

@Aspect
public class SingleClickAop {

    static final String TAG=SingleClickAop.class.getName();
    static final int KEY=R.id.click_id;

    @Pointcut("execution(@ com.example.aop.aop.annotation.SingleClick * *(..))")
    public void executionSingleClick(){

    }

    @Around("executionSingleClick() && @annotation(singleClick)")
    public void executionSingleClickAround(ProceedingJoinPoint joinPoint, SingleClick singleClick) throws Throwable {
//        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
//        SingleClick singleClick = methodSignature.getMethod().getAnnotation(SingleClick.class);
//        singleClick.clickIntervals();
        View view=null;
        for (Object o :joinPoint.getArgs()) {
            if(o instanceof View){
                view= (View) o;
            }
        }
        if(view!=null){
            Object tag = view.getTag(KEY);
            long lastClickTime= tag==null?0: (long) tag;
            Log.d(TAG, "executionSingleClickAround: lastClickTime  "+lastClickTime+"   clickIntervals  "+singleClick.clickIntervals());
            long currentTime=Calendar.getInstance().getTimeInMillis();
            if(currentTime-lastClickTime>=singleClick.clickIntervals()){
                view.setTag(KEY,currentTime);
                Log.d(TAG, "executionSingleClickAround: currentTime  "+currentTime);
                joinPoint.proceed();
            }
        }
    }
}

使用方法

@SingleClick(clickIntervals = 2000)
    @Override
    public void onClick(View v) {
        Toast.makeText(this, "1", Toast.LENGTH_SHORT).show();
    }

首先获取注解clickIntervals 有两种方法:

        /*方法一:*/
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        SingleClick singleClick = methodSignature.getMethod().getAnnotation(SingleClick.class);
        singleClick.clickIntervals();
        /*方法二:*/
        @Around("executionSingleClick() && @annotation(singleClick)")
        public void executionSingleClickAround(ProceedingJoinPoint joinPoint, SingleClick singleClick) throws Throwable {
            Log.d(TAG, "executionSingleClickAround:  "+"   clickIntervals  "+singleClick.clickIntervals());
      
    }

获取到注解的值之后,通过joinPoint.getArgs()判断onClick(View v)中方法参数,然后view.setTag()设置标识,判断下次点击是否已经点击过,如果点击过判断点击间隔是否大于singleClick.clickIntervals(),如果超过800毫秒就执行方法。。

对于刚刚学aop注意几个坑
1.在切入表达式中,没有代码提示不要写错单词,最好c+v
2.@Pointcut("execution(@ com.example.aop.aop.annotation.SingleClick * *(..))"),在SingleClick * * 中两个 * 之间一定要用空格分开。
3.使用@Pointcut 来写切入点的时候,复制方法名的时候不要忘记加上括号,不然切的是executionSingleClick或而不是executionSingleClick()。不要傻乎乎的,虽然我是傻乎乎过来的

  @Pointcut("execution(@ com.example.aop.aop.annotation.SingleClick * *(..))")
    public void executionSingleClick(){

    }

    @Around("executionSingleClick() && @annotation(singleClick)")

推荐阅读更多精彩内容