Android之AOP面向切面编程

这篇博客只是本人在Android进阶学习中AOP面向切面编程的学习笔记，适合入门级选手，如果想深入了解AOP面向切面编程可以找些大牛的博客来阅读。

在没有出现AOP面向切面编程之前谈论的都是OOP，即Object Oriented Programming，面向对象编程。在面向对象里，功能的实现都被划分成一个个独立的模块，每个模块独自干好自己的事情，模块之间通过设计好的接口进行交互；OOP的精髓是把功能或问题模块化，每个模块处理自己的家务事。但是在项目开发中，不是所有的问题用面向对象的思想都能得到很好的解决。

比如：要对项目中某些功能进行用户行为统计，用户在什么时候使用了这些功能，使用了多长等；

面向对象思想：

/**
  * 发送文本
  *
  * @param view
  */
public void btnText(View view) {
    //统计用户行为 的逻辑
    Log.i(TAG, "文字：  使用时间：   " + simpleDateFormat.format(new Date()));
    long beagin = System.currentTimeMillis();

    //发送文本的代码逻辑
    {
        SystemClock.sleep(3000);
        Log.i(TAG, "  发送文本");

    }

    Log.i(TAG, "消耗时间：  " + (System.currentTimeMillis() - beagin) + "ms");
}

会发现，需要在每个功能的业务逻辑前后添加统计用户行为的代码，这样子不仅代码重复，如果后期需求改变就要对每个地方的代码进行修改，这样子感觉是不是很不好，这个时候就可以使用面向切面编程的思想来解决。

在面向切面编程之前要先下载aspectjrt.jar，
下载地址：

http://www.eclipse.org/aspectj/downloads.php

将下载好的aspectjrt.jar拷贝到libs目录下面，并与项目工程进行关联

QQ截图20171006212727.jpg

compile files('libs/aspectjrt.jar')

接下来还有在app目录下build.gradle文件中进行相应的配置

QQ截图20171006213011.jpg

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.9'
        classpath 'org.aspectj:aspectjweaver:1.8.9'
    }
}
apply plugin: 'com.android.application'
repositories {
    mavenCentral()
}
android {
    compileSdkVersion 25
    buildToolsVersion "26.0.0"
    defaultConfig {
        applicationId "com.aopdemo"
        minSdkVersion 15
        targetSdkVersion 25
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    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')
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:25.3.1'
    testCompile 'junit:junit:4.12'
    compile files('libs/aspectjrt.jar')
}

弄好后就可以进行面向切面编程了，就将上面的统计用户行为的需求用面向切面编程的思想来实现下；

/**
 * Created by Administrator on 2017/10/6.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BehaviorTrace {
    String value();
    int type();
}

这个是一个注解类，

@Target该注解在什么地方起作用
ElementType.FIELD  代表的是在属性上
ElementType.METHOD  代表的是在方法上
ElementType.TYPE  代表的是在类上
ElementType.CONSTRUCTOR  代表的是在构造方法上

@Retention该注解在什么时候生效
RetentionPolicy.RUNTIME  运行时生效
RetentionPolicy.CLASS  编译时生效
RetentionPolicy.SOURCE  源码资源

/**
 * Created by Administrator on 2017/10/6.
 */
@Aspect
public class BehaviorAspect {
    private static final String TAG = "BehaviorAspect";
    SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     * 切点
     */
    @Pointcut("execution(@com.aopdemo.BehaviorTrace  * *(..))")
    public void annoBehavior(){

    }

    /**
     * 切面
     * @return
     */
    @Around("annoBehavior()")
    public Object dealPoint(ProceedingJoinPoint point) throws Throwable{
        //执行之前
        MethodSignature signature = (MethodSignature) point.getSignature();
        BehaviorTrace annotation = signature.getMethod().getAnnotation(BehaviorTrace.class);
        String value = annotation.value();
        int type = annotation.type();
        Log.i(TAG,value+"使用时间：   "+simpleDateFormat.format(new Date()));
        long beagin=System.currentTimeMillis();
        //执行方法
        Object object=null;
        try {
            object=point.proceed();
        }catch (Exception e){

        }
        //方法执行完成
        Log.i(TAG,"消耗时间：  "+(System.currentTimeMillis()-beagin)+"ms");
        return object;
    }
}

可以将用户触发行为的逻辑代码改为：

/**
 * 发送文本
 *
 * @param view
 */
@BehaviorTrace(value = "发送文本",type = 3)
public void btnText(View view) {
    //统计用户行为 的逻辑
    SystemClock.sleep(3000);
    Log.i(TAG, "  发送文本");
}

和面向对象的方式相比，代码整洁了不少，同时也便于后期项目的修改。

源码地址：
http://pan.baidu.com/s/1gfNAaTt