Android面向切面基于AOP实现登录拦截的场景示例

目录

• 前言
• 一、了解面向切面AOP
• 二、集成AOP框架
• 三、定义注解实现功能
• 总结

前言

场景如下：用户第一次下载App，点击进入首页列表，点击个人页面，需要校验登录，然后跳转到登录页面，注册/登录完成跳转到个人页面。

非常常见的场景，正常我们开发就只能判断是否已经登录，如果未登录就跳转到登录，然后登录完成之后怎么继续执行？如何封装？有哪些方式？其实很多人并不清楚。

这里做一个系列总结一下，看看公共有多少种方式实现，你们使用的是哪一种方案，或者说你们觉得哪一种方案最好用。

这一次分享的是全网最多的方案 ，面向切面 AOP 的方式。你去某度一搜，Android拦截登录 最多的结果就是AOP实现登录拦截的功能，既然大家都推荐，我们就来看看它到底如何？

一、了解面向切面AOP

我们学习Java的开始，我们一直就知道 OOP 面向对象，其实 AOP 面向切面，是对OOP的一个补充，AOP采取横向收取机制，取代了传统纵向继承体系重复性代码，把某一类问题集中在一个地方进行处理，比如处理程序中的点击事件、打印日志等。

AOP是编程思想就是把业务逻辑和横切问题进行分离，从而达到解耦的目的，提高代码的重用性和开发效率。OOP的精髓是把功能或问题模块化，每个模块处理自己的家务事。但在现实世界中，并不是所有功能都能完美得划分到模块中。AOP的目标是把这些功能集中起来，放到一个统一的地方来控制和管理。

我记得我最开始接触 AOP 还是在JavaEE的框架SSH的学习中，AspectJ框架，开始流行于后端，现在在Android开发的应用中也越来越广泛了，Android中使用AspectJ框架的应用也有很多，比如点击事件防抖，埋点，权限申请等等不一而足，这里不展开说明，毕竟我们这一期不是专门讲AspectJ的应用的。

简单的说一下AOP的重点概念（摘抄）：

• 前置通知（Before）：在目标方法被调用之前调用通知功能。
• 后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么。
• 返回通知（After-returning）：在目标方法成功执行之后调用通知。
• 异常通知（After-throwing）：在目标方法抛出异常后调用通知。
• 环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。
• 连接点：是在应用执行过程中能够插入切面的一个点。
• 切点： 切点定义了切面在何处要织入的一个或者多个连接点。
• 切面：是通知和切点的结合。通知和切点共同定义了切面的全部内容。
• 引入：引入允许我们向现有类添加新方法或属性。
• 织入：是把切面应用到目标对象，并创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中。在目标对象的生命周期中有多个点可以进行织入：
• 编译期： 在目标类编译时，切面被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。
• 类加载期：切面在目标加载到JVM时被织入。这种方式需要特殊的类加载器(class loader)它可以在目标类被引入应用之前增强该目标类的字节码。
• 运行期： 切面在应用运行到某个时刻时被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。SpringAOP就是以这种方式织入切面的。

简单理解就是把一个方法拿出来，在这个方法执行前，执行后，做一些特别的操作。关于AOP的基本使用推荐大家看看大佬的教程：

深入理解Android之AOP

不多BB，我们直接看看Android中如何使用AspectJ实现AOP逻辑，实现拦截登录的功能。

二、集成AOP框架

Java项目集成

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.aspectj:aspectjtools:1.8.9'
        classpath 'org.aspectj:aspectjweaver:1.8.9'
    }
}

组件build.gradle

dependencies {
    implementation 'org.aspectj:aspectjrt:1.9.6'
}
import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
// 获取log打印工具和构建配置
final def log = project.logger
final def variants = project.android.applicationVariants
variants.all { variant ->
    if (!variant.buildType.isDebuggable()) {
        // 判断是否debug，如果打release把return去掉就可以
        log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
        // return;
    }
    // 使aspectj配置生效
    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);
        //在编译时打印信息如警告、error等等
        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;
            }
        }
    }
}

Kotlin项目集成

dependencies {
        classpath 'com.android.tools.build:gradle:3.6.1'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.10'

项目build.gradle

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-kapt'
apply plugin: 'android-aspectjx'
android {
    ...
    // AOP 配置
    aspectjx {
        // 排除一些第三方库的包名（Gson、 LeakCanary 和 AOP 有冲突）
        exclude 'androidx', 'com.google', 'com.squareup', 'com.alipay', 'com.taobao',
                'org.apache',
                'org.jetbrains.kotlin',
                "module-info", 'versions.9'
    }
}
ependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'org.aspectj:aspectjrt:1.9.5'
}

集成AOP踩坑： zip file is empty

和第三方包有冲突，比如Gson,OkHttp等，需要配置排除一下第三方包,

gradle版本兼容问题

AGP版本4.0以上不支持 推荐使用3.6.1

kotlin兼容问题 :

基本都是推荐使用 com.hujiang.aspectjx

编译版本兼容问题:

4.0以上使用KT编译版本为Java11需要改为Java8

组件化兼容问题：

如果在library的moudle中自定义的注解, 想要通过AspectJ来拦截织入, 那么这个@Aspect类必须和自定义的注解在同一moudle中, 否则是没有效果的

等等...

难点就在集成，如何在指定版本的Gradle，Kotlin项目中集成成功。只要集成成功了，使用到是简单了。

三、定义注解实现功能

定义标记的注解

//不需要回调的处理
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Login {
}

定义处理类

@Aspect
public class LoginAspect {
    @Pointcut("@annotation(com.guadou.kt_demo.demo.demo3_bottomtabbar_fragment.aop.Login)")
    public void Login() {
    }
     //不带回调的注解处理
    @Around("Login()")
    public void loginJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
        YYLogUtils.w("走进AOP方法-Login()");
        Signature signature = joinPoint.getSignature();
        if (!(signature instanceof MethodSignature)){
            throw new RuntimeException("该注解只能用于方法上");
        }
        Login login = ((MethodSignature) signature).getMethod().getAnnotation(Login.class);
        if (login == null) return;
        //判断当前是否已经登录
        if (LoginManager.isLogin()) {
            joinPoint.proceed();
        } else {
            //如果未登录，去登录页面
            LoginManager.gotoLoginPage();
        }
    }

object LoginManager {
    @JvmStatic
    fun isLogin(): Boolean {
        val token = SP().getString(Constants.KEY_TOKEN, "")
        YYLogUtils.w("LoginManager-token:$token")
        val checkEmpty = token.checkEmpty()
        return !checkEmpty
    }
    @JvmStatic
    fun gotoLoginPage() {
        commContext().gotoActivity<LoginDemoActivity>()
    }
}

其实逻辑很简单，就是判断是否登录，看是放行还是跳转到登录页面

使用的逻辑也是很简单，把需要处理的逻辑使用方法抽取，并标记注解即可

    override fun init() {
        mBtnCleanToken.click {
            SP().remove(Constants.KEY_TOKEN)
            toast("清除成功")
        }
        mBtnProfile.click {
           //不带回调的登录方式
           gotoProfilePage2()
        }
    }
    @Login
    private fun gotoProfilePage2() {
        gotoActivity<ProfileDemoActivity>()
    }

效果：

这..这和我使用Token自己手动判断有什么区别，完成登录之后还得我再点一次按钮，当然了这只是登录拦截，我想要的是登录成功之后继续之前的操作，怎么办？

其实使用AOP的方式的话，我们可以使用消息通知的方式，比如LiveBus FlowBus之类的间接实现这个效果。

我们先单独的定义一个注解

//需要回调的处理用来触发用户登录成功后的后续操作
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginCallback {
}

修改定义的切面类

@Aspect
public class LoginAspect {
    @Pointcut("@annotation(com.guadou.kt_demo.demo.demo3_bottomtabbar_fragment.aop.Login)")
    public void Login() {
    }
    @Pointcut("@annotation(com.guadou.kt_demo.demo.demo3_bottomtabbar_fragment.aop.LoginCallback)")
    public void LoginCallback() {
    }
    //带回调的注解处理
    @Around("LoginCallback()")
    public void loginCallbackJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
        YYLogUtils.w("走进AOP方法-LoginCallback()");
        Signature signature = joinPoint.getSignature();
        if (!(signature instanceof MethodSignature)){
            throw new RuntimeException("该注解只能用于方法上");
        }
        LoginCallback loginCallback = ((MethodSignature) signature).getMethod().getAnnotation(LoginCallback.class);
        if (loginCallback == null) return;
        //判断当前是否已经登录
        if (LoginManager.isLogin()) {
            joinPoint.proceed();
        } else {
            LifecycleOwner lifecycleOwner = (LifecycleOwner) joinPoint.getTarget();
            LiveEventBus.get("login").observe(lifecycleOwner, new Observer<Object>() {
                @Override
                public void onChanged(Object integer) {
                    try {
                        joinPoint.proceed();
                        LiveEventBus.get("login").removeObserver(this);
                    } catch (Throwable throwable) {
                        throwable.printStackTrace();
                        LiveEventBus.get("login").removeObserver(this);
                    }
                }
            });
            LoginManager.gotoLoginPage();
        }
    }
    //不带回调的注解处理
    @Around("Login()")
    public void loginJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
        YYLogUtils.w("走进AOP方法-Login()");
        Signature signature = joinPoint.getSignature();
        if (!(signature instanceof MethodSignature)){
            throw new RuntimeException("该注解只能用于方法上");
        }
        Login login = ((MethodSignature) signature).getMethod().getAnnotation(Login.class);
        if (login == null) return;
        //判断当前是否已经登录
        if (LoginManager.isLogin()) {
            joinPoint.proceed();
        } else {
            //如果未登录，去登录页面
            LoginManager.gotoLoginPage();
        }
    }
}

在去登录页面之前注册一个LiveEventBus事件，当登录完成之后发出通知，这里就直接放行调用注解的方法。即可完成继续执行的操作。

使用：

    override fun init() {
        mBtnCleanToken.click {
            SP().remove(Constants.KEY_TOKEN)
            toast("清除成功")
        }
        mBtnProfile.click {
           //不带回调的登录方式
           gotoProfilePage()
        }
    }
    @LoginCallback
    private fun gotoProfilePage() {
        gotoActivity<ProfileDemoActivity>()
    }

效果：

总结

从上面的代码我们就基于AOP思想实现了登录拦截功能，以后我们对于需要用户登录之后才能使用的功能只需要在对应的方法上添加指定的注解即可完成逻辑，彻底摆脱传统耗时耗力的开发方式。

需要注意的是AOP框架虽然使用起来很方便，能帮我们轻松完成函数插桩功能，但是它也有自己的缺点。

AspectJ 在实现时会包装自己的一些类，不仅会影响切点方法的性能，还会导致安装包体积的增大。

最关键的是对Kotlin不友好，对高版本AGP不友好，所以大家在使用时需要仔细权衡是否适合自己的项目。如有需求可以运行源码查看效果。源码在此！

以上就是Android面向切面基于AOP实现登录拦截的场景示例的详细内容，更多关于Android AOP登录拦截的资料请关注我们其它相关文章！