Android AOP框架 AspectJ的使用

2024-06-16 12:58
文章标签 android 使用 框架 aop aspectj

本文主要是介绍Android AOP框架 AspectJ的使用，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

什么是AOP

AOP为Aspect Oriented Programming的缩写，意思是面向切面编程。
AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。也就是时候可以，在不需要修改目的程序代码的前提下，可以插入新的代码块，并且好处是，唯一修改，多处生效。
本质上是在编译时期由java文件生成class文件时，将aop代码插入到原来的程序中。

AOP应用场景

Spring中为了将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
Android应用场景：
条件判断：
检查权限是否开启
检查网络状态是否可用
检查用户登录
统计：
用户行为统计
等。。。

AOP与OOP

面向对象的特点是继承、多态和封装。为了符合单一职责的原则，OOP将功能分散到不同的对象中去。让不同的类设计不同的方法，这样代码就分散到一个个的类中。可以降低代码的复杂程度，提高类的复用性。往往分散代码的同时，也增加了代码的重复性，比如某些情况下，两个类，都需要同一个方法，那么按照面向对象的思路，我们要分别在两个类中都写一遍，又比如，在两个类中的方法加入日志统计，那么我们按照以往的编程思想，就要两个类的方法中都加入日志内容。也许他们是完全相同的，但是因为OOP的设计让类与类之间无法联系，而不能将这些重复的代码统一起来。AOP就是为了解决这类问题而产生的，它是在运行时动态地将代码切入到类的指定方法、指定位置上的编程思想。AOP 是 OOP 的有力补充，合理的使用，会对我们的开发带来极大的方便。

用户登录状态
检查网络状态是否可用
在实际开发中为例 在 个人中心页面，许多功能是需要检测用户登录状态的。

// An highlighted block
setOnclick(){
case 1: if(checkUser()) doEvent1();break;
case 2: if(checkUser()) doEvent2();break;
}

aop来实现------>

case 1： doEvent1();@CheckUser
void doEvent1(){}

用CheckUser这个注解去监听doEvent1() 方法，先去判断是否要登录，再执行原来的doEvent1()方法。

类似的 多个不同的类中有相似的判断，也可以用aop去处理，这样的好处是减少了大量的重复代码，比如添加日志功能，或者测试程序性能，这些与本身程序无关的逻辑。

AspectJ

AspectJ的特点：它是Java语言的无缝扩展，几乎是与java完全一致的语言，兼容java平台，易于学习使用，除了使用AspectJ特殊的语言外，AspectJ还支持原生的Java，只要加上对应的AspectJ注解就好。

基础概念

  1. Join Points(连接点)
    Join Points，简称JPoints，是AspectJ的核心思想之一，它就像一把刀，把程序的整个执行过程切成了一段段不同的部分。例如，构造函数被调用、构造函数内部执行、函数被调用、函数执行内部、异常处理等等，这些都是Join Points，实际上，也就是你想把新的代码插在程序的哪个地方，是插在构造方法中，还是插在某个方法调用前，或者是插在某个方法中，这个地方就是Join Points，当然，不是所有地方都能给你插的，只有能插的地方，才叫Join Points。

  2. Pointcuts(切入点)
    告诉代码注入工具，在何处注入一段特定代码的表达式。例如，在哪些 joint points 应用一个特定的 Advice。切入点可以选择唯一一个，比如执行某一个方法，也可以有多个选择,可简单理解为带条件的Join Points，作为我们需要的代码切入点。

  3. Advice（通知）
    如何注入到我的class文件中的代码。典型的 Advice 类型有 before、after 和 around，分别表示在目标方法执行之前、执行后和完全替代目标方法执行的代码。

  4. Aspect（切面）
    Pointcut 和 Advice 的组合看做切面。例如，我们在应用中通过定义一个 pointcut 和给定恰当的advice，添加一个日志切面。

  5. Weaving（织入）
    注入代码（advices）到目标位置（joint points）的过程。

下面以AspectJ为例介绍下Aop在android开发中的应用。

AspectJ接入项目

接入方式介绍

在项目主module下 创建 一个 aspectj.gradle 文件，文件内容如下

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
buildscript {repositories {mavenCentral()}dependencies {classpath 'org.aspectj:aspectjtools:1.8.9'}
}
repositories {mavenCentral()
}dependencies {
//    compile project(':gintonic')compile 'org.aspectj:aspectjrt:1.8.9'
}final def log = project.logger
final def variants = project.android.applicationVariantsvariants.all { variant ->
//    if (!variant.buildType.isDebuggable()) {
//        log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
//        return;
//    }JavaCompile javaCompile = variant.javaCompilejavaCompile.doLast {String[] args = ["-showWeaveInfo","-1.5","-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.thrownbreak;case IMessage.WARNING:log.warn message.message, message.thrownbreak;case IMessage.INFO:log.info message.message, message.thrownbreak;case IMessage.DEBUG:log.debug message.message, message.thrownbreak;}}}
}

接下来在主moudle 中依赖 apply from:‘aspectj.gradle’

以上完成了项目对AspectJ的依赖，接下来去使用AspectJ的功能，
有两种方式可以通过实现切入程序 一种是以原始的AspectJ语法，另一种是通过注解的方式。

使用

方式1

注解方式：

结构可以参考下图
在这里插入图片描述
首先声明性能检测的注解
PerformanceTrace

package org.android.aop.annotation;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;/***Retention 注解保留策略 枚举类型*SOURCE  注解在编译的时候丢弃，只在原文件中有效*CLASS   注解在class文件中有效，运行时不会被VM保留*RUNTIME 注解在class文件中，并在运行时由VM保留，因此可以反射地读取注释*/
@Retention(RetentionPolicy.CLASS)
/***Target 注解的作用目标*@Target(ElementType.TYPE)   接口、类、枚举、注解*@Target(ElementType.FIELD)  字段、枚举的常量*@Target(ElementType.METHOD) 方法*@Target(ElementType.PARAMETER) 方法参数*@Target(ElementType.CONSTRUCTOR)  构造函数*@Target(ElementType.LOCAL_VARIABLE) 局部变量*@Target(ElementType.ANNOTATION_TYPE) 注解*@Target(ElementType.PACKAGE) 包*/
@Target({ ElementType.CONSTRUCTOR, ElementType.METHOD })
public @interface PerformanceTrace {}

接下来声明@Aspect

/*** 切面声明 切面的切点 函数和构造函数* @author Administrator*/
@Aspect
public class AspectTrace {//ydc startprivate static final String TAG = "LinearLayout";//1 注解方式：private static final String POINTCUT_METHOD ="execution(@org.android.aop.annotation.PerformanceTrace * *(..))";private static final String POINTCUT_CONSTRUCTOR ="execution(@org.android.aop.annotation.PerformanceTrace*.new(..))";@Pointcut(POINTCUT_METHOD)public void methodAnnotatedWithPerformanceTrace() {}@Pointcut(POINTCUT_CONSTRUCTOR)public void constructorAnnotatedPerformanceTrace() {}@Around("methodAnnotatedWithPerformanceTrace() || constructorAnnotatedPerformanceTrace()")public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
//    Log.e(TAG,"weaveJoinPoint");//获取方法信息对象MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();//获取当前对象String className = methodSignature.getDeclaringType().getSimpleName();String methodName = methodSignature.getName();Object[] paramValues = joinPoint.getArgs();String[] paramNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();for(int i=0;i<paramNames.length;i++){Log.e(TAG,"原方法参数 "+(paramNames[i]+","+paramValues[i]));}//获取当前对象，通过反射获取类别详细信息 com.womai.activity.home.HomeActivityString className2 = joinPoint.getThis().getClass().getName();Log.e(TAG,""+className2);//初始化计时器final StopWatch stopWatch = new StopWatch();//开始监听stopWatch.start();//调用原方法的执行。Object result = joinPoint.proceed();//监听结束stopWatch.stop();Log.e(TAG,"函数耗时： "+className+"  "+buildLogMessage(methodName, stopWatch.getTotalTimeMillis()));return result;}
}

这样，我们可以使用上面的注解@PerformanceTrace 去检测我们想要检测得函数的执行耗时。比如这样：

   @PerformanceTraceprivate void doTestAop(String a){Log.e("LinearLayout","执行原方法  Thread.sleep 500ms");try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}}

在需要检测得方法上添加@PerformanceTrace注解，在编译阶段，我们的切面程序就会添加到doTestAop函数上，可以在下面这个目录下查看编译生成的class文件
在这里插入图片描述

    @PerformanceTraceprivate void doTestAop(String a) {JoinPoint var3 = Factory.makeJP(ajc$tjp_0, this, this, a);AspectTrace var10000 = AspectTrace.aspectOf();Object[] var4 = new Object[]{this, a, var3};var10000.weaveJoinPoint((new HomeActivity$AjcClosure1(var4)).linkClosureAndJoinPoint(69648));}

这里使用的是around 表示对方法整体进行拦截，前面介绍 Advice 类型有 before、after 和 around，分别表示在目标方法执行之前、执行后和完全替代目标方法执行的代码。

当使用@After的时候，@After(“methodAnnotatedWithDemandTrace() || constructorAnnotatedDemandTrace()”)

    @PerformanceTraceprivate void doTestAop(String a) {JoinPoint var2 = Factory.makeJP(ajc$tjp_0, this, this, a);try {Log.e("LinearLayout", "执行原方法  Thread.sleep 500ms");} catch (Throwable var5) {AspectTrace.aspectOf().weaveJoinPoint2(var2);throw var5;}AspectTrace.aspectOf().weaveJoinPoint2(var2);}

当使用@Before的时候，@Before(“methodAnnotatedWithDemandTrace() || constructorAnnotatedDemandTrace()”)

    @PerformanceTraceprivate void doTestAop(String a) {JoinPoint var2 = Factory.makeJP(ajc$tjp_0, this, this, a);AspectTrace.aspectOf().weaveJoinPoint2(var2);Log.e("LinearLayout", "执行原方法  Thread.sleep 500ms");}
方式2

AspectJ语法
示例：@Before("execution(* android.app.Activity.on(…))")**
使用execution或者call 去将代码注入到指定的方法位置。

  //Before和After的用法@Before("execution(* android.app.Activity.on*(android.os.Bundle))")public void onActivityMethodBefore(JoinPoint joinPoint) throws Throwable {String key = joinPoint.getSignature().toString();Log.e(TAG, "onActivityMethodBefore: " + key);}@After("execution(* android.app.Activity.on*(android.os.Bundle))")public void onActivityMethodAfter(JoinPoint joinPoint) throws Throwable {String key = joinPoint.getSignature().toString();Log.e(TAG, "onActivityMethodAfter: " + key);}

例如 监听Activity的on开始的方法。

  protected void onCreate(Bundle savedInstanceState) {JoinPoint var3 = Factory.makeJP(ajc$tjp_0, this, this, savedInstanceState);try {AspectTrace.aspectOf().onActivityMethodBefore(var3);super.onCreate(savedInstanceState);....省略代码....});} catch (Throwable var6) {AspectTrace.aspectOf().onActivityMethodAfter(var3);throw var6;}AspectTrace.aspectOf().onActivityMethodAfter(var3);}

可以看到
分别在原onCreate的开始，和结尾插入了AspectTrace.aspectOf().onActivityMethodBefore(var3);
与 AspectTrace.aspectOf().onActivityMethodAfter(var3);

这里除了用execution 还可以用call, call与 execution的区别call 是在方法调用的外面，execution 是在方法内部。

@Around("execution(* collectPageName(String,com.womai.MyApp,String))")
public Object executionMethod(ProceedingJoinPoint joinPoint) throws Throwable {joinPoint.proceed();MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();String className = methodSignature.getDeclaringType().getSimpleName();String methodName = methodSignature.getName();String result = "aroundWeaverPoint";Log.e(TAG,"----------------------------->aroundWeaverPoint"+"|"+joinPoint.getThis()+"|"+joinPoint.getArgs()+"|"+joinPoint.getKind()+"|"+joinPoint.getArgs()+"|"+className+"|"+methodName);return  result;//替换原方法的返回值
}
@Before("call(* collectPageName(String,com.womai.MyApp,String))")
public void callMethod(JoinPoint joinPoint){Log.e(TAG,"beforecall");
}

编译后的方法

    protected void onStart() {String var8 = "";MyApp var9 = this.myApp;String var10 = this.className;var10000 = ajc$tjp_1;Object[] var12 = new Object[]{var10, var9, var8};JoinPoint var7 = Factory.makeJP(var10000, this, this, var12);AspectTrace.aspectOf().callMethod(var7);//原方法this.collectPageName(var10, var9, var8);}private void collectPageName(String key, MyApp myApp, String title) {StaticPart var10000 = ajc$tjp_2;Object[] var8 = new Object[]{key, myApp, title};JoinPoint var7 = Factory.makeJP(var10000, this, this, var8);AspectTrace var10 = AspectTrace.aspectOf();Object[] var9 = new Object[]{this, key, myApp, title, var7};var10.executionMethod((new AbstractActivity$AjcClosure1(var9)).linkClosureAndJoinPoint(69648));}

ProceedingJoinPoint 是继承 JoinPoint 并暴露了proceed() 方法，这个方法的作用是执行原函数。调用原方法的执行， joinPoint.proceed();

call，execution，within,withincode 具体语法使用示例

call和execution

二者区别在于 call 是 函数被调用的地方， execution 是函数内部执行。

语法结构：execution / call ([修饰符]　返回值类型　方法名(参数)　［异常模式］) 蓝色表示可选部分。

例子：

execution / call(public *.*(..))　　所有的public方法。
execution / call(* hello(..))            所有的hello()方法
execution / call(String hello(..))   所有返回值为String的hello方法。
execution / call(* hello(String))  　　所有参数为String类型的hello()
execution / call(* hello(String..))      至少有一个参数，且第一个参数类型为String的hello方法
execution / call(* com.aspect..*(..))  　所有com.aspect包，以及子孙包下的所有方法
execution / call(* com..*.*Dao.find*(..))　　com包下的所有一Dao结尾的类的一find开头的方法
within 和 withincode
  // within 织入 除了HomeActivity以外的 collectPageName方法@Pointcut("execution(* collectPageName(String,com.womai.MyApp,String))&& !within(com.womai.activity.home.HomeActivity)")//&& within(com.womaipublic void withinMethod() {}@Before("withinMethod()")public void withinCall(JoinPoint joinPoint){Log.e(TAG,"withinCall" +   "   "+joinPoint.toString());}

withincode

// 在testAOP2()方法内
@Pointcut("withincode(* com.xys.aspectjxdemo.MainActivity.testAOP2(..))")
public void invokeAOP2() {
}// 调用testAOP()方法的时候
@Pointcut("call(* com.xys.aspectjxdemo.MainActivity.testAOP(..))")
public void invokeAOP() {
}// 同时满足前面的条件，即在testAOP2()方法内调用testAOP()方法的时候才切入
@Pointcut("invokeAOP() && invokeAOP2()")
public void invokeAOPOnlyInAOP2() {
}@Before("invokeAOPOnlyInAOP2()")
public void beforeInvokeAOPOnlyInAOP2(JoinPoint joinPoint) {String key = joinPoint.getSignature().toString();Log.d(TAG, "onDebugToolMethodBefore: " + key);
}

参考更多

AspectJ 语法文档
AspectJ in Android
AOP 之 AspectJ 全面剖析 in Android
AOP之AspectJ在Android中的应用

这篇关于Android AOP框架 AspectJ的使用的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1066520。

相关文章

使用Python和Pyecharts创建交互式地图

使用Python和Pyecharts创建交互式地图

《使用Python和Pyecharts创建交互式地图》在数据可视化领域,创建交互式地图是一种强大的方式,可以使受众能够以引人入胜且信息丰富的方式探索地理数据,下面我们看看如何使用Python和Pyec... 目录简介Pyecharts 简介创建上海地图代码说明运行结果总结简介在数据可视化领域，创建交互式地
阅读更多...
Java Stream流使用案例深入详解

Java Stream流使用案例深入详解

《JavaStream流使用案例深入详解》：本文主要介绍JavaStream流使用案例详解,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录前言1. Lambda1.1 语法1.2 没参数只有一条语句或者多条语句1.3 一个参数只有一条语句或者多
阅读更多...
Java Spring 中 @PostConstruct 注解使用原理及常见场景

Java Spring 中 @PostConstruct 注解使用原理及常见场景

《JavaSpring中@PostConstruct注解使用原理及常见场景》在JavaSpring中,@PostConstruct注解是一个非常实用的功能,它允许开发者在Spring容器完全初... 目录一、@PostConstruct 注解概述二、@PostConstruct 注解的基本使用2.1 基本代
阅读更多...
C#使用StackExchange.Redis实现分布式锁的两种方式介绍

C#使用StackExchange.Redis实现分布式锁的两种方式介绍

《C#使用StackExchange.Redis实现分布式锁的两种方式介绍》分布式锁在集群的架构中发挥着重要的作用,：本文主要介绍C#使用StackExchange.Redis实现分布式锁的... 目录自定义分布式锁获取锁释放锁自动续期StackExchange.Redis分布式锁获取锁释放锁自动续期分布式
阅读更多...
springboot使用Scheduling实现动态增删启停定时任务教程

springboot使用Scheduling实现动态增删启停定时任务教程

《springboot使用Scheduling实现动态增删启停定时任务教程》：本文主要介绍springboot使用Scheduling实现动态增删启停定时任务教程,具有很好的参考价值,希望对大家有... 目录1、配置定时任务需要的线程池2、创建ScheduledFuture的包装类3、注册定时任务，增加、删
阅读更多...
使用Python实现矢量路径的压缩、解压与可视化

使用Python实现矢量路径的压缩、解压与可视化

《使用Python实现矢量路径的压缩、解压与可视化》在图形设计和Web开发中,矢量路径数据的高效存储与传输至关重要,本文将通过一个Python示例,展示如何将复杂的矢量路径命令序列压缩为JSON格式,... 目录引言核心功能概述1. 路径命令解析2. 路径数据压缩3. 路径数据解压4. 可视化代码实现详解1
阅读更多...
Pandas透视表(Pivot Table)的具体使用

Pandas透视表(Pivot Table)的具体使用

《Pandas透视表(PivotTable)的具体使用》透视表用于在数据分析和处理过程中进行数据重塑和汇总,本文就来介绍一下Pandas透视表(PivotTable)的具体使用,感兴趣的可以了解一下... 目录前言什么是透视表？使用步骤1. 引入必要的库2. 读取数据3. 创建透视表4. 查看透视表总结前言
阅读更多...
Python 交互式可视化的利器Bokeh的使用

Python 交互式可视化的利器Bokeh的使用

《Python交互式可视化的利器Bokeh的使用》Bokeh是一个专注于Web端交互式数据可视化的Python库,本文主要介绍了Python交互式可视化的利器Bokeh的使用,具有一定的参考价值,感... 目录1. Bokeh 简介1.1 为什么选择 Bokeh1.2 安装与环境配置2. Bokeh 基础2
阅读更多...
Android使用ImageView.ScaleType实现图片的缩放与裁剪功能

Android使用ImageView.ScaleType实现图片的缩放与裁剪功能

《Android使用ImageView.ScaleType实现图片的缩放与裁剪功能》ImageView是最常用的控件之一,它用于展示各种类型的图片,为了能够根据需求调整图片的显示效果,Android提... 目录什么是 ImageView.ScaleType？FIT_XYFIT_STARTFIT_CENTE
阅读更多...
Java学习手册之Filter和Listener使用方法

Java学习手册之Filter和Listener使用方法

《Java学习手册之Filter和Listener使用方法》：本文主要介绍Java学习手册之Filter和Listener使用方法的相关资料,Filter是一种拦截器,可以在请求到达Servl... 目录一、Filter（过滤器）1. Filter 的工作原理2. Filter 的配置与使用二、Listen
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2