01.AOP（Aspect Orientated Programming面向切面编程）

最新推荐文章于 2024-10-16 15:47:27 发布

weixin_34112030

最新推荐文章于 2024-10-16 15:47:27 发布

阅读量85

点赞数

文章标签：移动开发 java 开发工具

原文链接：https://yq.aliyun.com/articles/657359

版权

AOP和OOP可以对比起来进行理解。

下载aspectj  地址   http://www.eclipse.org/aspectj/downloads.php

下载aspectj的adt地址http://www.eclipse.org/ajdt/downloads/#43zips

build.gradle  aspectJ  写法  http://fernandocejas.com/2014/08/03/aspect-oriented-programming-in-android/

Java本身是一种面相对象的设计语言，在java看来，万物皆对象，任何事物都可以看作一个对象来处理，那么任何一个对象所具有的任何一种功能，都可以看作一个方法，都可以进行封装，一个功能封装为一个方法，这个方法只用来实现这个唯一的功能，别的方法怎样，我不需要关心，我只实现自己的功能，我的功能如何实现，外界也不需要了解，只要在需要的地方调用即可，符合单一职责的编程原则。

但是可想而知，你知道，这只是一种理想的状态，是否真的如上所说，一个方法只要做一件事就可以呢，从大的方面来说，确实如此，但是难保没有意外，例如冰箱的制冷功能，我可能会想为了确保制冷功能正常进行，我要在制冷过程中不断的检测当前温度，当温度低于临界值的时候停止制冷，以达到节能减排的目的，那么很明显，在这个功能中加入检测温度的东西后，无疑已经对制冷功能造成了侵入性，单一职责原则就被破坏了，所以可以说，我们编程的过程其实是一个不断的向单一职责或者其他编程原则不断靠近的过程，想要真的达到这种要求，几乎是不可能的

AOP的出现就是为了解决这个问题，AOP面向切面，何为面向切面，从java来说，每个功能都是一个整体，是一个立体的模块，而从AOP来说，它的切入点是每一个整体模块的一个面，同一个整体中可能存在相同的面来处理相同的问题，最为常见的就是android中的log，每个方法中可能需要打印log，或者是每个点击事件之前的网络监测，都要根据当前网络状态进行是否进行网络请求的处理，或者给予用户提示等等，当我们将这些具有相同处理逻辑的面拿出来单独处理的时候，既能保证单一职责的完整性，也可以大大减少开发周期，以及为将来可能发生变化的业务逻辑铺平道路

下面是简单的代码实现，处理对某一功能的耗时统计和网络监测功能

01.build.gradle配置

//--------------------AOP配置-------------------///
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'
    }
}

repositories {
    mavenCentral()
}
//--------------------AOP配置-------------------///

apply plugin: 'com.android.application'

android {
    ......
    defaultConfig {
        .......
    }
    ......
    
    //********************** CMake 方式**********************//

}

dependencies {
    ......
}



//--------------------AOP配置-------------------///

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;
            }
        }
    }
}
//--------------------AOP配置-------------------///

02.在libs中添加jar包aspectjrt.jar（这个包可以在aspectj安装目录的lib文件夹中找到，前提是你安装了aspectj，aspectj是一个jar包形式的安装包）

03.注解CalculateConsume

package com.app.rzm.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by renzhenming on 2018/4/13.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CalculateConsume {
    //String value();
    //int type();
}

03.注解NetworkCheck

package com.app.rzm.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by renzhenming on 2018/4/13.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NetworkCheck {
    //String value();
    //int type();
}

04.BehaviorAspect

package com.app.rzm.aop;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.util.Log;
import android.widget.Toast;

import com.rzm.commonlibrary.general.BaseApplication;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;

/**
 * Created by renzhenming on 2018/4/13.
 * 切面
 */
@Aspect
public class BehaviorAspect {

    public static final String TAG = "BehaviorAspect";
    /**
     * 切点(指定当前要切入的是com.app.rzm.aop.CalculateConsume这个注解，* *表示任何方法名(..)表示任何参数)
     */
    @Pointcut("execution(@com.app.rzm.aop.CalculateConsume  * *(..))")
    public void ABehavior(){

    }

    /**
     * 切点(指定当前要切入的是com.app.rzm.aop.NetworkCheck这个注解，* *表示任何方法名(..)表示任何参数)
     */
    @Pointcut("execution(@com.app.rzm.aop.NetworkCheck  * *(..))")
    public void BBehavior(){

    }

    @Around("ABehavior()")
    public Object calculateTime(ProceedingJoinPoint point) throws  Throwable{
        MethodSignature signature = (MethodSignature) point.getSignature();
        CalculateConsume annotation = signature.getMethod().getAnnotation(CalculateConsume.class);
        if (annotation != null) {
            long start = System.currentTimeMillis();
            //执行方法
            Object object = point.proceed();
            long end = System.currentTimeMillis();
            //方法执行完成
            Log.i(TAG, "consume time = " + (end - start));
            return null;
        }
        return null;

    }

    @Around("BBehavior()")
    public Object checkNet(ProceedingJoinPoint point) throws  Throwable{
        MethodSignature signature = (MethodSignature) point.getSignature();
        NetworkCheck annotation = signature.getMethod().getAnnotation(NetworkCheck.class);
        if (annotation != null) {
            if (!isNetWorkConn(BaseApplication.getContext())) {
                Toast.makeText(BaseApplication.getContext(),"网络断开",Toast.LENGTH_SHORT).show();
                return null;
            }
            Object object = point.proceed();

            return null;
        }
        return null;
    }

    //判断网络是否连接
    public static boolean isNetWorkConn(Context context){
        ConnectivityManager manager= (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info=manager.getActiveNetworkInfo();
        if(null!=info){
            return info.isConnected();
        }else {
            return false;
        }
    }
}

05.测试

package com.app.rzm.test;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;

import com.app.rzm.R;
import com.app.rzm.aop.CalculateConsume;
import com.app.rzm.aop.NetworkCheck;
import com.rzm.commonlibrary.general.BaseApplication;
import com.rzm.commonlibrary.utils.LogUtils;

public class TestAOPActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test_aop);
    }

    @CalculateConsume()
    public void start(View view) {
        int sum = 0;
        for (int i = 0; i < 100000000; i++) {
            sum += i;
        }
        LogUtils.e("结果是："+sum);
    }
    @NetworkCheck()
    public void check(View view) {
        Toast.makeText(BaseApplication.getContext(),"网络正常",Toast.LENGTH_SHORT).show();
    }
}