如何手写一个RPC?

这篇具有很好参考价值的文章主要介绍了如何手写一个RPC?。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

在学习 RPC 框架之前,我们先来手写一个RPC。

我们在学习的过程中,一定要做到知其然,还要知其所以然。

架构演进

单体架构

要知道,在以前单体架构的时候,会将所有的应用功能都集中在一个服务当中。

如何手写一个RPC?,Dubbo,rpc,网络协议,网络,dubbo

单体架构初始开发简单,所有的功能都在一个项目中,容易理解整个应用的业务,而且部署也比较简单,就一个服务。
还有就是方便测试和更容易实现跨多个业务功能的事务性操作。

但是单体服务也存在很多缺点:可维护性差、难以扩展、可用性低等等

拆分服务

既然单体服务有这么多缺点,那咋办嘛,将服务根据业务需求进行拆分呗。
拆分服务之后,那服务之间需要互相调用啊,采用什么方式交流呢(通信方式)?数据的一致性怎么保证呢?

如何手写一个RPC?,Dubbo,rpc,网络协议,网络,dubbo

首先我们可能会想到,服务拆分了,但是数据库可以不用拆啊,多个服务共享统一份数据,
这样数据的一致性就很容易保证了。
或者对于数据一致性要求不高的服务采用消息中间件,保证数据的最终一致性就行;
再或者,服务之间通过RPC这种通讯机制通信也行啊。

RPC只是一种泛概念,在不同时期有不同的表现方式。

早期基于Web的RPC。如XML-RPC:使用XML格式编码其调用和HTTP作为传输机制。虽然它支持跨语言调用,但由于XML的冗余性,效率相对较低。
现代RPC系统,如JSON-RPC:一个无状态、轻量级的远程过程调用(RPC)协议,以JSON(JavaScript Object Notation)作为数据格式,可以使用各种传输协议。

在现代分布式系统开发中,RPC对任何开发者来说都是一项重要的技能,因此学习RPC就显得很重要了。

在正式学习RPC框架之前,我们手动实现一个PRC框架,方便于后面对其他RPC框架的学习。

手写RPC


如何手写一个RPC?,Dubbo,rpc,网络协议,网络,dubbo

首先来看看上面这张图,做一个详细的介绍: 两个角色、三个项目

两个角色:一个服务提供者和一个服务消费者

三个项目:rpc-api、rpc-provider和rpc-consumer

API工程是整个服务的标准
各类服务传输过程当中的传输对象的标准,包括接口的标准。

Provider工程
将依赖于上面的标准,就是API工程,并且将会去实现IService,即实现标准当中定义的接口。还要基于网络对外提供服务,因此会包含Net Server这个模块来提供网络服务。主要用来接收和解析网络请求,并去调用 Service Dispatch 来完成整个服务的调用和分发。

Consumer工程
Net Client 主要是完成网络的调用。
ProxyFactory,动态代理模式,主要在调用的过程当中屏蔽网络通讯相关的一些细节,使得我们开发人员在使用过程中不再关注网络细节。

工程搭建步骤

为了简单演示,rpc-api项目中只有一个接口,接口中有一个方法:addUser();
接口的具体实现在rpc-provider中;rpc-consumer中模拟调用addUser() 方法。

建立三个maven项目,首先创建API工程

搭建 rpc-api

如何新建maven工程这里就不做介绍了,下面只包含具体代码

1、pom文件

只包含一个lombok依赖,主要是为了方便不用手写getter和setter

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mntalk</groupId>
  <artifactId>rpc-api</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.30</version>
    </dependency>
  </dependencies>

</project>

2、UserDto

三个属性name、age、userId
因为需要在网络中传输,实现了Serializable,并添加了序列化id

package com.mntalk.dto;


import lombok.Data;
import java.io.Serializable;

@Data
public class UserDto implements Serializable {
    private static final long serialVersionUID = 4266781378102409837L;

    private String name;
    private int age;
    private String userId;
}

3、UserService

定义接口和方法

package com.mntalk.api;

import com.mntalk.dto.UserDto;

public interface UserService {
    // 添加用户
    public UserDto addUser(UserDto userDto);

}

4、RPACommonReqDto

定义统一的传输标准,这里先定义成这样,后面再详细解释,为什么会包含者几个属性

package com.mntalk.dto;

import lombok.Data;
import java.io.Serializable;
/**
 * 统一传输标准
 */
@Data
public class RPACommonReqDto implements Serializable {

    private static final long serialVersionUID = 6212822493972023391L;
    // 方法名
    private String methodName;

    // 类的全路径名
    private String classPath;

    // 形参列表
    private Object[] args;
}

5、将工程打成jar包,方便provider和consumer工程引入进行实现和调用

具体怎么打包就不做介绍了,可以使用命令打包,也可以接触idea打包

搭建 rpc-provider

提供接口实现,并使用Socket网络编程,模拟等待调用

1、pom文件

引入rpc-api工程

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mntalk</groupId>
  <artifactId>rpc-privider</artifactId>
  <version>1.0-SNAPSHOT</version>


  <dependencies>
    <dependency>
      <groupId>com.mntalk</groupId>
      <artifactId>rpc-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

</project>

2、实现UserService

实现具体的addUser方法,这里就模拟已经添加到数据库,并生成了userId,然后将生成的信息返回。
UserServiceImpl业务实现

package com.mntalk.impl;

import com.mntalk.api.UserService;
import com.mntalk.dto.UserDto;

import java.util.Random;

public class UserServiceImpl implements UserService {
    @Override
    public UserDto addUser(UserDto userDto) {
        // todo xxx

        // 模拟插入数据库并生成了userId
        System.out.println("接收:" + userDto);
        userDto.setUserId(new Random().nextInt(100000) + "");
        System.out.println("设置了用户id:" + userDto);

        return userDto  ;
    }
}

3、NetServer

根据上面实现手写RPC的思路图,现在需要Socket网络编程,模拟等待consumer来进行调用。

这里采用线程池来进行异步实现,为什么不不直接在主线程中等待呢?
因为ServerSocket的accept() 是典型的 Blocking IO,会阻塞工作线程。

package com.mntalk.net;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 对外提供服务
 */
public class NetServer {

    static final ExecutorService threadPool = Executors.newFixedThreadPool(50);

    public static void startUp(int port) throws IOException {

        ServerSocket serverSocket = new ServerSocket(port);


//        // 阻塞等待客户端连接
//        Socket socket = serverSocket.accept();
//
//        // 典型的 Blocking IO,会阻塞工作线程
//        socket.getOutputStream();
//        socket.getInputStream();

        // 多线程方式
        // 线程池
        while (true) {
            Socket socket = serverSocket.accept();
            threadPool.submit(new RPCProcessor(socket));
        }

    }

}

4、RPCProcessor

具体的socket处理,实现Runnable接口,方便放入多线程处理。
其中很重要的一点就是模拟服务的分发 ServiceDispatch.dispatch(reqObject);

package com.mntalk.net;

import com.mntalk.dispatch.ServiceDispatch;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Optional;

public class RPCProcessor implements Runnable {

    ObjectInputStream objectInputStream = null;
    ObjectOutputStream objectOutputStream = null;

    private final Socket socket;

    /**
     * 因为需要处理socket的流,所以需要注入socket
     */
    public RPCProcessor(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {


        try {
            // 将输入输出流包装成对象流
            objectInputStream = new ObjectInputStream(socket.getInputStream());

            // 读取客户端对象
            Object reqObject = objectInputStream.readObject();
            // 服务分发
            Object respObj = ServiceDispatch.dispatch(reqObject);


            // 将结果进行输出
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(respObj);
            objectOutputStream.flush();


        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (Optional.ofNullable(objectInputStream).isPresent()) {

                    objectInputStream.close();
                }
                if (Optional.ofNullable(objectOutputStream).isPresent()) {

                    objectOutputStream.close();
                }
            } catch (IOException e) {
                System.out.println("远程调用流关闭错误:" + e.getMessage());
            }
        }

    }
}

5、ServiceDispatch 服务分发

在这里详细解释一下,为什么之前要定义一个 RPACommonReqDto 标准传输对象,并且包含三个属性:
最主要的就是为了下面通过反射生成具体的instance,然后调用方法。

通过classPath可以生成字节码对象;通过方法参数列表,可以得到参数类型列表,然后再通过方法名,就可以得到具体的方法;
然后就可以进行方法调用了。

package com.mntalk.dispatch;


import com.mntalk.dto.RPACommonReqDto;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ServiceDispatch {

    /**
     * 服务分发
     */
    public static Object dispatch(Object reqObject) {
        // 大胆猜测一下,reqObject 中应该包含了分发的内容属性
        // type == 1    --> addUser
        // type == 2    --> deleteUser
        // 上面的这样太呆板了



        // 基于反射机制,就很灵活   instance方法的调用
        // classpath    全路径
        // 方法名 + 形参列表的类型列表
        // 实例对象   Class.newInstance
        // 方法在调用过程当中参数的值 ( getType 可以获得 形参列表的类型列表 )
        RPACommonReqDto reqDto = (RPACommonReqDto)reqObject;
        String classPath = reqDto.getClassPath();
        String methodName = reqDto.getMethodName();
        Object[] args = reqDto.getArgs();

        Class[] types = null;

        if (args != null && args.length > 0) {
            types = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                types[i] = args[i].getClass();
            }
        }

        Object respObject = null;

        // 方法获取及调用
        try {
            Class<?> clazz = Class.forName(classPath);
            Method method = clazz.getDeclaredMethod(methodName, types);
            Constructor<?> constructor = clazz.getDeclaredConstructor();
            respObject = method.invoke(constructor.newInstance(), args);

        } catch (Exception e) {
            e.printStackTrace();
        }


        return  respObject;
    }


}


搭建 rpc-consumer

模拟调用

1、pom文件

引入rpc-api工程

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mntalk</groupId>
  <artifactId>rpc-consumer</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>com.mntalk</groupId>
      <artifactId>rpc-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

</project>

2、TestRPC

模拟调用

package com.mntalk;

import com.mntalk.api.UserService;
import com.mntalk.dto.UserDto;
import com.mntalk.proxy.FactoryProxy;

public class TestRPC {
    public static void main(String[] args) {

        UserService userService = FactoryProxy.getInstanceByClassType(UserService.class);

        UserDto userDto = new UserDto();
        userDto.setName("feiz");
        userDto.setAge(18);

        System.out.println("invoke before: " + userDto);

        userDto = userService.addUser(userDto); // 实际上是跑到RPCInvocationHandler的invoke方法中去执行逻辑了

        System.out.println("invoke after: " + userDto);
    }
}


3、FactoryProxy 代理工厂

通过JDK的动态代理,底层会采用ASM字节码重组技术,会生成一个新的class字节码对象,
然后由ClassLoader将字节码对象加载到JVM进程当中,经由这个类的实例,
去创建出来了一个实例对象,这个class对象实现了interfaceClazz接口。

package com.mntalk.proxy;


import com.mntalk.api.UserService;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * 代理工厂
 */
public class FactoryProxy {

//    写死的情况(并不是我们需要的)
//    public static UserService getUserServiceInstance() {
//        return (UserService) null;
//    }
    
    // 你传入什么样的一个接口,我希望得到的是你传入接口的实例对象
    public static <T> T getInstanceByClassType(Class<T> interfaceClazz) {

        /**
         * 需要用到JDK的动态代理
         *
         * ClassLoader loader,      类加载器Bootstrap、Application、Extension、户自定义类加载器   这里默认用Application
         * Class<?>[] interfaces,   实现的接口列表
         * InvocationHandler h      处理器
         */
        return (T) Proxy.newProxyInstance(FactoryProxy.class.getClassLoader(),
                new Class[]{interfaceClazz},
                new RPCInvocationHandler()
                );
    }
}
4、RPCInvocationHandler

RPCInvocationHandler

package com.mntalk.proxy;

import com.mntalk.dto.UserDto;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

// 创建实例对象时使用
public class RPCInvocationHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("11111");
        UserDto userDto = new UserDto();
        userDto.setAge(99);
        userDto.setName("feifei");
        return userDto;
    }
}

在TestRPC中点击运行
实际上userService.addUser(userDto);是跑到RPCInvocationHandler的invoke方法中去执行逻辑了

如何手写一个RPC?,Dubbo,rpc,网络协议,网络,dubbo

在invoke方法中,实现了目标对象的保护和增强,
那么我们可以将网络实现的细节放到这里面来实现,让调用者无感知这件事情。

5、在invoke中组装网络请求

这里监听的是9999,因为provider中使用的是9999端口,自己根据自己的进行调整就行


package com.mntalk.proxy;

import com.mntalk.anno.ServiceMapped;
import com.mntalk.dto.RPACommonReqDto;
import com.mntalk.dto.UserDto;
import com.mntalk.net.NetClient;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

// 创建实例对象时使用
public class RPCInvocationHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 组装 RPACommonReqDto 对象,完成网络的调用。。。
        RPACommonReqDto commonReqDto = new RPACommonReqDto();
        commonReqDto.setArgs(args);
        commonReqDto.setMethodName(method.getName());
        String classPath = method.getDeclaringClass().getDeclaredAnnotation(ServiceMapped.class).value();
        commonReqDto.setClassPath(classPath);    // 使用注解的方式替代写死的方式


        // 完成网络的调用(host暂时写死)
        return NetClient.callRemoteService("localhost", 9999, commonReqDto);
    }
}

6、NetClient 拟调用
package com.mntalk.net;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Optional;

/**
 * 网络调用
 */
public class NetClient {

    public static Object callRemoteService(String host, int port, Object reqObject) {
        ObjectOutputStream objectOutputStream = null;
        ObjectInputStream objectInputStream = null;
        Object respObject = null;
        Socket socket = null;

        try {
            socket = new Socket(host, port);

            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(reqObject);
            objectOutputStream.flush();

            objectInputStream = new ObjectInputStream(socket.getInputStream());
            respObject = objectInputStream.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (Optional.ofNullable(objectInputStream).isPresent()) {
                    objectInputStream.close();
                }
                if (Optional.ofNullable(objectOutputStream).isPresent()) {
                    objectOutputStream.close();
                }
            } catch (IOException e) {
                System.out.println("远程调用流关闭错误:" + e.getMessage());
            }
        }

        return respObject;
    }

}


7、使用注解替代classPath写死的情况

在rpc-api中定义注解**@ServiceMapped**, 并且在 UserService 接口上添加注解 @ServiceMapped(“com.mntalk.impl.UserServiceImpl”)

package com.mntalk.anno;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface ServiceMapped {
    String value();
}

7、在TestRPC中运行

如下图,consumer调用provider成功,模拟插入数据,生成id并返回了。

如何手写一个RPC?,Dubbo,rpc,网络协议,网络,dubbo

小结

上面我们手动实现了一个RPC, 能够发起远程调用了,但是与 Dubbo 这样的框架相比,还有什么需要优化的点?

我们现在仅仅只是完成了跨进程、跨网络的调用。
这个机制还是有很多可以优化和调整的地方,比如说

序列化方式

给予Java的网络编程,Java的序列化还是不够妥当,Java的序列化和反序列化在安全性方面考虑得非常多,
把一个Java序列化和反序列化,都会把整个类的层级结构进行序列化,包括序列化ID的检查,所以序列化出来的二进制占用的空间是非常大的。
这样在网络中传输就会占用更大的带宽,带来更大的数据传输效率的影响。

Dubbo中默认采用Hessian2序列化
Hessian2是一种紧凑的、对各种语言友好的二进制协议,它在性能和跨语言互操作性方面都表现不错。

网络编程中流的处理

我们现在采用的是基于线程池的异步处理方式。

可以使用更为友好的网络编程方式进行处理,比如 MINA、Netty等等,Dubbo底层的默认通讯框架就是Netty

Netty:
这是一个异步的、事件驱动的网络应用程序框架,可以快速开发可维护的高性能协议服务器与客户端。
Netty广泛用于开发网络游戏、大数据传输应用、实时通讯系统等。它提供了对多种传输类型的支持,例如TCP和UDP的socket服务。

最后说一句(求关注,求赞,别白嫖我)

最近无意间获得一份阿里大佬写的刷题笔记和面经,一下子打通了我的任督二脉,进大厂原来没那么难。

这是大佬写的, 7701页的阿里大佬写的刷题笔记,让我offer拿到手软

求一键三连:点赞、分享、收藏

点赞对我真的非常重要!在线求赞,加个关注我会非常感激!@小郑说编程文章来源地址https://www.toymoban.com/news/detail-798709.html

到了这里,关于如何手写一个RPC?的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 分布式RPC框架Dubbo详解

    目录   1.架构演进 1.1 单体架构 1.2  垂直架构 1.3 分布式架构 1.4 SOA架构 1.5 微服务架构 2.RPC框架 2.1 RPC基本概念介绍 2.1.1 RPC协议 2.1.2 RPC框架 2.1.3 RPC与HTTP、TCP/ UDP、Socket的区别 2.1.4 RPC的运行流程  2.1.5 为什么需要RPC 2.2 Dubbo  2.2.1 Dubbo 概述 2.2.2 Dubbo实战   架构演进如下图: 这

    2024年02月07日
    浏览(38)
  • 用Netty自己实现Dubbo RPC

    1. RPC(Remote Procedure Call)— 远程过程调用,是一个计算机通信协议. 该协议 允许运行在一台计算机中的程序调用另一台计算机的子程序,而程序员无需额外地为这个交互作用编程; 2. 两个或多个应用程序都分布在不同的服务器上,它们之间的调用都像是本地方法调用一样 (如图): 3.常

    2024年02月10日
    浏览(92)
  • 深入浅出:理解 RPC 和 Dubbo 架构

    Apache Dubbo是一款高性能的Java RPC框架.其前身是阿里巴巴公司开源的一个高性能,轻量级的开源Java RPC框架,可以和Spring框架无缝集成. Dubbo 官网 RPC介绍 Remote Procedure Call 远程过程调用,是分布式架构的核心,按响应方式分以下两种: 同步调用:客户端调用服务方方法,等待直到服务方返

    2023年04月12日
    浏览(52)
  • 应用架构演变过程、rpc及Dubbo简介

            单一应用架构 - 垂直应用架构 - 分布式服务架构 - 微服务架构。 单一应用架构         当网站流量很小时,只需一个应用,将所有功能都部署在一起,以减少部署节点和成本。 此时,用于简化增删改查工作量的 数据访问框架(ORM) 是关键。         缺点:

    2024年02月02日
    浏览(49)
  • 不满足于RPC,详解Dubbo的服务调用链路

    【收藏向】从用法到源码,一篇文章让你精通Dubbo的SPI机制 面试Dubbo ,却问我和Springcloud有什么区别? 超简单,手把手教你搭建Dubbo工程(内附源码) Dubbo最核心功能——服务暴露的配置、使用及原理 并不简单的代理,Dubbo是如何做服务引用的 经过前面一系列的铺垫,今天终

    2024年02月16日
    浏览(42)
  • 【Dubbo3云原生微服务开发实战】「Dubbo前奏导学」 RPC服务的底层原理和实现

    Dubbo是一款高效而强大的RPC服务框架,它旨在解决微服务架构下的服务监控和通信问题。该框架提供了Java、Golang等多语言的SDK,使得使用者可以轻松构建和开发微服务。Dubbo具备远程地址发现和通信能力,可通过Dubbo独有的身临其境的服务治理特验为主导,以提高开发人员的功

    2024年02月05日
    浏览(47)
  • Java 【dubbo rpc改feign调用】controller注解处理

    【框架改造问题点记录,dubbo改为spring cloud alibaba】 【第三篇】controller注解处理 【描述】项目之前用了jboss,引入了很多ws.rs包,controller参数注解使用QueryParam。改造时批量替换成了@RequestParam(代表必传)。但是前端并不会传全部参数,会导致400,持续更新… 不加注解,表示

    2024年02月17日
    浏览(41)
  • 微服务学习 | Springboot整合Dubbo+Nacos实现RPC调用

    🏷️ 个人主页 :鼠鼠我捏,要死了捏的主页  🏷️ 系列专栏 :Golang全栈-专栏 🏷️ 个人学习笔记,若有缺误,欢迎评论区指正   前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站AI学习网站。 目录 前言 快速上手

    2024年02月19日
    浏览(37)
  • Netty核心技术十一--用Netty 自己 实现 dubbo RPC

    RPC(Remote Procedure Call) :远程 过程调用,是一个计算机 通信协议。该协议允许运 行于一台计算机的程序调 用另一台计算机的子程序, 而程序员无需额外地为这 个交互作用编程 两个或多个应用程序都分 布在不同的服务器上,它 们之间的调用都像是本地 方法调用一样(如图

    2024年02月16日
    浏览(45)
  • Java 【dubbo rpc改feign调用】feign接口异常统一处理

    【框架改造问题点记录,dubbo改为spring cloud alibaba】 【第一篇】feign接口异常统一处理 示例代码中【ApplicationException 】、【Payload 】为自定义异常类和通用结果返回实体类: 示例代码中【ApplicationException 】、【StringUtil】为自定义异常类和自定义工具,自己平替即可:

    2024年02月16日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包