Android AOP：最简单&粗暴（使用与原理）讲解

2019年3月19日 216次阅读 来源: AOP

《Android AOP：最简单&粗暴（使用与原理）讲解》

1.前言

  • 最近随着项目迭代业务与使用的用户逐渐增多，陆续的出现了一些性能或者BUG的问题(例如：1.某些功能执行响应慢；2.按键复电；等等)。
  • 根据上述部分性能问题，提出相对应的解决方案：
    • 某些功能执行响应慢 —> 性能监控
    • 按键复点 —> 按键防抖
  • 上述2个解决方案的最终实现原理：就是在执行函数的前或者后台添加对应的逻辑处理。
  • 选择实现方式：
    1.直接在方法前后添加对应的逻辑。
    2.使用静态/动态代理。
    3.使用AOP。
  • 1与2方式：当涉及修改的方法或者类较多时，实现比较复杂，而且侵入性大，更不方便后期扩展与维护。
  • 第3方式：侵入性很少；实现简单；解耦性很大；易维护。而这种方式是如何使用？原理是什么？。
  • 今天就为大家揭开AOP的面纱。
  • 文章中实例 linhaojian的Github

2.介绍

2.1 AOP 是什么

  • AOP为Aspect Oriented Programming的缩写。意为：面向切面编程。

2.2 AOP 作用

  • 通过预编译方式和运行期动态代理，来改变原来执行结果的技术。

2.3 AOP 特点

  • 使原执行逻辑与改变执行逻辑解耦。
  • 对原代码侵入性少。
  • 容易扩展辅助功能(例如：日志)。

2.4 Android 中应用

  • 日志
  • 持久化
  • 性能监控
  • 数据校验
  • 缓存
  • 按钮防抖
  • 其他更多

2.5 AOP 术语

  • 通知、增强处理（Advice）：就是你想要的功能，也就是上面说的日志、耗时计算等。
  • 连接点（JoinPoint）：允许你通知（Advice）的地方，那可就真多了，基本每个方法的前、后（两者都有也行），或抛出异常是时都可以是连接点（spring只支持方法连接点）。AspectJ还可以让你在构造器或属性注入时都行，不过一般情况下不会这么做，只要记住，和方法有关的前前后后都是连接点。
  • 切入点（Pointcut）：上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有十几个连接点了对吧，但是你并不想在所有方法附件都使用通知（使用叫织入，下面再说），你只是想让其中几个，在调用这几个方法之前、之后或者抛出异常时干点什么，那么就用切入点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。
  • 切面（Aspect）：切面是通知和切入点的结合。现在发现了吧，没连接点什么事，连接点就是为了让你好理解切点搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过before，after，around等AOP注解就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。
  • 织入（weaving）： 把切面应用到目标对象来创建新的代理对象的过程。

2.6 AOP 注解

  • @Aspect：声明切面，标记类
  • @Pointcut(切点表达式)：定义切点，标记方法
  • @Before(切点表达式)：前置通知，切点之前执行
  • @Around(切点表达式)：环绕通知，切点前后执行
  • @After(切点表达式)：后置通知，切点之后执行
  • @AfterReturning(切点表达式)：返回通知，切点方法返回结果之后执行
  • @AfterThrowing(切点表达式)：异常通知，切点抛出异常时执行

@Pointcut、@Before、@Around、@After、@AfterReturning、@AfterThrowing需要在切面类中使用，即在使用@Aspect的类中。

2.7 切点表达式

《Android AOP：最简单&粗暴（使用与原理）讲解》
《Android AOP：最简单&粗暴（使用与原理）讲解》
《Android AOP：最简单&粗暴（使用与原理）讲解》

  • 示例：
    // 返回类型：* 类名+函数名：com.lhj.test_apt..*ck(..) 
    // com.lhj.test_apt..*ck(..) ：意思是com.lhj.test_apt包下所有类中以ck结尾的函数
    @Pointcut("execution(* com.lhj.test_apt..*ck(..))")

3.使用

  • 3.1 项目根目录(build.gradle)的dependencies中，添加如下代码：
    dependencies {
        classpath 'org.aspectj:aspectjtools:1.8.13'    // add
        classpath 'org.aspectj:aspectjrt:1.8.13'       // add
    }
  • 3.2 在主项目或者需要引用的library的build.gradle中，示例如下：
apply plugin: 'com.android.library'
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
android {
    compileSdkVersion 28
    defaultConfig {
        minSdkVersion 17
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    // aop
    implementation 'org.aspectj:aspectjrt:1.8.13'
}
project.android.libraryVariants.all { variant ->
    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)]
        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler)
        def log = 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
                    break;
                case IMessage.WARNING:
                case IMessage.INFO:
                    log.info message.message, message.thrown
                    break;
                case IMessage.DEBUG:
                    log.debug message.message, message.thrown
                    break;
            }
        }
    }
}
  • 3.3 定义切面类（例如：在源码一些方法上添加额外日志打印）：
/** * 添加切面注解 */
@Aspect
public class AopTest {
    private static final String TAG = "linhaojian";
    /** * 定义切入点（定义那些类或者方法需要改变） */
    @Pointcut("execution(* com.lhj.test_apt..*ck(..))")
    public void pointcut1() {
    }
    /** * 使用注解方式，定义注解 */
    @Pointcut("execution(@com.lhj.test_apt.DebugLog * *ck(..))")
    public void pointcut() {
    }
    /** * 前置通知，切点之前执行 * @param point */
    @Before("pointcut()")
    public void logBefore(JoinPoint point){
        Log.e(TAG,"logBefore");
    }
    /** * 环绕通知，切点前后执行 * @param joinPoint * @throws Throwable */
    @Around("pointcut()")
    public void logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.e(TAG,"logAround");
        // 1.执行切点函数（如果不调用该方法，切点函数不被执行）
        joinPoint.proceed();
    }
    /** * 后置通知，切点之后执行 * @throws Throwable */
    @After("pointcut()")
    public void logAfter(JoinPoint point){
        Log.e(TAG,"logAfter");
    }
    /** * 返回通知，切点方法返回结果之后执行 * @throws Throwable */
    @AfterReturning("pointcut()")
    public void logAfterReturning(JoinPoint point, Object returnValue){
        Log.e(TAG,"logAfterReturning ");
    }
    /** * 异常通知，切点抛出异常时执行 * @throws Throwable */
    @AfterThrowing(value = "pointcut()",throwing = "ex")
    public void logAfterThrowing(Throwable ex){
        Log.e(TAG,"logAfterThrowing : "+ex.getMessage());
    }
}
  • 注意：注释1中，如果使用了@Around注释，记得调用joinPoint.proceed()，不然切点的函数是不会被调用的。
  • 3.4 切点的使用方式：
  • 无侵入式：@Pointcut定义不包含注解时，就能实现源代码零修改的改变。
  • 低侵入式：@Pointcut定义包含注解时，就需要在源代码的函数中添加相应的注解，如下代码块。
public class AopActivity extends AppCompatActivity {
    private Button button；
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.aop);
        button = findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                click();
            }
        });
    }
    @DebugLog
    public void click(){
        Log.e("linhaojian","onClick()");
    }
}
  • DebugLog注解代码
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DebugLog {
}
  • 3.5 运行结果
    《Android AOP：最简单&粗暴（使用与原理）讲解》

4.原理

  • 在分析其原理前，我们先看看包含切点功能的类，编译之后的class文件内容：
public class AopActivity extends AppCompatActivity {
    private Button button;
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        this.setContentView(layout.aop);
        this.button = (Button)this.findViewById(id.button);
        this.button.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                AopActivity.this.click();
            }
        });
    }
    @DebugLog
    public void click() {
        // 1
        JoinPoint var1 = Factory.makeJP(ajc$tjp_0, this, this);
        try {
            try {
                // 2
                AopTest.aspectOf().logBefore(var1);
               // 3
                click_aroundBody1$advice(this, var1, AopTest.aspectOf(), (ProceedingJoinPoint)var1);
            } catch (Throwable var4) {
                AopTest.aspectOf().logAfter(var1);
                throw var4;
            }
            AopTest.aspectOf().logAfter(var1);
            AopTest.aspectOf().logAfterReturning(var1, (Object)null);
        } catch (Throwable var5) {
            AopTest.aspectOf().logAfterThrowing(var5);
            throw var5;
        }
    }
}
@Aspect
public class AopTest {
    //...
    public static AopTest aspectOf() {
        if (ajc$perSingletonInstance == null) {
            throw new NoAspectBoundException("com.lhj.test_apt.AopTest", ajc$initFailureCause);
        } else {
            return ajc$perSingletonInstance;
        }
    }
    public static boolean hasAspect() {
        return ajc$perSingletonInstance != null;
    }
    static {
        try {
            // 4
            ajc$postClinit();
        } catch (Throwable var1) {
            ajc$initFailureCause = var1;
        }
    }
}
  • 从上面编译后的class文件，可以看很清楚编译时改变了原方法的执行流程或结果，添加了切面类中定义的一些额外执行逻辑（例如：logBefore、logAfter）；
  • 注释1：通过工厂类，创建ProceedingJoinPoint的实例；
  • 注释2：AopTest.aspectOf()代表获取AopTest的单例（单例时在注释4中通过static块初始化）；
  • 注释3：其实就是将原方法的执行内容封装至ProceedingJoinPoint，使它们之间关联。

5.总结

  • 到此，AOP就结束完毕。
  • 如果喜欢我的分享，可以点击  关注  或者  赞，你们支持是我分享的最大动力 。
    –  linhaojian的Github

欢迎关注linhaojian_CSDN博客或者linhaojian_简书！

不定期分享关于安卓开发的干货。

写技术文章初心

  • 技术知识积累
  • 技术知识巩固
  • 技术知识分享
  • 技术知识交流
    原文作者：AOP
    原文地址: https://blog.csdn.net/qwe851023/article/details/84983190
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞