android aspectj api,android- AspectJ 的接入使用

AspectJ 作为aop的著名工具，现在就让我们进行使用他，不逼逼。

接入有两种方式，一种是组件化式接入，一种是非组件化接入。组件化接入，就是当我们的项目是组件化开发时，有多个moudle。

非组件化接入：

第一步：在项目gradle中添加aspectJ的依赖

classpath 'org.aspectj:aspectjtools:1.8.6'

第二步：在app gradle中添加依赖和配置

implementation 'org.aspectj:aspectjrt:1.8.13'

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 ->

if (!variant.buildType.isDebuggable()) {

log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")

return;

}

JavaCompile javaCompile = variant.javaCompile

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;

}

}

}

}

以上代码放到最下面就好了。

现在配置就完成了

第三步：添加测试：

**

* Created by malei on 2019/2/28.

*/

@Aspect //必须使用@AspectJ标注，这样class DemoAspect就等同于 aspect DemoAspect了

public class DemoAspect {

String TAG = "DemoAspect";

/*

@Pointcut：pointcut也变成了一个注解，这个注解是针对一个函数的，比如此处的logForActivity()

其实它代表了这个pointcut的名字。如果是带参数的pointcut，则把参数类型和名字放到

代表pointcut名字的logForActivity中，然后在@Pointcut注解中使用参数名。

基本和以前一样，只是写起来比较奇特一点。后面我们会介绍带参数的例子

*/

@Pointcut("execution(* com.ml.maskpro.ui.MainActivity.onCreate(..)) ||"

+"execution(* com.ml.maskpro.ui.MainActivity.onStart(..))")

public void logForActivity(){}; //注意，这个函数必须要有实现，否则Java编译器会报错

/*

@Before：这就是Before的advice，对于after，after -returning，和after-throwing。对于的注解格式为

@After，@AfterReturning，@AfterThrowing。Before后面跟的是pointcut名字，然后其代码块由一个函数来实现。比如此处的log。

*/

@Before("logForActivity()")

public void log(JoinPoint joinPoint){

//对于使用Annotation的AspectJ而言，JoinPoint就不能直接在代码里得到多了，而需要通过

//参数传递进来。

Log.e(TAG, joinPoint.toShortString() + " aop拦截");

}

}

这样，我们的MainActivity的onCreate()方法被触发的时候，我们就会进行拦截，并打印指定的内容。

组件化接入

使用组件化的方式接入，就避免了重复编写代码的问题。

接下来，用几步就完成我们的组件化接俄入吧。

第一步：首先让我们创建一个moudle -->  aspectJlib

1)moudle 里面的东西都删除(除了build.gradle，但是要被gradle里面的所有内容删除)

2)在aspectJlib里面新增一个“src”文件夹，往src文件夹新增main文件夹，再往main文件夹新增groovy和resources文件夹

3)resources目录下新建文件夹META-INF，META-INF文件夹下新建gradle-plugins文件夹。

4)在groovy目录下新建项目包名，就像Java包名那样。

第二步：打开Module下的build.gradle文件，输入

apply plugin: 'groovy'

apply plugin: 'maven'

dependencies {

implementation gradleApi()//gradle sdk

implementation localGroovy()//groovy sdk

implementation 'com.android.tools.build:gradle:3.0.1'

implementation 'org.javassist:javassist:3.20.0-GA'

implementation 'org.aspectj:aspectjtools:1.8.13'

}

//上传到仓库

uploadArchives {

repositories.mavenDeployer {

pom.groupId = 'com.ml.pro'

pom.artifactId = 'aspectjlib'

pom.version = '1.0.0'

repository(url: uri('../repo'))

}

}

repositories {

jcenter()

}

uploadArchives闭包里面配置的是将插件发布到本地仓库。然后maven本地仓库的目录就是当前项目目录下的repo目录。

第三步：在groovy下的包名下新建一个文件，命名为AspectjPlugin.groovy

package com.ml.pro

import org.aspectj.bridge.IMessage

import org.aspectj.bridge.MessageHandler

import org.aspectj.tools.ajc.Main

import org.gradle.api.Plugin

import org.gradle.api.Project

/**

* @使用ajc编译java代码 ， 同 时 织 入 切 片 代 码

* 使用 AspectJ 的编译器(ajc，一个java编译器的扩展)

* 对所有受 aspect 影响的类进行织入。

* 在 gradle 的编译 task 中增加额外配置，使之能正确编译运行。

*/

public class AspectjPlugin implements Plugin{

void apply(Project project) {

project.dependencies {

compile 'org.aspectj:aspectjrt:1.8.9'

}

final def log = project.logger

log.error "========================";

log.error "Aspectj切片开始编织Class!";

log.error "========================";

project.android.applicationVariants.all { variant ->

def javaCompile = variant.javaCompile

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;

}

}

}

}

}

}

第四步：在resources/META-INF/gradle-plugins目录下新建一个 AspectjPlugin.properties 文件，命名就是刚才创建 .groovy 的名字.

在里面输入:

implementation-class=com.ml.pro.AspectjPlugin

第五步：右侧的gradle Toolbar就会在module下多出一个task，点击uploadArchives这个Task，就会在项目下多出一个repo目录，里面存着这个gradle插件。

这样切面组件的组件化部分就完成了。现在就可以提供给其他module使用了。

第六步：在项目 gadle中添加

buildscript {

repositories {

...

maven { url uri('repo') } //插件仓库路径

}

dependencies {

...

classpath 'com.ml.pro:aspectjlib:1.0.0' //插件

}

}

第七步：先Rebuild Project，最后在app下的build.gradle添加配置

apply plugin: 'AspectjPlugin'

同时也要添加依赖(但是在实际编码时，没有添加依然可以使用)：

compile 'org.aspectj:aspectjrt:1.8.9'

这样就完成了，我们就进行测试：

/**

* Created by malei on 2019/2/28.

*/

@Aspect

public class AspectTest {

final String TAG = AspectTest.class.getSimpleName();

/**

* 在MainActivity的所有生命周期的方法中打印log

* @param joinPoint

* @throws Throwable

*/

@Before("execution(* *..MainActivity+.on**(..))")

public void method(JoinPoint joinPoint) throws Throwable {

MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();

String className = joinPoint.getThis().getClass().getSimpleName();

Log.e(TAG, "class:" + className);

Log.e(TAG, "method:" + methodSignature.getName());

}

}