Android开发经验谈Android开发Android技术知识

【Android】AOP 面向切面编程（一） -- Aspect

2017-12-08  本文已影响343人  指间沙似流年

什么是AOP，与OOP的区别

OOP: (Object Oriented Programming) 面向对象的程序设计。所谓“对象”在显式支持面向对象的语言中，一般是指类在内存中装载的实例，具有相关的成员变量和成员函数（也称为：方法）。

AOP: (Aspect Oriented Programming) 面向切面编程。是目前软件开发中的一个热点，也是Spring框架中容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

[图片上传失败...(image-926a06-1512701224758)]

AOP的适用范围

埋点，日志记录，性能统计，安全控制，事务处理，异常处理等等。

AOP方式

  1. 代码预编译 -- AspectJ
  2. 运行期动态代理

AspectJ介绍

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

AspectJ概念

  1. pointcut

    是一个（组）基于正则表达式的表达式，有点绕，就是说他本身是一个表达式，但是他是基于正则语法的。通常一个pointcut，会选取程序中的某些我们感兴趣的执行点，或者说是程序执行点的集合。
    一个切入点通过一个普通的方法定义来提供，并且切入点表达式使用@Pointcut注解来声明，注解的方法返回类型必须为void型。
    要建立复杂的切入点表达式，可以通过&&、||和！进行组合，也可以通过名字引用切入点表达式。

    // 匹配所有com.fastaoe.aspectjdemo包下以test结尾的类的方法都会被执行
@Pointcut("execution(*com.fastaoe.aspectjdemo.*test * *(..))")  
public void pointcut1(){}  

// 匹配所有com.fastaoe.aspectjdemo.biz包下所有的类
@Pointcut("within(com.fastaoe.aspectjdemo.biz.*)")  
public void pointcut2(){} 

// 同时匹配2个方法
@Pointcut("pointcut1()&&pointcut2()")  
private void tradingOperation(){}
    aop_pointcut

  1. joinPoint

    通过pointcut选取出来的集合中的具体的一个执行点，我们就叫JoinPoint.

  2. Advice

    在选取出来的JoinPoint上要执行的操作、逻辑。关于５种类型，我不多说，不懂的同学自己补基础。

    • Before Advice：@Before
    • After returning advice：@AfterReturning，可在通知体内得到返回的实际值；
    • After throwing advice：@AfterThrowing
    • After (finally) advice : @After 最终通知必须准备处理正常和异常两种返回情况，它通常用于释放资源。
    • Around advice : @Around 环绕通知使用@Around注解来声明，通知方法的第一个参数必须是ProceedingJoinPoint类型，在通知内部调用ProceedingJoinPoint的Proceed()方法会导致执行真正的方法，传入一个Object[]对象，数组中的值将被作为一个参数传递给方法。

  3. aspect

    就是我们关注点的模块化。这个关注点可能会横切多个对象和模块，事务管理是横切关注点的很好的例子。它是一个抽象的概念，从软件的角度来说是指在应用程序不同模块中的某一个领域或方面。又pointcut和advice组成。

  4. Target

    被aspectj横切的对象。我们所说的joinPoint就是Target的某一行，如方法开始执行的地方、方法类调用某个其他方法的代码。

AspectJ例子

一般情况下，如果我们需要在获取网络数据的时候需要判断网络是否存在，如果不存在，Toast提示用户的话，代码是这样的。

public void getNetData1() {
   if (isNetworkAvailable(this)) {
       Toast.makeText(this, "开始获取新的网络信息1", Toast.LENGTH_LONG).show();
   } else {
       Toast.makeText(this,"请检查您的网络",Toast.LENGTH_LONG).show();
   }
}

public void getNetData2() {
   if (isNetworkAvailable(this)) {
       Toast.makeText(this, "开始获取新的网络信息2", Toast.LENGTH_LONG).show();
   } else {
       Toast.makeText(this,"请检查您的网络",Toast.LENGTH_LONG).show();
   }
}

/**
* 检查当前网络是否可用
*
* @return
*/
private static boolean isNetworkAvailable(Context context) {
   ConnectivityManager connectivityManager = (ConnectivityManager)
           context.getSystemService(Context.CONNECTIVITY_SERVICE);
   if (connectivityManager != null) {
       NetworkInfo[] networkInfo = connectivityManager.getAllNetworkInfo();

       if (networkInfo != null && networkInfo.length > 0) {
           for (int i = 0; i < networkInfo.length; i++) {
               if (networkInfo[i].getState() == NetworkInfo.State.CONNECTED) {
                   return true;
               }
           }
       }
   }
   return false;
}

如果只有几个这样的代码段维护还是比较简单的，但是如果在整个项目中有非常多的网络请求，如果都是这样的方式来判断网络是否可用的话，这就是非常痛苦的事情。
并且当产品的需求改变的时候，每个代码段都需要修改，很有可能修改的时候会出现修改不完全有遗漏的地方，并且回归测试的时候对于测试人员来说也是非常痛苦的事情。
所以我们需要其他的方式来改变这个现状，其中比较好的方式就是AOP。

  1. 引入aspectjrt.jar

    aspectj-downloads

    下载完成之后添加到app的libs中，并在build.gradle引入

    compile files('libs/aspectjrt.jar')

  1. 在build.gradle(app)中添加

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

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

  2. 添加注解

    @Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CheckNet {
}

  3. 创建AspectJ文件

    1. 需要在类上引用Aspect注解
    2. @Pointcut("execution(@com.fastaoe.aspectjdemo.CheckNet * *(..))") - 定义切入点，也就是需要处理的方法，切入点的内容是一个表达式，来描述切入哪些对象的哪些方法，("excute (*add*(..))")切入点表达表示将要切入所有以add开头的方法，该方法可带任意个数的参数
    3. @Around("checkNetBehavior()") - 定义处理的核心方法
    @Aspect
public class SectionAspect {

    @Pointcut("execution(@com.fastaoe.aspectjdemo.CheckNet * *(..))")
    public void checkNetBehavior() {

    }

    @Around("checkNetBehavior()")
    public Object checkNet(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.d("SectionAspect", "checkNetStart");
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        CheckNet annotation = signature.getMethod().getAnnotation(CheckNet.class);
        if (annotation != null) {
            Object object = joinPoint.getThis();
            Context context = getContext(object);
            if (context != null) {
                if (!isNetworkAvailable(context)) {
                    Toast.makeText(context,"请检查您的网络",Toast.LENGTH_LONG).show();
                    return null;
                }
            }
        }
        return joinPoint.proceed();
    }

    /**
     * 通过对象获取上下文
     *
     * @param object
     * @return
     */
    private Context getContext(Object object) {
        if (object instanceof Activity) {
            return (Activity) object;
        } else if (object instanceof Fragment) {
            Fragment fragment = (Fragment) object;
            return fragment.getActivity();
        } else if (object instanceof View) {
            View view = (View) object;
            return view.getContext();
        }
        return null;
    }

    /**
     * 检查当前网络是否可用
     *
     * @return
     */
    private static boolean isNetworkAvailable(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager)
                context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (connectivityManager != null) {
            NetworkInfo[] networkInfo = connectivityManager.getAllNetworkInfo();

            if (networkInfo != null && networkInfo.length > 0) {
                for (int i = 0; i < networkInfo.length; i++) {
                    if (networkInfo[i].getState() == NetworkInfo.State.CONNECTED) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
}

  4. 使用注解

    @CheckNet
private void getNetData() {
    Toast.makeText(this, "开始获取新的网络信息", Toast.LENGTH_LONG).show();
}
上一篇下一篇

猜你喜欢

热点阅读