aop

AspectJ从入门到实用

Posted by smallSohoSolo on February 26, 2017

AspectJ是Eclipse出品的Aop框架,可以帮助我们进行很方便的Aop编程。目前最新版是AspectJ 1.8.10

官网链接:http://www.eclipse.org/aspectj/

另附带Aop(面向切面编程)科普:什么是面向切面编程AOP?

优点

  • 无侵入性
  • 学习成本低
  • 支持各种格式,并且很成熟

缺点

  • 会增加方法数
  • 在动态修改字节码方面,性能不如asmdex
  • 强行凑三条

先装环境

大家根据我的gradle自行替换相对应的部分,我新建了一个叫draven的module来写切面的代码,推荐大家也这么做。

//app.gradle
apply plugin: 'com.android.application'

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.10'
    }
}

repositories {
    mavenCentral()
}

android {
    compileSdkVersion 25
    buildToolsVersion "25.0.2"
    defaultConfig {
        applicationId "com.test.smallsoho.myapplication"
        minSdkVersion 16
        targetSdkVersion 25
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    compile 'com.android.support:appcompat-v7:25.2.0'
    compile project(':draven')
}

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



//module的gradle
import com.android.build.gradle.LibraryPlugin
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main

apply plugin: 'com.android.library'

buildscript {

    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'com.android.tools.build:gradle:2.2.3'
        classpath 'org.aspectj:aspectjtools:1.8.10'
        classpath 'org.aspectj:aspectjweaver:1.8.10'
    }
}

android {
    compileSdkVersion 25
    buildToolsVersion "25.0.2"

    defaultConfig {
        minSdkVersion 16
        targetSdkVersion 25
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:25.2.0'
    compile 'org.aspectj:aspectjrt:1.8.10'
}

android.libraryVariants.all { variant ->
    LibraryPlugin plugin = project.plugins.getPlugin(LibraryPlugin)
    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", plugin.project.android.bootClasspath.join(
                File.pathSeparator)]

        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler)

        def log = project.logger
        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:
                case IMessage.INFO:
                    log.info message.message, message.thrown
                    break;
                case IMessage.DEBUG:
                    log.debug message.message, message.thrown
                    break;
            }
        }
    }
}

铺垫几个基础点

首先面向切面编程的核心就是切面,在AspectJ中,工作流程为:

  1. 看文档知道固定好的可以插入的点(joinPoint)
  2. 我就插这了(PointCut)
  3. 写确定插完了之后干什么(advice),此处扩展(Before(前面干什么),After(后面干什么,After还分几个分类一会说),Around(直接换了用我的逻辑0.0))

总共分三步 0.0 是不是很简单!~!~!

下面是枯燥的理论知识

对前文的提到的几个概念进行系统的介绍

joinPoint

首先Aop中你得知道你想要把逻辑插在什么位置,就是你在什么位置创造切面,你可以在AspectJ中支持的位置来进行切入,这个支持的位置就是joinPoint,joinPoint支持以下位置:

joinPoint

也就是你的Hook逻辑可以在这些位置插入

PointCut

什么是PointCut呢?PointCut用类似正则的方式来确定你需要的joinPoint来进行使用,因为并不是所有的joinPoint你都要用到,所以用PointCut来确定你需要的joinPoint,一段代码来看看:

我要在下面这个activity中的checkAspectJ方法的执行的时候做文章

//这是一个Activity
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                checkAspectJ(3, 5);
                startActivity(new Intent(MainActivity.this, SecondActivity.class));
            }
        });
    }

    public void checkAspectJ(int a, int b) {
        Log.d("smallsho", String.valueOf(a + b));
    }
}

//对应的PointCut代码,我要找到里面的checkAspectJ方法
@Pointcut("execution(* *..checkAspectJ(..)) && args(a,b)")
public void createPoint(int a, int b) {}

这里是怎么确认的呢?

上图!英文自行理解~

pointCut

filter

下面说说这个正则怎么写,位置一一对应

@PointCut("Pointcut_syntax(@注解 访问权限 返回值类型 包名.函数名(参数)) &&\|| 过滤条件 ") 
  • Pointcut_syntax就是上面那张表,按表查找
  • 注解和访问权限(public/private/protect,以及static/final)属于可选项。如果不设置它们,则默认都会选择。以访问权限为例,如果没有设置访问权限作为条件,那么public,private,protect及static、final的函数都会进行搜索。
  • 返回值类型就是普通的函数的返回值类型。如果不限定类型的话,就用*通配符表示
  • 包名.函数1名用于查找匹配的函数。可以使用通配符,包括*和..以及+号。其中*号用于匹配除 . 号之外的任意字符,而..则表示任意子package,+号表示子类。
    • java.*.Date:可以表示java.sql.Date,也可以表示java.util.Date
    • Test*:可以表示TestBase,也可以表示TestDervied
    • java..*:表示java任意子类
    • java..*Model+:表示Java任意package中名字以Model结尾的子类,比如TabelModel,TreeMode等
  • 参数匹配比较简单,主要是参数类型

    • 比如(int, char):表示参数只有两个,并且第一个参数类型是int,第二个参数类型是char
    • (String, ..):表示至少有一个参数。并且第一个参数类型是String,后面参数类型不限。在参数匹配中..代表任意参数个数和类型
    • (Object …):表示不定个数的参数,且类型都是Object,这里的…不是通配符,而是Java中代表不定参数的意思
    • (..):任意的参数
  • 我们也可以用||和&&来进行更深层的条件过滤,我例子中的条件就是查找执行的时候,名称为checkAspectJ参数随意 && 参数为 int,int的joinPoint,因为我要获取传入的参数,所以我在注解下面的函数上写上了两个参数的类型,在args(a,b)中使用a,b两个代替,ajc会自动找他俩的类型,跟args(int,int)是一样的

Advice

advice就是你要实现的逻辑,点找到了,也确定了插入的位置,那么插入的逻辑就要在此写了

上图!

advice

相比前两个,这个就简单多了,上段代码示例

//这是一个Activity
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                checkAspectJ(3, 5);
                startActivity(new Intent(MainActivity.this, SecondActivity.class));
            }
        });
    }

    public void checkAspectJ(int a, int b) {
        Log.d("陈龙博", String.valueOf(a + b));
    }
}

//这是我写的切面类
@Aspect
public class TraceAspect {

    private static final String TAG = "SMALLSOHO_TAG";

    @Pointcut("execution(* *..checkAspectJ(..)) && args(a,b)")
    public void createPoint(int a, int b) {}

    @After("createPoint(a,b)")
    public void logAfter(JoinPoint joinPoint, int a, int b) {
        Log.d(TAG, "After:" + joinPoint.toShortString() + "----" + a + "---" + b);
    }

    @Before("createPoint(a,b)")
    public void logBefore(JoinPoint joinPoint, int a, int b) {
        Log.d(TAG, "Before:" + joinPoint.toShortString() + "----" + a + "---" + b);
    }

    @Around("createPoint(a,b)")
    public Object logAround(ProceedingJoinPoint joinPoint, int a, int b) {
        Log.d(TAG, "Around:" + joinPoint.toShortString() + "----" + a + "---" + b);
        try {
            return joinPoint.proceed(new Object[]{a, b});
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return null;
    }
}

这里还可以获取到切入点的参数来进行操作。

反编译下,看看AOP之后的样子

附赠好用的反编译工具jadx 放进去apk直接就能看源码

public class MainActivity extends AppCompatActivity {
    private static final StaticPart ajc$tjp_0 = null;

    public class AjcClosure1 extends AroundClosure {
        public AjcClosure1(Object[] objArr) {
            super(objArr);
        }

        public Object run(Object[] objArr) {
            Object[] objArr2 = this.state;
            MainActivity.checkAspectJ_aroundBody0((MainActivity) objArr2[0], Conversions.intValue(objArr2[1]), Conversions.intValue(objArr2[2]), (JoinPoint) objArr2[3]);
            return null;
        }
    }

    static {
        ajc$preClinit();
    }

    private static void ajc$preClinit() {
        Factory factory = new Factory("MainActivity.java", MainActivity.class);
        ajc$tjp_0 = factory.makeSJP(JoinPoint.METHOD_EXECUTION, factory.makeMethodSig("1", "checkAspectJ", "com.test.smallsoho.myapplication.MainActivity", "int:int", "a:b", "", "void"), 26);
    }

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView((int) R.layout.activity_main);
        findViewById(R.id.button).setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                MainActivity.this.checkAspectJ(3, 5);
                MainActivity.this.startActivity(new Intent(MainActivity.this, SecondActivity.class));
            }
        });
    }

    static final void checkAspectJ_aroundBody0(MainActivity ajc$this, int a, int b, JoinPoint joinPoint) {
        try {
            Log.d("smallsoho", String.valueOf(a + b));
        } finally {
            TraceAspect.aspectOf().logAfter(joinPoint, a, b);
        }
    }

    public void checkAspectJ(int a, int b) {
        TraceAspect.aspectOf().logBefore(Factory.makeJP(ajc$tjp_0, this, this, Conversions.intObject(a), Conversions.intObject(b)), a, b);
        TraceAspect.aspectOf().logAround(new AjcClosure1(new Object[]{this, Conversions.intObject(a), Conversions.intObject(b), r0}).linkClosureAndJoinPoint(69648), a, b);
    }
}

重点看checkAspectJ函数,MainActivity的源码就在上面,大家可以比对着看,你会发现它根据不同的切入点进行了不同的代码改写

Before操作是在执行的第一句插入了一句代码,来执行你的advice After是用一个finally来保证方法的执行 Around是直接用一个新的方法替换了原来的方法

所以,使用AspectJ会导致方法数的增加,所以使用的时候要注意。

引用文献,站在巨人的肩膀上才能看的更远

深入理解Android之AOP ,很多图和语句修改自此博文

跟我学AspectJ系列

欢迎打赏

Money