Android性能优化神器-AspectJ

Bertha 。 2023-06-17 11:59 12阅读 0赞

## 一、AOP ##

AOP:面向切面编程(Aspect-Oriented Programming)。

如果说，OOP如果是把问题划分到单个模块的话，那么AOP就是把涉及到众多模块的某一类问题进行统一管理。

比如有三个模块：登陆、转账、大文件上传，现在需要加入性能检测功能，统计这三个模块每个方法耗时多少。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2VqaWVnZTY_size_16_color_FFFFFF_t_70]

OOP思想做法是设计一个性能检测模块，提供接口供这三个模块调用。这样每个模块都要调用性能检测模块的接口，如果接口有改动，需要在这三个模块中每次调用的地方修改。

AOP的思想做法是：在这些独立的模块间，在特定的切入点进行hook，将共同的逻辑添加到模块中而不影响原有模块的独立性。

所以这就是上面所说的：把涉及到众多模块的某一类问题进行统一管理

安卓AOP三剑客:APT,AspectJ,Javassist。

APT应用：Dagger，butterKnife，组件化方案等等

AspectJ:主要用于性能监控，日志埋点等

Javassist：热更新（可以在编译后，打包Dex之前干事情，可以突破一下限制）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2VqaWVnZTY_size_16_color_FFFFFF_t_70 1]

## 二、AspectJ ##

今天的主角是AspectJ，主要用于不想侵入原有代码的场景中，例如SDK需要无侵入的在宿主中插入一些代码，做日志埋点、性能监控、动态权限控制、甚至是代码调试等等。

接入说明

首先，需要在项目根目录的build.gradle中增加依赖：

buildscript { 
        repositories { 
            jcenter()
        }
        dependencies { 
            classpath 'com.android.tools.build:gradle:2.3.0-beta2'
            classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.6'
        }
    }

然后再主项目或者库的build.gradle中增加AspectJ的依赖：

compile 'org.aspectj:aspectjrt:1.8.9'

同时在build.gradle中加入AspectJX模块：

apply plugin: 'android-aspectjx'

这样就把整个Android Studio中的AspectJ的环境配置完毕了，如果在编译的时候，遇到一些『can’t determine superclass of missing type xxxxx』这样的错误，请参考项目README中关于excludeJarFilter的使用。

aspectjx { 
        //includes the libs that you want to weave
        includeJarFilter 'universal-image-loader', 'AspectJX-Demo/library'
    
        //excludes the libs that you don't want to weave
        excludeJarFilter 'universal-image-loader'
    }

#### 1、基本使用 ####

直接看代码

Activity中：

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState);
    
        testMethod();
    }
    
    private void testMethod() { 
        Log.e(DemoAspect.TAG, "testMethod-invoke");
    }

新建DemoAspect类：

@Aspect
    public class DemoAspect { 
        public static final String TAG = "DemoAspect";
    
        @Before("execution(* com.hujiang.library.demo.DemoActivity.test*(..))")
        public void testAspectBefore(JoinPoint point) { 
            Log.e(TAG, point.getSignature().getName()+"-before ");
        }
    }

运行时候打印：

testMethod-before com.hujiang.library.demo E/DemoAspect: testMethod-invoke

所以完成插入操作我们只需要

1）类上加入注释@Aspect

2）方法上加入注释@Before

3）Before里写入要插入的相关信息

是不是很简单，下面就一一详细讲解。

#### 2、Advice ####

就是说我们要插入的代码以何种方式插入，就是方法上的注释  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2VqaWVnZTY_size_16_color_FFFFFF_t_70 2]

Before和After很好理解，上面的例子已经展示的很清楚了。

**AfterReturning**  
适用于需要获取到返回值的情况比如：

private int AfterReturningTest() { 
        Log.e(DemoAspect.TAG, "AfterReturning-invoke");
        return 10;
    }
    
    
    @AfterReturning(value = "execution(* com.hujiang.library.demo.DemoActivity.AfterReturning*(..))", returning = "num")
    public void testAspectAfterReturning(int num) { 
        Log.e(TAG, "AfterReturning-num:" + num);
    }

这样就可以在切面方法里获取到返回值了，值得注意的是方法参数必须和注解中的值一致

【returning = “num”】===【int num】

**AfterThrowing**  
适用于收集和监控异常信息

private void AfterThrowingTest() { 
        View v = null;
        v.setVisibility(View.VISIBLE);
    }
    
    @AfterThrowing(value = "execution(* com.hujiang.library.demo.DemoActivity.AfterThrowing*(..))", throwing = "exception")
    public void testAspectAfterReturning(Exception exception) { 
        Log.e(TAG, "AfterThrowing-exception:" + exception.getMessage());
    }

同样，参数和注解里的值必须一致  
这里崩溃同样会发生，不会因为切面操作而直接catch住，只是在抛出异常之前会打印出异常信息而已

**Around**  
在方法执行前后都可调用，比较灵活

private void AroundTest() { 
        Log.e(DemoAspect.TAG, "AroundTest-invoke");
    }
    
    @Around("execution(* com.hujiang.library.demo.DemoActivity.AroundTest(..))")
    public void testAspectAround(ProceedingJoinPoint point) throws Throwable { 
        Log.e(TAG, point.getSignature().getName() + "-before ");
        point.proceed();
        Log.e(TAG, point.getSignature().getName() + "-after ");
    }

通过执行ProceedingJoinPoint的proceed方法调用原方法，灵活控制。如果你想的话也可以不调用，直接拦截了。

#### 3、Pointcut ####

告诉代码注入工具，在何处注入一段特定代码的表达式。也就是例子中的这句话：

@Before("execution(* com.hujiang.library.demo.DemoActivity.test*(..))")

我们分成几个部分依次来看：

**1)@Before**：Advice，也就是具体的插入点,我们已经介绍过

**2)execution**：处理Join Point的类型，例如call、execution、withincode

其中call、execution类似，都是插入代码的意思，区别就是execution是在被切入的方法中，call是在调用被切入的方法前或者后。

//对于Call来说：
    Call（Before）
    Pointcut{ 
        Pointcut Method
    }
    Call（After）
    
    //对于Execution来说：
    Pointcut{ 
      execution（Before）
        Pointcut Method
      execution（After）
    }

withcode这个语法通常来进行一些切入点条件的过滤，作更加精确的切入控制,比如：

@Override
    protected void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        test1();
        test2();
    }
    
    public void test() { 
        Log.e("qiuyunfei", "test");
    }
    
    public void test1() { 
        test();
    }
    
    public void test2() { 
        test();
    }

假如我们想要切test方法，但是只希望在test2中调用test才执行切面方法，就需要用到withincode

// 在test()方法内
    @Pointcut("withincode(* com.hujiang.library.aspect.MainActivity.test2(..))")
    public void invoke2() { 
    }
    
    // 调用test()方法的时候
    @Pointcut("call(* com.hujiang.library.aspect.MainActivity.test(..))")
    public void invoke() { 
    }
    
    // 同时满足前面的条件，即在test2()方法内调用test()方法的时候才切入
    @Pointcut("invoke() && invoke2()")
    public void invokeOnlyIn2() { 
    }
    
    @Before("invokeOnlyIn2()")
    public void beforeInvokeOnlyIn2(JoinPoint joinPoint) { 
        String key = joinPoint.getSignature().toString();
        Log.d(TAG, "beforeInvokeOnlyIn2: " + key);
    }

**3)MethodPattern**

这个是最重要的表达式，大致为:**@注解 访问权限 返回值的类型 包名.函数名(参数**)

**@注解和访问权限**（public/private/protect，以及static/final）属于可选项。如果不设置它们，则默认都会选择。以访问权限为例，如果没有设置访问权限作为条件，那么public，private，protect及static、final的函数都会进行搜索。

\*\*返回值类型:\*\*就是普通的函数的返回值类型。如果不限定类型的话，就用\*通配符表示

**包名.函数名**用于查找匹配的函数。可以使用通配符，包括和…以及+号。其中号用于匹配除.号之外的任意字符，而…则表示任意子package，+号表示子类。

下面我们解析例子中的匹配

* com.hujiang.library.demo.DemoActivity.test*(..)

第一部分：『』表示返回值，『』表示返回值为任意类型，  
第二部分：就是典型的包名路径，其中可以包含『』来进行通配，几个『』没区别。同时，这里可以通过『&&、||、!』来进行条件组合。  
类似【test\*】的写法，表示以test开头为方法名的任意方法  
第三部分：()代表这个方法的参数，你可以指定类型，例如android.os.Bundle，或者(…)这样来代表任意类型、任意个数的参数，也可以混合写法（android.os.Bundle，…）这样来代表第一个参数为bundle，后面随意。

**4)自定义Pointcuts**

有时候我们需要指定哪些方法需要进行AOP操作，目标明确，也可以通过注解的方式来完成  
首先声明注解

@Retention(RetentionPolicy.CLASS)
    @Target({ ElementType.METHOD, ElementType.TYPE})
    public @interface AspectAnnotation { 
    }

然后在切面类中定义：

//定义一个使用该注解的Pointcut
    @Pointcut("execution(@com.hujiang.library.aspect.AspectAnnotation * *(..))")
    public void AspectAnnotation(){ 
    
    }
    
    @Before("AspectAnnotation()")
    public void testAspectAnnotation(JoinPoint point){ 
        Log.e(TAG, point.getSignature().getName() + "-Before ");
    }
    
    //在Activity中使用
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState);
    
        AnnotationTest();
    }
    @AspectAnnotation
    private void AnnotationTest() { 
        Log.e(DemoAspect.TAG, "AnnotationTest-invoke");
    }

使用很简单,前面也介绍过MethodPattern，注释@在这里就不能省略了

#### 4、AspectJ实战 ####

**1）实现登录检查的操作**

很多app都有这个需求，在操作前提醒用户注册登录，跳转到注册或者登录界面，如果用AspectJ实现就显得非常简洁且无侵入性

private static final String TAG = "AspectCommonTool";
    
    @Pointcut("execution(@xxx.aspectj.annotation.NeedLogin * *(..))")
    public void needLoginMethod() { 
    }
    
    /** * 在@NeedLogin方法中插入 * 若在非Activity中使用@NeedLogin，参数必须传入Context作为跳转起始页 */
    @Around("needLoginMethod()")
    public void onNeedLoginAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { 
    	   ContextmContext = null;
    	   //proceedingJoinPoint.getThis()可以获取到调用该方法的对象
    	   if (proceedingJoinPoint.getThis() instanceof Context) { 
    	       mContext = (Context) proceedingJoinPoint.getThis();
    	   } else { 
    	       //proceedingJoinPoint.getArgs()可以获取到方法的所有参数
    	       for (Object context : proceedingJoinPoint.getArgs()) { 
    	           if (context instanceof Context) { 
    	               mContext = (Context) context;
    	               break;
    	           }
    	       }
    	   }
    	   if (mContext == null) { 
    	       return;
    	   }
    	   if (LoginUtils.isLogin()) { 
    	       /** * 如果用户登录则执行原方法 */
    	       proceedingJoinPoint.proceed();
    	   } else { 
    	       /** * 未登录情况下跳转至登录注册主界面 */
    	   }
    }

使用很方便，毫无侵入性，后期也很好维护。  
类似的思想也可以实现：检查网络状况、检查权限状态、避免按钮多次点击、自动完成缓存等情况。

**2）性能监控**

AspectJ其实在Android中的应用主要还是性能监控、日志埋点等，下面以一个简单的例子表示：  
我们监控布局加载耗时，判断布局是否嵌套过多或者过于复制导致Activity启动卡顿,首先我们知道Activity是通过setContentView方法加载布局的：  
1、布局解析过程，IO过程  
2、创建View为反射过程  
这两步均为耗时操作，所以我们需要监控setContentView

@Around("execution(* android.app.Activity.setContentView(..))")
    public void getContentViewTime(ProceedingJoinPoint point) throws Throwable { 
        String name = point.getSignature().toShortString();
        long time = System.currentTimeMillis();
        point.proceed();
        Log.e(TAG, name + " cost: " + (System.currentTimeMillis() - time));
    }
    
    //Activity
    public class DemoActivity extends AppCompatActivity { 
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
    
            setContentView(R.layout.activity_main);
        }
    }

打印日志如下：

DemoAspect: AppCompatActivity.setContentView(..) cost: 76

日常开发中，我们可以将耗时上传到服务器，收集用户信息，找到卡顿Activity做出对应优化。  
当然，这只是非常简单的实现，实际开发中还可以监控各种你想监控的位置。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2VqaWVnZTY_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191128225013939.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2VqaWVnZTY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2VqaWVnZTY_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191128225043941.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2VqaWVnZTY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2VqaWVnZTY_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191128225351706.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2VqaWVnZTY=,size_16,color_FFFFFF,t_70