Android AOP基础

最新推荐文章于 2024-08-18 10:16:41 发布
最新推荐文章于 2024-08-18 10:16:41 发布
阅读量1.1k 收藏
点赞数
分类专栏： Android 文章标签： AspectJ android aop 面向切面编程 代码注入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tscyds/article/details/75094107
版权
AOP概述

  1. AOP，即面向切面编程，是一种编程思想，强调的是在‘某一层面’上编写程序的方式，而这‘某一层面’就被称为切面。

  2. 比如打印log，作为调试的一种手段，一般会渗透到项目中的许多地方，那么打印log就可看成是一种切
    面，而AOP会指导我们怎样编写打印log会更好。

  3. AOP的主要目标是尽可能地对切面代码进行解耦。

Android代码注入

AOP采用代码注入技术来实现高度的代码解耦，而在Android中常见的代码注入主要分为以下几种：

  1. 编译时注入：在编译代码阶段直接对class文件进行代码注入，属于静态代码注入，它的特点是对性能的影响较小，而缺陷仅能注入参与编译的代码。AspectJ支持编译时注入，注意在Android中是无法注入系统API类，如android.jar下的类。但可以注入support包。

  2. 加载时注入：在Android的虚拟机加载dex文件时进行代码注入，特点是对性能的影响较小，缺陷是门槛较高，比如热更新等。

  3. 运行时注入：在程序运行阶段进行注入，相比前面的静态注入，运行时进行注入会更加的灵活，但是对性能的运行较大，比如Java的动态代理。

AspectJ

  1. AspectJ是AOP这种理论来指导实践的一种工具，更切确的说是一种编程语言，它也有自己的语法规则、编译工具等。

  2. 对于打印log这一切面进行编程，AspectJ的做法是通过代码注入技术来解耦，此种做法让人耳目一新。通过预先标记目标代码，在编译代码阶段注入切面代码。对于Java项目来说即在编译阶段往字节码注入代码，注入的技术支撑是hook。

  3. AspectJ与Java是两种不同语言，不能直接交流。目前较好的解决方案是：AspectJ通过java注解进行语法规则的映射，并借助gradle插件完成编译工作。

AspectJ核心

  1. Joint point：在AspectJ中，允许注入代码的地方被称为Joint point（连接点）。Joint point主要分为以下几种：
    这里写图片描述
    显然Joint point就是程序中关键的地方，如方法的调用与执行、字段的读写、异常和静态代码块等。虽Joint point类型是有限的，但对于一般的应用场景是足够了。重点关注execution与call的区别：

    • execution：这个Joint point是位于执行的方法体中
    • call：这个Joint point是位于该方法被调用的地方
    • handler：这个Joint point是位于异常throw的地方

  2. Pointcut：切入点，其作用是挑选出需要注入的目标Joint point。简单理解就是告诉AspectJ要在哪些Joint point执行代码注入。除了上图中包括的直接Joint point类型，Pointcut还提供了以下过滤Joint point的辅助工具：

    • within()：可以筛选出指定包或类下的Joint point
    • withincode()：可以筛选出指定构造方法或普通方法的execution类型的Joint point
    • cflow()：可以筛选出目标call类型Joint point中包括的所有Joint point，包括目标call这个Joint point，注意括号中的参数必须是Pointcut
    • cflowbelow()：与cflow()唯一区别就是不包括目标call这个Joint point
      总之，Pointcut借助于逻辑操作符（&&，||，！）可以组合成一个功能复杂的Pointcut

  3. Advice：作用决定代码注入的时机以及执行代码注入。比如对某个方法进行注入，到底是在方法执行之前或之后，甚至于替换这个方法。分为以下几种：

    • before：在目标方法执行之前注入
    • around：取得目标方法执行的控制权，可以替换目标方法
    • after：在目标方法执行之后注入

  4. Aspect：指的是Pointcut与Advice的组合，其代表的就是往目标切面注入代码。

  5. Weaving：代码织入，对于Android应用需要反编译代码才能看到AspectJ所注入的代码。

  6. 小结：上述AspectJ中的涉及的核心概念可总结为如下关系图：

这里写图片描述

Android AspectJ实践

  1. 目前AspectJ还未提供标准的gradle插件，考虑到接入成本，此处选用开源插件gradle_plugin_android_aspectjx。具体配置如下：在工程目录build.gradle的配置aspectjx插件依赖，如下代码

    dependencies {
    classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:1.0.10'
}

  2. 在app目录build.gradle的配置如下代码

    apply plugin: 'android-aspectjx'
aspectjx {
   excludeJarFilter '.jar'
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'org.aspectj:aspectjrt:1.8.+'
}

  3. 编写Pointcut，预先标记目标代码。Pointcut指明在何处注入代码，如下例子

    @Aspect
public class DemoAspect {

private static final Logger logger = LoggerFactory.getLogger(DemoAspect.class);

@Pointcut("execution(* com.example.dson.app.ui.activity.MainActivity.onCreate(..))")
public void injectCode() {
}

@Before("injectCode()")
public void execInjectCode(JoinPoint joinPoint) {
    logger.debug("joinPoint:" + joinPoint);
    logger.debug("getStaticPart:" + joinPoint.getStaticPart().getKind());
    logger.debug("getKind:" + joinPoint.getKind());
    logger.debug("getTarget:" + joinPoint.getTarget());
    logger.debug("getThis:" + joinPoint.getThis());
}
}
    public class MainActivity extends BaseActivity {

private static final String TAG = MainActivity.class.getSimpleName();

private ListView mListView;
private final List<ActivityEntry> mEntries = new ArrayList<>();
@Inject
ActivityEntryDao mDao;

@Override
protected void onCreate(Bundle savedInstanceState) {
    AndroidInjection.inject(this);
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    PackageManager pm = getPackageManager();
    try {
        PackageInfo packageInfo = pm.getPackageInfo(getPackageName(), PackageManager
                .GET_ACTIVITIES);
        ActivityInfo[] activityInfo = packageInfo.activities;
        int len = activityInfo.length;
        for (int i = 0; i < len; i++) {
            ActivityEntry entry = new ActivityEntry();
            entry.setActivityClass(Class.forName(activityInfo[i].name));
            String name = entry.getActivityClass().getSimpleName();
            if (name.equals(TAG)) {
                continue;
            }
            entry.setName(name);
            entry.setInfo(activityInfo[i]);
            mEntries.add(entry);
        }
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    Collections.sort(mEntries);
    mDao.saveAll(mEntries);
    mListView = (ListView) findViewById(R.id.activity_list);
    mListView.setAdapter(new ActivityAdapter());
    mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            Intent intent = new Intent(MainActivity.this, mEntries.get(position)
                    .getActivityClass());
            startActivity(intent);
        }
    });
}

@Override
public String getActivityTag() {
    return TAG;
}

private class ActivityAdapter extends BaseAdapter {

    @Override
    public int getCount() {
        return mEntries.size();
    }

    @Override
    public Object getItem(int position) {
        return mEntries.get(position);
    }

    @Override
    public long getItemId(int position) {
        return 0;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        Holder holder;
        if (convertView == null) {
            holder = new Holder();
            convertView = LayoutInflater.from(MainActivity.this).inflate(android.R.layout
                    .simple_list_item_1, null);
            holder.textView = (TextView) convertView.findViewById(android.R.id.text1);
            convertView.setTag(holder);
        } else {
            holder = (Holder) convertView.getTag();
        }
        ActivityEntry entry = (ActivityEntry) getItem(position);
        holder.textView.setText(entry.getName());
        return convertView;
    }
}

private static class Holder {
    TextView textView;
}
}

    运行结果如下：
    这里写图片描述
    这里写图片描述

  4. aspect编译与代码混淆的关系：结论是aspect编译阶段是在代码混淆之前执行的，因为gradle task是以依赖链的顺序执行的，aspect注入代码生成新包作为混淆的输入文件。比如如下构建过程的log：

#开始执行构建
:app:preBuild UP-TO-DATE

 #此处省略的其它log

:app:transformClassesWithAspectTransformForDebug
aspect start..........
excludeJar:::D:\code\MyApplication\app\libs\pinyin4j-2.5.0.jar
excludeJar:::C:\Users\tscyd\.gradle\caches\modules-2\files-2.1\com.github.tony19\logback-android-classic\1.1.1-4\f20b1158fcca0aef6043886ef8605556a09058ca\logback-android-classic-1.1.1-4.jar
excludeJar:::C:\Users\tscyd\.android\build-cache\a88d9c5e67accbd9b1823c970eac763ceaaa5d66\output\jars\classes.jar
excludeJar:::C:\Users\tscyd\.android\build-cache\b192e9d007b5d7be93e942b19d27dbb92e2180b7\output\jars\classes.jar

#此处省略的其它log

directoryInput:::D:\code\MyApplication\app\build\intermediates\classes\debug
aspect do work..........
aspect jar merging..........
aspect done...................
:app:transformClassesWithAspectTransformForDebug spend 1732ms
:app:processDebugJavaRes NO-SOURCE
:app:processDebugJavaRes spend 1ms
:app:transformResourcesWithMergeJavaResForDebug
:app:transformResourcesWithMergeJavaResForDebug spend 52ms
:app:transformClassesAndResourcesWithProguardForDebug

ProGuard, version 5.3.2
Reading input...
Reading program jar [D:\code\MyApplication\app\build\intermediates\transforms\mergeJavaRes\debug\jars\2\1f\main.jar] (filtered)
Reading program jar [D:\code\MyApplication\app\build\intermediates\transforms\AspectTransform\debug\jars\1\10\007a1ac9907af9957c6690d04b022d90eac5914e.jar] (filtered)
Reading program jar [D:\code\MyApplication\app\build\intermediates\transforms\AspectTransform\debug\jars\1\10\063b4994867b45bf033b64ccc6f46e3c5b4a4fde.jar] (filtered)
Reading program jar [D:\code\MyApplication\app\build\intermediates\transforms\AspectTransform\debug\jars\1\10\0c89586b3ffc5096ea8d8623ce3eeef124d37923.jar] (filtered)
Reading program jar [D:\code\MyApplication\app\build\intermediates\transforms\AspectTransform\debug\jars\1\1f\aspected.jar] (filtered)
Reading program jar [D:\code\MyApplication\app\build\intermediates\transforms\AspectTransform\debug\jars\1\2\505132f1bd3fb37ea5a4e2660b961781369b6547.jar] (filtered)
Reading library jar [C:\sdk\platforms\android-25\android.jar]
Reading library jar [C:\sdk\platforms\android-25\optional\org.apache.http.legacy.jar]

#此处省略的其它log

Shrinking...
Printing usage to [D:\code\MyApplication\app\build\outputs\mapping\debug\usage.txt]...
Removing unused program classes and class elements...
  Original number of program classes: 3011
  Final number of program classes:    2548

Obfuscating...
Printing mapping to [D:\code\MyApplication\app\build\outputs\mapping\debug\mapping.txt]...

Writing output...
Preparing output jar [D:\code\MyApplication\app\build\intermediates\transforms\proguard\debug\jars\3\1f\main.jar]

#此处省略的其它log

:app:transformClassesWithDexForDebug spend 882ms
:app:transformClassesWithShrinkResForDebug
Removed unused resources: Binary resource data reduced from 514KB to 492KB: Removed 4%
:app:transformClassesWithShrinkResForDebug spend 167ms
:app:mergeDebugJniLibFolders
:app:mergeDebugJniLibFolders spend 5ms
:app:transformNativeLibsWithMergeJniLibsForDebug
:app:transformNativeLibsWithMergeJniLibsForDebug spend 9ms
:app:transformNativeLibsWithStripDebugSymbolForDebug
:app:transformNativeLibsWithStripDebugSymbolForDebug spend 3ms
:app:validateSigningDebug
:app:validateSigningDebug spend 0ms
:app:packageDebug
:app:packageDebug spend 330ms
:app:assembleDebug
:app:assembleDebug spend 0ms

BUILD SUCCESSFUL in 11s
43 actionable tasks: 43 executed
Task spend time:
   1239ms   :app:mergeDebugResources
    471ms   :app:processDebugResources
   2373ms   :app:compileDebugJavaWithJavac
   1732ms   :app:transformClassesWithAspectTransformForDebug
     52ms   :app:transformResourcesWithMergeJavaResForDebug
   3078ms   :app:transformClassesAndResourcesWithProguardForDebug
    882ms   :app:transformClassesWithDexForDebug
    167ms   :app:transformClassesWithShrinkResForDebug
    330ms   :app:packageDebug
AspectJ实践总结
  1. 优点：AOP编程的神兵利器，可极大地提高编程的效率。
  2. 缺点：语法比较多，相关资料不多；方法数增加；延长编译时间。
  3. 局限：
    • 无法植入系统框架层代码，如view包等，对用户实现代码或依赖库则没有限制。
    • 多个工程项目依赖下，源码项目工程植入困难。
Dson2020
关注
专栏目录
Android AOP 总结
薄荷的专栏
03-16 3046
AndroidAOP 总结 一、AOP 1.1 什么是AOP AOP，AspectOriented Programming 面向切面编程 OOP，Object-orientedprogramming面向对象编程 AOP和OOP是不同的编程思想。OOP强调的是高内聚，低耦合，封装。 提倡的是将功能模块化，对象化。 可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统
Android中AOP的实际运用
自由奔跑的风
09-02 1312
Android中AOP的实际运用 一、AOP简介 AOP即面向切面编程，区别于OOP（面向对象编程）的功能模块化，AOP主要侧重于解决某一类的问题。曾经我也不知道面向切面到底是切的谁，直到我看到下面这个图才理解。 从上图可以看出，面向切面编程是在不影响原业务功能的情况下，将我们所需要的功能插入进原业务代码中。 通俗的讲，比如在我们的android商城应用中，点击按钮跳转到功能界面时，很多地方都判...
AOP在Android中的使用
02-23
一个可以在Andorid项目中使用AOP技术的Demo。
Android AOP入门配置及实战
qq_30878303的博客
03-01 300
0.概念 先上干货实战项目 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性...
XAOP：Android开发者的AOP利器
最新发布
gitblog_00690的博客
08-18 302
XAOP：Android开发者的AOP利器 XAOP????A lightweight AOP(Android) application framework. Includes the most practical AOP applications.(一个轻量级的AOP(Android)应用框架。囊括了最实用的AOP应用)项目地址:https://gitcode.com/gh_mirrors/xa/X...
深入理解Android之AOP
热门推荐
Innost的专栏
10-24 9万+
深入理解Android之AOP格式更加精美的PDF版请到：http://vdisk.weibo.com/s/z68f8l0xTgCLK 下载一、闲谈AOP大家都知道OOP，即ObjectOriented Programming，面向对象编程。而本文要介绍的是AOP。AOP是Aspect Oriented Programming的缩写，中译文为面向切向编程。OOP和AOP是什么关系呢？首先：l OO
AOP在Android中的应用
huohacker的专栏
02-23 1424
官网地址：http://fernandocejas.com/2014/08/03/aspect-oriented-programming-in-android/ OOP （面向对象编程）针对业务处理过程的 实体 及其 属性和行为 进行抽象封装，以获得 更加清晰高效的逻辑单元划分。而 AOP 则是针对业务处理过程中的切面进行提取，它所面 对的是处理过程中的某个步骤或阶
Android AOP
jielundewode的专栏
05-02 715
面向切面编程好处不用多说，看一下android实现吧。 翻来翻去找到一个不错的库，库地址 1.使用 在项目根目录的build.gradle里添加依赖： classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.0' 接下来，在app项目的build.gradle里应用插件： apply plugin...
Android AOP介绍及实现原理，小码农也有大梦想
m0_66145114的博客
02-18 690
//带有DebugLog注解的所有类 @Pointcut(“within(@com.example.aoplib.DebugLog *)”) public void withinAnnotatedClass() {} //在带有DebugLog注解的所有类，除去synthetic修饰的方法 @Pointcut(“execution(!synthetic * *(…)) && withinAnnotatedClass()”) public void methodInsideAnnotatedT
android架构师之路_aop
07-01
本资料"android架构师之路_aop"旨在帮助初学者搭建AOP基础，了解其在Android开发中的应用。 面向切面编程（Aspect-Oriented Programming，AOP）是一种编程范式，它允许程序员将关注点（如日志记录、事务管理等）与...
Android中AOP的应用实践之过滤重复点击
08-26
在Android开发中，AOP（Aspect Oriented Programming，面向切面编程）是一种强大的工具，能够帮助我们更好地组织代码，特别是处理那些横切多个模块的通用功能。本文将深入探讨如何利用AOP来过滤Android应用中的重复...
Android-一个简易的AOP(Android)应用框架。囊括了最实用的AOP应用。
08-12
一个简易的AOP(Android)应用框架。囊括了最实用的AOP应用。
Android代码-一个轻量级的AOP(Android)应用框架
08-06
XAOP 一个轻量级的AOP(Android)应用框架。囊括了最实用的AOP应用。 关于我 特点 支持快速点击切片@SingleClick，支持设置快速点击的时间间隔。 支持动态申请权限切片@Permission，支持自定义响应动作。 支持主线程切片@MainThread。 支持IO线程切片@IOThread，支持多种线程池类型。 支持日志打印切片@DebugLog，支持自定义日志记录方式。 支持内存缓存切片@MemoryCache，支持设置缓存大小。 支持磁盘缓存切片@DiskCache，支持自定义磁盘缓存，缓存有效时间等。 支持自动捕获异常的拦截切片@Safe，支持设置自定义异常处理者。 支持自定义拦截切片@Intercept，支持自定义切片拦截。 兼容Kotlin语法。 1、演示（请star支持） 2、如何使用 目前支持主流开发工具AndroidStudio的使用，直接配置build.gradle，增加依赖即可. 2.1、Android Studio导入方法，添加Gradle依赖 1.先在项目根目录的 build.gra
Android使用AOP做登录拦截
08-23
常见App中有两大类，一类是需要通过登录才能进入的App，另一类是不用登录，但是使用相关功能过程中需要登录后才能操作。那么第二类我们常见的做法就是，每次点击按钮的时候去用逻辑判断来实现，这样大大的增加了工作量。那么这篇文章将要改变你之前的做法，只需要一个注解，就可以解决
AOP编程之AspectJ实战
07-02
AspectJ、AOP编程、Android数据埋点、Android性能监控
Android AOP：最简单&粗暴（使用与原理）讲解
qwe851023的博客
12-13 961
1.前言 最近随着项目迭代业务与使用的用户逐渐增多，陆续的出现了一些性能或者BUG的问题(例如：1.某些功能执行响应慢；2.按键复电；等等)。 根据上述部分性能问题，提出相对应的解决方案： 某些功能执行响应慢 —&gt; 性能监控 按键复点 —&gt; 按键防抖 上述2个解决方案的最终实现原理：就是在执行函数的前或者后台添加对应的逻辑处理。 选择实现方式： 1.直接在方法前后添加对应的逻...
Android AOP介绍及实现原理，安卓面试题及答案
m0_66070056的博客
01-07 211
l OOP和AOP都是方法论。我记得在刚学习C++的时候，最难学的并不是C++的语法，而是C++所代表的那种看问题的方法，即OOP。同样，今天在AOP中，我发现其难度并不在利用AOP干活，而是从AOP的角度来看待问题，设计解决方法。这就是为什么我特意强调AOP是一种方法论的原因！ l 在OOP的世界中，问题或者功能都被划分到一个一个的模块里边。每个模块专心干自己的事情，模块之间通过设计好的接口交互。从图示来看，OOP世界中，最常见的表示比如： 图中所示为AndroidFramework中的模块。OOP世界
Android中Aop的简单使用和学习
u012556114的博客
01-02 1091
一、简介： 在Android 中使用注解主要有以下几个作用： 1.和编译器一起给开发者提示警告信息 2.配合一些ide 可以更加方便快捷 安全有效的编写Java代码。谷歌出的support-annotations这个库 就是主要干这个的。 3.和反射一起 提供一些类似于spring 可配置的功能，方便简洁。 二、使用： 2.1导包：在App的build目录下引入如下依赖： implementation 'org.aspectj:aspectjrt:1.8.9' 2.2在项目的build
Android 开发中使用 AOP
Jesse的专栏
03-19 4487
大家对AOP应该都不陌生, 就算没有用过也肯定听说过. 用过或了解过Java AOP的同学应该都知道AspectJ的大名. 因为AspectJ与java程序完全兼容，几乎是无缝关联, 所以只需要做一些简单的AJC适配就可以用在Android开发中. AspectJ用法简单容易上手, 不像之前说过的ASM那样有陡峭的学习曲线, 需要了解Java的字节码指令才能做代码注入. 同时AspectJ也很强大
Android AOP注解处理深度解析：APT工具与 Annotation 接口
本文将深入探讨Android中的Aspect-Oriented Programming (AOP) 注解处理机制，特别是关于注解提取与解释器的实现。在Android应用开发中，尽管我们可以通过@注解来增强代码的功能性，但这些注解本身并不具备自动执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值