Java-68 深入浅出 分布式服务 Netty实现自定义RPC 附详细代码

最新推荐文章于 2025-08-05 17:34:52 发布
最新推荐文章于 2025-08-05 17:34:52 发布
阅读量1.2k 收藏 18
点赞数 40
CC 4.0 BY-SA版权
分类专栏： Java Spring 分布式 文章标签： java 开发语言 后端 分布式 大数据 nio spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w776341482/article/details/149214987

点一下关注吧！！！非常感谢！！持续更新！！！

🚀 AI篇持续更新中！（长期更新）

AI炼丹日志-29 - 字节跳动 DeerFlow 深度研究框斜体样式架 私有部署 测试上手 架构研究，持续打造实用AI工具指南！📐🤖

💻 Java篇正式开启！（300篇）

目前2025年07月07日更新到：
Java-65 深入浅出 分布式服务 网络通信 BIO NIO AIO 详解 附代码
MyBatis 已完结，Spring 已完结，Nginx已完结，Tomcat已完结，分布式服务正在更新！深入浅出助你打牢基础！

📊 大数据板块已完成多项干货更新（300篇）：

包括 Hadoop、Hive、Kafka、Flink、ClickHouse、Elasticsearch 等二十余项核心组件，覆盖离线+实时数仓全栈！
大数据-278 Spark MLib - 基础介绍 机器学习算法 梯度提升树 GBDT案例 详解

请添加图片描述

Netty

Netty 是一个 面向 JVM 的异步事件驱动网络开发框架，目标是让高并发、高吞吐的网络程序开发像写普通业务代码一样简单。它在内部采用 Reactor/Proactor + 线程池 组合，将 I/O 多路复用、缓冲区管理、协议编解码等复杂细节彻底封装，从而让开发者只需关注 ChannelHandler 里的业务逻辑。

在这里插入图片描述

结构速览

  • Channel：套接字抽象，支持 NIO、Epoll、KQueue、io_uring、UDT、QUIC 等多种传输
  • EventLoop/Group：事件循环线程，单线程串行化 + 任务队列，天然避免锁竞争
  • ChannelPipeline：责任链，入站/出站双向流，动态编解码、聚合、加密
  • ByteBuf / Buffer：内存模型，直接内存池、零拷贝、引用计数，5.0 起改为更安全的 Buffer API

基于Netty自定义RPC

基本介绍

RPC（Remote Procedure Call）又称为远程过程调用，是分布式系统中服务间通信的重要方式。远程调用主要分为两种类型，现代微服务架构中服务间通信基本以这两种方式为主：

  1. 基于HTTP的RESTful形式的广义远程调用

    • 代表框架：Spring Cloud的Feign和RestTemplate
    • 通信协议：HTTP/HTTPS协议
    • 特点：
      • 遵循RESTful设计风格
      • 一般采用短连接方式
      • 协议参数和响应序列化以JSON格式为主，也支持XML格式
      • 典型的应用场景包括Web服务、跨语言系统集成等

  2. 基于TCP协议的RPC远程调用

    • 代表框架：阿里的Dubbo、gRPC等
    • 通信协议：自定义二进制协议
    • 特点：
      • 主要通过Netty实现4层网络协议
      • 采用NIO进行异步高效传输
      • 支持多种序列化方式：JSON、hessian2、protobuf、Java自带序列化等
      • 可配置性强，性能更高
      • 典型的应用场景包括高并发微服务、内部服务调用等

实现目标

我们将模仿Dubbo框架实现一个简单的RPC调用演示，包含以下核心功能：

  1. 消费者和生产者约定统一的接口和协议
  2. 消费者远程调用生产者的方法
    3.生产者返回一个字符串响应
  3. 消费者接收并打印返回数据

详细实现步骤

第一步：创建公共接口项目
  1. 新建Maven项目rpc-api
  2. 定义接口规范：
public interface DemoService {
    String sayHello(String name);
}
  1. 打包发布到本地仓库或私服，供生产者和消费者项目依赖
第二步：创建生产者服务
  1. 新建Maven项目rpc-provider，依赖rpc-api
  2. 实现接口：
public class DemoServiceImpl implements DemoService {
    @Override
    public String sayHello(String name) {
        return "Hello " + name + "!";
    }
}
  1. 配置Netty服务端：
    • 监听指定端口（如8080）
    • 使用自定义协议编解码器
    • 实现请求处理逻辑
  2. 启动时注册服务到注册中心（可选）
第三步：创建消费者服务
  1. 新建Maven项目rpc-consumer，依赖rpc-api
  2. 实现透明调用：
    • 创建动态代理类
    • 代理类内部使用Netty客户端发起远程调用
  3. 配置Netty客户端：
    • 连接生产者服务端
    • 序列化请求参数
    • 处理响应结果
  4. 测试调用：
public class ConsumerApp {
    public static void main(String[] args) {
        DemoService service = ProxyFactory.create(DemoService.class);
        String result = service.sayHello("World");
        System.out.println("Received: " + result);
    }
}
技术实现要点
  1. 序列化方案选择：建议使用hessian2或protobuf以提高性能
  2. 连接管理：需要实现连接池机制
  3. 超时处理：设置合理的调用超时时间
  4. 负载均衡：多服务提供者时需实现负载均衡策略
  5. 容错机制：失败重试、熔断降级等

通过以上步骤，可以完成一个基本的RPC调用演示，展现了RPC框架的核心工作原理。在实际生产环境中，还需要考虑服务发现、监控、链路追踪等更多功能。

公共模块

首先，在公共模块中添加 Netty 的依赖

<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.16.Final</version>
</dependency>

生产者和消费者都需要依赖这个模块，这样提供者来实现接口并提供网络调用，消费者直接根据接口来进行 TCP 通信及一定协议定制获取提供者的实现返回值。

接口定义

package icu.wzk.nettyrpc.service;

public interface WzkUserService {
    String sayHello(String str);
}

生产者

package icu.wzk.nettyrpc.service.impl;

import icu.wzk.nettyrpc.service.WzkUserService;
import icu.wzk.nettyrpc.hanlder.WzkUserServerHandler;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class WzkUserServiceImpl implements WzkUserService {

    @Override
    public String sayHello(String str) {
        System.out.println("调用函数: " + str);
        return "调用成功: " + str;
    }

    public static void startServer(String hostName, int port) throws Exception {
        NioEventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap
                .group(eventLoopGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();
                        pipeline
                                .addLast(new StringDecoder())
                                .addLast(new StringEncoder())
                                .addLast(new WzkUserServerHandler());
                    }
                });
        bootstrap.bind(hostName, port);
    }
}

在实现中加入了 Netty 的服务启动程序，上面的代码添加了 String 类型的 Handler：

package icu.wzk.nettyrpc.hanlder;

import icu.wzk.nettyrpc.service.impl.WzkUserServiceImpl;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class WzkUserServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg.toString().startsWith("WzkUserService")) {
            String result = new WzkUserServiceImpl()
                    .sayHello(msg.toString().substring(msg.toString().lastIndexOf("#") + 1));
            ctx.writeAndFlush(result);
        }
    }
}

我们通过这样的方式直接启动：

package icu.wzk.nettyrpc;

import icu.wzk.nettyrpc.service.impl.WzkUserServiceImpl;

public class WzkNettyRPCServer {
    public static void main(String[] args) throws Exception {
        WzkUserServiceImpl.startServer("localhost", 9999);
    }
}

消费者

消费者有一个需要注意的地方，就是调用需要透明，也就是说，框架使用者不用关心底层的网络实现。这里可以使用JDK的动态带来实现。
思路：客户端调用代理方法，返回一个实现了 HelloSerivce 接口的代理对象，调用代理对象的方法，返回结果。
我们需要在代理中做手脚，当调用代理方法的时候，我们需要初始化 Netty 客户端，还需要向服务端请求数据，并返回数据。
首先创建代理相关的类：

package icu.wzk.nettyrpc;

import icu.wzk.nettyrpc.hanlder.WzkUserClientHandler;
import icu.wzk.nettyrpc.service.WzkUserService;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.lang.reflect.Proxy;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class WzkNettyRPCClient {

    private static ExecutorService executor =
            Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    private static WzkUserClientHandler client;

    public Object createProxy(final Class<?> serviceClass, final String providerName) {
        return Proxy.newProxyInstance(
                Thread.currentThread().getContextClassLoader(),
                new Class<?>[]{serviceClass}, (proxy, method, args) -> {
                    if (null == client) {
                        initClient();
                    }
                    client.setParam(providerName + args[0]);
                    return executor.submit(client).get();
                }
        );
    }

    private static void initClient() throws Exception {
        client = new WzkUserClientHandler();
        EventLoopGroup group = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        bootstrap
                .group(group)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.TCP_NODELAY, true)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();
                        pipeline
                                .addLast(new StringDecoder())
                                .addLast(new StringEncoder())
                                .addLast(client);
                    }
                });
        bootstrap.connect("localhost", 9999).sync();
    }

    public static void main(String[] args) throws Exception {
        String providerName = "WzkUserService#sayHello#";
        WzkNettyRPCClient wzkNettyRPCClient = new WzkNettyRPCClient();
        WzkUserService wzkUserService =
                (WzkUserService) wzkNettyRPCClient.createProxy(WzkUserService.class, providerName);
        while (true) {
            Thread.sleep(1000);
            System.out.println(wzkUserService.sayHello("hello???"));
        }
    }
}

创建代理的逻辑：使用 JDK 的动态代理技术，代理对象中的 invoke 方法实现如下：如果 Client 没有初始化，则初始化 Client。将参数设置到 Client，使用线程池调用 Client 的 call 方法并阻塞等待数据返回。

初始化客户端逻辑：创建一个 Netty 的客户端，并连接提供者，并设置一个自定义 Handler，和一些 String 类型的序列化方式。

Handler

package icu.wzk.nettyrpc.hanlder;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.util.concurrent.Callable;

public class WzkUserClientHandler extends ChannelInboundHandlerAdapter implements Callable {

    private ChannelHandlerContext context;
    private String result;
    private String param;

    public void setParam(String param) {
        this.param = param;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        context = ctx;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        synchronized (this) {
            result = msg.toString();
            notify();
        }
    }

    @Override
    public Object call() throws Exception {
        synchronized (this) {
            context.writeAndFlush(param);
            wait();
            return result;
        }
    }
}

该类缓存了 ChannelHandlerContext，用于下次使用，有两个属性：返回结果和请求参数。
当成功连接后，缓存 ChannelHandlerContext，当调用 call 方法的时候，将请求参数发送到服务端。当服务端收到并返回数据后，调用 ChannelRead 方法，将返回值赋值给 result，并唤醒等待在 call 方法上的线程。

测试结果

我们启动两个程序，Server 端结果如下所示：
在这里插入图片描述

客户端如下所示：
在这里插入图片描述

启动微服务，后台一直报Java.lang.NumberFormatException: For input string “0商品的下架“，报错一直没停止。
小东学java
04-17 1966
引起该异常的直接原因：我在生产者中开始存入的消息是非存数字的字符串，后面又在java代码中把存入的消息改为了存数字，但是在队列中已经存在的代码改之前的消息并没有因为更改代码后而被消费。这样启动消费者时就一直报错（简单说就是存入的消息内容有问题，不能被消费）。 引起该异常的根本原因:开始存入队列的消息为非存数字的字符串，在消费者获取队列消息时消费不了。所以后台就一直报数字格式异常。 我的解决方案：登录mq的客户端直接删除队列，重启生产者和消费者就解决了。 ...
Netty中设计模式一模板方法模式
Qzaizai123的博客
12-06 364
1.代码复用：将公共逻辑放在抽象类中，子类只需要实现特定的业务逻辑。2.扩展性：容易添加新的解码器，不需要修改现有代码。3.控制反转：父类控制流程，子类提供具体实现。这些实现展示了模板方法模式在Netty中的广泛应用，特别是在需要统一处理流程但允许具体实现变化的场景中。
【Netty框架全解析】：从基础概念到高阶实践，从零玩转高性能网络框架！
2302_79380280的博客
07-10 883
本文深入剖析了Netty网络编程框架的核心原理与实战应用。首先系统解析了五大IO模型，通过代码示例和性能对比图表展示了BIO、NIO、AIO的差异及适用场景，重点阐述了Netty基于主从Reactor线程模型的高效实现。其次详细讲解了Netty的生命周期机制，包括Channel状态转换流程和关键回调方法的触发时机，并辅以状态图和时序图说明。
Java-67 深入浅出 分布式服务 Netty 实现服务端与客户端 附Java代码
永远好奇，无限进步！
07-08 719
Netty 是一个基于 Java NIO 的高性能网络通信框架，具备异步非阻塞、事件驱动等特性，广泛用于高并发场景下的网络开发。其内部采用 Reactor 模型与线程池协作，封装了底层的 I/O 多路复用、缓冲区管理与协议编解码，极大简化了开发难度。核心结构包括 Channel、EventLoop、Pipeline、ByteBuf 等，支持 Epoll、KQueue、io_uring 等平台优化。Netty 提供了零拷贝、内存池、动态编解码等高级特性，支持 HTTP/1.1、WebSocket、HTTP/2
Java-66 深入浅出 分布式服务 Netty详解 EventLoop
永远好奇，无限进步！
07-07 812
Netty 是一个基于 Java NIO 的高性能、异步、事件驱动的网络通信框架，广泛用于构建分布式系统、RPC、即时通信和高并发服务端。它封装了复杂的 NIO 接口，采用 Reactor 线程模型，实现了异步非阻塞通信、零拷贝数据传输、内存池化管理等技术，显著提升系统吞吐和并发能力。Netty 的核心由 Channel、EventLoop、ChannelPipeline、ChannelHandler 等组件构成，支持 TCP、UDP、HTTP 等多种协议。
Java-70 深入浅出 RPC Dubbo 详细介绍 上手指南
永远好奇，无限进步！
07-11 1087
Apache Dubbo 是一款高性能的 Java RPC 框架，源自阿里巴巴，现为 Apache 顶级项目。其核心特性包括基于 Netty 的高效网络通信、服务自动注册与发现、丰富的负载均衡与容错机制、以及完善的服务治理能力。Dubbo 架构由服务提供者、消费者、注册中心、监控中心等组成，支持同步与异步调用，并可通过注解、XML、API 等多种方式进行配置。Dubbo 强调 SOA 服务治理，通过服务注册、流量控制、服务降级和链路追踪等手段保障系统的稳定性与可维护性。
Java-73 深入浅出 RPC Dubbo 上手 消费者模块详解+主程序 附代码
永远好奇，无限进步！
07-15 1236
通过 ReferenceConfig 和 DubboBootstrap 读取本地配置和注册中心服务信息，消费者可自动订阅并路由服务列表，最终由 ProxyFactory 生成本地代理对象，实现调用方的透明化访问。核心链路包括目录路由、负载均衡、集群容错、异步调用、Filter 链处理等，支持泛化调用和 SPI 插件机制。开发中通过引入服务 API、配置消费者属性、编写调用组件和配置类，配合 Spring 注解快速集成服务调用。同时提供多种通信协议、序列化方式和高级参数（如超时、重试、Mock 等）。
Java-72 深入浅出 RPC Dubbo 上手 生产者模块详解
永远好奇，无限进步！
07-14 895
生产者模块即服务提供者，负责实现业务接口并通过Dubbo框架导出服务，供消费者调用。其职责包括：实现接口（通过@DubboService标注）、协议暴露、注册中心报到、资源管理（线程池、连接池）以及服务治理（限流、熔断、分组、版本等）。关键组件如序列化SPI（推荐使用Protobuf等高性能方案）、连接池、过滤器等也需合理配置。开发中需配置POM依赖、实现类、配置文件和注册中心连接。在Spring Boot中，Dubbo可通过注解方式无缝集成，支持注册、暴露、治理等完整流程。
Java-71 深入浅出 RPC Dubbo 上手 父工程配置编写 附详细POM与代码
永远好奇，无限进步！
07-12 356
Dubbo 是一个基于接口的 RPC 框架，服务提供者通过实现接口并注册至注册中心，消费者通过引用同一接口并连接相同注册中心实现调用与集群感知。整个项目采用 Maven 构建，划分为父工程和三个子模块：API、Provider、Consumer。API 模块定义公共接口，Provider 实现接口并发布服务，Consumer 引用接口进行远程调用。服务注册依赖 Zookeeper，Dubbo 协议默认使用 Netty 通信。通过配置类与属性文件实现服务扫描与注册，项目结构清晰，适合中小型微服务架构实践。
深入浅出Netty
03-18
《深入浅出Netty》是一本专注于介绍Netty框架的专著，旨在帮助读者全面理解并熟练运用这个高性能、异步事件驱动的网络应用框架。Netty是由Java编写的，广泛应用于各种网络通信场景，包括但不限于服务器开发、云计算...
深入浅出netty-3.rar
12-02
《深入浅出Netty》是针对Java网络编程框架Netty的一份详细讲解文档，由阿里巴巴的专家编写。Netty是一个高性能、异步事件驱动的网络应用程序框架，它为开发可维护的高性能协议服务器和客户端提供了丰富的组件和API。...
Netty进阶之路-跟着案例学Netty
05-16
总的来说，《Netty进阶之路-跟着案例学Netty》是一本深入浅出、实践性强的Netty教程，无论你是初学者还是有一定经验的开发者，都能从中受益匪浅，提升你的网络编程技能。通过阅读这本书，你将能够熟练地利用Netty...
netty全文指南-高清
11-28
总之，《Netty 全文指南》高清版是一本深入浅出的教程，对于想要深入了解和使用 Netty 的开发者来说，能够提供宝贵的指导，帮助他们构建稳定、高效的网络应用。通过阅读这本书，你可以掌握 Netty 的核心概念、最佳...
JVM 01 运行区域
2301_79308687的博客
08-02 995
虚拟机隐藏平台差异，解决不同平台代码运行结果不一致问题，实现，实现用户代码跨平台。它本身是一个操作系统上的应用程序，将字节码文件翻译成特定机器的机器码。
Flash循环存储的地址回绕处理：跨边界写入的三种实现方案
最新发布
u010360138的博客
08-05 513
本文介绍了三种实现Flash循环存储地址计算的方法：1）条件判断法通过显式判断是否溢出实现地址回绕，逻辑清晰通用性强；2）模运算法利用取模运算自动处理地址回绕，代码简洁；3）位掩码法在存储区大小为2的幂时使用位与运算替代模运算，性能最优。三种方法功能等效但各有特点，选择时应考虑存储区特性、性能需求和代码可读性。关键注意事项包括写入延迟、地址有效性检查和边界条件处理。
基于Java的AI/机器学习库（Smile、Weka、DeepLearning4J）的实用
keny-大成的博客
08-04 592
在Java中定义AI动作，通常涉及枚举或常量类来列举可识别的合理动作。挥手（WAVE）点头（NOD）摇头（SHAKE_HEAD）鼓掌（CLAP）举手（RAISE_HAND）叉腰（HANDS_ON_HIPS）抱臂（CROSS_ARMS）指向前方（POINT_FORWARD）竖起大拇指（THUMBS_UP）竖起小拇指（THUMBS_DOWN）比心（HAND_HEART）敬礼（SALUTE）握拳（FIST）张开双手（OPEN_HANDS）双手合十（PRAY）
mybatis-plus动态数据源
qq_62408075的博客
08-01 213
不同于mybatis动态数据，mybatisplus自带很多查询方法。
YAML文件
2301_80251684的博客
08-04 134
YAML是一种数据序列化格式，常用于配置文件、数据交换和存储。其设计目标是简洁易读，同时支持复杂数据结构。
Mybatis学习之特殊SQL的执行（六）
PP东博客
08-05 213
{ids}不推荐使用，因为这边会自动添加单引号，变成 delete from t_user where id in (‘9,10’)。上述三种方式，推荐是哟第二第三种。Java的Mapper接口。Java的Mapper接口。Java的Mapper接口。Java的Mapper接口。Mapper.xml文件。Mapper.xml文件。Mapper.xml文件。Mapper.xml文件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

武子康

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

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

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

打赏作者

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

抵扣说明：

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

余额充值