AOP之AspectJ的简单使用

个人博客

http://www.milovetingting.cn

AOP之AspectJ的简单使用

AOP的定义

AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

以上关于AOP的定义引用自百度百科。

AOP的运用场景

日志记录、性能统计、权限控制、埋点等

AOP的具体实现方案有很多,这里选用AspectJ来简单实现

  1. 监听View的点击、页面打开、关闭
  2. 为方法添加开始、结束的日志
  3. 统计方法运行时间

AspectJ的使用

AspectJ的引入

这里引用AspectJX,AspectJX是基于AspectJ的一个AOP框架

新建Android工程,在项目根目录下的build.gradle文件中添加依赖

dependencies {
        //...
        classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.8'
        //...
    }

新建Module,类型选择Android Library,在新建的library的build.gradle文件中,添加相应的依赖

apply plugin: 'android-aspectjx'

在app的build.gradle文件中增加对刚才新建的library的引用及AspectJ的依赖

apply plugin: 'android-aspectjx'

dependencies {
    //...
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
}

监听View的点击、页面打开、关闭

在library中新建回调接口TrackCallBack

public interface TrackCallBack {

    /**
     * 当View被点击
     *
     * @param pageName
     * @param viewIdName
     */
    void onClick(String pageName, String viewIdName);

    /**
     * 当页面打开时
     *
     * @param pageName
     */
    void onPageOpen(String pageName);

    /**
     * 当页面关闭时
     *
     * @param pageName
     */
    void onPageClose(String pageName);

}

在library中新建切入点TrackPoint

public class TrackPoint {

    private static TrackCallBack mTrackCallBack;

    private TrackPoint() {

    }

    /**
     * 初始化
     * @param trackCallBack
     */
    public static void init(TrackCallBack trackCallBack) {
        mTrackCallBack = trackCallBack;
    }

    static void onClick(String pageName, String viewIdName) {
        if (mTrackCallBack == null) {
            return;
        }
        mTrackCallBack.onClick(pageName, viewIdName);
    }

    static void onPageOpen(String pageName) {
        if (mTrackCallBack == null) {
            return;
        }
        mTrackCallBack.onPageOpen(pageName);
    }

    static void onPageClose(String pageName) {
        if (mTrackCallBack == null) {
            return;
        }
        mTrackCallBack.onPageClose(pageName);
    }

}

在library中新建切面TraceAspect

@Aspect
public class TraceAspect {

    private static final String TAG = TraceAspect.class.getSimpleName();

    @Pointcut("execution(* onClick(..))")
    public void onClickPointcut() {

    }

    @Pointcut("execution(* android.app.Activity+.onCreate(..))")
    public void activityOnCreatePointcut() {

    }

    @Pointcut("execution(* android.app.Activity+.onDestroy(..))")
    public void activityDestroyPointcut() {

    }

    @Around("onClickPointcut()")
    public void onClick(ProceedingJoinPoint joinPoint) throws Throwable {
        Object target = joinPoint.getTarget();
        String className = "";
        if (target != null) {
            className = target.getClass().getName();
        }
        Object[] args = joinPoint.getArgs();
        if (args.length > 0 && args[0] instanceof View) {
            View view = (View) args[0];
            String entryName = view.getResources().getResourceEntryName(view.getId());
            TrackPoint.onClick(className, entryName);
        }
        joinPoint.proceed();
    }

    @Around("activityOnCreatePointcut()")
    public void pageOpen(ProceedingJoinPoint joinPoint) throws Throwable {
        Object target = joinPoint.getTarget();
        String className = target.getClass().getName();
        TrackPoint.onPageOpen(className);
        joinPoint.proceed();
    }

    @Around("activityDestroyPointcut()")
    public void pageClose(ProceedingJoinPoint joinPoint) throws Throwable {
        Object target = joinPoint.getTarget();
        String className = target.getClass().getName();
        TrackPoint.onPageClose(className);
        joinPoint.proceed();
    }

}

在app模块新建Application,在onCreate中执行初始化:

public class App extends Application {

    private static final String TAG = TraceAspect.class.getSimpleName();

    @Override
    public void onCreate() {
        super.onCreate();
        TrackPoint.init(new TrackCallBack() {
            @Override
            public void onClick(String pageName, String viewIdName) {
                Log.d(TAG, "onClick:" + pageName + "-" + viewIdName);
                //执行相应的业务
            }

            @Override
            public void onPageOpen(String pageName) {
                Log.d(TAG, "onPageOpen:" + pageName);
                //执行相应的业务
            }

            @Override
            public void onPageClose(String pageName) {
                Log.d(TAG, "onPageClose:" + pageName);
                //执行相应的业务
            }
        });
    }
}

新增的Application需要在AndroidManifest中引用才会生效。

运行App后,点击打开另一个Activity,然后依次退出Activity,输出日志如下:

2020-01-13 16:50:17.373 16610-16610/com.wangyz.aspectjdemo D/TraceAspect: onPageOpen:com.wangyz.aspectjdemo.MainActivity
2020-01-13 16:50:19.243 16610-16610/com.wangyz.aspectjdemo D/TraceAspect: onClick:com.wangyz.aspectjdemo.MainActivity-btn_open
2020-01-13 16:50:19.298 16610-16610/com.wangyz.aspectjdemo D/TraceAspect: onPageOpen:com.wangyz.aspectjdemo.SecondActivity
2020-01-13 16:50:21.392 16610-16610/com.wangyz.aspectjdemo D/TraceAspect: onPageClose:com.wangyz.aspectjdemo.SecondActivity
2020-01-13 16:50:22.320 16610-16610/com.wangyz.aspectjdemo D/TraceAspect: onPageClose:com.wangyz.aspectjdemo.MainActivity

为方法添加开始、结束的日志

在library中增加注解AddLog

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

在TraceAspect增加以下代码

@Pointcut("execution(@com.wangyz.library.AddLog * *(..))")
    public void addLogPointcut() {

    }

@Around("addLogPointcut()")
    public void addLog(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        AddLog addLog = signature.getMethod().getAnnotation(AddLog.class);
        if (addLog != null) {
            Object target = joinPoint.getTarget();
            String className = "";
            if (target != null) {
                className = target.getClass().getName();
            }
            Log.d(TAG, "start execute:" + className + "-" + signature.getMethod().getName());
            joinPoint.proceed();
            Log.d(TAG, "end execute:" + className + "-" + signature.getMethod().getName());
        } else {
            joinPoint.proceed();
        }
    }

在MainActivity的onCreate上增加AddLog注解

@AddLog
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //...
    }

运行App后,输入日志如下:

2020-01-13 16:50:17.373 16610-16610/com.wangyz.aspectjdemo D/TraceAspect: start execute:com.wangyz.aspectjdemo.MainActivity-onCreate
2020-01-13 16:50:17.392 16610-16610/com.wangyz.aspectjdemo D/TraceAspect: end execute:com.wangyz.aspectjdemo.MainActivity-onCreate

统计方法运行时间

在library中增加注解ExecTime

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

在TraceAspect增加以下代码

@Pointcut("execution(@com.wangyz.library.ExecTime * *(..))")
    public void execTimePointcut() {

    }

@Around("execTimePointcut()")
    public void execTime(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        ExecTime execTime = signature.getMethod().getAnnotation(ExecTime.class);
        if (execTime != null) {
            long start = System.currentTimeMillis();
            joinPoint.proceed();
            long end = System.currentTimeMillis();
            Object target = joinPoint.getTarget();
            String className = "";
            if (target != null) {
                className = target.getClass().getName();
            }
            Log.d(TAG,
                    "execute time:" + className + "-" + signature.getMethod().getName() + " : " + (end - start) + "ms");
        } else {
            joinPoint.proceed();
        }
    }

在onClick方法上增加ExecTime注解

@ExecTime
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_open:
                Intent intent = new Intent(this, SecondActivity.class);
                startActivity(intent);
                break;
            default:
                break;
        }
    }

运行App后,输出日志如下:

2020-01-13 16:50:19.272 16610-16610/com.wangyz.aspectjdemo D/TraceAspect: execute time:com.wangyz.aspectjdemo.MainActivity-onClick : 28ms

源码地址:https://github.com/milovetingting/Samples/tree/master/AspectJDemo

原文地址:https://www.cnblogs.com/milovetingting/p/12188399.html

时间: 2024-08-05 01:30:16

AOP之AspectJ的简单使用的相关文章

比较分析 Spring AOP 和 AspectJ 之间的差别

面向方面的编程(AOP) 是一种编程范式,旨在通过允许横切关注点的分离,提高模块化.AOP提供方面来将跨越对象关注点模块化.虽然现在可以获得许多AOP框架,但在这里我们要区分的只有两个流行的框架:Spring AOP和AspectJ.这里将会帮助你基于一些关键信息,为你的项目选择正确的技术. Spring AOP不同于大多数其他AOP框架.Spring AOP的目的并不是为了提供最完整的AOP实现(虽然Spring AOP具有相当的能力):而是为了要帮助解决企业应用中的常见问题,提供一个AOP实

Spring AOP With AspectJ

一.AOP和拦截器 某些情况下,AOP和拦截器包括Filter能够实现同样的功能,一般都是请求即controller层的操作,这三个执行顺序为Filter>Interceptor>AOP,当然这里面的区别我会重新写一篇文章讲解,这里面提一下就是想告诉大家,不一定要使用AOP,个人感觉用Filter和Interceptor实现的更方便简单一点. 二.AOP 准备 在spring框架下,你还需要添加aspectjrt,aspectjweaver和cglib 的相关jar包,maven项目的pom.

AspectJ的简单使用

aspectj是一款优秀的面向切面的编程框架,下面就简单介绍一下入门教程吧: 1.官网下载AspectJ的jar包,我这里下的是最新版本1.8.7的. 2.因为AspectJ.jar 是一个可执行的jar文件,需要运行安装   进入jar所在目录,输入命令 java -jar ***.jar: 3.进入安装: 4.选择next,会有如下提示,默认选择电脑所安装的jre: 5.选择next,然后选择安装的目录,自己得记住该目录,到后面有用: 6.安装完成后,有提示将lib中aspectjrt.ja

Java之代理(jdk静态代理,jdk动态代理,cglib动态代理,aop,aspectj)

一.概念 代理是什么呢?举个例子,一个公司是卖摄像头的,但公司不直接跟用户打交道,而是通过代理商跟用户打交道.如果:公司接口中有一个卖产品的方法,那么公司需要实现这个方法,而代理商也必须实现这个方法.如果公司卖多少钱,代理商也卖多少钱,那么代理商就赚不了钱.所以代理商在调用公司的卖方法后,加上自己的利润然后再把产品卖给客户.而客户部直接跟公司打交道,或者客户根本不知道公司的存在,然而客户最终却买到了产品. 专业点说:代理模式是对象的结构型模式,代码模式给某一个对象提供代理,并由代理对象控制原对象

【Spring】—AOP之AspectJ注解方式实现声明式事务管理

前言 这回来说下注解方式的声明式事务管理. 正文 Demo 1.引入相关的jar包这里写图片描述 2.引入AOP约束<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/con

专门的aop框架-AspectJ

在前面的spring的aop的使用的基础上:切面类只能写一个方法,只能增强一个功能.就需要创建多个切面对象,配置多个<aop:advisor> AspectJ的注解式开发步骤 定义一个普通的类,添加@Aspect注解,表明是一个切面类 定义要增强的方法,通过注解确定增强的类型 @Before:前置通知 @AfterReturning:后置通知 @Around:环绕通知 @AfterThrowing:异常通知 @After:最终通知(相当于java中的finally) 通过aspectj的exe

基于Spring aop写的一个简单的耗时监控

前言:毕业后应该有一两年没有好好的更新博客了,回头看看自己这一年,似乎少了太多的沉淀了.让自己做一个爱分享的人,好的知识点拿出来和大家一起分享,一起学习. 背景: 在做项目的时候,大家肯定都遇到对一些对方法,模块耗时的监控,为了方便性能的监控,问题的定位等.如果每一个方法里都加上 ... Stopwatch watch = Stopwatch.createStarted(); ... watch.elapsed(TimeUnit.MILLISECONDS) ... 类似的代码肯定没问题,但是就会

spring学习(二) ———— AOP之AspectJ框架的使用

前面讲解了spring的特性之一,IOC(控制反转),因为有了IOC,所以我们都不需要自己new对象了,想要什么,spring就给什么.而今天要学习spring的第二个重点,AOP.一篇讲解不完,所以这篇文章主要介绍一下什么是AOP,如何去理解AOP.理解完之后,在spring中如何使用AspectJ AOP框架的.看得懂,写的出spring配置的那么就学的差不多了.加油.建议都自己手动实现一遍,这样才能更好的理解. --WH 一.什么是AOP? AOP:面向切面编程,采用横向抽取机制,取代了传

漫谈AOP开发之初探AOP及AspectJ的用法

一.为什么需要AOP技术 AOP 是一个很成熟的技术. 假如项目中有方法A.方法B.方法C……等多个方法, 如果项目需要为方法A.方法B.方法C……这批方法增加具有通用性质的横切处理. 下图可以形象的说明具有通用性质的横切处理的思想: 在以前传统的做法是 1.先定义一个Advice方法,该方法实现这个通用性质的横切处理.2.打开方法A.方法B.方法C……的源代码修改,使得方法A.方法B.方法C……去调用Advice方法. 客户电话: 为每个方法都增加日志. 客户电话: 为每个方法前都增加权限控制