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。

相关文章

C语言中联合体union的使用

C语言中联合体union的使用

本文编辑整理自： http://bbs.chinaunix.net/forum.php?mod=viewthread&tid=179471 一、前言 “联合体”(union）与“结构体”(struct)有一些相似之处。但两者有本质上的不同。在结构体中,各成员有各自的内存空间, 一个结构变量的总长度是各成员长度之和。而在“联合”中,各成员共享一段内存空间, 一个联合变量
阅读更多...
Tolua使用笔记（上）

Tolua使用笔记（上）

目录   1.准备工作 2.运行例子 01.HelloWorld：在C#中，创建和销毁Lua虚拟机 和 简单调用。 02.ScriptsFromFile：在C#中，对一个lua文件的执行调用 03.CallLuaFunction：在C#中，对lua函数的操作 04.AccessingLuaVariables：在C#中，对lua变量的操作 05.LuaCoroutine：在Lua中，
阅读更多...
Vim使用基础篇

Vim使用基础篇

本文内容大部分来自 vimtutor，自带的教程的总结。在终端输入vimtutor 即可进入教程。 先总结一下，然后再分别介绍正常模式，插入模式，和可视模式三种模式下的命令。 目录 看完以后的汇总 1.正常模式（Normal模式） 1.移动光标 2.删除 3.【:】输入符 4.撤销 5.替换 6.重复命令【. ; ,】 7.复制粘贴 8.缩进 2.插入模式 INSERT
阅读更多...
Lipowerline5.0 雷达电力应用软件下载使用

Lipowerline5.0 雷达电力应用软件下载使用

1.配网数据处理分析 针对配网线路点云数据，优化了分类算法，支持杆塔、导线、交跨线、建筑物、地面点和其他线路的自动分类；一键生成危险点报告和交跨报告；还能生成点云数据采集航线和自主巡检航线。 获取软件安装包联系邮箱:2895356150@qq.com，资源源于网络，本介绍用于学习使用，如有侵权请您联系删除！ 2.新增快速版，简洁易上手 支持快速版和专业版切换使用，快速版界面简洁，保留主
阅读更多...
如何免费的去使用connectedpapers？

如何免费的去使用connectedpapers？

免费使用connectedpapers 1. 打开谷歌浏览器2. 按住ctrl+shift+N,进入无痕模式3. 不需要登录（也就是访客模式）4. 两次用完，关闭无痕模式（继续重复步骤 2 - 4） 1. 打开谷歌浏览器 2. 按住ctrl+shift+N,进入无痕模式 输入网址：https://www.connectedpapers.com/ 3. 不需要登录（也就是
阅读更多...
19.手写Spring AOP

19.手写Spring AOP

1.Spring AOP顶层设计 2.Spring AOP执行流程 下面是代码实现 3.在 application.properties中增加如下自定义配置: #托管的类扫描包路径#scanPackage=com.gupaoedu.vip.demotemplateRoot=layouts#切面表达式expression#pointCut=public .* com.gupaoedu
阅读更多...
Eclipse+ADT与Android Studio开发的区别

Eclipse+ADT与Android Studio开发的区别

下文的EA指Eclipse+ADT,AS就是指Android Studio。 就编写界面布局来说AS可以边开发边预览（所见即所得,以及多个屏幕预览），这个优势比较大。AS运行时占的内存比EA的要小。AS创建项目时要创建gradle项目框架，so,创建项目时AS比较慢。android studio基于gradle构建项目，你无法同时集中管理和维护多个项目的源码，而eclipse ADT可以同时打开
阅读更多...
android 免费短信验证功能

android 免费短信验证功能

没有太复杂的使用的话，功能实现比较简单粗暴。 在www.mob.com网站中可以申请使用免费短信验证功能。 步骤： 1.注册登录。 2.选择“短信验证码SDK” 3.下载对应的sdk包，我这是选studio的。 4.从头像那进入后台并创建短信验证应用，获取到key跟secret 5.根据技术文档操作（initSDK方法写在setContentView上面） 6.关键：在有用到的Mo
阅读更多...
android一键分享功能部分实现

android一键分享功能部分实现

为什么叫做部分实现呢，其实是我只实现一部分的分享。如新浪微博，那还有没去实现的是微信分享。还有一部分奇怪的问题：我QQ分享跟QQ空间的分享功能，我都没配置key那些都是原本集成就有的key也可以实现分享，谁清楚的麻烦详解下。 实现分享功能我们可以去www.mob.com这个网站集成。免费的，而且还有短信验证功能。等这分享研究完后就研究下短信验证功能。 开始实现步骤（新浪分享，以下是本人自己实现
阅读更多...
Android我的二维码扫描功能发展史（完整）

Android我的二维码扫描功能发展史（完整）

最近在研究下二维码扫描功能，跟据从网上查阅的资料到自己勉强已实现扫描功能来一一介绍我的二维码扫描功能实现的发展历程： 首页通过网络搜索发现做android二维码扫描功能看去都是基于google的ZXing项目开发。 2、搜索怎么使用ZXing实现自己的二维码扫描：从网上下载ZXing-2.2.zip以及core-2.2-source.jar文件，分别解压两个文件。然后把.jar解压出来的整个c
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2