首页 / ANDROID / 12个Android中使用AspectJ实现AOP的实例操作

12个Android中使用AspectJ实现AOP的实例操作

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了12个Android中使用AspectJ实现AOP的实例操作，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含15273字，纯文字阅读大概需要22分钟。

内容图文

文章目录

AspectJ语法
AspectJ配置
AspectJ实例

1. 添加日志
2. 防止快速点击
3. 登录态检测
4. 请求权限
5. 埋点
6. 异步执行
7. 异常捕获
8. Hook方法
9. 缓存
10. Null检查
11. view的控制
12. 更改Toast信息

AOP开发问题总结
github地址

AspectJ语法

https://www.eclipse.org/aspectj/doc/released/progguide/index.html

AspectJ配置

根目录的build中的dependencies增加：

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

app或者library的build中增加aspectjrt的依赖：

implementation 'org.aspectj:aspectjrt:1.8.14'

另外还需在app和library中增加配置：

apply plugin: 'android-aspectjx'

AspectJ实例

添加日志、权限拦截、防止双击、状态检测、埋点、异步、拦截崩溃、HOOK、缓存、Null判空、添加View控件、拦截Toast等，你能想到的，AOP都能做到。

1. 添加日志

功能：
计算方法执行的时间并打印出来。
annotation

@Retention(RetentionPolicy.CLASS)
@Target({ElementType.METHOD})
public @interface InsertLog {
}

aspect

@Aspect
public class InsertLogAspect {

    private final String TAG = "InsertLogAspect";
    private final String POINTCUT = "execution(@com.androidwind.quickaop.library.annotation.InsertLog * *(..))";
    private long startTime, endTime;
    private String className;
    private String methodName;

    @Pointcut(POINTCUT)//切点annotation
    public void onInsertLogMethod() {

    }

    @Before("onInsertLogMethod()")//Before:在原方法前面插入
    public void before(JoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        className = methodSignature.getDeclaringType().getSimpleName();
        methodName = methodSignature.getName();
        startTime = System.nanoTime();
        Log.i(TAG, className + "." + methodName + "'s start time: " + startTime);
    }

    /**
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("onInsertLogMethod()")//重写原方法
    public void doInsertLogMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        Log.i(TAG, "Around before proceed:" + className + "." + methodName);
        //
        Object result = joinPoint.proceed();//执行原方法
        //
        Log.i(TAG, "Around after proceed:" + className + "." + methodName);
    }

    @After("onInsertLogMethod()")//After:在原方法后面插入, 注意要写在Around后
    public void after() {
        endTime = System.nanoTime();
        Log.i(TAG, className + "." + methodName + "'s end time: " + endTime);
        Log.i(TAG, className + "." + methodName + " spent: " + (TimeUnit.NANOSECONDS.toMillis(endTime - startTime)));//换算成毫秒
    }
}

使用方法

@InsertLog
    public void insertLog(View view) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.i(TAG, "this is an insert log.");
    }

2. 防止快速点击

功能
防止段时间内对view控件的多次点击，这里可以设置时间间隔，即多长时间内不能多次点击。
annotation

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface SingleClick {
    long value() default 1000L;

    int[] ids() default {View.NO_ID}; //支持多个值
}

aspectj

@Aspect
public class SingleClickAspect {

    private final String TAG = "SingleClickAspect";

    private static int TIME_TAG = R.id.click_time;

    @Pointcut("execution(@com.androidwind.quickaop.library.annotation.SingleClick * *(..))")
    public void onSingleClickMethod() {
    }

    @Around("onSingleClickMethod() && @annotation(singleClick)")
    public void doSingleClickMethod(ProceedingJoinPoint joinPoint, SingleClick singleClick) throws Throwable {
        Log.d("SingleClickAspect", "singleClick=" + singleClick.hashCode());
        View view = null;
        for (Object arg : joinPoint.getArgs()) {
            if (arg instanceof View) {
                view = (View) arg;
                break;
            }
        }
        if (view != null) {
            Object tag = view.getTag(TIME_TAG);
            long lastClickTime = ((tag != null) ? (long) tag : 0);
            Log.d("SingleClickAspect", "lastClickTime:" + lastClickTime);
            long currentTime = Calendar.getInstance().getTimeInMillis();
            long value = singleClick.value();
            int[] ids = singleClick.ids();
            if (currentTime - lastClickTime > value || !hasId(ids, view.getId())) {
                view.setTag(TIME_TAG, currentTime);
                Log.d("SingleClickAspect", "currentTime:" + currentTime);
                joinPoint.proceed();//执行原方法
            }

        }
    }

    public static boolean hasId(int[] arr, int value) {
        for (int i : arr) {
            if (i == value)
                return true;
        }
        return false;
    }
}

使用方法

@SingleClick(value = 2000L, ids = {R.id.singleClick1})
    public void singleClick1(View view) {
        Log.i(TAG, "this is a single click log.");
    }

    @SingleClick(ids = {R.id.singleClick2})
    public void singleClick2(View view) {
        Log.i(TAG, "this is a single click log.");
    }

3. 登录态检测

功能
检测当前是否已经登录，如果登录继续执行，如果没登录则提示。
annotation

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

aspectj

@Aspect
public class CheckLoginAspect {
    private final String TAG = "CheckLoginAspect";
    private final String POINTCUT = "execution(@com.androidwind.quickaop.annotation.CheckLogin * *(..))";

    @Pointcut(POINTCUT)
    public void onCheckLoginMethod() {
    }

    @Around("onCheckLoginMethod()")
    public void doCheckLoginMethod(ProceedingJoinPoint joinPoint) throws Throwable {
       if (MyApplication.isLogin()) {
           joinPoint.proceed();//执行原方法
       } else {
           Toast.makeText(MyApplication.getApplication(), "还未登录", Toast.LENGTH_SHORT).show();
       }
    }
}

使用方法

@CheckLogin
    public void checkLogin(View view) {
        Log.i(TAG, "this is an operation after login.");
    }

4. 请求权限

功能
在执行方法前检测app是否已经获得了相应的权限。
这里引入RxPermissions作为权限检测工具。
annotation

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

    String[] value();
}

aspectj

@Aspect
public class RequirePermissionAspect {

    private final String TAG = "RequirePermissionAspect";
    private final String POINTCUT = "execution(@com.androidwind.quickaop.annotation.RequirePermission * *(..))";

    @Pointcut(POINTCUT)
    public void onRequirePermissionMethod() {
    }

    @Around("onRequirePermissionMethod() && @annotation(requirePermission)")
    public void doRequirePermissionMethod(ProceedingJoinPoint joinPoint, RequirePermission requirePermission) throws Throwable {
        FragmentActivity activity = null;
        final Object object = joinPoint.getThis();
        if (object instanceof FragmentActivity) {
            activity = (FragmentActivity) object;
        } else if (object instanceof Fragment) {
            activity = ((Fragment) object).getActivity();
        }
        if (activity == null) {
            joinPoint.proceed();
        } else {
            new RxPermissions(activity)
                    .request(requirePermission.value())
                    .subscribe(new Consumer<Boolean>() {
                        @Override
                        public void accept(Boolean granted) throws Exception {
                            if (granted) { // Always true pre-M
                                try {
                                    joinPoint.proceed();
                                } catch (Throwable throwable) {
                                    throwable.printStackTrace();
                                }
                            } else {
                                Toast.makeText(MyApplication.getApplication(), "授权失败！", Toast.LENGTH_SHORT).show();
                            }
                        }
                    });
        }
    }
}

使用方法

@RequirePermission(value = {Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE})
    public void requirePermission(View view) {
        Toast.makeText(MyApplication.getApplication(), "授权成功，继续进行", Toast.LENGTH_SHORT).show();
    }

5. 埋点

功能
添加埋点信息，用于数据统计功能。
annotation

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

    String key();

    String value();
}

aspectj

@Aspect
public class EventTrackingAspect {

    private final String TAG = "EventTrackingAspect";
    private final String POINTCUT = "execution(@com.androidwind.quickaop.library.annotation.EventTracking * *(..))";

    @Pointcut(POINTCUT)
    public void onEventTrackingMethod() {
    }

    @Around("onEventTrackingMethod() && @annotation(eventTracking)")
    public void doEventTrackingMethod(ProceedingJoinPoint joinPoint, EventTracking eventTracking) throws Throwable {

        String key = eventTracking.key();
        String value = eventTracking.value();
        SPUtils.getInstance().put(key, value);
        joinPoint.proceed();
    }
}

使用方法

@EventTracking(key = "1000", value = "埋点值1")
    public void eventTracking(View view) {
        Log.i(TAG, "this is an event tracking log, the eventTracking is " + SPUtils.getInstance().getString("1000"));
    }

6. 异步执行

功能
保证方法是通过异步方式执行，这里使用RxJava实现异步。
annotation

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

aspectj

@Aspect
public class AsynchronizeAspect {

    private final String TAG = "AsynchronizeAspect";
    private final String POINTCUT = "execution(@com.androidwind.quickaop.annotation.Asynchronize * *(..))";

    @Pointcut(POINTCUT)
    public void onAsynchronizeMethod() {
    }

    @Around("onAsynchronizeMethod()")
    public void doAsynchronizeMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
                System.out.println("[Thread Name-AsynchronizeAspect: ]" + Thread.currentThread().getName());
                try {
                    joinPoint.proceed();
                } catch (Throwable throwable) {
                    throwable.printStackTrace();
                }
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe();
    }
}

使用方法

@Asynchronize
    public void asynchronize(View view) {
        System.out.println("[Thread Name-asynchronize: ]" + Thread.currentThread().getName());
    }

7. 异常捕获

功能
捕获此方法所可能产生的异常情况，保证执行此方法不会导致app崩溃。
annotation

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

aspectj

@Aspect
public class CatchExceptionAspect {

    private final String TAG = "CatchExceptionAspect";
    private final String POINTCUT = "execution(@com.androidwind.quickaop.library.annotation.CatchException * *(..))";

    @Pointcut(POINTCUT)
    public void onCatchExceptionMethod() {
    }

    @Around("onCatchExceptionMethod()")
    public void doCatchExceptionMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        try {
            joinPoint.proceed();
        } catch (Exception e) {
            LogUtils.e(TAG, getException(e));
        }
    }

    private String getException(Throwable ex) {
        StringWriter errors = new StringWriter();
        ex.printStackTrace(new PrintWriter(errors));
        return errors.toString();
    }
}

使用方法

@CatchException
    public void catchException(View view) {
        String s = null;
        s.toString();
    }

8. Hook方法

功能
可以在执行某个方法的前和后，执行另外指定的方法。
annotation

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface HookMethod {
    String beforeMethod();

    String afterMethod();
}

aspectj

@Aspect
public class HookMethodAspect {

    private final String TAG = "HookMethodAspect";
    private final String POINTCUT = "execution(@com.androidwind.quickaop.library.annotation.HookMethod * *(..))";

    @Pointcut(POINTCUT)
    public void onHookMethodMethod() {
    }

    @Around("onHookMethodMethod()")
    public void doHookMethodMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        HookMethod hookMethod = method.getAnnotation(HookMethod.class);

        if (hookMethod == null) {
            return;
        }

        String beforeMethod = hookMethod.beforeMethod();
        String afterMethod = hookMethod.afterMethod();

        if (!StringUtils.isEmpty(beforeMethod)) {
            try {
                ReflectUtils.reflect(joinPoint.getTarget()).method(beforeMethod);
            } catch (ReflectUtils.ReflectException e) {
                e.printStackTrace();
                Log.e(TAG, "no method " + beforeMethod);
            }
        }

        joinPoint.proceed();

        if (!StringUtils.isEmpty(afterMethod)) {
            try {
                ReflectUtils.reflect(joinPoint.getTarget()).method(afterMethod);
            } catch (ReflectUtils.ReflectException e) {
                e.printStackTrace();
                Log.e(TAG, "no method " + afterMethod);
            }
        }
    }
}

使用方法

@HookMethod(beforeMethod = "beforeMethod", afterMethod = "afterMethod")
    public void hookMethod(View view) {
        Log.i(TAG, "this is a hookMethod");
    }

    private void beforeMethod() {
        Log.i(TAG, "this is a before method");
    }

    private void afterMethod() {
        Log.i(TAG, "this is an after method");
    }

9. 缓存

功能
将方法执行结果保存到缓存中，这里使用sharedpreferences。
annotation

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

    String key();
}

aspectj

@Aspect
public class CacheAspect {
    private static final String POINTCUT_METHOD = "execution(@com.androidwind.quickaop.library.annotation.Cache * *(..))";

    @Pointcut(POINTCUT_METHOD)
    public void onCacheMethod() {
    }

    @Around("onCacheMethod() && @annotation(cache)")
    public Object doCacheMethod(ProceedingJoinPoint joinPoint, Cache cache) throws Throwable {
        String key = cache.key();

        Object result = joinPoint.proceed();
        if (result instanceof String) {
            SPUtils.getInstance().put(key, (String)result);
        }

        return result;
    }
}

使用方法

@Cache(key = "name")
    public String cache(View view) {
        return "Jerry";
    }

10. Null检查

功能
对入参进行null检测。
annotation

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface NullCheck {
    int position() default 0;//the input params position
}

aspectj

@Aspect
public class NullCheckAspect {

    private final String TAG = "NullCheckAspect";
    private final String POINTCUT = "execution(@com.androidwind.quickaop.library.annotation.NullCheck * *(..))";

    @Pointcut(POINTCUT)
    public void onNullCheckMethod() {
    }

    @Around("onNullCheckMethod() && @annotation(nullCheck)")
    public void doNullCheckMethod(ProceedingJoinPoint joinPoint, NullCheck nullCheck) throws Throwable {
        int position = nullCheck.position();
        Object[] objects = joinPoint.getArgs();
        if (objects.length > 0 && position < objects.length) {
            if (!ObjectUtils.isEmpty(objects[position])) {
                joinPoint.proceed();
            }
        }
    }
}

使用方法

public void nullCheck(View view) {
        getString("Tommy", null);
    }

    @NullCheck(position = 1)
    private void getString(String name, String country) {
        Log.i(TAG, "this is after nullcheck input");
    }

11. view的控制

功能
Android UI初始化完毕后，对View的操作，这里以显示一个View布局为例。
annotation
这里需要注意ElementType选择的是TYPE，因为作用的是类。

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface AddView {
}

aspectj

@Aspect
public class AddViewAspect {
    private final String TAG = "AddViewAspect";
    private final String POINTCUT = "execution(* android.app.Activity.onCreate(..)) && within(@com.androidwind.quickaop.annotation.AddView *)";

    @After(POINTCUT)
    public void addView(JoinPoint joinPoint) throws Throwable {
        FragmentActivity activity = null;
        String signatureStr = joinPoint.getSignature().toString();
        Log.d(TAG, "[addView]" + signatureStr);
        final Object object = joinPoint.getThis();
        if (object instanceof FragmentActivity) {
            activity = (FragmentActivity) object;
            TextView tv = activity.findViewById(R.id.view);
            tv.setVisibility(View.VISIBLE);
        }
    }
  }

使用方法

@AddView
public class MainActivity extends AppCompatActivity {

    private final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, "[addView]" + "MainActivity->onCreate");
        System.out.println("[Thread Name-MainActivity: ]" + Thread.currentThread().getName());
    }
 }

12. 更改Toast信息

功能
这里我们实现拦截一个Toast信息，并且更改Toast里面的内容。
这里主要用到了aspectj的call方法。
call是在方法调用处织入代码，execution是在方法内部织入代码。
annotation
ElementType选择的也是TYPE。

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface AddView {
}

aspectj

@Aspect
public class AddViewAspect {

    private final String TAG = "AddViewAspect";
    private final String POINTCUT = "execution(* android.app.Activity.onCreate(..)) && within(@com.androidwind.quickaop.annotation.AddView *)";
    
    @Before("call(* android.widget.Toast.show())")
    public void changeToast(JoinPoint joinPoint) throws Throwable {
        Toast toast = (Toast) joinPoint.getTarget();
        toast.setText("修改后的toast");
        Log.d(TAG, "[changeToast]");
    }
}

使用方法
在一个Activity类中，这个类有AddView注释修饰。

public void toast(View view) {
        Toast.makeText(this,"原始的toast",Toast.LENGTH_SHORT).show();
    }

AOP开发问题总结

https://blog.csdn.net/ddnosh/article/details/103988614

github地址

实例代码参考工程：
https://github.com/ddnosh/QuickAOP

内容总结

以上是互联网集市为您收集整理的12个Android中使用AspectJ实现AOP的实例操作全部内容，希望文章能够帮你解决12个Android中使用AspectJ实现AOP的实例操作所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/628168.html

来源：【匿名】

首页 / ANDROID / 12个Android中使用AspectJ实现AOP的实例操作

12个Android中使用AspectJ实现AOP的实例操作

内容导读

内容图文

文章目录

AspectJ语法

AspectJ配置

AspectJ实例

1. 添加日志

2. 防止快速点击

3. 登录态检测

4. 请求权限

5. 埋点

6. 异步执行

7. 异常捕获

8. Hook方法

9. 缓存

10. Null检查

11. view的控制

12. 更改Toast信息

AOP开发问题总结

github地址

内容总结

内容备注

内容手机端

【12个Android中使用AspectJ实现AOP的实例操作】教程文章相关的互联网学习教程文章

Android Aspectj 接入 - 非组件【代码】

Android Aspectj 接入 - 非组件【代码】

12个Android中使用AspectJ实现AOP的实例操作【代码】【图】

Android AspectJ 常用埋点，拦截，监听注解使用【代码】【图】

android – React-Camera：undefined不是对象(评估’CameraManager.Aspect.fill)

Android aspectJ Aop【代码】

ANDROID - 相关标签

ASPECT - 相关标签

实例 - 相关标签

ANDROID - 最新教程

ANDROID - 最热教程