Java动态代理之实践

最新推荐文章于 2023-08-26 23:58:41 发布
最新推荐文章于 2023-08-26 23:58:41 发布
阅读量389 收藏
点赞数 1
分类专栏： Java 设计模式 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sted_zxz/article/details/77170328
版权

动态代理实现方式

Java中的动态代理给我们提供一种动态生成类的方式，有很好的灵活性，这种技术一般会出现在一些第三方框架中，来降低接入方的使用成本。以下为常用的实现动态代理的几种方式：

1.JDK自带的Proxy方式
优点：JDK亲儿子，无依赖，使用简单。
缺点：代理类必须继承至少一个接口，无法继承已有父类。

2.asm方式，基于class字节码的操作
优点：很底层到操作，性能高，对性能要求苛刻的建议使用。
​缺点：使用成本高，要熟悉JVM汇编指令。

3.javassist方式，基于class字节码的操作
优点：Api简单，通熟易懂，使用成本低。
缺点：性能相对偏低。

4.cglib方式，这个是基于ASM的
​优点：Api简单，高性能，高灵活性，支持继承父类，可以不用实现接口。
缺点：这个真的很强大，个人感觉比JDK自带的要强大很多，一定要说的话只能说使用这个需要加jar包依赖。

本文就介绍最常用的JDK自带的Proxy方式。

非动态代理模式处理业务问题

User，一个表示用户信息的类：

public class User {
    public String userName;
    public String sex;
    public String address;

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

NetWorkHelper，一个处理网络请求(这里只是模拟)的类：

private static final Gson sGson = new Gson();

    public static String request(String url, Map<String, Object> params) {
        if (params != null) {
            if ("ting说你跳".equals(params.get("username"))
                    && "123456".equals(params.get("password"))) {

                User user = new User();
                user.address = "上海";
                user.sex = "男";
                user.userName = "ting说你跳";
                return sGson.toJson(user);
            }
        }
        return null;
    }

这里我们模拟一个简单的网络请求。
当我们业务场景需要调用网络请求执行登录操作的时候，会这样写：

private static final String API_LOGIN = "http://tsnt.dynamicproxy.com";

    private static final Gson   sGson     = new Gson();

    public static User login(String username, String password) {
        Map<String, Object> params = new HashMap<>();
        params.put("username", username);
        params.put("password", password);
        String response = NetWorkHelper.request(API_LOGIN, params);
        //注，这里只是为了举例说明一下，就假设此时的数据结构就是跟User一致的
        return sGson.fromJson(response, User.class);
    }

那么，有什么问题呢。其实如果只是一个单单的login方法很难直观的反馈出来问题所在，很多时候我们为了去验证一个事物的合理性我们不妨去开始极端遐想一下这种情况：现在UserApi中又多了register方法，query方法，getToken方法，validate方法……甚至接下来一个UserApi已经满足不了我们了，我们开始有GoodsApi，OrderApi，MessageApi等等等等，试想一下N个Api的类，每个Api类都有N个类似于上面login的这种方法，而实际情况下我们request的入参还远远不止username，password两个这么简单。当我们业务场景扩大的时候，这些都是我们势必要面对的。这是一个问题，那能不能去以一种更优雅的方式去解决从而简化业务方的代码量并且降低使用成本呢。这里便引入了我们的动态代理。

动态代理模式处理业务问题

我们的目标是状态是这样的：让业务方写写接口，加注解配置，就可以直接使用。代码量少，简洁明了，方便使用。
因为下面内容会涉及到到注解和反射，如果不清楚注解和反射的同学建议先看一下这两篇文章：
1.Java反射
2.Java注解

定义两个支持配置的注解

@Inherited
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface URL {
    String value();
}
@Inherited
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@interface Param {
    String value();
}

这里不过多说明，就是两个可配字符串的注解。

定义一套接口和实现类：

网络请求的接口 ：

public interface IRequest {

    String url();

    Map<String, Object> params();

    Class<?> responseCls();
}

网络请求的实现类：

public class Request implements IRequest {
    String              url;
    Map<String, Object> params;
    Class<?>            responseCls;

    public Request(String url, Map<String, Object> params, Class<?> responseCls) {
        this.url = url;
        this.params = params;
        this.responseCls = responseCls;
    }

    @Override
    public String url() {
        return url;
    }

    @Override
    public Map<String, Object> params() {
        return params;
    }

    @Override
    public Class<?> responseCls() {
        return responseCls;
    }
}

执行网络请求的接口:

public interface INetExecutor {

    <T> T execute(IRequest request);
}

执行网络请求的实现类:

public class DefaultNetExecutor implements INetExecutor {

    private static final Gson sGson = new Gson();

    @Override
    public <T> T execute(IRequest request) {
        String response = NetWorkHelper.request(request.url(), request.params());
        return (T) sGson.fromJson(response, request.responseCls());
    }
}

以上的执行网络请求的实现类已经有默认的实现方式（使用上面的NetWorkHelper），主要是抽象出接口可以让业务方自主定制真正的执行操作。

动态代理器

public class ApiGenerator {

    private static final Map<Class, Object> sApiCache = new HashMap<>();

    private static INetExecutor sNetExecutor;

    private static class Handler<T> implements InvocationHandler {

        private Class<T> apiInterface;

        public Handler(Class<T> apiInterface) {
            this.apiInterface = apiInterface;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            IRequest request = resolveRequest(method, args, apiInterface);
            if (sNetExecutor == null) {
                sNetExecutor = defaultNetExecutor();
            }
            return sNetExecutor.execute(request);
        }
    }

    private static INetExecutor defaultNetExecutor() {
        return new DefaultNetExecutor();
    }

    private static <T> IRequest resolveRequest(Method method, Object[] args, Class<T> apiInterface) {
        StringBuilder urlBuilder = new StringBuilder();
        Map<String, Object> params = null;
        if (apiInterface.isAnnotationPresent(URL.class)) {
            String baseUrl = apiInterface.getAnnotation(URL.class).value();
            if (!TextUtils.isEmpty(baseUrl)) {
                urlBuilder.append(baseUrl);
            }
        }
        if (method.isAnnotationPresent(URL.class)) {
            String subUrl = method.getAnnotation(URL.class).value();
            if (!TextUtils.isEmpty(subUrl)) {
                urlBuilder.append(subUrl);
            }
        }
        int index = 0;
        for (Annotation[] annotations : method.getParameterAnnotations()) {
            for (Annotation annotation : annotations) {
                if (annotation instanceof Param) {
                    String key = ((Param) annotation).value();
                    if (!TextUtils.isEmpty(key)) {
                        if (params == null) {
                            params = new HashMap<>();
                        }
                        params.put(key, args[index]);
                    }
                    break;
                }
            }
            index++;
        }
        return new Request(urlBuilder.toString(), params, method.getReturnType());
    }

    public static <T> T generateApi(Class<T> apiInterface) {
        if (apiInterface == null || !apiInterface.isInterface()) {
            throw new RuntimeException("the apiInterface is null or isn't interface.");
        }
        synchronized (ApiGenerator.class) {
            Object api = sApiCache.get(apiInterface);
            if (api == null) {
                api = Proxy.newProxyInstance(apiInterface.getClassLoader(),
                        new Class[]{apiInterface},
                        new Handler(apiInterface));
                sApiCache.put(apiInterface, api);
            }
            return (T) api;
        }
    }

    /**
     * 外部提供自定义执行器
     *
     * @param netExecutor 网络执行器
     */
    public static void setNetExecutor(INetExecutor netExecutor) {
        sNetExecutor = netExecutor;
    }
}

到此，我们的动态代理的编码部分就结束了。我们可以看一下ApiGenerator这个类有个sApiCache的静态变量，他缓存了动态代理生成的对象，这里这样做还是很有必要的，防止重复创建Api的代理类造成额外的性能消耗。

使用

业务方只需要按照我们约束的一套标准来写一个interface即可：

@URL("http://tsnt.dynamicproxy.com")
public interface LoginApi {
    User login(@Param("username") String username,
               @Param("password") String password);
}

这个是业务方要写的接口，以及对应的一些注解配置。接下来就可以直接使用LoginApi生成的具体实例了：

public class MainActivity extends AppCompatActivity {

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

    private void initView() {
        findViewById(R.id.login).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                login();
            }
        });
    }

    private void login() {
        LoginApi loginApi = ApiGenerator.generateApi(LoginApi.class);
        User user = loginApi.login("123", "456");
        Toast.makeText(MainActivity.this, user.toString(), Toast.LENGTH_SHORT).show();
    }
}

由于此处模拟的网络请求，就不考虑主线程的进行这个操作了。

使用对比

这里我再贴一下两种使用前后的代码对比。
传统的方式：

public class UserApi {
    private static final String API_LOGIN = "http://tsnt.dynamicproxy.com";

    private static final Gson   sGson     = new Gson();

    public static User login(String username, String password) {
        Map<String, Object> params = new HashMap<>();
        params.put("username", username);
        params.put("password", password);
        String response = NetWorkHelper.request(API_LOGIN, params);
        //注，这里只是为了举例说明一下，就假设此时的数据结构就是跟User一致的
        return sGson.fromJson(response, User.class);
    }
}

使用动态代理：

@URL("http://tsnt.dynamicproxy.com")
public interface LoginApi {
    User login(@Param("username") String username,
               @Param("password") String password);
}

对比一下，明显能感觉到代码比之前精简了一大圈，看上去清晰明了。当业务逐渐扩大的时候，这两种模式下，无论是开发效率上还是代码精简度上根本不具有可比性。

以上就是Java动态代理的实践。

代码地址：https://github.com/tingshuonitiao/DynamicProxy_practice

ting说你跳
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java反射机制和动态代理
12-22
主要讲述Java反射机制与设计模式之一：代理模式的原理与应用；同时详细讲述了Java对代理模式的支持以及Java中动态代理的原理，应用与实践。
Java理论与实践：用动态代理进行修饰
12-22
简介：动态代理工具 是 java.lang.reflect 包的一部分，在 JDK 1.3 版本中添加到 JDK，它允许程序创建 代理对象，代理对象能实现一个或多个已知接口，并用反射代替内置的虚方法分派，编程地分派对接口方法的调用。...
Java之动态代理实践
csy_insist的博客
08-26 217
Java的动态代理，是代理模式的具体实现，即为其他对象提供一个代理以控制对某个对象的访问。Java的动态代理主要涉及两个类：java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler，内部使用了缓存机制和反射机制实现。
java 中的动态代理实现
qq_38217393的博客
06-02 878
相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。代理模式是常见的设计模式之一，顾名思义，代理模式就是代理对象具备真实对象的功能，并代替真实对象完成相应操作，并能够在操作执行的前后，对操作进行增强处理。代理模式就是为其他对象提供一种代理来控制这个对象的访问，在某些情况下一个对象不适合或不能直接引用另一个对象，而代理对象可以在客户类和目标对象直接起到中介的作用。这时，可以在a和c之间创建一个b类代理，a类访问b类，b类访问c类。生成的代理类源码方法。
Java中动态代理的实现方式
qq_39939541的博客
07-29 749
动态代理（Dynamic Proxy）是一种在运行时创建代理对象的机制，它允许我们在不事先知道具体类型的情况下，通过代理对象来调用目标对象的方法。动态代理通常使用在面向对象编程中的AOP（面向切面编程）中，用于在目标对象的方法执行前后，添加一些额外的逻辑（如日志记录、性能监控、事务管理等），而不需要修改目标对象的源代码。
【java】java动态代理实现与原理详细分析
DreamSun的博客
03-12 805
生成的代理类：$Proxy0 extends Proxy implements Person，我们看到代理类继承了Proxy类，所以也就决定了java动态代理只能对接口进行代理，Java的继承机制注定了这些动态代理类们无法实现对class的动态代理。上面的动态代理的例子，其实就是AOP的一个简单实现了，在目标对象的方法执行之前和执行之后进行了处理，对方法耗时统计。Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。
静态代理和jdk动态代理
qq_45718545的博客
08-25 250
当一个对象不能直接使用，可以在客户端和目标对象直接创建一个中介，这个中介就是代理。代理模式的作用：1.功能的增强：在你原有的功能上，增加了额外的功能2.控制访问：代理类不让你访问目标，例如商家不让用户访问厂家代理类是自己手工实现的，自己创建一个Java类，代表代理类案例：模拟一个用户购买U盘的行为用户是客户端商家：代理，代表某个品牌的U盘厂家：目标类商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。
java动态代理项目实践优化(3)
08-31
java动态代理项目实践优化(3)
java动态代理项目实践优化 (1)
08-31
java动态代理项目实践优化_(1)
java动态代理项目实践优化(2)
08-31
java动态代理项目实践优化(2)
Java中实现动态代理5种实现
austinlyway的博客
02-15 3051
Java动态代理的5中实现
最全介绍的代理模式---第二节-JDK 动态代理
qq_39743001的博客
12-20 536
JDK 动态代理模式
记一次Java动态代理实践
weixin_45583158的博客
04-25 136
导语：在Java生态中，我们经常直接或者间接的用到动态代理，比如通过动态代理调用远程服务，再比如通过动态代理实现解耦。本文结合京东服务框架JSF，讲述京东使用动态代理进行...
java 代理之动态代理实践
yangfenggh的博客
01-25 489
JDk动态代理实践 模拟JDK动态代理(手写代码) java代理之静态代理实践（一）
代理模式之动态代理实践
刘玉杰 点滴之笔
09-13 1419
在前一篇博客中讲解了一些代理模式的基础知识，是否还记得它们的分类：静态代理和动态代理。那么它们到底怎么用呢？接下来就结合实战来体验一下动态代理的奥妙。 一、背景         在drp实现FlowCardManagerImpl的时候，刚开始每个方法的实现都有打开-提交-回滚-关闭事务的流程，但是Manager层的作用是实现业务逻辑，和事务的实现没有必然的联系，并且都是重复的代码。所以这里明
JDK动态代理的实践
anLA_的专栏
08-10 440
动态代理在各大框架中用的十分的频繁， 本文主要介绍通过JDK来实现动态代理的机制。 对代理不理解？ 可以参看我的设计模式这一篇：代理模式-让替身帮你区干事 我们需要完成下面几个步骤： 1、编写服务类和接口，这个是真正的服务提供商，在JDK代理中，接口是必须的。 2、编写代理类，提供绑定和代理方法。 具体代码： 首先一个接口类HelloService类： package s
关于动态代理的一点体会
baidu_35249394的博客
06-29 291
代理模式是Java设计模式中的一种，其特征为代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现业务，而是通过调用委托类对象的相关方法来提供具体业务。在Java中的java.lang.reflect包下提供了一个Proxy类和一个Inv...
CgLib动态代理初步实践
anLA_的专栏
08-10 482
上面一篇主要讲了jdk提供的实现动态代理的方法， 本文主要接着上文给出了cglib动态代理基本写法。 传送门：JDK动态代理实践 里面共有2个新家的类，一个是用于实现invocationhandler（注意导包或者maven） package study.JDKProxy; import java.lang.reflect.Method; import net.sf.cglib
实践一下动态代理
苏云南雁的博客
05-05 250
Java实现动态代理涉及Proxy和InvocationHandler两个类。 此处的代码想要模范AOP的日志模块 LogIntercepter.java public class LogIntercepter { Object obj; //被代理的目标 public Object getObj() { return obj; } public void setObj
anylogic中编写java代码
最新发布
10-16
- 代码应遵循Java的编码规范和最佳实践。 - 应尽量使用AnyLogic提供的内置函数和特性，以便与模型的其他部分保持一致。 - 可以使用AnyLogic的模型库中的代码示例和文档来了解如何编写特定功能的代码。 总之，通过在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值