精华内容
下载资源
问答
  • android aop

    2014-11-11 21:26:43
    自己写的android aop的例子 可以说明在android开发中如何使用aop编码的
  • android AOP

    2019-04-12 12:35:02
    AOP:在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一...

    AOP:在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

    android AOP流程: 

    1.导入aspectjrt.jar 包

    2.在build.gradle里加上

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

    上面的是第三方编译  就是用它把java 编译成class 

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

    上面代码是为了能在AOP上打印出日志,也在build.gradle里面

     

    3.  这就是切面里可以自己写想实现的逻辑,我这里用的统计时间

    @Aspect
    public class BehaviorTraceAspect {
        //定义切面的规则
        //1.就在原来应用中哪些注释的地方放到当前切面进行处理
        //execution(注释名   注释用的地方)
        @Pointcut("execution(@com.example.annotation.BehaviorTrace * *(..))")
        public void methodAnnotatedWithBehaviorTrace(){}
    
        //2.对进入切面的内容如何处理
        //advice
        //@Before()  在切入点之前运行
        //@After()   在切入点之后运行
        //@Around()  在切入点前后都运行
        @Around("methodAnnotatedWithBehaviorTrace()")
        public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable{
            MethodSignature methodSignature=(MethodSignature)joinPoint.getSignature();
            String className=methodSignature.getDeclaringType().getSimpleName();
            String methodName=methodSignature.getName();
            String funName=methodSignature.getMethod().getAnnotation(BehaviorTrace.class).value();
    
            //统计时间
            long begin=System.currentTimeMillis();
            //joinPoint.proceed(); 表示执行你注解的那个方法
            Object result=joinPoint.proceed();
            long duration=System.currentTimeMillis()-begin;
            Log.d("jett",String.format("功能:%s,%s类的%s方法执行了,用时%d ms",funName,className,methodName,duration));
            return result;
        }
    }

    4.可以在想统计时间的地方的方法上面加上注解@BehaviorTrace

     

    例如:

    /**
     * 用来标识性能监测
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface BehaviorTrace {
        String value();
    }
        @BehaviorTrace("语音消息")
        public void mAudio(View view){
           SystemClock.sleep(new Random().nextInt(2000));
        }

     

    如果你调用这个mAudio方法的话,就看到效果了

    demo:https://download.csdn.net/download/u011586504/11109286

    如果还不懂可以参考:https://www.jianshu.com/p/aa1112dbebc7

     

    展开全文
  • Android AOP

    2018-05-02 17:04:26
    面向切面编程好处不用多说,看一下android实现吧。 翻来翻去找到一个不错的库,库地址 1.使用 在项目根目录的build.gradle里添加依赖: classpath '...

    面向切面编程好处不用多说,看一下android实现吧。
    翻来翻去找到一个不错的库,库地址

    1.使用

    在项目根目录的build.gradle里添加依赖:

    classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.0'

    接下来,在app项目的build.gradle里应用插件:

    apply plugin: 'android-aspectjx'

    一般切面会新建一个库,这里为了简单就在原有项目里进行操作,需要添加AspectJ依赖:

    implementation 'org.aspectj:aspectjrt:1.8.+'

    配置要注意的地方(摘录自作者的github):
    AspectJX配置
    AspectJX默认会处理所有的二进制代码文件和库,为了提升编译效率及规避部分第三方库出现的编译兼容性问题,AspectJX提供include,exclude命令来过滤需要处理的文件及排除某些文件(包括class文件及jar文件)。

    注意:2.0.0版本之后旧版本的includeJarFilter和excludeJarFilter命令废弃,不再支持使用

    2.0.0版本的 include,exclude通过package路径匹配class文件及jar文件,不再支持通过jar物理文件路径匹配的方式,比如:

    支持

    aspectjx {
    //排除所有package路径中包含android.support的class文件及库(jar文件)
    exclude ‘android.support’
    }
    不支持

    aspectjx {
    excludeJarFilter ‘universal-image-loader’
    }

    //或者
    aspectjx {
    exclude ‘universal-image-loader’
    }
    支持和*匹配

    aspectjx {
    //忽略所有的class文件及jar文件,相当于AspectJX不生效
    exclude ‘*’
    }
    提供enabled 开关

    enabled默认为true,即默认AspectJX生效

    aspectjx {
    //关闭AspectJX功能
    enabled false
    }
    至此,配置完成。

    2.简单使用

    这里假设需要为所有的OnClick事件添加一个toast,即执行onclick时,先弹一个toast:

    import org.aspectj.lang.annotation.After
    import org.aspectj.lang.annotation.Around
    import org.aspectj.lang.annotation.Aspect
    import org.aspectj.lang.reflect.MethodSignature
    
    @Aspect
    open class CheckOnClickAspectJ {
        @Around("execution( * android.view.View.OnClickListener.onClick(..))")
        @Throws(Throwable::class)
        open fun checkClick(joinPoint: ProceedingJoinPoint) {
            var signature = joinPoint.signature as MethodSignature
            var view = joinPoint.args[0] as View
            var context: Any = joinPoint.`this`
            //如果有任何检测的不符合条件 返回null即可不执行方法
            ALog.e("开始执行click:${context.javaClass.name}")
            ALog.e("开始执行click2:${view.context}")
            CommonUtils.showToast(view.context as Activity, "你点击了")
    
            joinPoint.proceed()
        }

    代码说明:
    1.注意别导错包;
    2.注意类需要添加@Aspect声明
    3.ProceedingJoinPoint类方法自己看一下即可,里面的方法都很重要,根据需要使用
    4.除了@Around,还有@After和@Before,看名字就知道啥意思,不再赘述

    展开全文
  • AndroidAop aop 小栗子 为什么要用Aop 简化我们的代码,对于公用的逻辑我们可以抽取出来统一处理。比如对于很多地方我们 都需要判断网络是否连接,如果连接,那么页面上的一些按钮点击之后是可以成功发出 请求与后台...
  • Jet-AOP一个Android AOP框架,使用注释, AspectJ等技术实现
  • Android AOP 等在Android上应用越来越广泛,例如框架ButterKnife,Dagger2,EventBus3等等,这里我自己总结了一个学习路程。 – Java的注解Annotation – 注解处理解析器APT(Annotation Processing Tool) – ...
  • 框架知识整理之Android AOP编程思想
  • android AOP编程

    2019-10-09 01:39:45
    android AOP编程 一、简述 1、AOP的概念 如果你做过java后台开发,那么你一定知道AOP这个编程方式: AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理...

    一、简述

    1、AOP的概念

    如果你做过java后台开发,那么你一定知道AOP这个编程方式:

    AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

    2、项目场景

    常用于日志、权限拦截、异常捕获、执行效率监控、防止重复提交(android中防止按钮快速点击)等。

    3、AOP的实现方式

    • AspectJ: android 可以使用AspectJ来实现切面编程。

    二、AspectJ的引入

    对于eclipse与Android Studio的引入是不一样的,本篇只介绍Android Studio如何引入AspectJ,eclipse请自行百度。Android Studio需要在app模块的build.gradle文件中引入,总共分为3个步骤:

    1)添加核心依赖

    apply plugin: 'android-aspectjx'
    
    dependencies {
        implementation 'org.aspectj:aspectjrt:1.8.9'
    }

     

    2)编写gradle编译脚本

    buildscript {
        ext.kotlin_version = '1.3.31'
        repositories {
            google()
            jcenter()
            
        }
        dependencies {
            classpath 'com.android.tools.build:gradle:3.5.0-beta04'
            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
            classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.0'
    
        }
    }

    三、AOP的基本知识

    在使用AspectJ之前,还是需要先介绍下AOP的基本知识。

    1、AOP术语

    1. 通知、增强处理(Advice):就是你想要的功能,也就是上面说的日志、耗时计算等。
    2. 连接点(JoinPoint):允许你通知(Advice)的地方,那可就真多了,基本每个方法的前、后(两者都有也行),或抛出异常是时都可以是连接点(spring只支持方法连接点)。AspectJ还可以让你在构造器或属性注入时都行,不过一般情况下不会这么做,只要记住,和方法有关的前前后后都是连接点。
    3. 切入点(Pointcut):上面说的连接点的基础上,来定义切入点,你的一个类里,有15个方法,那就有十几个连接点了对吧,但是你并不想在所有方法附件都使用通知(使用叫织入,下面再说),你只是想让其中几个,在调用这几个方法之前、之后或者抛出异常时干点什么,那么就用切入点来定义这几个方法,让切点来筛选连接点,选中那几个你想要的方法。
    4. 切面(Aspect):切面是通知和切入点的结合。现在发现了吧,没连接点什么事,连接点就是为了让你好理解切点搞出来的,明白这个概念就行了。通知说明了干什么和什么时候干(什么时候通过before,after,around等AOP注解就能知道),而切入点说明了在哪干(指定到底是哪个方法),这就是一个完整的切面定义。
    5. 织入(weaving) 把切面应用到目标对象来创建新的代理对象的过程。

    上述术语的解释引用自《AOP中的概念通知、切点、切面》这篇文章,作者的描述非常直白,很容易理解,点个赞。

    2、AOP注解与使用

    • @Aspect:声明切面,标记类
    • @Pointcut(切点表达式):定义切点,标记方法
    • @Before(切点表达式):前置通知,切点之前执行
    • @Around(切点表达式):环绕通知,切点前后执行
    • @After(切点表达式):后置通知,切点之后执行
    • @AfterReturning(切点表达式):返回通知,切点方法返回结果之后执行
    • @AfterThrowing(切点表达式):异常通知,切点抛出异常时执行

    @Pointcut、@Before、@Around、@After、@AfterReturning、@AfterThrowing需要在切面类中使用,即在使用@Aspect的类中。

    1)切点表达式是什么?

    这就是切点表达式:execution (* com.lqr..*.*(..))。切点表达式的组成如下:

    execution(<修饰符模式>? <返回类型模式> <方法名模式>(<参数模式>) <异常模式>?)
    

    除了返回类型模式、方法名模式和参数模式外,其它项都是可选的。

    修饰符模式指的是public、private、protected,异常模式指的是NullPointException等。

    对于切点表达式的理解不是本篇重点,下面列出几个例子说明一下就好了:

    @Before("execution(public * *(..))")
    public void before(JoinPoint point) {
        System.out.println("CSDN_LQR");
    }
    

    匹配所有public方法,在方法执行之前打印"CSDN_LQR"。

    @Around("execution(* *to(..))")
    public void around(ProceedingJoinPoint joinPoint) {
        System.out.println("CSDN");
        joinPoint.proceed();
        System.out.println("LQR");
    }
    

    匹配所有以"to"结尾的方法,在方法执行之前打印"CSDN",在方法执行之后打印"LQR"。

    @After("execution(* com.lqr..*to(..))")
    public void after(JoinPoint point) {
        System.out.println("CSDN_LQR");
    }
    

    匹配com.lqr包下及其子包中以"to"结尾的方法,在方法执行之后打印"CSDN_LQR"。

    @AfterReturning("execution(int com.lqr.*(..))")
    public void afterReturning(JoinPoint point, Object returnValue) {
        System.out.println("CSDN_LQR");
    }
    

    匹配com.lqr包下所有返回类型是int的方法,在方法返回结果之后打印"CSDN_LQR"。

    @AfterThrowing(value = "execution(* com.lqr..*(..))", throwing = "ex")
    public void afterThrowing(Throwable ex) {
        System.out.println("ex = " + ex.getMessage());
    }
    

    匹配com.lqr包及其子包中的所有方法,当方法抛出异常时,打印"ex = 报错信息"。

    2)@Pointcut的使用

    @Pointcut是专门用来定义切点的,让切点表达式可以复用。

    你可能需要在切点执行之前和切点报出异常时做些动作(如:出错时记录日志),可以这么做:

    @Before("execution(* com.lqr..*(..))")
    public void before(JoinPoint point) {
        System.out.println("CSDN_LQR");
    }
    
    @AfterThrowing(value = "execution(* com.lqr..*(..))", throwing = "ex")
    public void afterThrowing(Throwable ex) {
        System.out.println("记录日志");
    }
    

    可以看到,表达式是一样的,那要怎么重用这个表达式呢?这就需要用到@Pointcut注解了,@Pointcut注解是注解在一个空方法上的,如:

    @Pointcut("execution(* com.lqr..*(..))")
    public void pointcut() {}
    

    这时,"pointcut()"就等价于"execution(* com.lqr..*(..))",那么上面的代码就可以这么改了:

    @Before("pointcut()")
    public void before(JoinPoint point) {
        System.out.println("CSDN_LQR");
    }
    
    @AfterThrowing(value = "pointcut()", throwing = "ex")
    public void afterThrowing(Throwable ex) {
        System.out.println("记录日志");
    }
    

    四、实战

    经过上面的学习,下面是时候实战一下了,这里我们来一个简单的例子。

    1、切点

    这是界面上一个按钮的点击事件,就是一个简单的方法而已,我们拿它来试刀。

    public void test(View view) {
        System.out.println("Hello, I am CSDN_LQR");
    }
    

    2、切面类

    要织入一段代码到目标类方法的前前后后,必须要有一个切面类,下面就是切面类的代码:

    @Aspect
    public class TestAnnoAspect {
    
        @Pointcut("execution(* com.lqr.androidaopdemo.MainActivity.test(..))")
        public void pointcut() {
    
        }    
    
        @Before("pointcut()")
        public void before(JoinPoint point) {
            System.out.println("@Before");
        }
    
        @Around("pointcut()")
        public void around(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("@Around");
        }
    
        @After("pointcut()")
        public void after(JoinPoint point) {
            System.out.println("@After");
        }
    
        @AfterReturning("pointcut()")
        public void afterReturning(JoinPoint point, Object returnValue) {
            System.out.println("@AfterReturning");
        }
    
        @AfterThrowing(value = "pointcut()", throwing = "ex")
        public void afterThrowing(Throwable ex) {
            System.out.println("@afterThrowing");
            System.out.println("ex = " + ex.getMessage());
        }
    }
    

    3、各通知的执行结果

    先来试试看,这几个注解的执行结果如何。

     
     

    不对啊,按钮的点击事件中有打印"Hello, I am CSDN_LQR"的,这里没有,怎么肥事?

    这里因为@Around环绕通知会拦截原方法内容的执行,我们需要手动放行才可以。代码修改如下:

    @Around("pointcut()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("@Around");
        joinPoint.proceed();// 目标方法执行完毕
    }
    
     
     

    也不对啊,少了一个@AfterThrowing通知。这个通知只有在切点抛出异常时才会执行,我们可以让代码出现一个简单的运行时异常:

    public void test(View view) {
        System.out.println("Hello, I am CSDN_LQR");
        int a = 1 / 0;
    }
    
     
     

    这下@AfterThrowing通知确实被调用了,而且也打印出了错误信息(divide by zero)。但@AfterReturning通知反而不执行了,原因很简单,都抛出异常了,切点肯定是不能返回结果的。也就是说:@AfterThrowing通知与@AfterReturning通知是冲突的,在同个切点上不可能同时出现。

    4、方法耗时计算的实现

    因为@Around是环绕通知,可以在切点的前后分别执行一些操作,AspectJ为了能肯定操作是在切点前还是在切点后,所以在@Around通知中需要手动执行joinPoint.proceed()来确定切点已经执行,故在joinPoint.proceed()之前的代码会在切点执行前执行,在joinPoint.proceed()之后的代码会切点执行后执行。于是,方法耗时计算的实现就是这么简单:

    @Around("pointcut()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        long beginTime = SystemClock.currentThreadTimeMillis();
        joinPoint.proceed();
        long endTime = SystemClock.currentThreadTimeMillis();
        long dx = endTime - beginTime;
        System.out.println("耗时:" + dx + "ms");
    }
    

    5、JoinPoint的作用

    发现没有,上面所有的通知都会至少携带一个JointPoint参数,这个参数包含了切点的所有信息,下面就结合按钮的点击事件方法test()来解释joinPoint能获取到的方法信息有哪些:

    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    String name = signature.getName(); // 方法名:test
    Method method = signature.getMethod(); // 方法:public void com.lqr.androidaopdemo.MainActivity.test(android.view.View)
    Class returnType = signature.getReturnType(); // 返回值类型:void
    Class declaringType = signature.getDeclaringType(); // 方法所在类名:MainActivity
    String[] parameterNames = signature.getParameterNames(); // 参数名:view
    Class[] parameterTypes = signature.getParameterTypes(); // 参数类型:View
    

    6、注解切点

    前面的切点表达式结构是这样的:

    execution(<修饰符模式>? <返回类型模式> <方法名模式>(<参数模式>) <异常模式>?)
    

    但实际上,上面的切点表达式结构并不完整,应该是这样的:

    execution(<@注解类型模式>? <修饰符模式>? <返回类型模式> <方法名模式>(<参数模式>) <异常模式>?)
    

    这就意味着,切点可以用注解来标记了。

    1)自定义注解

    如果用注解来标记切点,一般会使用自定义注解,方便我们拓展。

    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface TestAnnoTrace {
        String value();
        int type();
    }
    
    • @Target(ElementType.METHOD):表示该注解只能注解在方法上。如果想类和方法都可以用,那可以这么写:@Target({ElementType.METHOD,ElementType.TYPE}),依此类推。
    • @Retention(RetentionPolicy.RUNTIME):表示该注解在程序运行时是可见的(还有SOURCE、CLASS分别指定注解对于那个级别是可见的,一般都是用RUNTIME)。

    其中的value和type是自己拓展的属性,方便存储一些额外的信息。

    2)使用自定义注解标记切点

    这个自定义注解只能注解在方法上(构造方法除外,构造方法也叫构造器,需要使用ElementType.CONSTRUCTOR),像平常使用其它注解一样使用它即可:

    @TestAnnoTrace(value = "lqr_test", type = 1)
    public void test(View view) {
        System.out.println("Hello, I am CSDN_LQR");
    }
    

    3)注解的切点表达式

    既然用注解来标记切点,那么切点表达式肯定是有所不同的,要这么写:

    @Pointcut("execution(@com.lqr.androidaopdemo.TestAnnoTrace * *(..))")
    public void pointcut() {}
    

    切点表达式使用注解,一定是@+注解全路径,如:@com.lqr.androidaopdemo.TestAnnoTrace。

    亲测可用 ,不贴图了。

    4)获取注解属性值

    上面在编写自定义注解时就声明了两个属性,分别是value和type,而且在使用该注解时也都为之赋值了,那怎么在通知中获取这两个属性值呢?还记得JoinPoint这个参数吧,它就可以获取到注解中的属性值,如下所示:

    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    Method method = signature.getMethod();
    // 通过Method对象得到切点上的注解
    TestAnnoTrace annotation = method.getAnnotation(TestAnnoTrace.class);
    String value = annotation.value();
    int type = annotation.type();
    posted on 2019-07-11 17:57 ggband 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/ggband/p/11171674.html

    展开全文
  • 本篇文章主要介绍了Android AOP框架AspectJ使用详解,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Android AOP网络检查

    2021-04-28 17:36:31
    Android AOP实现网络检查功能: 无网时提示或弹窗显示

    Android AOP网络检查

    在这里插入图片描述

    在这里插入图片描述

    功能实现

    定义注解

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface CheckNet {
        int SHOW_TIP = 1;
        int SHOW_DIALOG = 2;
    
        int value() default SHOW_TIP;
    }
    

    定义切面类

    @Aspect
    public class CheckNetAspect {
    
        @Pointcut("execution(@com.example.mylibrary.network.CheckNet * *(..))")
        public void method() {
        }
    
        @Around("method()")
        public void handleCheckNet(ProceedingJoinPoint joinPoint) throws Throwable {
            MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
            CheckNet checkNet = methodSignature.getMethod().getAnnotation(CheckNet.class);
            if (checkNet != null) {
                Object aThis = joinPoint.getThis();
                Context context = getContext(aThis);
                if (context != null && !isNetworkAvailable(context)) {
                    if (checkNet.value() == CheckNet.SHOW_TIP) {
                        showTip(context);
                    } else if (checkNet.value() == CheckNet.SHOW_DIALOG) {
                        showSettingDialog(context);
                    }
                    return;
                }
            }
            joinPoint.proceed();
        }
    
        /**
         * 显示提示
         */
        private void showTip(Context context) {
            Toast.makeText(context, "当前没有网络连接,请检查网络设置", Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 显示弹窗
         */
        private void showSettingDialog(Context context) {
            new AlertDialog.Builder(context)
                    .setMessage("当前没有网络连接,请检查网络设置")
                    .setPositiveButton("设置", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            context.startActivity(new Intent(android.provider.Settings.ACTION_WIRELESS_SETTINGS)
                                    .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
                        }
                    })
                    .show();
        }
    
        /**
         * 判断网络是否能用
         */
        private boolean isNetworkAvailable(Context context) {
            ConnectivityManager manager = ContextCompat.getSystemService(context, ConnectivityManager.class);
            if (manager != null) {
                NetworkInfo info = manager.getActiveNetworkInfo();
                // 判断网络是否连接
                if (info == null || !info.isConnected()) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * 获取Context对象
         */
        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;
        }
    }
    

    使用

    @CheckNet()
    private void getUserInfo() {
        Log.e(TAG, "获取用户信息");
    }
    
    @CheckNet(CheckNet.SHOW_DIALOG)
    private void getUserInfo2() {
        Log.e(TAG, "获取用户信息2");
    }
    

    代码下载

    展开全文
  • Android AOP限制快速点击: 工具类方案, 代理类方案, 基于AOP方案
  • Android AOP 总结

    千次阅读 2017-03-16 21:24:45
    AndroidAOP 总结 一、AOP 1.1 什么是AOP AOP,AspectOriented Programming 面向切面编程 OOP,Object-orientedprogramming面向对象编程 AOP和OOP是不同的编程思想。OOP强调的是高内聚,低耦合,封装。 提倡的是将...
  • Android AOP注解Annotation详解(一) Android AOP之注解处理解释器详解(二) Android AOP 注解详解及简单使用实例(三) 一、提取Annotation信息 当开发者使用了Annotation修饰了类、方法、Field等成员之后,这些...
  • android aop实现

    2019-02-19 14:20:03
    最近寒休假期中,这二十七八天的,寻思着也不能浪费光阴啊,正好把以前写小玩意给捣鼓捣鼓。主要用到aspectj和apt,详细就不开展... Android AOP就是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技...
  • Android AOP注解Annotation详解(一) Android AOP之注解处理解释器详解(二) Android AOP 注解详解及简单使用实例(三) 一、简介 在Android 里面 注解主要用来干这么几件事: 和编译器一起给你一些提示警告信息...
  • Android AOP 框架 Lancet 应用与解析 Lancet 是一个轻量级 Android AOP 框架。它可以用来替换某个方法的代码实现,或者在方法执行前后插入代码。 Lancet 应用举例 待修改的 MainActivity 如下: public class ...
  • Android在许多情况下需要知道一些方法的耗时,然后对与这些耗时进行一些处理和优化。当然我们可以在方法的开头和结尾分别来打一行日志来解决这个问题。但是这个方式侵入性强,而且比较难以修改和删除这些日志,所以...
  • Android AOP面向切面编程详解

    千次阅读 2017-10-09 17:18:28
    Android aop github
  • title: Android AOP之字节码插桩author: 陶超description: 实现数据收集SDK时,为了实现非侵入的,全量的数据采集,采用了AOP的思想,探索和实现了一种AndroidAOP的方式。本文基于数据收集SDK的AOP实现总结而成。...
  • AndroidAOP之路一 注解Annotation

    千次阅读 2017-03-03 19:08:12
    Android AOP 等在Android上应用越来越广泛,例如框架ButterKnife,Dagger2,EventBus3等等,这里我自己总结了一个学习路程。 - Java的注解Annotation - 注解处理解析器APT(Annotation Processing Tool) - Android...
  • Android AOP使用

    2021-04-19 23:28:14
    AOP概述, AspectJ框架说明, AOP实现案例
  • android AOP 编程之aspectj实战笔记背景一 操作步骤(1) 配置环境(2) 写切面文件aspect 切面piontcut 切点advice总结参考文章 背景 现在一提到aspectj,大家都是想到aspectjx这个别人封装好的插件,确实也很好用,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,540
精华内容 616
关键字:

androidaop