Java泛型详解 —— 出参入参绑定技巧

原创 已于 2025-06-18 10:49:39 修改 · 1.1k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

于 2025-05-21 17:47:36 首次发布

1. 泛型出参入参绑定

公司 p8 大佬给我出了一道题：我希望执行 execute() 方法之后，不同的调用方能够返回不同的响应结果，并且 execute()方法内部是没有任何实现的。例如：RequestA 调用方法后会返回 ResponseA，RequestB 调用方法后会返回 ResponseB

那具体应该如何实现呢？我们首先想到的肯定是需要通过泛型来建立 Request 和 Response 之间的联系，那这个泛型类型应该如何写呢？

代码：

  1. 定义 execute 泛型方法
public class Actuator {
    // 泛型方法
    public static <T> T execute(Request<T> req) {
        return null;
    }
}

我们定义了一个泛型方法 execute，这个方法巧妙的地方在于形参接收一个 Request，返回值是 Request 的泛型参数

🤔 思考：这里不用泛型方法可以吗？

那肯定是不可以的，原因有两点：

  1. Actuator 不是泛型类，这种使用场景下肯定是不希望把 Actuator 声明成泛型类的，不然执行一次 execute 方法就要 new 一个对应类型的 Actuator 实例
  2. execute 方法是一个静态方法，就算 Actuator 是泛型类，静态方法也是不可以使用泛型类中的泛型参数的

  1. 定义 Request 抽象类
/**
 * @Description TODO
 * @Author Mr.Zhang
 * @Date 2025/4/24 22:10
 * @Version 1.0
 */
public abstract class Request<T> {
    
}

因为将来不同的 Request 实现类都会调用同一个 execute 方法，所以为了代码的复用性，抽取一个 Request 抽象类来当作 execute 方法的入参

  1. 定义 RequestA、RequestB 实现类
/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/4/25 09:15
 * @Description:
 * @Version: 1.0
 */
public class RequestA extends Request<ResponseA> {
}


/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/4/25 09:16
 * @Description:
 * @Version: 1.0
 */
public class RequestB extends Request<ResponseB> {
}

不同的实现类指定不同的泛型参数

  1. 定义 ResponseA、ResponseB
@Data
public class ResponseA {
}

@Data
public class ResponseB {
}

  1. 测试是否成功
public static void main(String[] args) {
    RequestA requestA = new RequestA();
    RequestB requestB = new RequestB();

    ResponseA responseA = execute(requestA);
    ResponseB responseB = execute(requestB);
}

我们发现，泛型成功转换了！

那这个知识点学了有什么用呢？一开始博主也对其使用场景百思不得其解。直到在一次偶然的机会看到了拼多多和京东的对外 SDK 包源码，我发现了这种用法的使用场景：出参入参绑定配合统一入口方法实现统一入口规范

2. 实际使用案例

最近在阅读拼多多和京东的 SDK 源码的时候，发现它们都不约而同的使用到了 泛型出参入参绑定 结合 统一入口方法 的方式来实现客户端 client 和服务端

我们发现他们在定义方法入参的时候都指定了对应接口的出参。我在深入分析后，才发现了这样设计的独到之处

2.1. 使用场景

在介绍代码实现之前，先说一下出参入参绑定这种方式的使用场景：

  1. 把需要对外发布的接口封装成一个 SDK，给外部系统调用（主要使用场景）
  2. 调用外部系统接口，但是外部系统没有提供 SDK，只提供了入参和出参的定义

注：出参入参绑定这种方式只有这两种使用场景！

2.2. 实际案例

我们以需求带入场景，通过代码带大家深入体会在这两种使用场景下使用出参入参绑定的效果

需求如下：

假设现在有两个接口，分别是商品详情接口和商品列表接口

  1. 如果以上两个接口是我们内部需要提供的对外接口，我们应该如何实现对外提供服务的 SDK？
  2. 如果以上两个接口是外部系统提供好的，我们需要调用应该如何实现？
代码实现

以上两种使用场景在代码实现上完全一致，此处以我们平常接触最多的调用第三方接口的场景为例

如果是我们调用外部系统提供好的接口，并且外部系统只提供了入参和出参的定义，需要我们自己实现调用方法

a. 常规实现
  1. 首先我们需要定义商品详情接口和商品列表接口的请求参数和响应参数
/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/16 23:44
 * @Description: 商品详情请求类
 * @Version: 1.0
 */
@Data
public class GoodsDetailRequest {

    /**
     * 商品 ID
     */
    private String goodsId;
}


/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/16 23:45
 * @Description: 商品详情响应类
 * @Version: 1.0
 */
@Data
public class GoodsDetailResponse implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * 商品 ID
     */
    private String goodsId;

    /**
     * 商品编码
     */
    private String goodsCode;

    /**
     * 商品价格
     */
    private String goodsPrice;

    /**
     * 商品名称
     */
    private String goodsName;

    /**
     * 商品描述
     */
    private String goodsDesc;

    /**
     * 商品图片
     */
    private String goodsImg;
}
/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/16 23:54
 * @Description:
 * @Version: 1.0
 */
@Data
public class GoodsListRequest implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * 商品 ID 列表
     */
    private List<String> goodsIds;

    /**
     * 商品名称
     */
    private String goodsName;

}


/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/16 23:58
 * @Description:
 * @Version: 1.0
 */
@Data
public class GoodsListResponse implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * 商品列表
     */
    private List<GoodsItem> goodsList;


    class GoodsItem implements Serializable {
        /**
         * 商品 ID
         */
        private String goodsId;

        /**
         * 商品编码
         */
        private String goodsCode;

        /**
         * 商品价格
         */
        private String goodsPrice;

        /**
         * 商品名称
         */
        private String goodsName;

        /**
         * 商品描述
         */
        private String goodsDesc;

        /**
         * 商品图片
         */
        private String goodsImg;
    }
}
  1. 定义 Client，接收不同接口响应数据
@Service
@AllArgsConstructor
public class Client {

    /**
     * 此处这个方法的作用是外部系统开放给我们的请求接口.通过传参到这个接口拿到返回回来的响应
     * <p>
     * TODO 需要注意的是: 通过 URL 调用到外部系统时,由于涉及到网络传输,需要将返回结果序列化为 JSON 字符串返回调用方
     *
     * @param body
     * @return
     */
    private String postRequest(String body) {
        return HttpUtil.createPost("http://localhost:8080/api").body(body).execute().body();
    }


    /**
     * 获取商品列表
     *
     * @param request
     * @return
     */
    public GoodsListResponse getGoodsList(GoodsListRequest request) {
        String result = postRequest(JSONUtil.toJsonStr(request));
        return JSONUtil.toBean(result, GoodsListResponse.class);
    }

    /**
     * 获取商品详情
     *
     * @param request
     * @return
     */
    public GoodsDetailResponse getGoodsDetail(GoodsDetailRequest request) {
        String result = postRequest(JSONUtil.toJsonStr(request));
        return JSONUtil.toBean(result, GoodsDetailResponse.class);
    }
}
  1. 测试
/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/17 00:27
 * @Description:
 * @Version: 1.0
 */
public class Main {

    /**
     * 常规实现 
     *
     * @param args
     */
    public static void main(String[] args) {
        Client client = new Client();

        GoodsListRequest goodsListRequest = new GoodsListRequest();
        GoodsListResponse goodsListResponse = client.getGoodsList(goodsListRequest);
        System.out.println(goodsListResponse);

        GoodsDetailRequest goodsDetailRequest = new GoodsDetailRequest();
        GoodsDetailResponse goodsDetailResponse = client.getGoodsDetail(goodsDetailRequest);
        System.out.println(goodsDetailResponse);
    }
}

这种实现方式看起来并没有什么问题，也是我们平常最常使用的，但仔细想想这种实现方式有什么弊端呢？

  • 不够灵活：当前只有两个接口还好。但假设需要调用外部系统的一百个接口，那岂不是意味着我们需要在 Client 类中写一百个不同的方法来对应不同的接口，且这些方法都是千篇一律的调用同一个 postRequest()方法，以及将响应数据解析成对应的返回结果对象返回。这样的实现方式显然不好，大致相同的实现逻辑却要一直重复写。太不优雅了！

b. 出参入参绑定实现

那为了优雅且方便的实现对接外部系统的众多接口，我们不妨学习拼多多和京东的做法，使用出参入参绑定的方式来优雅实现

  1. 定义基类请求类，通过泛型实现出参入参绑定
/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/17 18:08
 * @Description: 请求基类
 * @Version: 1.0
 */
public abstract class BaseRequest<T extends BaseResponse> {

    /**
     * 请求方法名

     TODO methodName 参数的作用是通过统一方法调用的时候,告诉服务提供方自己要调用的是哪个方法
     */
    private String methodName;

    public abstract Class<T>  getResponseType();
}
  1. 定义基类响应类
/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/17 18:08
 * @Description: 响应基类
 * @Version: 1.0
 */
@Data
public abstract class BaseResponse implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * 响应码
     */
    private String code;

    /**
     * 响应信息
     */
    private String message;
}
  1. 定义商品详情接口和商品列表接口的请求类和响应类，分别实现基类请求类和基类响应类
/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/17 18:14
 * @Description:
 * @Version: 1.0
 */
@Data
public class GoodsDetailRequest extends BaseRequest<GoodsDetailResponse> {

    /**
     * 商品 ID
     */
    private String goodsId;

    @Override
    public Class<GoodsDetailResponse> getResponseType() {
        return GoodsDetailResponse.class;
    }
}

/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/17 18:14
 * @Description:
 * @Version: 1.0
 */
@Data
public class GoodsDetailResponse extends BaseResponse {

    /**
     * 商品 ID
     */
    private String goodsId;

    /**
     * 商品编码
     */
    private String goodsCode;

    /**
     * 商品价格
     */
    private String goodsPrice;

    /**
     * 商品名称
     */
    private String goodsName;

    /**
     * 商品描述
     */
    private String goodsDesc;

    /**
     * 商品图片
     */
    private String goodsImg;
}


/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/17 18:17
 * @Description:
 * @Version: 1.0
 */
@Data
public class GoodsListRequest extends BaseRequest<GoodsListResponse> {

    /**
     * 商品 ID 列表
     */
    private List<String> goodsIds;

    /**
     * 商品名称
     */
    private String goodsName;

    @Override
    public Class<GoodsListResponse> getResponseType() {
        return GoodsListResponse.class;
    }
}


/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/16 23:58
 * @Description:
 * @Version: 1.0
 */
@Data
public class GoodsListResponse extends BaseResponse {

    /**
     * 商品列表
     */
    private List<GoodsItem> goodsList;


    class GoodsItem implements Serializable {
        /**
         * 商品 ID
         */
        private String goodsId;

        /**
         * 商品编码
         */
        private String goodsCode;

        /**
         * 商品价格
         */
        private String goodsPrice;

        /**
         * 商品名称
         */
        private String goodsName;

        /**
         * 商品描述
         */
        private String goodsDesc;

        /**
         * 商品图片
         */
        private String goodsImg;
    }
}
  1. 定义 client 类，通过 execute() 方法接收不同接口的响应参数
/**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/17 18:19
 * @Description:
 * @Version: 1.0
 */
@Service
@AllArgsConstructor
public class Client {

    /**
     * 此处这个方法的作用是外部系统开放给我们的请求接口.通过传参到这个接口拿到返回回来的响应
     * <p>
     * TODO 需要注意的是: 通过 URL 调用到外部系统时,由于涉及到网络传输,需要将返回结果序列化为 JSON 字符串返回调用方
     *
     * @param body
     * @return
     */
    private String postRequest(String body) {
        return HttpUtil.createPost("http://localhost:8080/api").body(body).execute().body();
    }

    /**
     * 统一执行方法,外部系统开放给我们的所有 API 接口,都可以通过这一个方法实现调用.提高了代码优雅以及降低了冗余性
     *
     * @param request
     * @return
     * @param <T>
     */
    public <T extends BaseResponse> T execute(BaseRequest<T> request) {
        // TODO 从服务端接收到的结果会序列化为 JSON 字符串
        String result = postRequest(JSONUtil.toJsonStr(request));
        return JSONUtil.toBean(result, request.getResponseType());
    }
}
  1. 测试
 /**
 * @Author: ZhangGongMing
 * @CreateTime: 2025/5/18 21:34
 * @Description:
 * @Version: 1.0
 */
public class Main {
    
    public static void main(String[] args) {
        Client client = new Client();
        
        GoodsDetailRequest goodsDetailRequest = new GoodsDetailRequest();
        GoodsDetailResponse goodsDetailResponse = client.execute(goodsDetailRequest);
        System.out.println(goodsDetailResponse.toString());

        GoodsListRequest goodsListRequest = new GoodsListRequest();
        GoodsListResponse goodsListResponse = client.execute(goodsListRequest);
        System.out.println(goodsListResponse.toString());
        
    }
}

通过对比常规实现中，我们使用出参入参绑定的这种方式的好处是显而易见的

  • 无论外部系统给我们开放多少个 API 接口，我们都只需要通过一个execute()方法即可。只需要在定义请求类的时候把对应的响应类绑定下即可。这种实现既方便维护，提高代码质量又极其优雅！
  • 后期如果需要新增对外接口，这个客户端类的代码是完全不用动的，不需要改动原来的业务逻辑，只需要再定义新的接口的入参和出参就可以！这样也符合 Java 的开闭原则：即对扩展开放，对修改关闭
2.3. 深入点

不知道大家有没有疑惑，我明明在前面有提到 统一入口方法 ，为什么一直没有体现呢？

  • 大家需要注意的是，无论是哪种使用场景，无论是我们自己封装的 SDK 还是调用外部系统的 API 接口。我们都相当于客户端。而出参入参绑定正是用于客户端的优化技术
  • 而统一入口方法实际上是用于服务端的优化手段。通过统一入口方法可以让调用方在只知道一个 URL 路径的前提下，配合方法参数就可以实现自动调用不同的视线方法
    • 不知道大家有没有注意到，在我的 BaseRequest 基类中有一个 methodName 属性。这个属性就是用来标记不同的视线方法的。例如需要查询商品详情的时候，methodName 就可以赋值为 getGoodsDetail。这样通过服务端那边的技术实现就可以找到对应的实现方法

此处为语雀内容卡片，点击链接查看：统一入口方法 · 语雀

有想要具体了解服务端的优化技术：统一入口方法。可以看我这篇博客~

最后送一句阿里 P8 大佬的话给大家：

RPC框架的本质就是：屏蔽调用目标的差异，屏蔽中间步骤序列化和反序列化差异

java中入参和出参使用泛型实例
gb4215287的博客
09-30 829
java中入参和出参使用泛型实例
夯实JAVA基本之一——泛型详解(2)：高级进阶
热门推荐
启舰
11-17 2万+
前言：被温水煮惯了，梦想的东西总是不敢于尝试，失败了又怎样，最多从头来过。 相关文章： 1、《夯实JAVA基本之一 —— 泛型详解(1):基本使用》 2、《夯实JAVA基本之一——泛型详解(2)：高级进阶》 3、《夯实JAVA基本之二 —— 反射（1）：基本类周边信息获取》 4、《夯实JAVA基本之二 —— 反射（2）：泛型相关周边信息获取》 5、《夯实JAVA基本之二 —— ...
4.1核心库（泛型）
weixin_43363689的博客
10-08 306
泛型 概述 泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 使用 泛型类 定义一个泛型类： public class ClassName<T>{ private T data; public T getData() { return data; } public void setData(T data) { this.data = data; }
java中入参_JAVA传参
weixin_27009347的博客
02-28 2534
概述java中的参数传递问题可以根据参数的类型大致可以分为三类：传递基本类型，传递String类型，传递引用类型，至于最终是否可以归纳为值传递和引用传递，根据每个人的理解不同，答案不同，此处不做强调。传递基本类型public class Test1 {public static void main(String[] args) {int n = 3;System.out.println("Befo...
Java 泛型 方法入参
weixin_41013875的博客
07-07 844
Java 泛型方法入参 在Java中，泛型是一种编程技术，用于让类或方法能够接受任意类型的数据。泛型方法是指定义在类中的一个方法，具有一个或多个泛型类型参数。 泛型方法的定义 泛型方法的定义方式如下： 登录后复制 public <T> void methodName(T param) { // 方法体...
java对象、数组作为函数的入参和出参
听海边涛声
08-01 910
java对象、数组作为函数的入参和出参
Java泛型详解：集合中的类型安全与使用规范
这种类型绑定发生在编译期而非运行期，体现了泛型的“擦除”机制——即泛型信息在编译完成后会被擦除，JVM实际执行时并不知晓泛型的存在，这也是Java泛型实现向后兼容的关键所在。尽管存在类型擦除带来的限制（如...
Java基础核心技术：多线程、反射与泛型详解
首先从**Java基础**来看，虽然标题未明确列出“面向对象”、“集合框架”或“异常处理”等内容，但从所提供的文档如《Java泛型.doc》和《java反射机制详解与应用.docx》可以推断，这些内容是构建整个知识体系的前提...
Java泛型源码解析与实现详解
结合标签列表——包括“Java泛型”、“源码解析”、“泛型类”、“类型安全”、“编译器检查”、“集合框架”等关键词，可以判断该资源不仅涵盖了泛型的基本语法使用，更深入探讨了其在实际项目开发中的高级应用、...
Java泛型原理与应用教程详解
在深入讨论《夯实JAVA基本之一——泛型详解(1)》的源码之前，我们需要了解泛型在Java编程中的重要性。泛型（Generics）是Java SE 5.0版本引入的一个新特性，它允许在编译时期提供类型安全性，同时避免了类型转换...
java之方法入参和返回值
最新发布
weixin_44348521的博客
08-22 477
【代码】java之方法入参和返回值。
小议出参入参
weixin_33939843的博客
08-25 240
在实际应用中， 我们经常碰到入参和出参， 下面简要说说我个人的体会： 1. 入参的值是被调函数需要， 出参的值是主调函数需要的。 2. 最好不要让参数既做出餐， 又做入参， 否则混乱啊。 3. 入参最好搞成const类型的， 别人一看就知道是入参， 而且安全性高； 出参不要搞成const类型的。 4. 如果字符串做出参数， 传进去的时候一定要携带size, 否则就是...
java中方法入参解析
lixiaotao_1的博客
03-11 2330
java中方法入参解析参数分为基本类型参数和对象类型参数当基本数据类型（Boolean，byte，char，String，int，Long，float，double）作为参数传递时，传递的是实参值的副本，即传的是值，无论在函数中怎么操作这个副本，实参的值是不会被改变的。当对象作为参数传递时，实际上传递的是一份“引用的拷贝”。 （实际传递的是对象的引用）。对象的内部值可以被改变，但对象的引用不能被改...
java入参为方法_Java命令注入原理结合Java Instrument技术（FreeBuf首发）
weixin_39633452的博客
01-25 726
一、前言命令注入：恶意用户构造恶意请求，对一些执行系统命令的功能点进行构造注入，从而达到执行命令的效果。二、演示环境搭建这里采用springboot+swagger搭建一个模拟的web环境：启动成功后访问：http://localhost:8090/swagger-ui.html#/command主要有三个接口:1 /command/exec/string 主要实现Runtime.get...
泛型看这一篇就够了
轩轩吖的博客
09-16 404
1、为什么我们需要泛型？通过两段代码就可以知道为什么需要泛型 /*** * 没有泛型的时候实现加法 */ public class NonGeneric { //我们接...
入参出参 白话讲解 JAVA
Fristm的博客
11-17 1万+
入参 就是 前台往后台传的。出参 就是 后台给前台反的。
Java入参关键字_Java基础17-成员变量、return关键字和多参方法
weixin_33472998的博客
02-24 230
1.成员变量在类中声明的变量为成员变量//Dog类class Dog{String name;//成员变量}public class Test1{public static void main(String[] args){String name="xiaoxiao";//局部变量Dog A=new Dog();System.out.println(A.name);System.out.print...
java 入参校验_java参数校验validation-api
weixin_36398572的博客
02-13 1609
一、参数校验的由来​校验参数在项目中是很常见的，在java中，几乎每个有入参的方法，在执行下一步操作之前，都要验证参数的合法性，比如是入参否为空，数据格式是否正确等等，往常的写法就是一大推的if-else,既不美观也不优雅，这个时候JCP组织站出来了，并且制定了一个标准来规范校验的操作，这个标准就是Java Validation API(JSR 303)。但是这个仅仅是一个标准而是，并没有具体的实...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CodeSuc

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值