使用JAVA操作netty框架

最新推荐文章于 2024-05-01 12:15:03 发布
最新推荐文章于 2024-05-01 12:15:03 发布
阅读量1k 收藏
点赞数
分类专栏： 其他开源技术 文章标签： java mina date user 框架 设计模式
之前使用过MINA框架，感觉效率非常好，使用长连接可以支持10万次以上的并发。 
今天尝试使用了Netty框架，感觉使用上也非常方便，具体效率问题，在接下来的博客会详细解读： 

NioServerSocketChannelFactory创建服务端的ServerSocketChannel，采用多线程执行非阻塞IO，和Mina的设计 

模式一样，都采用了Reactor模式。其中bossExecutor、workerExecutor是两个线程池，bossExecutor用来接收客户端连接，workerExecutor用来执行非阻塞的IO操作，主要是read，write。 





Java代码   收藏代码
  1. package netty;  
  2.   
  3. import org.jboss.netty.bootstrap.ServerBootstrap;  
  4. import org.jboss.netty.channel.ChannelFactory;  
  5. import org.jboss.netty.channel.ChannelPipeline;  
  6. import org.jboss.netty.channel.ChannelPipelineFactory;  
  7. import org.jboss.netty.channel.Channels;  
  8. import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;  
  9. import org.jboss.netty.handler.codec.string.StringDecoder;  
  10. import org.jboss.netty.handler.codec.string.StringEncoder;  
  11.   
  12. import java.net.InetSocketAddress;  
  13. import java.util.concurrent.Executors;  
  14.   
  15. /** 
  16.  * Created by IntelliJ IDEA. 
  17.  * User: flychao88 
  18.  * Date: 12-6-6 
  19.  * Time: 上午10:14 
  20.  * To change this template use File | Settings | File Templates. 
  21.  */  
  22. public class DiscardServer {  
  23.     public static void main(String[] args) throws Exception {  
  24.         ChannelFactory factory = new NioServerSocketChannelFactory(  
  25.             Executors.newCachedThreadPool(),  
  26.             Executors.newCachedThreadPool());  
  27.         ServerBootstrap bootstrap = new ServerBootstrap (factory);  
  28.         bootstrap.setPipelineFactory(new ChannelPipelineFactory() {  
  29.             public ChannelPipeline getPipeline() {  
  30.                  ChannelPipeline pipeline = Channels.pipeline();  
  31.                 pipeline.addLast("encode",new StringEncoder());  
  32.                 pipeline.addLast("decode",new StringDecoder());  
  33.                 pipeline.addLast("handler",new DiscardServerHandler());  
  34.                 return pipeline;  
  35.             }  
  36.         });  
  37.         bootstrap.setOption("child.tcpNoDelay", true);  
  38.         bootstrap.setOption("child.keepAlive", true);  
  39.         bootstrap.bind(new InetSocketAddress(8080));  
  40.     }  
  41. }  


Java代码   收藏代码
  1. package netty;  
  2.   
  3. import org.jboss.netty.buffer.ChannelBuffer;  
  4. import org.jboss.netty.buffer.ChannelBuffers;  
  5. import org.jboss.netty.channel.*;  
  6.   
  7. /** 
  8.  * Created by IntelliJ IDEA. 
  9.  * User: flychao88 
  10.  * Date: 12-6-6 
  11.  * Time: 上午10:10 
  12.  * To change this template use File | Settings | File Templates. 
  13.  */  
  14. public class DiscardServerHandler extends SimpleChannelUpstreamHandler  {  
  15.     @Override  
  16.     public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {  
  17.        System.out.println("服务器接收1："+e.getMessage());  
  18.     }  
  19.       
  20.     @Override  
  21.     public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {  
  22.         e.getCause().printStackTrace();  
  23.         Channel ch = e.getChannel();  
  24.         ch.close();  
  25.     }  
  26. }  



Java代码   收藏代码
  1. package netty;  
  2.   
  3. import org.jboss.netty.bootstrap.ClientBootstrap;  
  4. import org.jboss.netty.channel.ChannelFactory;  
  5. import org.jboss.netty.channel.ChannelPipeline;  
  6. import org.jboss.netty.channel.ChannelPipelineFactory;  
  7. import org.jboss.netty.channel.Channels;  
  8. import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;  
  9. import org.jboss.netty.handler.codec.string.StringDecoder;  
  10. import org.jboss.netty.handler.codec.string.StringEncoder;  
  11.   
  12. import java.net.InetSocketAddress;  
  13. import java.util.concurrent.Executors;  
  14.   
  15. /** 
  16.  * Created by IntelliJ IDEA. 
  17.  * User: flychao88 
  18.  * Date: 12-6-6 
  19.  * Time: 上午10:21 
  20.  * To change this template use File | Settings | File Templates. 
  21.  */  
  22. public class TimeClient {  
  23.     public static void main(String[] args) throws Exception {  
  24.           
  25.         ChannelFactory factory = new NioClientSocketChannelFactory(  
  26.             Executors.newCachedThreadPool(),  
  27.             Executors.newCachedThreadPool());  
  28.         ClientBootstrap bootstrap = new ClientBootstrap(factory);  
  29.         bootstrap.setPipelineFactory(new ChannelPipelineFactory() {  
  30.             public ChannelPipeline getPipeline() {  
  31.                 ChannelPipeline pipeline = Channels.pipeline();  
  32.                 pipeline.addLast("encode",new StringEncoder());  
  33.                 pipeline.addLast("decode",new StringDecoder());  
  34.                 pipeline.addLast("handler",new TimeClientHandler());  
  35.                 return pipeline;  
  36.             }  
  37.         });  
  38.         bootstrap.setOption("tcpNoDelay" , true);  
  39.         bootstrap.setOption("keepAlive", true);  
  40.         bootstrap.connect (new InetSocketAddress("127.0.0.1", 8080));  
  41.     }  
  42. }  



Java代码   收藏代码
  1. package netty;  
  2.   
  3. /** 
  4.  * Created by IntelliJ IDEA. 
  5.  * User: flychao88 
  6.  * Date: 12-6-6 
  7.  * Time: 上午10:22 
  8.  * To change this template use File | Settings | File Templates. 
  9.  */  
  10. import org.jboss.netty.buffer.ChannelBuffer;  
  11. import org.jboss.netty.buffer.ChannelBuffers;  
  12. import org.jboss.netty.channel.*;  
  13.   
  14. import java.util.Date;  
  15.   
  16.   
  17. public class TimeClientHandler extends SimpleChannelUpstreamHandler  {  
  18.     @Override  
  19.     public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {  
  20.         e.getChannel().write("abcd");  
  21.     }  
  22.   
  23.     @Override  
  24.     public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {  
  25.         e.getChannel().close();  
  26.     }  
  27.       
  28.     @Override  
  29.     public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {  
  30.         e.getCause().printStackTrace();  
  31.         e.getChannel().close();  
  32.     }  
  33. }  
摩西_玄晨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
怎么通俗的理解Netty呢？
l081499的博客
09-25 409
目录 Netty（3.X） 有了Netty，你可以实现自己的HTTP服务器，FTP服务器，UDP服务器，RPC服务器，WebSocket服务器，Redis的Proxy服务器，MySQL的Proxy服务器等等。 如果你想知道Nginx是怎么写出来的，如果你想知道Tomcat和Jetty是如何实现的，如果你也想实现一个简单的Redis服务器，那都应该好好理解一下Netty，它们高性能的原理都是类似的。 看一下传统的HTTP服务器的原理： 创建一个ServerSocket，监听并绑定一个端口 一系列客户端
java使用netty
congge
03-13 9350
Netty为什么会高效？回答就是良好的线程模型，和内存管理。在Java的NIO例子中就我将客户端的操作单独放在一个线程中处理了，这么做的原因在于如果将客户端连接串起来，后来的连接就要等前一个处理完，当然这并不意味着多线程比单线程有优势，而是在于每个客户端都需要进行读取准备好的缓存数据，再执行一些业务逻辑。如果业务逻辑耗时很久，那么顺序执行的方式没有多线程优势大。另一个方面目前多核CPU很常见了，...
Java Netty：基础入门（一）
AcWare 学习笔记
12-05 852
Netty：异步的，基于事件驱动的网络应用框架，快速开发高性能的服务端和客户端
2024年运维最新Netty框架学习之(一）：Netty框架简介_at io
最新发布
2401_83627805的博客
05-01 1139
官方定义为：”Netty 是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器和客户端”,按照惯例贴上一张High Level的架构图：纵观Java系的多种服务器/大数据框架，都离不开Netty做出的贡献，本文对Netty做一个简单的概述。
Netty框架详解
qq_33807380的博客
10-24 6895
Netty是一款基于Java NIO的网络编程、高性能、异步事件驱动的网络应用框架。它的设计目标是提供简单易用、高性能、可扩展的网络编程框架。
Java常用框架（三）SpringBoot及Netty
folyh
02-23 2929
Java常用框架（三）SpringBoot及Netty
Java NIO框架Netty简单使用的示例
08-28
Java NIO 框架 Netty 简单使用的示例 Java NIO 框架 Netty 是业界最流行的 NIO 框架之一，具有良好的健壮性、功能、性能、可定制性和可扩展性。Netty 提供了简单的 API，大大简化了我们的网络编程。本文将介绍 Java...
java netty框架
02-16
Java Netty框架是一款高效、灵活且强大的网络应用框架，主要用于构建高性能、异步的网络应用程序。Netty由Java开发，广泛应用于后端服务，尤其在处理高并发、低延迟的场景下表现出色。Apache Netty是由JBoss组织维护...
java-netty:netty框架例子代码
05-14
6. **Future 和 Promise**：Netty 使用 Future 和 Promise 来处理异步操作的结果。Future 表示一个可能会在将来完成的操作，Promise 是一个可写的 Future，允许你在操作完成前设置其结果。 在实际应用中，`java-...
Java_NIO框架Netty教程
07-22
资源名称：Java_NIO框架Netty教程资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
Java-NIO-Netty框架学习
07-22
资源名称：Java-NIO-Netty框架学习资源目录：【】Netty5.0架构剖析和源码解读【】Netty5用户指南【】Netty_in_Action(第五版-目录修正版)【】Netty_in_Action_v08_MEAP【】Netty_in_Action_v10_MEAP【】Netty_代码...
一文快速上手高性能网络框架netty
Huangjiazhen711的博客
10-05 674
快速开发的快速不仅仅在于netty提供了恰当的处理网络通信的框架逻辑，更在于其内部提供了丰富的成熟的编解码器，我们只需要将它们加入我们的pipline，便可以轻易的处理如HTTP/HTTPS/Websocket/IMAP/ProtoBuf等等协议。事件驱动指的是netty处理网络消息的方式，框架内部为我们提供了完善的接口/抽象类，其中的各个方法代表了在网络传输过程中发生的各种事件，在我们编码过程中只需要完善各个方法，就可以处理各种网络通信！又提供了大量的编解码器，使得我们可以拔插式的添加协议解析。
Java网络之Netty学习(1)
天上飞的云传奇
02-02 919
是什么？ 是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。基于Nio的 特点？ 高并发，基于Nio的 传输快，使用零拷贝，减少不必要的内存拷贝 封装好，简化了Nio的API 高性能体现：IO线程模型，内存零拷贝，内存池设计，申请的内存可以重复使用，指直接内存，高性能序列化协议。 TCP粘包/拆包问题和解决 是什么：TCP是基于流进行传输数据，可能把数据拆成几个包。也可能把几个小的数据封装成一个大的包发送 粘包就是，小的数据合并一个大的包。 拆包就是：大的数据，超过了T
Netty简介
刘飞
09-05 194
Netty 介绍 2010-08-05 15:20:12| 分类： java网络编程 | 标签： |字号大中小 订阅 . 本指南对Netty 进行了介绍并指出其意义所在。 1. 问题 现在，我们使用适合一般用途的应用或组件来和彼此通信。例如，我们常常使用一个HTTP客户端从远程服务器获取信息或者通过web services进行远程方法的调用。 然而，一个适合普...
Netty入门教程——认识Netty
pony12的专栏
10-23 570
Netty 什么是Netty？ Netty 是一个利用 Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架。 Netty 是一个广泛使用的 Java 网络编程框架（Netty 在 2011 年获得了Duke's Choice Award，见https://www.java.net/dukeschoice/2011）。它活跃和成长于用户社区，像大型公司 Facebook 和 Instagram 以及流行 开源项目如 Infinispan, HornetQ..
Netty框架介绍
weixin_38682092的博客
07-27 582
Netty是由提供的一个java开源框架，现为上的独立项目。Netty提供异步的、的网络框架和工具，用以快速开发高性能、的和客户端程序。也就是说，Netty 是一个基于NIO的客户、的编程框架，使用Netty 可以确保你快速和简单的开发出一个，例如实现了某种协议的客户、应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于和的socket服务开发。“快速”和“简单”并不用产生维护性或性能上的问题。Netty 是一个吸收了多种协议（包括。
分布式网络通信框架Netty_5 Netty编(解)码器和网络通信序列机制
田宝宝的博客
11-01 183
分布式网络通信框架Netty Netty编(解)码器与网络通信序列机制 学习总结 ...
Netty框架
zhijingzhi的博客
06-08 1万+
概述Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty 提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络 IO 程序。Netty 是一个基于 NIO 的网络编程框架，使用 Netty 可以帮助你快速、简单的开发出一个网络应用，相当于简化和流程化了 NIO 的开发过程。作为当前最流行的 NIO 框架，Netty 在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的 Elasticsearch 、Dubbo 框架内部都采用了 Net
Netty框架基本介绍
热门推荐
zhijingzhi的博客
06-09 1万+
NIO 1.概述：NIO全称java non-blocking IO ，是指JDK1.4开始，java提供了一系列改进的输入/输出的新特性，被统称为NIO(即New IO )。新增了许多用于处理输入输出的类，这些类都被放在java.nio包及子包下，并且对java.io包中的许多类进行了改写，新增了满足NIO的功能。NIO和BIO有着相同的目的和作用，但是他们的实现方式完全不同，BIO以流的方式处理数据，而NIO以块的方式处理数据，块I/O的效率比流I/O高很多。另外，NIO是非阻塞式的，这一点跟BIO也很
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
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值