Android——AOP面向切面编程

1.什么是AOP？

   AOP（Aspect Oriented Programming ）：AOP是面向切面编程，把某一方面的一些功能提取出来与一批对象进行隔离，提取之后我们就可以对某个对象单方面的功能进行编程，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。有利用未来的可操作性和可维护性

2.AOP与OOP有什么关系呢？

AOP和OOP是面向不同领域的两种思想：
   AOP面向切面编程是针对业务处理过程中的切面进行提取，它所面对的是处理过程中某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。
   OOP面向对象编程主要是针对业务处理过程中的实体的属性和行为的抽象与封装，以获得更加清晰高效地逻辑单元。

3.AOP的套路

  将众多方法中的所有共有的代码全部抽取出来，放置到某个地方集中管理，然后在具体运行时，class文件由AspectJ去编译，aspect会copy我们的代码。
  1.Android程序员在编写具体业务逻辑处理方法时，只需关心核心的业务逻辑处理，提高工作效率，使得代码简洁优雅
  2. 在日后的维护中由于业务逻辑代码与共有代码分开存放，而且共有代码是集中存放，因此维护起来变得轻松
  3. 面向切面编程AOP技术就是为解决这个问题诞生的，切面就是横切面，代表是普遍存在的共有功能，例如：日志切面，权限切面，网络切面等等。

4.AspectJ配置使用

1.下载AspectJ面向切面的框架，或者直接在app.gradle中直接配置

  下载地址：http://www.eclipse.org/aspectj/downloads.php
2.gradle配置：implementation 'org.aspectj:aspectjrt:1.8.9'

在这里插入图片描述

2.AndroidStudio中配置AspectJ

    buildscript {
        repositories {
            mavenCentral()
        }
        dependencies {
            classpath 'org.aspectj:aspectjtools:1.8.9'
            classpath 'org.aspectj:aspectjweaver:1.8.9'
        }
    }
    
    import org.aspectj.bridge.IMessage
    import org.aspectj.bridge.MessageHandler
    import org.aspectj.tools.ajc.Main
    
    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;
            }
        }
    }
}

5.AOP实现一个检查网络

5.1 创建注解(创建切点)

    /**
     * Created by ych on 2019/8/25.
     * Description:
     *  定义我们的切点：也就是注解
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface CheckNet {
    }

5.2 创建处理切点类

    @Aspect
    public class CheckNetAspect {

        /**
         * 2.找到标记的切点
         *      * *(..)表示处理所有的方法
         */
        @Pointcut("execution(@com.example.customview.aop.checknet.CheckNet * *(..))")
        public void checkNetBehavior(){
    
        }
    
        /**
         * 处理切面
         *  @Around("checkNetBehavior()") 表示围绕哪个点，也就是上方的方法
         */
        @Around("checkNetBehavior()")
        public Object checkNet(ProceedingJoinPoint joinPoint) throws Throwable{
            //1.获取切点注解CheckNet
            //获取连接上的签名，强转为MethodSignature
            MethodSignature signature = (MethodSignature)joinPoint.getSignature();
            CheckNet checkNet = signature.getMethod().getAnnotation(CheckNet.class);
    
            if (checkNet!=null){
                /**
                 * 2.判断是否有网络,需要上下文获取上下文(怎么获取)
                 * 这个object 可以为Activity  Fragment  View
                 */
                Object object = joinPoint.getThis();
                Context context = getContext(object);
                if (context!=null){
                    if (!isNetworkConnected(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;
        }
    
        /**
         * 为什么不用工具类，使用的时候我只需要copy这个嘞就可以，不脱泥带水，不会牵扯各种类
         * 判断网络是否可用，包括wifi net连接等
         * @param context
         * @return
         */
        private static boolean isNetworkConnected(Context context) {
            if (context != null) {
                ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                        .getSystemService(Context.CONNECTIVITY_SERVICE);
                if (mConnectivityManager!=null){
                    //获取NetWork
                    NetworkInfo[] mNetworkInfo = mConnectivityManager.getAllNetworkInfo();
                    if (mNetworkInfo != null && mNetworkInfo.length > 0) {
                        for (int i = 0; i < mNetworkInfo.length; i++) {
                            //判断当前网络状态是否为连接状态
                            if (mNetworkInfo[i].getState() == NetworkInfo.State.CONNECTED){
                                return true;
                            }
                        }
                    }
                }
            }
            return false;
        }
}

5.3 代码中使用

    public class AOPActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_aop);
        }
    
        /**
         * 只需添加 @CheckNet
         */
        @CheckNet
        public void checkNet(View view) {
            Intent intent = new Intent(this, UserActivity.class);
            startActivity(intent);
        }
    
    }

5.4 效果

           在这里插入图片描述