netty小案例demo

最新推荐文章于 2024-08-13 18:05:52 发布
最新推荐文章于 2024-08-13 18:05:52 发布
阅读量6.3k 收藏 5
点赞数 2
分类专栏： netty 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010011737/article/details/52121654
版权

Netty是业界最流行的NIO框架之一，它的健壮性、功能、性能、可定制性和可扩展性在同类框架中都是首屈一指的，它已经得到成百上千的商用项目验证，例如Hadoop的RPC框架avro使用Netty作为底层通信框架。很多其它业界主流的RPC框架，也使用Netty来构建高性能的异步通信能力。

通过对Netty的分析，我们将它的优点总结如下：

1)      API使用简单，开发门槛低；

2)      功能强大，预置了多种编解码功能，支持多种主流协议；

3)      定制能力强，可以通过ChannelHandler对通信框架进行灵活的扩展；

4)      性能高，通过与其它业界主流的NIO框架对比，Netty的综合性能最优；

5)      成熟、稳定，Netty修复了已经发现的所有JDK NIO BUG，业务开发人员不需要再为NIO的BUG而烦恼；

6)      社区活跃，版本迭代周期短，发现的BUG可以被及时修复，同时，更多的新功能会被加入；

7)      经历了大规模的商业应用考验，质量已经得到验证。在互联网、大数据、网络游戏、企业应用、电信软件等众多行业得到成功商用，证明了它可以完全满足不同行业的商业应用。

正是因为这些优点，Netty逐渐成为Java NIO编程的首选框架。

接下来看一个demo 

1、用到的jar


配置文件  config.properties

#netty 服务端ip
nioServerIp=127.0.0.1
#netty 服务端端口
nioServerPort=19990


2.服务段代码：

package netty.test;


import java.io.InputStream;

import java.util.Properties;



/** properties文件加载类
 * @author xiefg
 *
 */
public class Configuration {
	
    private static Properties SYSTEM_CONFIG = new Properties();

    
    public static String fileName = "";
       
    private static final String PATH_SERVER_CONF = "netty/config/config.properties";
    

    public static void init() {
        try {
            InputStream inputStream = null;
            ClassLoader classLoader = null;
            classLoader = Thread.currentThread().getContextClassLoader();
            inputStream = classLoader.getResourceAsStream(PATH_SERVER_CONF);
            SYSTEM_CONFIG.load(inputStream);
            
        	fileName = "";
			int index = PATH_SERVER_CONF.lastIndexOf("/") == -1 ? PATH_SERVER_CONF
					.lastIndexOf("\\") : PATH_SERVER_CONF.lastIndexOf("/");
			if (index > 0) {
				fileName = PATH_SERVER_CONF.substring(index + 1);
			}
            inputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return;
    }

    public static String getProperty(String key, String defaultValue) {
        try {
            return SYSTEM_CONFIG.getProperty(key, defaultValue);
        } catch (Exception e) {
            return null;
        }
    }

    public static String getProperty(String key) {
		try {
			String value = SYSTEM_CONFIG.getProperty(key);
			return value;
		} catch (Exception e) {
			return null;
		}
	}

    public static void main(String[] args) {
    	init();
    	System.out.println(Configuration.getProperty("nioServerIp"));
		
	}
}



package netty.test;


import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;
/***
 * 
  * @ClassName: NettyServer
  * @Description: TODO  netty 提供服务
  * @author xiefg
  * @date 2016年8月4日 下午5:02:05
  *
 */
public class NettyServer {
	//ip 地址
    private static   String IP = "127.0.0.1";
    //默认端口
    private  static  int PORT = 5656;
    
    private static final int BIZGROUPSIZE = Runtime.getRuntime().availableProcessors()*2;
    
    private static final int BIZTHREADSIZE = 100;
    private static final EventLoopGroup bossGroup = new NioEventLoopGroup(BIZGROUPSIZE);
    private static final EventLoopGroup workerGroup = new NioEventLoopGroup(BIZTHREADSIZE);
    public static void init() throws Exception {
    	
        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(bossGroup, workerGroup);
        bootstrap.channel(NioServerSocketChannel.class);
        bootstrap.childHandler(new ChannelInitializer<Channel>() {

            @Override
            protected void initChannel(Channel ch) throws Exception {
                // TODO Auto-generated method stub
                ChannelPipeline pipeline = ch.pipeline();
                 pipeline.addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));
                    pipeline.addLast(new LengthFieldPrepender(4));
                    pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
                    pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
                    pipeline.addLast(new ServerHandler());
            }
            
        });
        IP =Configuration.getProperty("nioServerIp");
        PORT=Integer.parseInt(Configuration.getProperty("nioServerPort"));
        System.out.println("【TCP服务器IP】"+IP+"【TCP服务器PORT】"+PORT);
          ChannelFuture f = bootstrap.bind(IP, PORT).sync();
            f.channel().closeFuture().sync();
            System.out.println("TCP服务器已启动");
        }

    
    
        protected static void shutdown() {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }

        public static void main(String[] args) throws Exception {
            System.out.println("初始化配置文件...");
            Configuration.init();   
            System.out.println("开始启动TCP服务器...");
            NettyServer.init();
//         HelloServer.shutdown();
        }
}


package netty.test;


import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
/**
 * 
  * @ClassName: ServerHandler
  * @Description: TODO
  * @author xiefg
  * @date 2016年8月4日 下午5:34:19
  *
 */
public class ServerHandler extends ChannelInboundHandlerAdapter {
    
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {
       
        System.out.println("server receive message :"+ msg);
        ctx.channel().writeAndFlush("yes server already accept your message" + msg);
        ctx.close();
    }
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // TODO Auto-generated method stub
        System.out.println("【channelActive】。。。");
    }
      @Override
   public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("【exception is general】");
    }
}
3、客户端代码 

package netty.test;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
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.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

/**
 * 
  * @ClassName: NettyClient
  * @Description: TODO
  * @author xiefg
  * @date 2016年8月4日 下午5:46:43
  *
 */
public class NettyClient implements Runnable {
	
    @Override
     public void run() {
            EventLoopGroup group = new NioEventLoopGroup();
            try {
                Bootstrap b = new Bootstrap();
                b.group(group);
                b.channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY, true);
                b.handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));
                        pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));
                        pipeline.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
                        pipeline.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));

                        pipeline.addLast("handler", new Client());
                    }
                });
             
             ChannelFuture f = b.connect("127.0.0.1", 19990).sync();
             f.channel().writeAndFlush("Netty Hello Service!"+Thread.currentThread().getName()+":--->:"+Thread.currentThread().getId());
             f.channel().closeFuture().sync();
             
               

            } catch (Exception e) {

            } finally {
                group.shutdownGracefully();
            }
        }

        public static void main(String[] args) throws Exception {
        	
            for (int i = 0; i < 10; i++) {
                new Thread(new NettyClient(),"【this thread】 "+i).start();
            }
        }
}


package netty.test;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
/**
 * 
  * @ClassName: Client
  * @Description: TODO
  * @author xiefg
  * @date 2016年8月4日 下午6:18:08
  *
 */
public class Client extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("【client接收到服务器返回的消息】:" + msg);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("【client exception is general】");
    }
}

启动服务端如下图：



启动服务端后客户端 如下图



服务端接收消息如下图




早上的阳光
关注
专栏目录
netty案例，netty4.1基础入门篇十一《netty udp通信方式案例Demo》源码
10-11
netty案例，netty4.1基础入门篇十一《netty udp通信方式案例Demo》源码 https://mp.weixin.qq.com/s?__biz=MzIxMDAwMDAxMw==&mid=2650724927&idx=1&sn=a16bc8e98d6a27816da0896adcc83778&scene=19#wechat_redirect
netty实时通讯demo 详细讲解
weixin_54063400的博客
06-12 2661
Netty 是一个高性能、异步事件驱动的网络应用程序框架，主要用于开发高性能、高可靠性的网络服务器和客户端。Netty 支持多种传输协议和编解码技术，如 TCP、UDP、HTTP、WebSocket、SSL 等，并且提供了简单易用的 API 接口，使得开发者可以轻松地构建各种网络应用程序。
Netty(一) netty实现服务端小Demo
2301_79376376的博客
12-17 547
用netty框架实现一个可以http访问的服务端（只是一个小demo）。
Java Netty Demo
最新发布
weixin_42660202的博客
08-13 122
【代码】Java Netty Demo。
Netty简述以及应用案例
delete_bug的博客
09-26 2526
Netty的官网：https://Netty.io/Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。Netty是由JBOSS提供的一个java开源框架，现为 Github上的独立项目。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。
Netty(应用场景,入门案例,架构模型BIO和Reactor,核心组件剖析)
m0_46690280的博客
03-31 1853
Netty通信技术进阶Netty通信技术进阶1. Netty介绍1.1. Netty简介1.1.1. 异步、事件驱动1.1.2. 核心架构1.1.3. Netty优势1.2. Netty应用场景1.3. Netty VS 原生NIO2. Netty入门案例2.2. Netty服务端实现2.2.1. Netty服务端启动配置2.2.2. Netty通道初始化2.2.3. Netty通道接收处理器2.2.4. Netty服务端测试2.3 客户端2.3.1 Netty客户端启动配置2.3.2 Netty通道接收处
2019年java工作面试题汇总
目不识丁
11-05 1185
临近年关，有些java人事都在考虑向新的工作发起挑战， 还是需要对相关的知识点进行系统的复习一下。整理了一些面试准备的知识点，后续会陆续的发出来，让大家更好的学习。 1. JDK 和 JRE 有什么区别？ JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。 JRE：Java Runtime Environment 的简称，...
NettyDemo包含客户端服务端
01-04
综上所述，"NettyDemo" 示例提供了 Netty 在 Android 和 SpringBoot 环境下的实际应用案例，帮助开发者理解如何在不同平台上构建高效、可靠的网络通信系统。通过研究这个示例，可以深入学习 Netty 的核心概念以及...
读书笔记：netty案例集锦netty demonetty实战.zip
07-22
读书笔记：netty案例集锦netty demonetty实战
netty案例，netty4.1基础入门篇七《嗨！NettyClient》源码
10-11
netty案例，netty4.1基础入门篇七《嗨！NettyClient》源码 https://mp.weixin.qq.com/s?__biz=MzIxMDAwMDAxMw==&mid=2650724783&idx=1&sn=bc827e680ebd533fe67720fd695257be&scene=19#wechat_redirect
netty案例，netty4.1中级拓展篇十三《Netty基于SSL实现信息传输过程中双向加密验证》源码
10-11
netty案例，netty4.1中级拓展篇十三《Netty基于SSL实现信息传输过程中双向加密验证》源码 ...
Netty 介绍、使用场景及案例
日常记录
01-11 6547
https://github.com/netty/nettyNetty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可扩展的网络服务器和客户端。它是一个开源项目，最初由JBoss公司开发，现在由社区维护。Netty的设计和实现以处理高并发、低延迟、可靠性和灵活性为目标，因此非常适合构建各种网络应用，包括网络服务器、代理、聊天应用、在线游戏、实时通信和分布式系统等。以下是一些Netty的主要特点和优势：异步和事件驱动：Netty采用异步非阻塞的IO模型，允许处理大量并发连接而不会阻塞应用程序线程。
Netty实例
weixin_33670713的博客
05-18 496
Netty是基于JDK NIO的网络框架 简化了NIO编程, 不用程序自己维护selector, 将网络通信和数据处理的部分做了分离 多用于做底层的数据通信, 心跳检测(keepalived) 1. 数据通信 1.1 Hello World public class Server { public static void main(String[] args)...
netty入门介绍及应用实例
懵齐的博客
03-10 1011
Netty介绍及使用 1. Netty介绍 1.1 简介 Netty是由JBOSS提供的一个java开源框架，现为Github上的独立项目。Netty是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠的网络IO程序。Netty主要针对在TCP协议下，面向Clients端的高并发应用，或Peer-to-Peer场景下的大量数据持续传输的应用。Netty本质是NIO框架，适用于服务器通讯相关的多种应用场景。 要透彻理解Netty，先学习NIO java NIO介绍及入门案例 NIO的类库和AP
学习Netty之Netty客户端服务端Demo(以前写的了，发出来记录)
Mr.Yin
08-12 685
客户端代码: public class NettyClient { public static void main(String[] args) { NioEventLoopGroup group = new NioEventLoopGroup(); try{ Bootstrap b = new Bootstrap(); b.group(group).ch...
Netty应用实例学习
小小默：进无止境
11-20 1142
Netty 是一个 Java NIO 客户端服务器框架，使用它可以快速简单地开发网络应用程序，比如服务器和客户端的协议。Netty 大大简化了网络程序的开发过程比如 TCP 和 UDP 的 socket 服务的开发。 【1】Netty 实现聊天功能 ①SimpleChatServerHandler 服务端处理器 handler 是由 Netty 生成用来处理 I/O 事件的，SimpleChat...
[Netty入门] 最简单的Netty应用程序实例
卧龙小蛋的博客
08-19 1837
客户端和服务器之前的交互相对比较简单。在客户端与服务器建立连接之后，它会向服务器发送一个或多个消息。反过来，服务器也会将每个消息回送给客户端。接下来将从具体的实例代码来简单看下客户端和服务器具体是怎么交互的。
Springboot整合Netty，自定义协议实现
Andrew_Chenwq的博客
12-13 2224
对netty进行配置，绑定netty相关配置设置 Netty通常由一个Bootstrap开始，主要作用是配置整个Netty程序，串联各个组件，Netty中Bootstrap类是客户端程序的启动引导类，ServerBootstrap是服务端启动引导类。数据处理器，针对不同类型数据分类处理 在处理不同接收数据时使用了枚举类型，在使用switch时可以做下处理，具体参考代码，这里只演示如何操作，并没实现数据处理业务类。数据编码 netty服务端回复消息时，对消息转JsonString增加分割符，并进行编码。
Netty应用实例
Java硬件工程师的博客
05-27 971
群聊系统 实例要求 1.编写一个 Netty 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞） 2.实现多人群聊 3.服务器端：可以监测用户上线，离线，并实现消息转发功能 4.客户端：通过 channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息（有服务器转发得到） 5.目的：进一步理解 Netty 非阻塞网络编程机制 GroupChatServer import io.netty.bootstrap.ServerBootstrap; import io.netty.ch
netty自定义协议demo
05-30
以下是一个简单的Netty自定义协议的示例代码，该协议由消息头和消息体组成，消息头包含消息的长度信息，消息体包含具体的消息内容。 1. 定义消息类 ```java public class MyMessage { private int length; ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值