网络通信框架——Netty示例

最新推荐文章于 2023-07-10 23:59:30 发布
最新推荐文章于 2023-07-10 23:59:30 发布
阅读量2.4k 收藏 3
点赞数 5
分类专栏： Java Web 文章标签： java netty 网络通信框架 server client
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alionsss/article/details/103724630
版权
Java 同时被 2 个专栏收录
61 篇文章 1 订阅
订阅专栏
Web
12 篇文章 0 订阅
订阅专栏

文章目录

网络通信框架——Netty示例

概述

  • Netty 是基于NIO封装的网络通信库，相较于Java原生IO库来说具有以下优点

    • API封装性好
    • 简单、易用
    • 功能强大，提供了各种常用库的接口

  • 推荐文章：https://segmentfault.com/a/1190000007282628

Netty 架构示意图

  • 服务端
    Netty 架构示意图
  • 客户端
    • 和服务端相似，但是只有一个EventLoopGroup，全部由它一个负责连接、数据处理。
  • 需要注意的点
    • BossGroup与WorkerGroup使用同一个EventLoopGroup，并都使用1个线程时，那么对应的是Reactor中的单线程模型
    • BossGroup使用1个线程，WorkerGroup使用多个线程时，那么对应的是Reactor中的多线程模型
    • Netty中并没实现Reactor中的主从多线程模型，即便BossGroup中可以传入多个线程的参数（实际只有一个线程在处理连接，其余的用于和其他ServerBootstrap共享时使用）
    • 推荐看一下：http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf

依赖

  • Maven依赖 pom.xml
    <dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.43.Final</version>
</dependency>
  • Gradle依赖 build.gradle
    compile 'io.netty:netty-all:4.1.43.Final'

Server/Client 简单示例

  • 使用最基础的ByteBuf进行传输
  • Netty 简单服务端示例
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * Description: Netty 简单服务端示例
 * <br/>
 * Date: 2019/12/27 1:42
 *
 * @author ALion
 */
public class SimpleServer {

    public static void main(String[] args) {
        // linux 下建议使用 EpollEventLoopGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        ServerBootstrap bootstrap = new ServerBootstrap()
                .group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new SimpleServerHandler());
                    }
                });

        try {
            ChannelFuture future = bootstrap.bind(23333).sync();
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

}
  • Netty 简单服务器的处理器
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

/**
 * Description: Netty 简单服务器的处理器
 * <br/>
 * Date: 2019/12/27 1:44
 *
 * @author ALion
 */
public class SimpleServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("SimpleServerHandler.channelRead");
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("Server received: " + buf.toString(CharsetUtil.UTF_8));

        ByteBuf byteBuf = Unpooled.copiedBuffer("happy", CharsetUtil.UTF_8);
        ctx.writeAndFlush(byteBuf);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

}
  • Netty 简单客户端示例
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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.util.CharsetUtil;

import java.util.Scanner;

/**
 * Description: Netty 简单客户端示例
 * <br/>
 * Date: 2019/12/27 1:48
 *
 * @author ALion
 */
public class SimpleClient {

    public static void main(String[] args) {
        // linux 下建议使用 EpollEventLoopGroup
        EventLoopGroup loopGroup = new NioEventLoopGroup();

        Bootstrap bootstrap = new Bootstrap()
                .group(loopGroup)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new SimpleClientHandler());
                    }
                });

        try {
            ChannelFuture future = bootstrap.connect("127.0.0.1", 23333).sync();
            Channel channel = future.channel();

            Scanner scanner = new Scanner(System.in);
            for (int i = 0; i < 10; i++) {
                String s = scanner.nextLine();
                ByteBuf byteBuf = Unpooled.copiedBuffer(s, CharsetUtil.UTF_8);
                channel.writeAndFlush(byteBuf);
            }

            future.channel().close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            loopGroup.shutdownGracefully();
        }
    }

}
  • Netty 简单客户端的处理器
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

/**
 * Description: Netty 简单客户端的处理器
 * <br/>
 * Date: 2019/12/27 1:50
 *
 * @author ALion
 */
public class SimpleClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("SimpleClientHandler.channelRead");
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("Client received: " + buf.toString(CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
    
}

Server/Client 聊天示例

  • 示例中展示了部分Netty提供的简化代码编写的API
  • Netty 聊天服务器示例
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * Description: Netty 聊天服务器示例
 * <br/>
 * Date: 2019/12/16 3:19
 *
 * @author ALion
 */
public class MyChatServer {

    public static void main(String[] args) {
        // linux 下建议使用 EpollEventLoopGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        ServerBootstrap serverBootstrap = new ServerBootstrap()
                .group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new MyChatServerInitializer());

        try {
            ChannelFuture future = serverBootstrap.bind(23333).sync();
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }

}
  • Netty 聊天服务端的初始化器
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
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;

/**
 * Description: Netty 聊天服务端的初始化器
 * <br/>
 * Date: 2019/12/16 2:23
 *
 * @author ALion
 */
public class MyChatServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline()
                .addLast(new DelimiterBasedFrameDecoder(4096, Delimiters.lineDelimiter()))
                .addLast(new StringDecoder(CharsetUtil.UTF_8))
                .addLast(new StringEncoder(CharsetUtil.UTF_8))
                .addLast(new MyChatServerHandler());
    }

}
  • Netty 聊天服务器的处理器
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

/**
 * Description: Netty 聊天服务器的处理器
 * <br/>
 * Date: 2019/12/16 2:30
 *
 * @author ALion
 */
public class MyChatServerHandler extends SimpleChannelInboundHandler<String> {

    private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    public static final String SEPARATOR = System.lineSeparator();

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        System.out.println("MyChatServerHandler.handlerAdded");

        Channel channel = ctx.channel();
        channelGroup.add(channel);
        channelGroup.writeAndFlush("Server> " + channel.remoteAddress() + " add" + SEPARATOR);
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("MyChatServerHandler.channelActive");
        System.out.println(ctx.channel().remoteAddress() + " 连接");
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        Channel channel = ctx.channel();
        System.out.println("===========|" + channel.remoteAddress() + "> " + msg);

        for (Channel ch : channelGroup) {
            if (ch != channel) {
                ch.writeAndFlush(channel.remoteAddress() + "> " + msg + SEPARATOR);
            } else {
                ch.writeAndFlush("自己" + "> " + msg + SEPARATOR);
            }
        }
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("MyChatServerHandler.channelInactive");
        System.out.println(ctx.channel().remoteAddress() + " 断开");
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("MyChatServerHandler.handlerRemoved");

        Channel channel = ctx.channel();
        channelGroup.remove(channel); // Netty会自动寻找断掉的channel，然后移除，可以不用手动移除
        channelGroup.writeAndFlush("Server> " + channel.remoteAddress() + " remove" + SEPARATOR);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

}
  • Netty 聊天客户端示例
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

import java.util.Scanner;

/**
 * Description: Netty 聊天客户端示例
 * <br/>
 * Date: 2019/12/16 2:41
 *
 * @author ALion
 */
public class MyChatClient {

    public static void main(String[] args) {
        // linux 下建议使用 EpollEventLoopGroup
        EventLoopGroup loopGroup = new NioEventLoopGroup();

        Bootstrap bootstrap = new Bootstrap()
                .group(loopGroup)
                .channel(NioSocketChannel.class)
                .handler(new MyChatClientInitializer());

        try {
            ChannelFuture future = bootstrap.connect("127.0.0.1", 23333).sync();
            Channel channel = future.channel();

            Scanner scanner = new Scanner(System.in);
            while (true) {
                String msg = scanner.nextLine();
                if ("exit".equals(msg)) break;
                channel.writeAndFlush(msg + System.lineSeparator());
            }

            channel.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            loopGroup.shutdownGracefully();
        }

    }

}
  • Netty 客户端的初始化器
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

/**
 * Description: Netty 客户端的初始化器
 * <br/>
 * Date: 2019/12/16 2:44
 *
 * @author ALion
 */
public class MyChatClientInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline()
                .addLast(new DelimiterBasedFrameDecoder(4096, Delimiters.lineDelimiter()))
                .addLast(new StringDecoder(CharsetUtil.UTF_8))
                .addLast(new StringEncoder(CharsetUtil.UTF_8))
                .addLast(new MyChatClientHandler());
    }

}
  • Netty 客户端的处理器
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

/**
 * Description: Netty 客户端的处理器
 * <br/>
 * Date: 2019/12/16 2:46
 *
 * @author ALion
 */
public class MyChatClientHandler extends SimpleChannelInboundHandler<String> {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("MyClientHandler.channelActive");
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
//        Channel channel = ctx.channel();
        System.out.println(msg);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
    
}
蒋含竹
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络通信 netty_io
01-13
1. BIO模型 源码 2. NIO模型 源码 3. AIO模型 源码 4. Netty 源码
Netty有什么用？
soulofball的博客
09-29 89
随着移动互联网的爆发性增长，小明公司的电子商务系统访问量越来越大，由于现有系统是个单体的巨型应用，已经无法满足海量的并发请求，拆分势在必行。 在微服务的大潮之中， 架构师小明把系统拆分成了多个服务，根据需要部署在多个机器上，这些服务非常灵活，可以随着访问量弹性扩展。 世界上没有免费的午餐， 拆分成多个“微服务”以后虽然增加了弹性，但也带来了一个巨大的挑战：服务之间互相调用的开销。 比如说：原来用户下一个订单需要登录，浏览产品详情，加入购物车，支付，扣库存等一系列操作，在单体应用的时候它们都在一台机器的同一个
OpenHub框架进行的异步通信
最佳 Java 编程
06-07 205
在本系列的前一部分中，我们介绍了OpenHub框架 。 这部分显示了框架最强大的功能之一- 异步消息传递模型 。 当源系统无法等待目标系统的响应时，将使用系统之间的异步通信。 有以下几个原因： 源系统必须尽可能地响应 ，并且不受外部影响（通信缓慢，目标系统不稳定等）的影响 目标系统中的处理需要很多时间 异步通信对性能和流量产生积极影响 异步方案 当您决定异步通信时，您必...
【Netty】Netty框架实现及学习
Wligt的博客
07-10 733
Netty框架学习
使用Netty实现客户端和服务端之间的双向通信
weixin_44030476的博客
07-20 3979
在上个月的开发计划中，有一个系统控制喇叭播放的功能。当时就想到了使用netty进行通信操作。于是在调研途中，发现网上写的都是简单案例，不适用于当前的复杂通信模式。比如超时断线，断线重连，通信监听，错误记录存储，以及断线和上线后的钉钉通知等等。所以自己从头到尾重新写了一个完整项目，供大家参考。提示以下是本篇文章正文内容，下面案例可供参考。......
Netty学习二：Netty整体框架
weixin_41402069的博客
07-08 2787
Netty学习系列
Netty编程框架开发例子
rishengcsdn的专栏
11-03 6968
为什么要用Netty开发NIO程序 ＪＡＶＡ原生的ＮＩＯ程序包，不担编程麻烦，而已ＢＵＧ很多，性能差，所以就需要很多第三方工具包来实现ＮＩＯ网络通信。 Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务
Netty简述以及应用案例
delete_bug的博客
09-26 2337
Netty的官网：https://Netty.io/Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。Netty是由JBOSS提供的一个java开源框架，现为 Github上的独立项目。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。
Netty初探：掌握高性能网络通信框架，提升Java网络编程技能
最新发布
01-05
Netty是一个高性能、异步的网络通信框架，它解决了JDK自带的NIO API使用复杂的问题，提供了更高的性能和更低的延迟。Netty广泛应用于互联网行业、游戏行业和大数据领域，如阿里的Dubbo和RocketMQ等都使用了Netty作为...
Java NIO框架Netty简单使用的示例
08-28
本篇文章主要介绍了Java NIO框架Netty简单使用的示例,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
netty通信完整示例
08-27
netty通信完整示例，含jar包，server端，client端，编码器，解码器 本人亲测成功。
netty通讯示例
09-29
netty教程实例，简单易用，易于理解。断线消息触发，无需自己定时去判断是否断线
java-netty:netty框架例子代码
05-14
java-netty netty 框架的通信例子，参考www.itstack.org
SOFA-Bolt网络通信框架-其他
06-12
SOFABolt 是蚂蚁金融服务集团开发的一套基于 Netty 实现的网络通信框架。 为了让 Java 程序员能将更多的精力放在基于网络通信的业务逻辑实现上，而不是过多的纠结于网络底层 NIO 的实现以及处理难以调试的网络问题，...
Netty高性能网络应用框架-其他
06-11
Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一...
Flink示例——Flink-CDC
热门推荐
蒋含竹的博客
09-18 1万+
Flink示例——Flink-CDC 版本信息 Mavan依赖 主从同步配置、数据准备 使用Flink-CDC 简单的测试 Flink示例——Flink-CDC 版本信息 产品 版本 Flink 1.11.1 flink-cdc-connectors 1.1.0 Java 1.8.0_231 MySQL 5.7.16 注意：官方说目前支持MySQL-5.7和8，但笔者还简单测试过mariadb-10.0.38（对应MySQL-5.6）。包括增加、删除、更新、聚合，目前皆可用，但不排除未知问题。 Mavan
设计一个简易的订阅/分发消息的工具
蒋含竹的博客
10-20 6474
发布/订阅消息机制 单例设计模式 观察者设计模式 HashMap类 按value注册观察者 按value分发消息
CDC变化数据捕获——Debezium-Embedded
蒋含竹的博客
05-07 4461
文章目录CDC变化数据捕获——Debezium-Embedded0. 前言1. 配置MySQL主从同步2. Debezium-Embedded 代码开发2.1 Maven导包2.2 代码-简单示例2.3 代码-使用Connect.class创建引擎2.4 代码-批量处理CDC事件2.5 启动代码运行即可 CDC变化数据捕获——Debezium-Embedded 0. 前言 CDC(Change Data Capture)是变化数据捕获的意思，可以捕获数据库数据的增加、更新、删除等记录，RedHat的 De
数据序列化框架——Kryo
蒋含竹的博客
08-22 4307
文章目录数据序列化框架——Kryo1. 概览2. Java中使用Kryo示例2. Scala中使用Kryo示例 数据序列化框架——Kryo 1. 概览 简介     Kryo是一款专用于Java的快速、高效的数据序列化的框架，同时也支持Scala、Clojure、Objective-C等 特点 快速、高效、占用空间小 使用简单（不用像protobuf一样...
ktor框架基于netty吗
04-04
是的，Ktor框架是基于Netty的。Netty是一个高性能的网络编程框架，而Ktor则是一个构建在Netty之上的异步Web框架。Ktor利用了Netty的异步I/O和事件驱动的特性，使得它能够处理高并发和高吞吐量的请求。同时，Ktor还提供了一套简单易用的API，使得开发者可以快速构建Web应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值