面向切面编程（aop），实现Android网络请求

最新推荐文章于 2023-11-08 15:31:33 发布
置顶 最新推荐文章于 2023-11-08 15:31:33 发布
阅读量645 收藏
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010755087/article/details/73628285
版权

        在项目中使用了百度语音功能打开sdk发现了一个面向切面的支持包(aop)。由于代码被混淆过看起来着实痛苦，通过大胆猜测和验证终于将代码复原并为我所用。aop的代码思路是通过反射执行代理对象已注册的方法，在方法前遍历所有的拦截器，通过验证拦截器的返回值判断是否执行次方法，如果执行在方法后遍历所有的拦截器。在执行网络请求之前我们要判断网络是否可用、 是否重复请求、弹出加载框、打印参数结果日志，而在这里我将它们定义为4种拦截器。

      1. NewWorkInterceptor 网络拦截器

      2. RepeatInterceptor 重复拦截器

      3. ProgressDialogInterceptor 对话框拦截器（不拦截，只加载）

      4. HttpLogInterceptor 日志拦截器（不拦截，值打印参数、结果、耗时）

代码：先贴aop代码

过滤器

public interface IInterceptor {

    /**
     * 方法执行前
     *
     * @param proxy
     * @param method
     * @param args
     * @return
     */
    Object before(Object proxy, Method method, Object[] args);

    /**
     * 方法执行后
     *
     * @param proxy
     * @param method
     * @param args
     * @param methodReturn
     * @return
     */
    Object after(Object proxy, Method method, Object[] args, Object methodReturn);
}
拦截器处理者 
public interface IInterceptorHandler extends InvocationHandler {

    /**
     * 注册多个方法
     */
    void registerMethods();

    /**
     * 注册一个方法
     * @param methodName
     */
    void registerMethod(String methodName);

    /**
     * 注销一个方法
     * @param methodName
     */
    void unregisterMethod(String methodName);

    /**
     * 是否拦截
     * @param methodName
     * @return
     */
    boolean canIntercept(String methodName);

    /**
     * 绑定
     * @param proxied
     * @param interceptors
     * @return
     */
    Object bind(Object proxied, List<IInterceptor> interceptors);
}
代理工厂 
public interface IProxyFactory<T> {

    /**
     * 创建被代理对象
     *
     * @return
     */
    T createProxied();

    /**
     * 拦截器处理对象
     *
     * @return
     */
    IInterceptorHandler createInterceptorHandler();

    /**
     * 创建拦截器集合
     *
     * @return
     */
    List<IInterceptor> createInterceptors();

    /**
     * 执行代理
     *
     * @return
     */
    T makeProxy();
}
抽象拦截器 
public abstract class AInterceptor implements IInterceptor {

    public static final String TAG = "HttpLog";

    protected List<String> methods = new ArrayList();

    public AInterceptor() {
        this.addMetodName();
    }

    @Override
    public Object before(Object proxied, Method method, Object[] args) {
        return this.isAdd(method.getName()) ? this.interceptor(proxied, method, args) : AInterceptorHandler.DEFAULT;
    }

    @Override
    public Object after(Object proxied, Method method, Object[] args, Object methodReturn) {
        return AInterceptorHandler.DEFAULT;
    }

    private boolean isAdd(String methodName) {
        return methods.contains(methodName);
    }

    protected abstract void addMetodName();

    protected abstract Object interceptor(Object proxied, Method method, Object[] args);
}
抽象拦截器处理者 
public abstract class AInterceptorHandler implements IInterceptorHandler {

    public static final Object DEFAULT = Integer.valueOf(0);
    public static final Object END = Integer.valueOf(1);
    protected List<IInterceptor> interceptors;
    protected Object proxied;
    protected List<String> methodNames = new ArrayList();

    public AInterceptorHandler() {
    }

    @Override
    public Object bind(Object proxied, List<IInterceptor> interceptors) {
        this.proxied = proxied;
        this.interceptors = interceptors;
        Class clazz = this.proxied.getClass();
        Object proxy = Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
        Log.d("AInterceptorHandler", "proxy=" + proxy);
        return proxy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        boolean canIntercept = this.canIntercept(methodName);
        if (canIntercept) {
            Object result = null;
            Object beforeResult = this.before(this.proxied, method, args);
            if (beforeResult.equals(END)) {
                return result;
            } else {
                result = method.invoke(this.proxied, args);
                Object afterResult = this.after(this.proxied, method, args, result);
                Log.d("AInterceptorHandler", "afterResult=" + afterResult);
                return result;
            }
        } else {
            return method.invoke(this.proxied, args);
        }
    }

    @Override
    public void registerMethod(String methodName) {
        if (methodName != null) {
            this.methodNames.add(methodName);
        }

    }

    @Override
    public void unregisterMethod(String methodName) {
        if (methodName != null) {
            this.methodNames.remove(methodName);
        }

    }

    @Override
    public boolean canIntercept(String methodName) {
        return this.methodNames.contains(methodName);
    }

    protected Object before(Object proxy, Method method, Object[] args) {
        Object result = DEFAULT;
        int size = this.interceptors.size();

        for (int i = 0; i < size; ++i) {
            result = this.interceptors.get(i).before(proxy, method, args);
            if (result.equals(END)) {
                return result;
            }
        }

        return result;
    }

    protected Object after(Object proxy, Method method, Object[] args, Object methodReturn) {
        Object result = DEFAULT;
        int size = this.interceptors.size();

        for (int i = size - 1; i >= 0; --i) {
            result = this.interceptors.get(i).after(proxy, method, args, methodReturn);
        }

        return result;
    }
}
下面是网络请求部分

网络拦截器

public class NetWorkInterceptor extends AInterceptor {
    @Override
    protected void addMetodName() {
        methods.add("requestPost");
        methods.add("requestGet");
    }

    @Override
    protected Object interceptor(Object proxied, Method method, Object[] args) {
        IDataProvider dataProvider = DataProviderManager.getDataProvider();
        if (dataProvider.getNetType() == NetState.NETWORN_NONE) {
            T.ToastShort("当前无网络，请检查网络设置");
            return AInterceptorHandler.END;
        }
        return AInterceptorHandler.DEFAULT;
    }
}
重复拦截器 
public class RepeatInterceptor extends AInterceptor {

    private List<String> urlList;
    private boolean interceptor;

    public RepeatInterceptor() {
        urlList = Collections.synchronizedList(new ArrayList());
    }

    @Override
    protected void addMetodName() {
        methods.add("requestPost");
        methods.add("requestGet");
    }

    @Override
    public Object before(Object proxied, Method method, Object[] args) {
        if (!Util.isEmpty(args)) {
            String url = args[0].toString();
            if (urlList.contains(url)) {
                interceptor = true;
            } else {
                interceptor = false;
                urlList.add(url);
            }
        }
        return super.before(proxied, method, args);
    }

    @Override
    protected Object interceptor(Object proxied, Method method, Object[] args) {
        String url = args[0].toString();
        if (interceptor) {
            L.d(TAG, "过滤重复请求" + url);
            return AInterceptorHandler.END;
        }
        return AInterceptorHandler.DEFAULT;
    }

    @Override
    public Object after(Object proxied, Method method, Object[] args, Object methodReturn) {
        if (!Util.isEmpty(args)) {
            String url = args[0].toString();
            urlList.remove(url);
        }
        return super.after(proxied, method, args, methodReturn);
    }
}
对话框拦截器 
public class ProgressDialogInterceptor extends AInterceptor {

    private DialogHelper mDialogHelper;
    private SimpleHttpCallback callback;

    @Override
    protected void addMetodName() {
        methods.add("requestPost");
        methods.add("requestGet");
    }

    @Override
    protected Object interceptor(Object proxied, Method method, Object[] args) {
        return AInterceptorHandler.DEFAULT;//不做拦截
    }

    @Override
    public Object before(Object proxied, Method method, Object[] args) {
        if (mDialogHelper != null) {
            mDialogHelper.showLoadingProgressDialog();
        }
        if (args[2] != null && args[2] instanceof SimpleHttpCallback) {
            callback = (SimpleHttpCallback) args[2];
        }
        return super.before(proxied, method, args);
    }

    @Override
    public Object after(Object proxied, Method method, Object[] args, Object methodReturn) {
        if (callback != null) {
            callback.addResult(new SimpleHttpCallback.IResult() {
                @Override
                public void result(String data) {
                    if (mDialogHelper != null) {
                        mDialogHelper.dismissProgressDialog();
                    }
                }
            });
        } else {
            if (mDialogHelper != null) {
                mDialogHelper.dismissProgressDialog();
            }
        }
        return super.after(proxied, method, args, methodReturn);
    }

    public void setDialogHelper(DialogHelper dialogHelper) {
        this.mDialogHelper = dialogHelper;
    }
}
日志拦截器 
public class HttpLogInterceptor extends AInterceptor {

    /**
     * 开始时间
     */
    private long beginTime;
    private SimpleHttpCallback callback;

    @Override
    protected void addMetodName() {
        methods.add("requestPost");
        methods.add("requestGet");
    }

    @Override
    protected Object interceptor(Object proxied, Method method, Object[] args) {
        return AInterceptorHandler.DEFAULT; //不做拦截
    }

    @Override
    public Object before(Object proxied, Method method, Object[] args) {
        beginTime = System.currentTimeMillis();
        if (!Util.isEmpty(args)) {

            //打印url
            L.d(TAG, "url:" + args[0].toString() + "\n");

            //打印参数
            if (args[1] != null) {
                Map<String, String> map = (Map) args[1];
                for (Map.Entry<String, String> entry : map.entrySet()) {
                L.d(TAG, "          "+entry.getKey() + " : " + entry.getValue());
                }
            }

            //请求回调
            if (args[2] != null && args[2] instanceof SimpleHttpCallback) {
                callback = (SimpleHttpCallback) args[2];
            }
        }
        return super.before(proxied, method, args);
    }

    @Override
    public Object after(Object proxied, Method method, Object[] args, Object methodReturn) {
        if (callback != null) {
            callback.addResult(new SimpleHttpCallback.IResult() {
                @Override
                public void result(String data) {
                    L.d(TAG, "result:" + data);
                    L.d(TAG, "          网络耗时 : " + (System.currentTimeMillis() - beginTime) / 1000f + " 秒 ");
                }
            });
        }
        return super.after(proxied, method, args, methodReturn);
    }
}
拦截器处理者 
public class HttpHandler extends AInterceptorHandler {
    @Override
    public void registerMethods() {
        methodNames.add("requestPost");
        methodNames.add("requestGet");
    }
}
拦截器工厂 
public class HttpFactory extends AProxyFactory<AiJuHttp> {

    private ArrayList interceptors = new ArrayList();

    private HttpHandler mHttpHandler;
    private ProgressDialogInterceptor mDialogInterceptor;

    private static volatile HttpFactory instance;

    public static HttpFactory getInstance() {
        if (instance == null) {
            synchronized (HttpFactory.class) {
                if (instance == null) {
                    instance = new HttpFactory();
                }
            }
        }
        return instance;
    }

    private HttpFactory() {
        mHttpHandler = new HttpHandler();
        mHttpHandler.registerMethods();
        mDialogInterceptor = new ProgressDialogInterceptor();

        //网络拦截
        interceptors.add(new NetWorkInterceptor());
        //重复请求拦截
        interceptors.add(new RepeatInterceptor());
        //不拦截，加入加载对话框
        interceptors.add(mDialogInterceptor);
        //不拦截，加入打印参数、返回值、耗时日志
        interceptors.add(new HttpLogInterceptor());
    }

    public void setDialogHelper(DialogHelper dialogHelper) {
        if (mDialogInterceptor != null) {
            mDialogInterceptor.setDialogHelper(dialogHelper);
        }
    }

    @Override
    public AiJuHttp createProxied() {
        return  AiJuHttpProxy.getInstance();
    }

    @Override
    public IInterceptorHandler createInterceptorHandler() {
        return mHttpHandler;
    }

    @Override
    public List<IInterceptor> createInterceptors() {
        return interceptors;
    }
}
这里有很多项目封装的类，功能大家都知道的代码就不贴出了。

DateProviderManager 项目基础信息

L 日志打印工具类

T 吐司工具类

DialogHelper 对话框工具类

AjJuHttpProxy 网络请求代理类隔离第三组件


这里贴出日志打印结果：1.url  2. 参数 3. 结果 4. 网络耗时



童心未泯佐为
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android中AOP（面向切向编程）的深入讲解
08-26
面向切面编程（AOP，Aspect Oriented Programming）在Android开发中主要用来解决代码的横切关注点，例如日志记录、性能监控、权限检查等，这些功能往往贯穿于多个类或方法之中，使得代码耦合度增加。AOP允许我们将...
Android切面编程知识点详解
08-27
Android切面编程是一种面向切面编程(AOP)的实现方式，它是解决传统面向对象编程(OOP)中高耦合性问题的有效工具。在OOP中，我们通常通过对象和模块来实现功能，但当多个模块共享相同的服务（如日志、事务管理或性能...
Android中使用AOP进行拦截统一处理功能(如网络判断)
fuzhongbin的博客
08-25 1349
Android的Kotlin中AOP切面的实现,通过这个可以实现网络判断拦截,鉴权等,通过注解完美实现多入口鉴权
安卓开发常用工具和第三方库汇总
weixin_34413065的博客
10-09 617
本文讲的是安卓开发常用工具和第三方库汇总，我的名字叫 Ryan Cooke 我在 Pinterest 的核心体验团队工作。今天在这里我会谈论各种 Android 库：它们各自的优点，缺点和其他相关知识。目的是高效地概述尽可能多的库，这样，当你遇到一个问题的时候，你知道这是不是个已经解决的问题？什么样的方案更好？同时也能帮助你避免那些陷阱。 选择正确的...
Android三方框架
最新发布
pengxiaoping66的博客
11-08 142
MVVM：因为presenter的逻辑太复杂，使用View-Model代替presenter，将“数据模型数据双向绑定”的思想作为核心，因此在View和Model之间没有联系，通过ViewModel进行交互，而且Model和ViewModel之间的交互是双向的，因此视图的数据的变化会同时修改数据源，而数据源数据的变化也会立即反应到View上。socket自动选择最好路线，并支持自动重连，拥有自动维护的socket连接池，减少握手次数，减少了请求延迟，共享Socket,减少对服务器的请求次数。
spring boot 拦截器实现拦截前端请求并返回json至前端页面
热门推荐
欲为诸佛龙象，先为牛马众生
09-06 2万+
拦截器主体 import com.alibaba.fastjson.JSONObject; import com.ufclub.vis.constant.StatusConstant; import com.ufclub.vis.entity.BaseResult; import com.ufclub.vis.entity.admin.order.OrderInfo; import com.u...
使用拦截器和redis+token实现防重复提交完整代码
qq_41358574的博客
11-18 1622
文章目录redis配置：自定义一个注解：自定义类继承HandlerInterceptormvc添加刚刚自定义的拦截器使之生效tokenservicecontroller redis配置： # redis spring.redis.host=47.101.210.219 spring.redis.port=6379 spring.redis.timeout=0 <dependency> <groupId>org.springframework.boo
Android基于注解的6.0权限动态请求框架详解
08-27
JPermission是一个轻量级的框架，它利用了AspectJ库实现面向切面编程（AOP），允许开发者通过在方法上添加注解来请求权限。以下是对这个框架的详细介绍： 1. **注解使用**： - 在需要请求权限的方法上添加`@...
基于SSH的Android客户端与服务器端的数据交互.pdf
09-21
Spring框架是整个应用的容器，提供依赖注入（DI）和面向切面编程（AOP），用于管理对象和事务，同时也整合了Struts2和Hibernate，使整个应用的结构更加清晰和模块化。 在基于SSH的Android数据交互中，服务器端通常...
AOP在Android中的使用
02-23
一个可以在Andorid项目中使用AOP技术的Demo。
SpringMVC学习篇(十)
SSS4362的博客
11-18 360
springmvc拦截器之重复提交
Android AOP 之 AspectJ 统一处理网络检测
louisgeek的专栏
03-19 275
利用 AOP 之 Eclipse AspectJ //采用 AspectJX 来快速配置 Eclipse AspectJ //project gradle dependencies { classpath "com.android.tools.build:gradle:4.1.2" //add classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.10' } plugins {
java springboot 重复提交，笔记
cscscssjsp的博客
10-12 165
基于注解实现，也可以把注解去掉，直接aop全局使用 1.RepeatAnnotation.java package com.repeat.annotation; import java.lang.annotation.*; import java.util.concurrent.TimeUnit; /** * @author */ @Target(ElementType.METHO...
springmvc中的interceptor配置
tongyimplin的专栏
12-16 477
在尝试过多方配置无效的情况下可以试试如下 配置 #拦击器，继承自HandlerInterceptor #配置将已有的RequestMappingHandlerMapping重新生成一个，并为其赋值拦截器
Spring Boot第六弹，拦截器如何配置，看这儿~
码猿技术专栏
10-06 234
持续原创输出，点击上方蓝字关注我吧目录前言Spring Boot 版本什么是拦截器？如何自定义一个拦截器？如何使其在Spring Boot中生效？举个栗子思路根据什么判断这个接口已经请求...
Xposed hook Android的http请求
weixin_35756892的博客
02-10 597
Xposed 是一个 Android 平台上的模块化框架，它可以用来对系统进行修改和扩展。如果你想 hook Android 的 http 请求，可以使用 Xposed 框架来实现。具体步骤如下： 安装 Xposed 框架：首先你需要安装 Xposed 框架，并且确保你的设备已经获得了 root 权限。 安装 Xposed 模块：接下来你需要安装一个 Xposed 模块，该模块支持 hook ...
AOP面向切面编程是怎么实现的？
06-09
AOP（面向切面编程）的实现主要依赖于代理技术，通常有两种代理方式：静态代理和动态代理。 静态代理是通过手动编写代理类来实现的，代理类和目标类都要实现同一个接口，代理类中持有一个目标类的引用，在代理类中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值