纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术

AspectJ在android中使用 在Android项目中使用AspectJ的详细攻詻

唯鹿   2021-06-24 我要评论
想了解在Android项目中使用AspectJ的详细攻詻的相关内容吗唯鹿在本文为您仔细讲解AspectJ在android中使用的相关知识和一些Code实例欢迎阅读和指正我们先划重点:AspectJ在android中使用,android使用AspectJ下面大家一起来学习吧

AOP
全称“Aspect Oriented Programming”,面向切面编程由于面向对象的思想要求高内聚低耦合的风格使模块代码间的可见性变差对于埋点日志输出等需求就会变的十分复杂如果手动编写代码入侵性很大不利于扩展AOP应运而生

AspectJ
AspectJ实际上是对AOP编程的实践目前还有很多的AOP实现如ASMDex但笔者选用的是AspectJ

使用场景

当我们需要在某个方法运行前和运行后做一些处理时便可使用AOP技术具体有:

  • 统计埋点
  • 日志打印/打点
  • 数据校验
  • 行为拦截
  • 性能监控
  • 动态权限控制

AOP(aspect-oriented programming)指的是面向切面编程而AspectJ是实现AOP的其中一款框架内部通过处理字节码实现代码注入

AspectJ从2001年发展至今已经非常成熟稳定同时使用简单是它的一大优点至于它的使用场景可以看本文中的一些小例子获取能给你启发

1.集成AspectJ

使用插件gradle-android-aspectj-plugin

这种方式接入简单但是此插件截止目前已经一年多没有维护了考虑到AGP的兼容性害怕以后无法使用这里就不推荐了(这里存在特殊情况文章后面会提到)

常规的Gradle 配置方式

这种方法相对配置会多一些但相对可控

首先在项目根目录的build.gradle中添加:

classpath "com.android.tools.build:gradle:4.2.1"
classpath 'org.aspectj:aspectjtools:1.9.6'

然后在app的build.gradle中添加:

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

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main

final def log = project.logger
final def variants = project.android.applicationVariants

variants.all { variant ->
	// 注意这里控制debug下生效可以自行控制是否生效
    if (!variant.buildType.isDebuggable()) {
        log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
        return
    }

    JavaCompile javaCompile = variant.javaCompileProvider.get()
    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
            }
        }
    }
}

在 module 使用的话一样需要添加配置代码(略有不同):

dependencies {
	...
    implementation 'org.aspectj:aspectjrt:1.9.6'

}

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main

final def log = project.logger

android.libraryVariants.all{ variant ->
    if (!variant.buildType.isDebuggable()) {
        log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
        return
    }

    JavaCompile javaCompile = variant.javaCompileProvider.get()
    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
            }
        }
    }
}

2.AspectJ基础语法

Join Points

连接点用来连接我们需要操作的位置比如连接普通方法、构造方法还是静态初始化块等位置以及是调用方法外部还是调用方法内部常用类型有Method callMethod executionConstructor callConstructor execution等

Pointcuts

切入点是带条件的Join Points确定切入点位置

Pointcuts语法 说明
execution(MethodPattern) 方法执行
call(MethodPattern) 方法被调用
execution(ConstructorPattern) 构造方法执行
call(ConstructorPattern) 构造方法被调用
get(FieldPattern) 读取属性
set(FieldPattern) 设置属性
staticinitialization(TypePattern) static 块初始化
handler(TypePattern) 异常处理

execution和call的区别如下图:

call和execution区别

Pattern规则如下:

Pattern 规则(注意空格)
MethodPattern [@注解] [访问权限] 返回值类型 [类名.]方法名(参数) [throws 异常类型]
ConstructorPattern [@注解] [访问权限] [类名.]new(参数) [throws 异常类型]
FieldPattern [@注解] [访问权限] 变量类型 [类名.]变量名
TypePattern * 单独使用事表示匹配任意类型.. 匹配任意字符串.. 单独使用时表示匹配任意长度任意类型+ 匹配其自身及子类还有一个 ... 表示不定个数也可以使用&&||!进行逻辑运算
  • 上表中中括号为可选项没有可以不写
  • 方法匹配例子:
 java.*.Date:可以表示java.sql.Date也可以表示java.util.Date  
Test*:可以表示TestBase也可以表示TestDervied  
 java..*:表示java任意子类
java..*Model+:表示Java任意package中名字以Model结尾的子类比如TabelModelTreeModel 等  

参数匹配例子:

(int, char):表示参数只有两个并且第一个参数类型是int第二个参数类型是char 
 (String, ..):表示至少有一个参数并且第一个参数类型是String后面参数类型不限.
..代表任意参数个数和类型  
 (Object ...):表示不定个数的参数且类型都是Object这里的...不是通配符而是Java中代表不定参数的意思

Advice

用来指定代码插入到Pointcuts的什么位置

Advice 说明
@Before 在执行JPoint之前
@After 在执行JPoint之后
@AfterReturning 方法执行后返回结果后再执行
@AfterThrowing 处理未处理的异常
@Around 可以替换原代码如果需要执行原代码可以使用ProceedingJoinPoint#proceed()

After、Before 示例

这里我们实现一个功能在所有Activity的onCreate方法中添加Trace方法来统计onCreate方法耗时

@Aspect // <-注意添加才会生效参与编译
public class TraceTagAspectj {

    @Before("execution(* android.app.Activity+.onCreate(..))")
    public void before(JoinPoint joinPoint) {
        Trace.beginSection(joinPoint.getSignature().toString());
    }

    @After("execution(* android.app.Activity+.onCreate(..))")
    public void after() {
        Trace.endSection();
    }
}

编译后的class代码如下:

可以看到经过处理后它并不会直接把 Trace 函数直接插入到代码中而是经过一系列自己的封装如果想针对所有的函数都做插桩AspectJ 会带来不少的性能影响
不过大部分情况我们可能只会插桩某一小部分函数这样 AspectJ 带来的性能影响就可以忽略不计了

AfterReturning示例

获取切点的返回值比如这里我们获取TextView打印它的text值

private TextView testAfterReturning() {
    return findViewById(R.id.tv);
}
@Aspect
public class TextViewAspectj {

    @AfterReturning(pointcut = "execution(* *..*.testAfterReturning())", returning = "textView") // "textView"必须和下面参数名称一样
    public void getTextView(TextView textView) {
        Log.d("weilu", "text--->" + textView.getText().toString());
    }
}

编译后的class代码如下:
在这里插入图片描述
log打印:
在这里插入图片描述
使用@AfterReturning你可以对方法的返回结果做一些修改(注意是“=”赋值String无法通过此方法修改)

AfterThrowing示例

当方法执行出现异常且异常没有处理时可以使用@AfterThrowing比如下面的例子中我们捕获异常并上报(这里用log输出实现)

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        testAfterThrowing();
    }

    private void testAfterThrowing() {
        TextView textView = null;
        textView.setText("aspectj");
    }
}
@Aspect
public class ReportExceptionAspectj {

    @AfterThrowing(pointcut = "call(* *..*.testAfterThrowing())", throwing = "throwable")  // "throwable"必须和下面参数名称一样
    public void reportException(Throwable throwable) {
        Log.e("weilu", "throwable--->" + throwable);
    }
}

编译后的class代码如下:
在这里插入图片描述
log打印:
在这里插入图片描述
这里要注意的是程序最终还是会崩溃因为最后执行了throw var3如果你想不崩溃可以使用@Around

Around示例

接着上面的例子我们这次直接try catch住异常代码:

@Aspect
public class TryCatchAspectj {
    
    @Pointcut("execution(* *..*.testAround())")
    public void methodTryCatch() {
    }

    @Around("methodTryCatch()")
    public void aroundTryJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
       
         try {
             joinPoint.proceed(); // <- 调用原代码
         } catch (Exception e) {
              e.printStackTrace();
         }
    }
}

编译后的class代码如下:
在这里插入图片描述
@Around 明显更加灵活我们可以自定义实现"偷梁换柱"的效果比如上面提到的替换方法的返回值

3.进阶

withincode

withincode表示某个方法执行过程中涉及到的JPoint通常用来过滤切点例如我们有一个Person对象:

public class Person {

    private String name;
    private int age;

    public Person() {
        this.name = "weilu";
        this.age = 18;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Person对象中有两处set age的地方如果我们只想让构造方法的生效让setAge方法失效可以使用@Around("execution(* com.weilu.aspectj.demo.Person.setAge(..))")不过如果有更多处set age的地方我们这样一个个去匹配就很麻烦

这里就可以考虑使用set这个Pointcuts:

public class FieldAspectJ {

    @Around("set(int com.weilu.aspectj.demo.Person.age)")
    public void aroundFieldSet(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.e("weilu", "around->" + joinPoint.getTarget().toString() + "#" + joinPoint.getSignature().getName());
    }
}

由于set(FieldPattern)的FieldPattern限制不能指定参数这样会将所有的set age都切入:
在这里插入图片描述
这时就可以使用withincode添加过滤条件:

@Aspect
public class FieldAspectJ {

    @Pointcut("!withincode(com.weilu.aspectj.demo.Person.new())")
    public void invokePerson() {
    }

    @Around("set(int com.weilu.aspectj.demo.Person.age) && invokePerson()")
    public void aroundFieldSet(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.e("weilu", "around->" + joinPoint.getTarget().toString() + "#" + joinPoint.getSignature().getName());
    }
}

结果如下:
在这里插入图片描述

还有一个within它和withincode类似不同的是它的范围是类而withincode是方法例如:within(com.weilu.activity.*)表示此包下任意的JPoint

args

用来指定当前执行方法的参数条件比如上一个例子中如果需要指定第一个参数是int后面参数不限就可以这样写

@Around("execution(* com.weilu.aspectj.withincode.Person.setAge(..)) && args(int,..)")

cflow

cflow是call flow的意思cflow的条件是一个pointcut

举一个例子来说明一下它的用途a方法中调用了b、c、d方法此时要统计各个方法的耗时如果按之前掌握的语法我们最多需要写四个Pointcut方法越多越麻烦

使用cflow我们可以方便的掌握方法的“调用流”我们测试方法如下:

private void test() {
    testAfterReturning();
    testAround();
    testWithInCode();
}

实现如下:

@Aspect
public class TimingAspect {

    @Around("execution(* *(..)) && cflow(execution(* com.weilu.aspectj.demo.MainActivity.test(..)))")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = currentTimeMillis();
        Log.e("weilu", joinPoint.getSignature().toString() + " -> " + (endTime - startTime) + " ms");
        return result;
    }

}

cflow(execution(* com.weilu.aspectj.demo.MainActivity.test(..)))表示调用test方法时所包含的JPoint包括自身JPoint

execution(* *(..))的作用是去除TimingAspect自身的代码避免自己拦截自己形成死循环

log结果如下:
在这里插入图片描述

还有一个cflowbelow它和cflow类似不同的是它不包括自身JPoint也就是例子中不会获取test方法的耗时

4.实战 拦截点击

拦截点击的目的是避免因快速点击控件导致重复执行点击事件例如打开多次页面弹出多次弹框请求多次接口我之前发现在部分机型上很容易复现此类情况所以避免抖动这算是项目中的一个常见需求

例如butterknife中就自带DebouncingOnClickListener来避免此类问题
在这里插入图片描述
如果你已不在使用butterknife也可以复制这段代码一个个的替换已有的View.OnClickListener还有以前使用Rxjava操作符来处理防抖但这些方式侵入式大且替换的工作量也大

这种场景就可以考虑AOP的方式处理拦截onClick方法判断是否可以点击

@Aspect
public class InterceptClickAspectJ {

    // 最后一次点击的时间
    private Long lastTime = 0L;
    // 点击间隔时长
    private static final Long INTERVAL = 300L;

    @Around("execution(* android.view.View.OnClickListener.onClick(..))")
    public void clickIntercept(ProceedingJoinPoint joinPoint) throws Throwable {
        // 大于间隔时间可点击
        if (System.currentTimeMillis() - lastTime >= INTERVAL) {
            // 记录点击时间
            lastTime = System.currentTimeMillis();
            // 执行点击事件
            joinPoint.proceed();
        } else {
            Log.e("weilu", "重复点击");
        }
    }

}

实现代码很简单效果如下:
在这里插入图片描述
考虑到有些view的点击事件不需要防抖例如checkBox否则checkBox状态变了但事件没有执行我们可以定义一个注解用withincode过滤有此注解的方法具体需求可以根据实际项目自行拓展这里仅提供思路

埋点

前面的例子中都是无侵入的方式使用AspectJ这里说一下侵入式的方式简单说就是使用自定义注解用注解作为切入点的规则(其实也可以自定义一种方法命名来当做切入规则)

首先定义两个注解一个用来传固定参数比如eventName、eventId同时负责当做切入点一个用来传动态参数的key

@Retention(RetentionPolicy.RUNTIME)
public @interface TrackEvent {
    /**
     * 事件名称
     */
    String eventName() default "";

    /**
     * 事件id
     */
    String eventId() default "";
}

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface TrackParameter {

    String value() default "";

}

Aspectj代码如下:

@Aspect
public class TrackEventAspectj {

    @Around("execution(@com.weilu.aspectj.tracking.TrackEvent * *(..))")
    public void trackEvent(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();

        // 获取方法上的注解
        TrackEvent trackEvent = signature.getMethod().getAnnotation(TrackEvent.class);

        String eventName = trackEvent.eventName();
        String eventId = trackEvent.eventId();

        JSONObject params = new JSONObject();
        params.put("eventName", eventName);
        params.put("eventId", eventId);

        // 获取方法参数的注解
        Annotation[][] parameterAnnotations = signature.getMethod().getParameterAnnotations();

        if (parameterAnnotations.length != 0) {
            int i = 0;
            for (Annotation[] parameterAnnotation : parameterAnnotations) {
                for (Annotation annotation : parameterAnnotation) {
                    if (annotation instanceof TrackParameter) {
                        // 获取key value
                        String key = ((TrackParameter) annotation).value();
                        params.put(key, joinPoint.getArgs()[i++]);
                    }
                }
            }
        }

        // 上报
        Log.e("weilu", "上报数据---->" + params.toString());

        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

使用方法:

 @TrackEvent(eventName = "点击按钮", eventId = "100")
    private void trackMethod(@TrackParameter("uid") int uid, String name) {
        Intent intent = new Intent(this, KotlinActivity.class);
        intent.putExtra("uid", uid);
        intent.putExtra("name", name);
        startActivity(intent);
    }

	trackMethod(10, "weilu");

结果如下:
在这里插入图片描述
由于匹配key value的代码问题建议将需要动态传入的参数都写在前面避免下标越界

还有一些使用场景比如权限控制总结一下AOP适合将一些通用逻辑分离出来然后通过AOP将此部分注入到业务代码中这样我们可以更加注重业务的实现代码也显得清晰起来

5.其他问题 lambda

如果我们代码中有使用lambda例如点击事件会变为:

tv.setOnClickListener(v -> Log.e("weilu", "点击事件执行"));

这样之前的点击切入点就无效了这里涉及到D8这个脱糖工具和invokedynamic字节码指令相关知识这里我也无法说的清楚详细简单说使用lambda会生成lambda$开头的中间方法所以只能如下处理:

@Around("execution(* *..lambda$*(android.view.View))")

这种暂时处理起来比较麻烦且可以看出容错率也比较低很容易切入其他无关方法所以建议AOP不要使用lambda

配置

一开始介绍了两种配置虽说AspectJX插件最近不太维护了但是它的支持了AAR、JAR及Kotlin的切入而默认仅是对自己的代码进行切入

在AspectJ常规配置中有这样的代码:"-inpath", javaCompile.destinationDir.toString()代表只对源文件进行织入在查看Aspectjx源码时发现在“-inputs”配置加入了.jar文件使得class类可以被织入代码这么理解来看AspectJ也是支持对class文件的织入的只是需要对它进行相关的配置而配置比较繁琐所以诞生了AspectJx等插件

例如Kotlin在需要在常规的Gradle 配置上增加如下配置:

def buildType = variant.buildType.name

String[] kotlinArgs = [
	"-showWeaveInfo",
    "-1.8",
    "-inpath", project.buildDir.path + "/tmp/kotlin-classes/" + buildType,
    "-aspectpath", javaCompile.classpath.asPath,
    "-d", project.buildDir.path + "/tmp/kotlin-classes/" + buildType,
    "-classpath", javaCompile.classpath.asPath,
    "-bootclasspath", project.android.bootClasspath.join(File.pathSeparator)]

MessageHandler handler = new MessageHandler(true)
new Main().run(kotlinArgs, handler)

同时注意用kotlin写对应的Aspect类毕竟你需要注入的是kotlin代码用java的肯定不行但是反过来却可行

建议有AAR、JAR及Kotlin需求的使用插件方式即使后期无人维护可自行修改源码适配GAP相对难度不大


这部分内容较多同时也比较枯燥断断续续整理了一周的时间基本介绍了AspectJ在Android 中的配置以及常用的语法与使用场景对于应用AspectJ来说够用了

最后本篇涉及的代码都已上传至Github有兴趣的同学可以用做参考

参考

AOP之AspectJ在Android中的应用
AOP 之 AspectJ 全面剖析 in Android
编译插桩的三种方法:AspectJ、ASM、ReDex
Android 引入AspectJ的记录


相关文章

猜您喜欢

  • springcloud Feign超时 springcloud之Feign超时问题的解决

    想了解springcloud之Feign超时问题的解决的相关内容吗Moshow郑锴在本文为您仔细讲解springcloud Feign超时的相关知识和一些Code实例欢迎阅读和指正我们先划重点:springcloud,Feign超时下面大家一起来学习吧..
  • python学生信息管理系统 python面向对象版学生信息管理系统

    想了解python面向对象版学生信息管理系统的相关内容吗珂鸣玉在本文为您仔细讲解python学生信息管理系统的相关知识和一些Code实例欢迎阅读和指正我们先划重点:python学生信息管理系统,python学生管理系统,python信息管理系统下面大家一起来学习吧..

网友评论

Copyright 2020 www.gamerfx.net 【游戏天空】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式