美文网首页Android开发经验谈Android开发Android技术知识
【Android】AOP 面向切面编程(一) -- Aspect

【Android】AOP 面向切面编程(一) -- Aspect

作者: 指间沙似流年 | 来源:发表于2017-12-08 10:47 被阅读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上要执行的操作、逻辑。关于5种类型,我不多说,不懂的同学自己补基础。

      • 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();
      }
      

    相关文章

      网友评论

        本文标题:【Android】AOP 面向切面编程(一) -- Aspect

        本文链接:https://www.haomeiwen.com/subject/hazsixtx.html