Android AOP 之 Aspectj 实践

最新推荐文章于 2021-07-08 20:56:59 发布
最新推荐文章于 2021-07-08 20:56:59 发布
阅读量318 收藏
点赞数
分类专栏： android 文章标签： Aspectj AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vv765947965/article/details/81393781
版权

1、AOP的概念：

        面向侧面的程序设计（aspect-oriented programming，AOP，又译作面向方面的程序设计、观点导向编程、剖面导向程序设计）是计算机科学中的一个术语，指一种程序设计范型。该范型以一种称为侧面（aspect，又译作方面）的语言构造为基础，侧面是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点（crosscutting concern）。
侧面的概念源于对面向对象的程序设计的改进，但并不只限于此，它还可以用来改进传统的函数。与侧面相关的编程概念还包括元对象协议、主题（subject）、混入（mixin）和委托。(摘自维基百科)

2、AOP在Android中的应用点：

      aop是一种面向切面的编程思想，目的在于从切面插入自己需要的代码，在不破坏、不耦合原有代码逻辑的基础上，实现相关的功能，在Android中的应用场景非常丰富，如：数据统计、日志记录、用户行为统计、应用性能统计、数据校验、行为拦截，等等应用场景。

3、在Android中，如何实现AOP编程：

      aop编程的实现技术方案有很以下几种：

      1、APT(直接插入java文件)；

      2、Aspectj(编织class文件)；

      3、javassist(修改class文件)；

     通这里主要介绍aspectj的使用

4、Aspectj框架入门介绍：

  1. 环境搭建:

    aspectj的环境搭建步骤比较复杂，这里参考了Hujiang的项目(该插件目前有些问题未修复)，对gradle插件进行了封装；

    使用步骤：

    在项目的build.gradle文件中加入如下代码:

     

    repositories {
    ...
    maven { url 'https://jitpack.io' }
}
    dependencies {
    ...
 classpath 'com.github.alfredxl:android-aspectj:0.9.0'
}

    在application模块中的build.gradle文件中加入:

    apply plugin: 'android-aspectjx'

    aspectj介绍: 

    aspectj术语

    名称

    描述

    JPoint代码可注入的点，比如一个方法的调用处或者方法内部、“读、写”变量等。
    Pointcut用来描述 JPoint 注入点的一段表达式，比如：调用 Animal 类 fly 方法的地方，call(* Animal.fly(..))。
    Advice常见的有 Before、After、Around 等，表示代码执行前、执行后、替换目标代码，也就是在 Pointcut 何处注入代码。
    AspectPointcut 和 Advice 合在一起称作 Aspect。

    JPoint语法:

    符号

    描述

    *表示任何数量的字符,除了(.)
    ..表示任何数量的字符包括任何数量的(.)
    +描述指定类型的任何子类或者子接口
    !一 元操作符:
    ||、&& 二 元操作符

     

    主要例子:

    例子

    解析

    *Account使用Account名称结束的类型,如SavingsAccount和CheckingAccount
    java.*.Date类型Date在任何直接的java子包中,如java.util.Date和java.sql.Date
    java..*任何在java包或者所有子包中的类型,如java.awt和java.util或者java.awt.event 和java.util.logging
    javax..*Model+所有javax包或者子包中以Model结尾的类型和其所有子类,如TableModel,TreeModel。
    !vector所有除了Vector的类型
    Vector || HashtableVector或者Hashtable类型
    java.util.RandomAccess+

    RandomAccess的所有子类

    void Account.set*(*) 

    		Account中以set开头,并且只有一个参数类型，无返回值的方法
    void Account.*() Account中所有的没有参数的void 方法
    public * Account.*() Account中所有没有参数的public 方法
    public * Account.*(..) Account中所有的public 方法
    * Account.*(..) Account中的所有方法,包括private方法
    !public * Account.*(..) 所有的非public 方法
    * Account+.*(..) 

    所有的方法,包括子类的方法

    * java.io.Reader.read(..)所有的read方法
    * java.io.Reader.read(char[],..) 所有以read(char[])开始的方法,包括read(char[])和read(char[],int,int)
    * javax..*.add*Listener(EventListener+) 命名以add开始,以Listener结尾的方法,参数中为EventListener或子类
    * *.*(..) throws RemoteException 抛出RemoteException的所有方法

     

    Pattern规则

    名称

    描述

    MethodPattern : [!] [@Annotation] [public,protected,private] [static] [final] 返回值类型 [类名.]方法名(参数类型列表) [throws 异常类型]
    ConstructorPattern:  [!] [@Annotation] [public,protected,private] [final] [类名.]new(参数类型列表) [throws 异常类型]
    FieldPattern: [!] [@Annotation] [public,protected,private] [static] [final] 属性类型 [类名.]属性名

     

    TypePattern:  

    其他 Pattern 涉及到的类型规则也是一样，可以使用 '!'、''、'..'、'+'，'!' 表示取反，'' 匹配除 . 外的所有字符串，

    '*' 单独使用事表示匹配任意类型，'..' 匹配任意字符串，'..' 单独使用时表示匹配任意长度任意类型，'+' 匹配其自身及子类，

    还有一个 '...'表示不定个数

    Pointcut语法:

    语法

    描述

    execution(MethodPattern)方法执行
    call(MethodPattern)方法调用
    execution(ConstructorPattern)构造函数执行
    call(ConstructorPattern)构造函数被调用
    staticinitialization(TypePattern)static 块初始化
    get(FieldPattern)属性读操作
    set(FieldPattern)属性写操作
    handler(TypePattern)异常处理
    adviceexecution()所有 Advice 执行

    间接选择Pointcut语法：

    语法

    描述

    within(TypePattern):  TypePattern表示某个包或者类中包含的JPoint，可以使用通配符；
    withincode(ConstructorPattern|MetodPattern): 表示某个类的构造函数或方法中涉及到的JPoint；
    cflow(pointcuts):

    比如cflow(call Animal.fly): 标识调用Animal.fly函数时所包含的JPoint，包含fly的call这个JPoint本身；

    cflowbelow(pointcuts):比如cflowbelow(call Animal.fly): 标识调用Animal.fly函数时所包含的JPoint，但不包含fly的call这个JPoint本身；
    this(Type):JPoint所在的对象是否满足instanceof Type条件（注：不能使用通配符，与within类似，但within包含内部类， 而this不包含)；
    target(Type):与this相对，表示Pointcut所在对象是否满足instanceof Type条件(注：不能使用通配符);

    args(TypeSignature):

    		Constructor Signature|Method Signature的参数类型，比如args(int,..)表示第一个参数是int, 后面的参数个数和类型不限；
    if(BooleanExpression): 满足表达式的 Join Point，表达式只能使用静态属性、Pointcuts 或 Advice 暴露的参数、thisJoinPoint 对象。

     

    Advice语法:

    语法

    描述

    Before(Pointcut): 在执行JPoint之前；
    After(Pointcut):在执行JPonit之后;
    Aroud(Pointcut):替换原需要执行的代码，如需执行原代码，需调用joinPoint.proceed()方法，不可与Before和After同时使用
    AfterReturning(Pointcut):JPoint 为方法调用且正常 return 时，不指定返回类型时匹配所有类型
    AfterThrowing(Pointcut):JPoint 为方法调用且抛出异常时，不指定异常类型时匹配所有类型

     

    aspectj示例:

    execution(MethodPattern)（JPoint方法执行）

    @Aspect
public class OtherJpoint {

@Before("execution(* android.view.View.OnClickListener.onClick(android.view.View))")
public void onViewClickListener(JoinPoin joinPoint) throws Throwable {
if (joinPoint.getArgs() != null && joinPoint.getArgs().length > 0) {
            Object object = joinPoint.getArgs()[0];
 if (object instanceof TextView) {
                Log.d("aopLog", "clickViewName: " + ((TextView) object).getText().toString());
 }
        }
 }
}

    该切入点执行的效果为：在所有实现View的点击事件的onClick方法内部代码执行之前打印View的信息

    execution(ConstructorPattern)（JPoint构造器执行）

    @Before("execution(com.aspectj.demo.bean.Person.new(..))")
public void onStartPageConstructor(JoinPoint joinPoint) throws Throwable {
    Log.d("aopLog", "this:" + joinPoint.getThis().toString());
}

    该切入点执行的效果为：在所有创建Person对象的时候，执行Person对象构造函数之前打印该对象的信息；

    注意： 构造函数执行， 没有返回值类型， 且函数名只能是new

    call(MethodPattern)  (JPoint方法调用)

    @Before("call(* com.aspectj.demo.StartPage.setButtonOneData(..))")
public void onCallStartPagesetButtonOneData(JoinPoint joinPoint) throws Throwable {
if (joinPoint.getArgs() != null && joinPoint.getArgs().length > 0) {
        Object object = joinPoint.getArgs()[0];
 Log.d("aopLog", "button_text: " + object.toString());
 }
}

    该切入点的效果为：在所有调用com.aspectj.demo.StartPage.setButtonOneData(..)该方法的代码之前打印传递给该方法的型参

    staticinitialization(TypePattern)  (JPoint类初始化)

    @Before("staticinitialization(com.aspectj.demo.bean.Person)")
public void onStartPageStaticinitialization(JoinPoint joinPoint) throws Throwable {
    Log.d("aopLog", "staticinitialization_this:" + joinPoint.getStaticPart().toString());
}

    该切入点的效果为：在Person初始化之前打印信息

    get(FieldPattern)  (JPoint属性读操作)

    @Before("get(* com.aspectj.demo.bean.Person.*)")
public void getPersonField(JoinPoint joinPoint) throws Throwable {
    Log.d("aopLog", "getPersonField:" + joinPoint.getStaticPart().toString());
}

    该切入点的效果为，在所有获取Person对象属性的代码之前插入打印信息

    set(FieldPattern)  (JPoint属性写操作)

    @Before("set(* com.aspectj.demo.bean.Person.*)")
public void setPersonField(JoinPoint joinPoint) throws Throwable {
    Log.d("aopLog", "setPersonField:" + joinPoint.getStaticPart().toString());
}

    该切入点的效果为，在所有设置Person对象属性值的代码之前插入打印信息

    handler(TypePattern)  (JPoint例外处理执行)

    private fun showToast(message: String) {
if (message.isNotEmpty()) {
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
    }
try {
throw IllegalArgumentException()
    } catch (e: IllegalArgumentException) {

    }
}
    @Before("handler(java.lang.IllegalArgumentException)")
public void handlerIllegalArgumentException(JoinPoint joinPoint) throws Throwable {
    Log.d("aopLog", "handlerIllegalArgumentException:" + joinPoint.getStaticPart().toString());
}

    该切入点的效果为，在所有编译时匹配的IllegalArgumentException异常，将在异常抛出前，打印信息；

    注意： handler只支持Before，而且只能匹配编译期异常捕获，并且不能捕获该异常的子类。

    within(TypePattern) 

    @Pointcut("within(com.aspectj.demo.StartPage)")
public void withinStartPage() {
}

@Pointcut("call(* android.widget.Toast.show(..))")
public void showToast() {
}

@Before("withinStartPage() && showToast()")
public void withinStartPageAndShowToast(JoinPoint joinPoint) throws Throwable {
    Log.d("aopLog", "withinStartPageAndShowToast:" + joinPoint.getStaticPart().toString());
}

    该切入点的效果为，在StartPage类中调用Toast方法之前打印相关信息

    withincode(MethodPattern) 

    @Pointcut("withincode(* com.aspectj.demo.StartPage.showToast(..))")
public void inStartPageShowToast() {
}
    @Pointcut("call(* android.widget.Toast.show(..))")
public void showToast() {
}
    @Before("inStartPageShowToast() && showToast()")
public void inStartPageShowToastAndShowToast(JoinPoint joinPoint) throws Throwable {
    Log.d("aopLog", "inStartPageShowToastAndShowToast: " + joinPoint.getSignature().getName());
}

    该切入点的效果为：在com.aspectj.demo.StartPage.showToast()方法中调用了Toast方法之前打印相关信息

    注解

    @Retention(RetentionPolicy.CLASS)
@Target({ElementType.METHOD})
public @interface ActivityOnCreate {
}
    @Pointcut("execution(@com.aspectj.aspectjaplay.activitylife.ActivityOnCreate * *(..))")
public void ActivityOnCreate() {
}

@Around("ActivityOnCreate()")
public void ActivityOnCreate(ProceedingJoinPoint joinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
 joinPoint.proceed();
 long endTime = System.currentTimeMillis();
 String key = joinPoint.getSignature().getName();
 Log.d("aopLog", "execution_onActivityMethodAround: " + joinPoint.getThis().getClass().getSimpleName() + "_" + key + ":" + (endTime - startTime));
}

    该切入点的效果为，在使用了ActivityOnCreate 注解的目标方法执行前进行拦截并实行相关操作

    这里关于Around的切入方式需要特殊说明一下，由于Around是切入整个方法的执行体，把整个方法执行体作为一个返回参数，所以在切有返回值的方法时，必须如下定义

    @Around("Test()")
    public Object Test(ProceedingJoinPoint joinPoint) throws Throwable {
    Object object = joinPoint.proceed();
    return object ;
    }

     

    即切入点方法撰写的时候必须是返回Object的方法，然后返回 joinPoint.proceed() 的值

     

总结：

本篇介绍，对AOP及Aspectj的介绍仅仅只涉及到到入门知识，更输入的学习，欢迎大家一起加入。

Github项目地址

繁华落尽666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android AspectJ详解
m0_67595789的博客
05-03 1345
@Aspect 用它声明一个类，表示一个需要执行的切面。 @Pointcut 声明一个切点。 @Before/@After/@Around/…（统称为Advice类型） 声明在切点前、后、中执行切面代码。 这么说你可能有点蒙，我们换个角度解释。 假设你是一个AOP框架的设计者，最先需要理清的其基本组成要素。既然需要做代码织入那是不是一定得配置代码的织入点呢？这个织入点就是Pointcut，有了织入点我们还需要指定具体织入的代码，这个代码写在哪里呢？就是写在以@Before/@After/@Around注.
Android AOP编程之AspectJ
殇神马的博客
07-06 689
一、AspectJ Aspectj是一个AOP框架，也是通过对字节码操作，来实现AOP的，但是与ASM需要开发者直接编写操作字节码的代码之外，使用Aspectj不需要开发者直接编写操作字节码代码， 而是只需要按照规范编写我们需要处理的Java代码即可;由Aspectj帮助我们将编写的Java代码的字节码织入到.class字节码文件中实现字节码插桩操作； 二、AspectJ中的基本概念 1.切面 Aspect 我们在学习AOP的时候，知道AOP实际就是针对的是业务逻辑中的某个处理步骤，比如日志处理，登录判断
极简Android AOP之AspectJ
阿根的专栏
07-08 487
环境： android studio版本：4.2.2 android gradle插件版本：3.1.2 参考文档： android aop(三) AspectJ AspectJ在Android中的使用 1.配置环境（引入AspectJ插件） （1）在project的build.gradle中补充如下配置 buildscript { repositories { mavenCentral() } dependencies { cla.
Android中使用AspectJ
vonnie_jade的博客
04-02 2572
aop学习 深入理解Android之AOP什么是AOPAOP是Aspect Oriented Programming的缩写，即『面向切面编程』。它和我们平时接触到的OOP都是编程的不同思想，OOP，即『面向对象编程』，它提倡的是将功能模块化，对象化，而AOP的思想，则不太一样，它提倡的是针对同一类问题的统一处理，当然，我们在实际编程过程中，不可能单纯的安装AOP或者OOP的思想来编程，很多时候，可能
Android AOP简介及AspectJ的应用
ChatGPTer
06-24 1112
AOP: Aspect Oriented Programming，即面向切面编程。作用是通过预编译方式和运行期动态代理实现程序功能的统一维护。
Android中AOP的应用实践之过滤重复点击
01-05
前言 大家对AOP应该都不陌生, 就算没有用过也肯定听说过，切面编程一直是一个热点的话题，AOP即Aspect ...AOP是一种编程思想,或者说方法论,AspectJ则是专为AOP设计的一种语言,它支持原生的JAVA,可用于在java中处理
android架构师之路_aop
07-01
在Android开发领域，成为一个架构师不仅意味着掌握基本的编程技巧，还需要深入理解系统架构、设计模式、性能优化以及特殊技术...通过实践，你将逐步建立起自己的AOP知识体系，为成为优秀的Android架构师奠定坚实基础。
Android-框架知识整理之AndroidAOP编程思想
08-13
虽然Android原生并不支持AspectJ，但通过使用AspectJ的编译工具（如AspectJ Weaver），开发者可以在Android项目中利用AspectJ进行AOP编程。 3. **Android Annotation库**：像Dagger、Butter Knife等流行的Android库...
深入理解Android之AOP
01-26
而Android自身虽未直接提供AOP支持，但我们可以通过第三方库，如AspectJ、Dagger等来实现AOP。 在实际应用中，比如要为Android中各个Activity的生命周期方法添加日志记录，如果我们使用AOP，则只需定义一个切面，并...
Android中AOP实践之三AspectJ解析篇
郝捷的专栏
11-12 1050
介绍AspectJ是Java的一个简单实用的面向方面的扩展。通过几个新的构造，AspectJ提供了对一系列横切关注的模块化实现的支持。在现有的Java开发项目中采用AspectJ可能是一个简单而且增量的任务。一条路径是从开发方面开始，继续使用生产方面，然后在使用AspectJ建立经验之后再使用方面。采用也可以遵循其他途径。例如，一些开发人员将从马上使用生产方面受益。
Android AspectJ 使用
09-02
Android AspectJ 简单使用
android中aspectj 的使用
12-17
android用aspectj在android如何用动态代理的
Android使用Aspectj(AOP)
weixin_30788731的博客
03-21 120
使用AspectJ 集成步骤： 　　1、AS配置Aspectj环境 　　2、配置使用ajc编译 　　4、定义注解 　　5、Aspect 　　6、使用 　　7、Example AS配置Aspectj环境。Aspect目前最新版本为 1.8.10，AS中需要集成aspectjtool及aspectjrt并配置ajc编译,具体如下： build.gradle(project) ...
Android AOP编程（一）——AspectJ基础知识
大前端程序猿
07-05 6907
什么是AOP 以下是维基百科上对AOP的介绍： 面向切面的程序设计（Aspect-oriented programming，AOP，又译作面向方面的程序设计、剖面导向程序设计）是计算机科学中的一种程序设计思想，旨在将横切关注点与业务主体进行进一步分离，以提高程序代码的模块化程度。通过在现有代码基础上增加额外的通知（Advice）机制，能够对被声明为“切点（Pointcut）”的代码块进行统一管理与装饰，如“对所有方法名以‘set*’开头的方法添加后台日志”。该思想使得开发人员能够将与代码核心业务逻辑关系不那
AOP-Android-AspectJ使用
ddxxii的博客
01-13 2201
一. 介绍 以下介绍的其中部分内容是摘抄修改自网络： AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 它并没有帮助我们解决任何新的问题，它只是提供了一种更好的办法，能够用更少的工作量来解决现有的一些问题，并且使得系统更加健壮，可维护性更好。同时，它让我们在进行系统架构和模块设计的时候多了新的...
在Android项目中使用AspectJ
weixin_30577801的博客
04-20 117
版权声明：本文为博主原创文章，未经博主允许不得转载。 转载请表明出处：http://www.cnblogs.com/cavalier-/p/8888459.html 什么是AOP AOP是 Aspect Oriented Programming 的缩写，即面向切面编程，和平常遇到的面向对象OOP编程不一样的是，OOP是将功能模块化对象化，AOP是针对同一类的问题统一化处理。例如做日志埋点，性能...
AspectJ 在 Android 中的使用
yxhuang2008的专栏
06-29 4495
AspectJ 在 Android 中的使用 在介绍 AspectJ 之前，我们先看看常见的几种编程架构思想。 面向对象编程 Object Oriented Programming 面向过程编程 Procedure Oriented Programming 面向切面编程 Aspect Oriented Programming 面向对象、面向过程、面向切面， 这三种是我们常见的三种编程架构思想，...
Android AOP实践：使用AspectJ实现面向切面编程
在Android中，最常用的AOP实现工具是AspectJ。AspectJ提供了一种静态编译和运行时织入的方式，使得开发者能够方便地编写和应用切面。其他选项包括Javassist for Android、DexMaker和ASMDEX，它们主要用于字节码操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值