AOP面向切面设计编程

本文将从理论知识、集成步骤、实践例子三部分介绍AOP，希望看到此文的朋友能对AOP有基本的认识。

一、AOP基本知识

1. OOP
   OOP全称Object Oriented Programming，面向对象编程，好处是高度模块化。
2. AOP定义
   就是我们把某个方面的功能提出来与一批对象进行隔离，这样与一批对象之间降低耦合性，就可以对某个功能进行编程。
3. AOP的意义
   把某个功能集中起来管理，降低耦合性
4. AOP应用
   应用在j2ee的Spring框架；在Android中的用户行为统计场景和权限管理。
5. AOP实践
   AspectJ：是一个面向切面的框架，扩展了java语言所以它有一个专门的编译器来生成遵守java字节码规范的Class文件。

二、Android Studio中AOP编程步骤

• 下载AspectJ，解压。下载地址，点击这里
• 将解压后aspect\lib目录下aspectJ.jar复制到我们项目libs下
• build.gradle中配置，下面代码中加粗部分要注意修改为你下载好的aspectJ版本。当然你也可以参考官网配置：参考官网配置

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'
        classpath 'org.aspectj:aspectjweaver:1.8.10'**
    }
}

repositories {
    mavenCentral()
}


android {
    compileSdkVersion 23
    buildToolsVersion "23.0.3"

    defaultConfig {
        applicationId "cn.gxh.aopdemo"
        minSdkVersion 16
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
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;
            }
        }
    }
}


dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.3.0'
    compile files('libs/aspectjrt.jar')
}

• 此时重构一下，可以写代码了。

三、AOP实践

可能大家看了上面写的更加云里雾里了，没关系，我们写个例子就一目了然了。假设我们有三个模块，分别是“摇一摇”、“发红包”、“语音”，现在有个需求：就是对各个模块进行用户行为统计，包括使用的时间、功能每次运行时间。

public void shake(View view){
        Log.d("----shake----","使用时间:"+mSimpleDateFormat.format(new Date()));
        long startTime = System.currentTimeMillis();

        //摇一摇的逻辑代码
        SystemClock.sleep(3000);
        Log.d("----shake----","摇到了哦。。。");

        long endTime = System.currentTimeMillis();
        Log.d("----shake----","消耗时间:"+(endTime-startTime)+"ms");
 }

上面的代码是摇一摇模块的模拟代码，如果三个模块都这么写的话，相信大家都能看出我们写了很多重复代码，如果需求改了的话，那我们修改起来得累个半死，而且这种写法也违反了单一职责原则。可能此时有人建议把统计的代码写成工具类来用，这种方法平时也是可以的，但是现在大家注意看一下，这里分两处统计了一个时间差，恐怕工具类的方法用起来也费劲，这里最好的方法就是AOP面向切面编程。
我们会给每个模块打个标记，这个标记是用注解实现的。把统计的代码提出来统一管理。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BehaviorTrace {
    String value();
}

@BehaviorTrace("摇一摇")
public void shake(View view){
    //摇一摇的逻辑代码
    SystemClock.sleep(3000);
    Log.d("----shake----","摇到了哦。。。");
}

/**
 * 切面
 * Created by GXH on 2017/6/29.
 */
@Aspect
public class BehaviorAspect {
    SimpleDateFormat mSimpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     * 切点，去拿有这个注解标记的方法
     * 注解Pointcut
     * cn.gxh.aopdemo.BehaviorTrace 表示包名+自定义注解名
     * * *(..) 表示方法、参数是所有的
     */
    @Pointcut("execution(@cn.gxh.aopdemo.BehaviorTrace * *(..))")
    public void annoBehavior() {
        //可以不写代码逻辑
    }

    /**
     * 拿到方法处理
     *
     * @param point
     * @return
     */
    @Around("annoBehavior()")
    public Object dealPoint(ProceedingJoinPoint point) throws Throwable {

        //方法执行前
        MethodSignature methodSignature = (MethodSignature) point.getSignature();
        BehaviorTrace behaviorTrace = methodSignature.getMethod()
                .getAnnotation(BehaviorTrace.class);
        String contentType=behaviorTrace.value();

        Log.d("----dealPoint----","contentType:"+contentType+
                "----"+"使用时间:"+mSimpleDateFormat.format(new Date()));
        long startTime = System.currentTimeMillis();

       //方法执行时

        Object object=point.proceed();


        //方法执行后
        long endTime = System.currentTimeMillis();
        Log.d("----dealPoint----","contentType:"+contentType+
                "----"+"消耗时间:"+(endTime-startTime)+"ms");

        return object;
    }
}

可以发现，AOP编程的性能并没有什么更大的消耗。
好了，大概就写这么多吧，大家可以下载Demo代码体验下。代码下载，点击这里