Netty框架中文编码

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： JAVA # netty 随笔 文章标签： java netty socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzx5290/article/details/120411493
版权
JAVA 同时被 3 个专栏收录
50 篇文章 0 订阅
订阅专栏
随笔
13 篇文章 0 订阅
订阅专栏
netty
12 篇文章 1 订阅
订阅专栏

netty实战

1. 背景

此篇主要是针对中文传输时的编码问题进行实战。

2. telnet 命令实验

使用命令行，发送汉字“你好”。

2.1 GBK编码

win10系统下，打开命令行使用chcp命令可以看到显示活动代码页：936，936表示是GBK编码，使用telnet 127.0.0.1 8001命令后，输入“你好”回车，看到服务端接收到4个字节如下：

         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| c4                                              |.               |
+--------+-------------------------------------------------+----------------+
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| e3                                              |.               |
+--------+-------------------------------------------------+----------------+
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| ba                                              |.               |
+--------+-------------------------------------------------+----------------+
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| c3                                              |.               |
+--------+-------------------------------------------------+----------------+

2.2 UTF-8编码

打开命令行，使用chcp 65001，将命令行切换为utf-8编码环境，使用telnet 127.0.0.1 8001命令后，输入“你好”回车，不知什么原因闪退，所以无法验证，服务端后台输出日志如下：

13:44:12.494 [nioEventLoopGroup-3-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x03215ed2, L:/127.0.0.1:8001 - R:/127.0.0.1:1525] REGISTERED
13:44:12.495 [nioEventLoopGroup-3-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x03215ed2, L:/127.0.0.1:8001 - R:/127.0.0.1:1525] ACTIVE
13:44:17.153 [nioEventLoopGroup-3-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x03215ed2, L:/127.0.0.1:8001 - R:/127.0.0.1:1525] READ COMPLETE
13:44:17.153 [nioEventLoopGroup-3-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x03215ed2, L:/127.0.0.1:8001 - R:/127.0.0.1:1525] FLUSH
13:44:17.153 [nioEventLoopGroup-3-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x03215ed2, L:/127.0.0.1:8001 ! R:/127.0.0.1:1525] INACTIVE
13:44:17.153 [nioEventLoopGroup-3-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x03215ed2, L:/127.0.0.1:8001 ! R:/127.0.0.1:1525] UNREGISTERED

3. 客户端单元代码

3.1 jdk原生

写一个main方法，实现java原生socket客户端，头两字节表示报文长度，来验证服务端对两种编码的报文处理。

3.1.1 GBK编码（JDK 原生）

服务端后台日志显示，读取了6B，头俩字节表示报文长度为4B，“你好”汉字的十六进制为“c4 e3 ba c3”，一个汉字占2B。

         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 30 34 c4 e3 ba c3                               |04....          |
+--------+-------------------------------------------------+----------------+

3.1.2 UTF-8编码（JDK 原生）

服务端后台日志显示，读取了8B，头俩字节表示报文长度为6B，“你好”汉字的十六进制为“e4 bd a0 e5 a5 bd”，一个汉字占3B。

         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 30 36 e4 bd a0 e5 a5 bd                         |06......        |
+--------+-------------------------------------------------+----------------+

3.2 netty客户端

使用netty框架编写一个main方法，直接发送报文内容来验证服务端对两种编码的报文处理。

3.2.1 GBK编码（netty客户端）

客户端指定编码为GBK格式。

Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group)
	.channel(NioSocketChannel.class)
	.option(ChannelOption.TCP_NODELAY, true)
	.handler(new ChannelInitializer<NioSocketChannel>() {
		@Override
	    protected void initChannel(NioSocketChannel ch) throws Exception {
	        final ChannelPipeline pipeline = ch.pipeline();
	        pipeline.addLast(new LoggingHandler(LogLevel.INFO));
	        pipeline.addLast(new StringEncoder(Charset.forName("GBK")));
	    }
	});

服务端后台读取报文日志如下：

         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| c4 e3 ba c3                                     |....            |
+--------+-------------------------------------------------+----------------+

3.2.2 UTF-8编码（netty客户端）

客户端指定编码为UTF-8格式，代码同上，只把编码格式改了即可。
服务端后台读取报文日志如下：

         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| e4 bd a0 e5 a5 bd                               |......          |
+--------+-------------------------------------------------+----------------+

4. 小结

不同编码的中文字节是不同的，我们实际开发中在报文通信标准中会明确表示中文采用哪一种编码方式，避免通信两端出现中文乱码问题。
假如针对老系统升级，面向的客户端是不同的主体，并且因为各种原因出现了编码不一致的问题（实际情况下很难出现的场景），那么我们该如何处理？之前我想到一种办法是使用Nginx代理stream，但是经过验证不可行。后边我还有一种想法是通过程序来实现，根据对端的IP来指定不同的编码方式，采用配置化的方式实现。此种方式有待于进一步学习动态handler来进行验证。

5. 附

5.1 服务端代码

public class FirstHandler extends ChannelInboundHandlerAdapter {
	public static final Logger log = LoggerFactory.getLogger(FirstHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        log.info("服务端接收消息是：{}", msg);
        ctx.write(msg);
    }
	
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ctx.flush();
    }
    
    @Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
		log.info("exceptionCaught: " + cause.getLocalizedMessage());
	}
}

public class FirstServer {
	public static final Logger log = LoggerFactory.getLogger(FirstServer.class);
    private final String ip = "127.0.0.1";
    private final String port = "8001";

    public void init(){
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        ServerBootstrap bs = new ServerBootstrap();
        bs.group(bossGroup, workerGroup);
        bs.channel(NioServerSocketChannel.class);
        bs.childHandler(new ChannelInitializer<Channel>(){
            @Override
            protected void initChannel(Channel ch) throws Exception {
                final ChannelPipeline pipeline = ch.pipeline();
                pipeline.addLast(new LoggingHandler(LogLevel.INFO));
                pipeline.addLast(new FirstHandler());
            }
        });

        try {
            ChannelFuture channelFuture = bs.bind(ip, Integer.parseInt(port)).sync();
            log.info("Netty Server 启动成功! Ip： " + channelFuture.channel().localAddress().toString() + " ! ");;

            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

5.2 客户端代码

5.2.1 netty客户端

public class CodeClient {

	public void connect(int port, String host) throws InterruptedException {
		EventLoopGroup group = new NioEventLoopGroup();
		
		Bootstrap bootstrap = new Bootstrap();
		bootstrap.group(group)
		    .channel(NioSocketChannel.class)
		    .option(ChannelOption.TCP_NODELAY, true)
		    .handler(new ChannelInitializer<NioSocketChannel>() {
		    	@Override
	            protected void initChannel(NioSocketChannel ch) throws Exception {
	                final ChannelPipeline pipeline = ch.pipeline();
	                pipeline.addLast(new LoggingHandler(LogLevel.INFO));
	                pipeline.addLast(new StringEncoder(Charset.forName("UTF-8")));
	            }
		    });
		
		ChannelFuture future = bootstrap.connect("127.0.0.1", 8001).sync();
		
		future.channel().writeAndFlush("你好");
		
		future.syncUninterruptibly();
		
		future.channel().closeFuture().sync();
	}
	
	public static void main(String[] args) throws InterruptedException {
		new CodeClient().connect(8001, "127.0.0.1");
	}
}

5.2.2 jdk原生

public class InData extends BufferedInputStream {
	
	private static final Logger logger = LoggerFactory.getLogger(InData.class);
	
	private byte[] bdat;
    private int head;
    private int len;
    private String decode;

    public InData(InputStream in, int head, String decode) {
        super(in);
        this.head = head;
        bdat = new byte[this.head];
        this.decode = decode;
    }

    public String readLine() throws Exception {
        String indata;
        int ret = 0;
        try {
        	ret = read(bdat, 0, head);
        } catch (IOException ioe) {
            throw ioe;
        }
        indata = new String(bdat, decode);
        len = (new Integer(indata.trim())).intValue();
        logger.info("接收数据长度 <<[" + indata + "]");
        bdat = new byte[len];
        try {
            ret = read(bdat, 0, len);
        } catch (IOException e) {
            logger.info("ioe : " + e.toString());
            throw e;
        }
        if (ret != len || ret <= 0) {
            throw new Exception("报文包头长度错误");
        }
        indata = new String(bdat, decode);
        logger.info("接收数据 <<[" + indata+ "]");
        return indata;
    }
}

public class OutData extends BufferedOutputStream {

	private static final Logger logger = LoggerFactory.getLogger(OutData.class);
	
    private byte[] bdat;
    private int head_len;
    private String outdata = "";
    private String encode;

    public OutData(OutputStream out, int head_len, String encode) {
        super(out);
        this.head_len = head_len;
        this.encode = encode;
    }

    public int writeLine(String outdata) {
        String tmp;
        int len_src;
        try {
            tmp = new String(outdata.getBytes(), encode);
            
        } catch (UnsupportedEncodingException ex) {
            return -1;
        }
        len_src = tmp.getBytes().length;
        
        for (int i = 0; i < (head_len - new Integer(len_src).toString().length()); i++)
            this.outdata = this.outdata.concat(" ");
        this.outdata = this.outdata + new Integer(len_src).toString() + outdata;
        
        len_src = len_src + head_len;
        
        try {
            bdat = new byte[len_src];
            bdat = this.outdata.getBytes();
            this.write(bdat, 0, len_src);
            this.flush();
        } catch (IOException ioe) {
            logger.info("发送服务器数据时 异常 : " + ioe.toString());
            return -1;
        }
        return 0;
    }
}

public class SocketUtils {

	private Socket serv;
    private InData inServer;
    private OutData outServer;
    private String codeing;
    
    public void init(String ip, int port, int head, String codeing) throws Exception {
        try {
            serv = new Socket(ip, port);
            serv.setSoTimeout(3600000);
        } catch (UnknownHostException uhe) {
            throw new Exception(uhe.toString());
        } catch (IOException ioe) {
            throw new Exception(ioe.toString());
        } catch (Exception e) {
            throw new Exception(e.toString());
        }
        this.codeing = codeing;
        inServer = new InData(serv.getInputStream(), head, this.codeing);
        outServer = new OutData(serv.getOutputStream(), head, this.codeing);
    }
    
    
    public String send(String sendline) throws Exception {
        String recvline;
        try {
            if (outServer.writeLine(sendline) != 0) {
                throw new Exception("发送服务器数据异常");
            }
            recvline = inServer.readLine();
        } catch (IOException e) {
            throw e;
        } catch (Exception e) {
            throw e;
        }
        return recvline;
    }

    public void close() throws Exception {
        if (inServer != null) {
        	try {
        		inServer.close();
            } catch (Exception e) {
            	throw e;
            }
        }
        if (outServer != null) {
        	try {
        		outServer.close();
            } catch (Exception e) {
            	throw e;
            }
        }
        if (serv != null) {
        	try {
                serv.close();
            } catch (Exception e) {
            	throw e;
            }
        }
    }
}
Jinwen5290
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
netty发送utf-8编码的信息
weixin_30349597的博客
08-17 602
/** * */ @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { // (1) //发送告警信息 List<FaultAlarm> faultsAlarms=Read...
netty中 解决服务器到客户端传输数据 中文乱码问题
热门推荐
已被格式化的叔叔
06-06 1万+
//编码格式 arg0.pipeline().addLast(new StringEncoder(Charset.forName("GBK"))); //解码格式 arg0.pipeline().addLast(new StringDecoder(Charset.forName("UTF-8"))); ch.pipeline().addLast(new StringEncoder(Cha...
Netty4编写服务器客户端，自定义编解码，发送自定义消息
02-24
根据给定的消息协议，自己定义一个消息类，编写好服务端与客户端，自定义好编解码器，在客户端发送此消息，服务端获取消息并向客户端发送同样格式的消息；导入Eclipse maven项目运行即可跑通。
Netty框架中文编码（二）
蜗牛的高铁
09-23 192
netty实战1. 背景2. 思路3. 实现4. 日志分析5. 总结 1. 背景 我在上一篇文章中提到，假如针对老系统升级，面向的客户端是不同的主体，并且因为各种原因出现了编码不一致的问题（实际情况下很难出现的场景），那么我们该如何处理？之前我想到一种办法是使用Nginx代理stream，但是经过验证不可行。后边我还有一种想法是通过程序来实现，根据对端的IP来指定不同的编码方式，采用配置化的方式实现。此种方式有待于进一步学习动态handler来进行验证。今天我就简单记录下实战情况。 2. 思路 初始化in
netty8---自定义编码解码器
weixin_34127717的博客
05-20 340
package com.cn.codc; import org.jboss.netty.buffer.ChannelBuffer; import org.jboss.netty.channel.Channel; import org.jboss.netty.channel.ChannelHandlerContext; import org.jboss.netty.handler.codec....
Netty11-编码和解码-Protobuf
weixin_47409774的博客
06-29 510
Netty 自身提供了一些 codec(编解码器)Netty 提供的编码器 • StringEncoder，对字符串数据进行编码 • ObjectEncoder，对 Java 对象进行编码Netty 提供的解码器 • StringDecoder, 对字符串数据进行解码 • ObjectDecoder，对 Java 对象进行解码Netty 本身自带的 ObjectDecoder 和 ObjectEncoder 可以用来实现 POJO 对象或各种业务对象的编码和解码，底层使用的仍是 Java 序列化技术 , 而
netty系列之:netty中的核心编码器base64
程序那些事
04-22 542
文章目录简介netty codec的实现逻辑netty中Base64的实现netty中的base64编码和解码器Base64EncoderBase64Decoder总结 简介 我们知道数据在netty中传输是以ByteBuf的形式进行的,可以说ByteBuf是netty的数据传输基础。但是对于现代的应用程序来说，通常我们需要用到其他的数据结构或者类型。 为了方便我们在程序中的编写，一种方式就是在将数据传入到netty中的时候由程序员自身将数据格式进行转换，然后再调用netty的系统方法。另外一种方式就是定义
Netty进制转换乱码问题
07-20
总结，Netty中的进制转换乱码问题通常源于字符编码不一致或处理不当。解决此类问题的关键在于确保数据的发送和接收端都采用相同的字符编码，正确使用ByteBuf的方法进行读写，并可能需要自定义解码逻辑。通过仔细的...
Netty:Netty框架的学习
05-15
【Netty：深入理解Netty框架】 Netty是一款高性能、异步事件驱动的网络应用程序框架，主要用于快速开发可维护的高性能协议服务器和客户端。在Java领域，Netty因其易用性、灵活性和卓越的性能而备受推崇。它简化了...
java netty框架
02-16
Java Netty框架是一款高效、灵活且强大的网络应用框架，主要用于构建高性能、异步的网络应用程序。Netty由Java开发，广泛应用于后端服务，尤其在处理高并发、低延迟的场景下表现出色。Apache Netty是由JBoss组织维护...
dubbo协议、netty框架总结
07-04
Dubbo协议和Netty框架是构建高性能分布式服务的关键技术，它们在现代企业级应用中扮演着重要角色。Dubbo协议是Dubbo服务框架的核心部分，主要用于实现服务提供者与消费者之间的高效通信。它采用请求-响应模式，支持...
java Netty 框架例子源码.rar
12-15
Java Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。Netty 提供了一组高度抽象的API，使得开发者可以更专注于业务逻辑，而无需深入理解底层网络通信的复杂性...
netty 编码器解码器
qq_42221396的博客
12-07 306
netty是区别于以往的传输方式，通过字节来传输。 编码器和解码器主要用于解析，加密，可以按自己的逻辑去实现数据的传输格式，可以自定义协议。 通过ChannelPipeline对象可以向链路中添加 解码器和编码器 RequestDataEncoder 编码器（继承MessageToByteEncoder） ResponseDataDecoder 解码器 （继承ReplayingDecoder）
p8架构师告诉你Netty的常用编解码器与使用
mid56579的博客
07-26 284
一、开发客户端 1.开发客户端的Handler public class CodecClientHandler extends ChannelInboundHandlerAdapter { @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { System.out.println("连接成功"); } @Override p...
关于 telnet 在windows 中的乱码问题
Leon的专栏
07-22 1万+
在使用 windows 的 telnet 过程中，经常遇到乱码问题 下面是一个简单解决方法，忘记是从哪儿学到的了，在此感谢原作者： 1. 使用 telnet 连接上服务器之后，按下 ctrl+] 2. 回车即可
网络编程-Netty篇
又逢乱世
01-15 527
非阻塞 vs 阻塞、 Selector （多路复用）、 消息边界问题、 零拷贝
Netty Review - StringEncoder字符串编码器和StringDecoder 解码器的使用与源码解读
小工匠
12-21 3973
Netty是一个高性能的网络应用程序框架，它提供了丰富的功能，包括编解码器，这些编解码器用于在网络中发送和接收数据时进行数据的编码和解码。在Netty中，和功能是一个字符编码器，它将字符串（String）数据转换为字节数组（byte[]）。用途：在网络通信中，数据传输是以字节流的形式进行的，因此，当需要发送文本数据时，需要将字符串转换为字节。就是执行这种转换的组件。工作方式：它使用指定的字符集（如UTF-8）将字符串编码为字节。功能。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 547
1.导入hutool的maven依赖。2.复制一下代码执行。
java rpc netty框架代码
05-15
以下是一个简单的 Java RPC Netty 框架代码实现： ```java // 定义 RPC 请求实体类 public class RpcRequest implements Serializable { private String className; private String methodName; private Object[] parameters; // 省略 getter 和 setter 方法 } // 定义 RPC 响应实体类 public class RpcResponse implements Serializable { private Object result; private String error; // 省略 getter 和 setter 方法 } // 定义 RPC 服务接口 public interface RpcService { // 定义服务方法 public int add(int a, int b); } // 实现 RPC 服务接口 public class RpcServiceImpl implements RpcService { @Override public int add(int a, int b) { return a + b; } } // 定义 RPC 服务器端 public class RpcServer { private static final Logger LOGGER = LoggerFactory.getLogger(RpcServer.class); private String host; private int port; public RpcServer(String host, int port) { this.host = host; this.port = port; } public void start() throws InterruptedException { // 创建线程池 EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { // 配置服务器启动类 ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { // 添加解码器和编码器 ch.pipeline().addLast(new ObjectDecoder(ClassResolvers.cacheDisabled(null))); ch.pipeline().addLast(new ObjectEncoder()); // 添加业务处理类 ch.pipeline().addLast(new RpcServerHandler()); } }) .option(ChannelOption.SO_BACKLOG, 128) .childOption(ChannelOption.SO_KEEPALIVE, true); // 启动服务器 ChannelFuture f = b.bind(host, port).sync(); LOGGER.info("Server started on {}:{}", host, port); // 等待直到服务器 socket 关闭 f.channel().closeFuture().sync(); } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } } // 定义业务处理类 private class RpcServerHandler extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { RpcRequest request = (RpcRequest) msg; LOGGER.info("Received request: {}", request); // 调用服务 RpcResponse response = new RpcResponse(); try { Class<?> clazz = Class.forName(request.getClassName()); Method method = clazz.getMethod(request.getMethodName(), request.getParameters().getClass()); Object result = method.invoke(clazz.newInstance(), request.getParameters()); LOGGER.info("Result: {}", result); response.setResult(result); } catch (Exception e) { LOGGER.error("Error occurred while invoking service: {}", e.getMessage()); response.setError(e.getMessage()); } // 返回响应 ctx.writeAndFlush(response); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { LOGGER.error("Error occurred in server: {}", cause.getMessage()); ctx.close(); } } } // 定义 RPC 客户端 public class RpcClient { private static final Logger LOGGER = LoggerFactory.getLogger(RpcClient.class); private String host; private int port; public RpcClient(String host, int port) { this.host = host; this.port = port; } public Object invoke(String className, String methodName, Object... parameters) { // 创建连接 EventLoopGroup group = new NioEventLoopGroup(); try { Bootstrap b = new Bootstrap(); b.group(group) .channel(NioSocketChannel.class) .handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { // 添加解码器和编码器 ch.pipeline().addLast(new ObjectDecoder(ClassResolvers.cacheDisabled(null))); ch.pipeline().addLast(new ObjectEncoder()); // 添加业务处理类 ch.pipeline().addLast(new RpcClientHandler()); } }) .option(ChannelOption.SO_KEEPALIVE, true); // 连接服务器 ChannelFuture f = b.connect(host, port).sync(); LOGGER.info("Connected to server {}:{}", host, port); // 发送请求 RpcRequest request = new RpcRequest(); request.setClassName(className); request.setMethodName(methodName); request.setParameters(parameters); f.channel().writeAndFlush(request); // 等待服务器响应 RpcResponse response = RpcClientHandler.getResponse(); if (response.getError() != null) { LOGGER.error("Error occurred while invoking service: {}", response.getError()); } else { LOGGER.info("Result: {}", response.getResult()); return response.getResult(); } // 关闭连接 f.channel().closeFuture().sync(); } catch (Exception e) { LOGGER.error("Error occurred in client: {}", e.getMessage()); } finally { group.shutdownGracefully(); } return null; } // 定义业务处理类 private static class RpcClientHandler extends ChannelInboundHandlerAdapter { private static RpcResponse response; public static RpcResponse getResponse() { return response; } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { response = (RpcResponse) msg; LOGGER.info("Received response: {}", response); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { LOGGER.error("Error occurred in client: {}", cause.getMessage()); ctx.close(); } } } // 测试代码 public class RpcTest { public static void main(String[] args) throws InterruptedException { // 启动服务器 RpcServer server = new RpcServer("localhost", 8080); server.start(); // 等待服务器启动 Thread.sleep(1000); // 创建客户端并调用服务 RpcClient client = new RpcClient("localhost", 8080); RpcService service = (RpcService) client.invoke("RpcServiceImpl", "add", 1, 2); System.out.println(service.add(1, 2)); } } ``` 以上代码实现了一个简单的 Java RPC Netty 框架，包括 RPC 请求和响应实体类、RPC 服务接口和实现类、RPC 服务器端和客户端。其中，RPC 服务器端和客户端都使用了 Netty 框架，通过序列化和反序列化实现了数据的传输和处理。在测试代码中，我们启动了一个 RPC 服务器，并通过客户端调用了 RPC 服务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Jinwen5290

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

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

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

打赏作者

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

抵扣说明：

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

余额充值