分布式--NIO Netty

最新推荐文章于 2021-02-16 22:19:25 发布
最新推荐文章于 2021-02-16 22:19:25 发布
阅读量131 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mazaiting/article/details/85001760
版权
1. Netty

Netty是一个提供异步事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络服务器和客户端程序。换句话说，Netty是一个NIO框架，使用它可以简单快速地开发网络应用程序，比如客户端和服务端的协议。Netty大大简化了网络程序的开发过程比如TCP和UDP的 Socket的开发。快速和简单”并不意味着应用程序会有难维护和性能低的问题，Netty是一个精心设计的框架，它从许多协议的实现中吸收了很多的经验比如FTP、SMTP、HTTP、许多二进制和基于文本的传统协议，Netty在不降低开发效率、性能、稳定性、灵活性情况下，成功地找到了解决方案。
Netty下载，建议不要下载最新的包。
Netty学习
Netty In Action 中文版

2. 入门--DISCARD(丢弃服务，指的是会忽略所有接收的数据的一种协议)
1). 创建DiscardServerHandler继承自ChannelInboundHandlerAdapter
/**
 * 忽略所有消息--继承ChannelHandlerAdapter
 * @author mazaiting
 */
public class DiscardServerHandler extends ChannelInboundHandlerAdapter {
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 释放
        ReferenceCountUtil.release(msg);
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 打印错误信息
        cause.printStackTrace();
        // 关闭
        ctx.close();
    }
}
2). 创建忽略服务器消息的服务器
/**
 * 忽略消息的服务器
 * @author mazaiting
 */
public class DiscardServer {
    /**端口*/
    private int port;
    
    public DiscardServer(int port) {
        this.port = port;
    }
    
    public void run() throws Exception{
        // 创建处理I/O操作的多线程事件循环器
        // 接收进来的连接
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        // 处理已经被接收的连接
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 启动NIO服务的辅助启动类
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap
                // 设置组
                .group(bossGroup, workerGroup)
                // 设置管道
                .channel(NioServerSocketChannel.class)
                // 设置过滤
                .childHandler(new ChannelInitializer<SocketChannel>() {

                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        // 设置过滤
                        ch.pipeline().addLast(new DiscardServerHandler());
                    }                   
                })
                // 后台日志
                .option(ChannelOption.SO_BACKLOG, 128)
                // 保持存活
                .childOption(ChannelOption.SO_KEEPALIVE, true);
                
                // 绑定端口并开启服务器
                ChannelFuture future = bootstrap.bind(port).sync();
                // 等待知道这个服务器关闭
                future.channel().closeFuture().sync();
        } finally {
            // 关闭
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }       
    }
    
    public static void main(String[] args) throws Exception {
        int port = 8081;
        new DiscardServer(port).run();
    }
}
3). 测试

在命令提示符窗口，使用telnet localhost 8081来进行数据的测试, 由于此处为忽略所有的消息，故控制台无打印数据产生。此时修改DiscardServerHandler为

/**
 * 忽略所有消息--继承ChannelHandlerAdapter
 * @author mazaiting
 */
public class DiscardServerHandler extends ChannelInboundHandlerAdapter {
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 忽略数据
        ByteBuf in = (ByteBuf) msg;
        try {
            System.out.println(in.toString(CharsetUtil.US_ASCII));
        } finally {
            ReferenceCountUtil.release(msg);
        }
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 打印错误信息
        cause.printStackTrace();
        // 关闭
        ctx.close();
    }
    
}

再次使用telnet localhost 8081测试时，控制台即可打印出数据。

3110861-2e4490ee13452c67.png
图1.png

3. ECHO服务（响应式协议）
1). 创建响应式Handler
/**
 * 返回客户端发回的消息
 * @author mazaiting
 */
public class EchoServerHandler extends ChannelInboundHandlerAdapter{
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ctx.write(msg);
        ctx.flush();
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 打印错误信息
        cause.printStackTrace();
        // 关闭
        ctx.close();
    }

}
2). 创建服务器
/**
 * 返回客户端消息的服务器
 * @author mazaiting
 */
public class EchoServer {
    /**端口*/
    private int port;
    
    public EchoServer(int port) {
        this.port = port;
    }
    
    public void run() throws Exception{
        // 创建处理I/O操作的多线程事件循环器
        // 接收进来的连接
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        // 处理已经被接收的连接
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 启动NIO服务的辅助启动类
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap
                // 设置组
                .group(bossGroup, workerGroup)
                // 设置管道
                .channel(NioServerSocketChannel.class)
                // 设置过滤
                .childHandler(new ChannelInitializer<SocketChannel>() {

                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        // 设置过滤
                        ch.pipeline().addLast(new EchoServerHandler());
                    }                   
                })
                // 后台日志
                .option(ChannelOption.SO_BACKLOG, 128)
                // 保持存活
                .childOption(ChannelOption.SO_KEEPALIVE, true);
                
                // 绑定端口并开启服务器
                ChannelFuture future = bootstrap.bind(port).sync();
                // 等待知道这个服务器关闭
                future.channel().closeFuture().sync();
        } finally {
            // 关闭
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }       
    }
    
    public static void main(String[] args) throws Exception {
        int port = 8082;
        new EchoServer(port).run();
    }
}
3). 测试

在命令提示符窗口输入telnet localhost 8081命令，将' 你好啊'复制进去点击回车

3110861-85d3a060241716a7.png
图2.png
4. TIME服务(时间协议的服务)
1). 创建TimeServerHandler
public class TimeServerHandler extends ChannelInboundHandlerAdapter{

    /**
     * 将会在连接被建立并且准备进行通信时被调用
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 申请4个字节
        final ByteBuf time = ctx.alloc().buffer(4);
        // 存入数据
        time.writeInt((int)(System.currentTimeMillis() / 1000L + 2208988800L));
        // 写入数据
        final ChannelFuture f = ctx.writeAndFlush(time);
        // 设置监听
        f.addListener(new ChannelFutureListener() {
            
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                assert f == future;
                ctx.close();
            }
        });
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 打印错误信息
        cause.printStackTrace();
        // 关闭
        ctx.close();
    }
}
2). TimeServer
/**
 * 返回客户端消息的服务器
 * @author mazaiting
 */
public class TimeServer {
    /**端口*/
    private int port;
    
    public TimeServer(int port) {
        this.port = port;
    }
    
    public void run() throws Exception{
        // 创建处理I/O操作的多线程事件循环器
        // 接收进来的连接
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        // 处理已经被接收的连接
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 启动NIO服务的辅助启动类
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap
                // 设置组
                .group(bossGroup, workerGroup)
                // 设置管道
                .channel(NioServerSocketChannel.class)
                // 设置过滤
                .childHandler(new ChannelInitializer<SocketChannel>() {

                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        // 设置过滤
                        ch.pipeline().addLast(new TimeServerHandler());
                    }                   
                })
                // 后台日志
                .option(ChannelOption.SO_BACKLOG, 128)
                // 保持存活
                .childOption(ChannelOption.SO_KEEPALIVE, true);     
                // 绑定端口并开启服务器
                ChannelFuture future = bootstrap.bind(port).sync();
                // 等待知道这个服务器关闭
                future.channel().closeFuture().sync();
        } finally {
            // 关闭
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }       
    }
    
    public static void main(String[] args) throws Exception {
        int port = 8083;
        new TimeServer(port).run();
    }
}
3). TimeClientHandler
public class TimeClientHandler extends ChannelInboundHandlerAdapter{
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf mBuf = (ByteBuf) msg;
        try {
            long currentTimeMillis = (mBuf.readUnsignedInt() - 2208988800L) * 1000L;
            System.out.println(new Date(currentTimeMillis));
            ctx.close();
        } finally {
            mBuf.release();
        }
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

}
4). TimeClient
public class TimeClient {
    public static void main(String[] args) throws InterruptedException {
        String host = "127.0.0.1";
        int post = 8083;
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap
                .group(workerGroup)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.SO_KEEPALIVE, true)
                .handler(new ChannelInitializer<SocketChannel>() {

                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new TimeClientHandler());
                    }
                });
            // 开启客户端
            ChannelFuture future = bootstrap.connect(host, post).sync();
            
            // 等待直到连接关闭
            future.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}
5). 测试，首先运行TimeServer, 其次再运行TimeClient，查看控制台打印
3110861-edda5f517c238f6d.png
图3.png
代码下载
mazaiting
关注
BIO与NIO、AIO的区别
weixin_34301132的博客
12-22 9117
     IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。 一、BIO      在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信，默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程相应，如果没有则会一直等待或...
Netty + Redis + Websocket IM 分布式集群实现 ---用户多端登陆消息推送
轰轰烈烈的生活
05-29 2930
继续上篇完善Netty + Redis + Websocket IM 分布式集群实现 MyWebsocketHandler 更新代码 /** * 处理客户端与服务端之间的websocket业务 * * @param ctx ctx * @param frame frame */ private void ...
分布式网络通信框架Netty_基于Netty+Zookeeper手写RPC远程调用框架_2 Dubbo框架完整实现
田宝宝的博客
11-04 591
分布式网络通信框架Netty 基于Netty+Zookeeper纯手写RPC远程调用框架 2 Dubbo框架完整实现 ...
学习笔记（50):第4章 分布式通信之Netty-【直播:2020.06.20】Java IO演进之路 03
qq_28500837的博客
02-16 121
本章从BIO、NIO到AIO的演进过程开始，介绍网络IO的通信原理。然后，介绍Netty的基本设计原理，带大家用Netty手写一个Tomcat和一个RPC框架。接着，深入分析Netty的源码，掌握Netty的核心组件如BootStrap、EventLoop、Pipeline、Promise、Future等，最后，将带大家完成一个消息推送系统，模拟百万链接性能调优。...
学习笔记（49):第4章 分布式通信之Netty-【直播:2020.06.20】Java IO演进之路 02
qq_28500837的博客
02-16 158
本章从BIO、NIO到AIO的演进过程开始，介绍网络IO的通信原理。然后，介绍Netty的基本设计原理，带大家用Netty手写一个Tomcat和一个RPC框架。接着，深入分析Netty的源码，掌握Netty的核心组件如BootStrap、EventLoop、Pipeline、Promise、Future等，最后，将带大家完成一个消息推送系统，模拟百万链接性能调优。...
使用NIO实现非阻塞式的网络通信
Alan_Xiang的博客
02-12 2116
实现这样一个程序：客户端读取键盘输入，并发送到服务器端，服务器端接收信息并打印。 　　首先先写一个阻塞式的程序：package nio;import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; imp
netty-netty-4.1.69.Final.tar.gz
10-20
这个“netty-netty-4.1.69.Final.tar.gz”文件是Netty的最新稳定版本，版本号为4.1.69.Final，它是一个压缩包文件，通常包含源码、编译后的类库、文档和其他相关资源。 Netty的核心特点包括： 1. **异步事件驱动**...
netty-netty-4.1.79.Final.tar.gz
07-21
这个“netty-netty-4.1.79.Final.tar.gz”文件是一个包含Netty 4.1.79.Final版本的压缩包，通常用于Java开发环境。解压后，我们可以得到Netty的源代码、库文件和其他相关资源。 Netty的核心特性包括： 1. **异步...
2024年Java常见的-BIO,NIO,AIO,Netty面试题
04-20
### 2024年Java常见BIO、NIO、AIO、Netty面试题解析 #### 一、基础知识概述 1. **IO概念**： - Java中的I/O（Input/Output）指的是输入输出操作，它以流为基础进行数据的输入输出。所有的数据在Java中都是以流的...
Java-NIO-Netty框架学习
03-23
Java NIO (Non-blocking Input/Output) 是...随着对Netty的理解加深，可以尝试实现更复杂的网络应用，如分布式系统、实时通信应用等。同时，阅读Netty的源码也是一个很好的学习途径，能让你更深入地了解其内部机制。
Netty （netty-netty-4.1.74.Final.tar.gz）
02-17
Netty （netty-netty-4.1.74.Final.tar.gz）是一个 NIO 客户端服务器框架，可以快速轻松地开发协议服务器和客户端等网络应用程序。它极大地简化和流线了网络编程，例如 TCP 和 UDP 套接字服务器。 “快速和简单”并...
分布式服务框架介绍：最成熟的开源NIO框架Netty
weixin_30299539的博客
09-13 118
尽管JDK提供了丰富的NIO类库,网上也有很多NIO学习例程,但是直接使用Java NIO类库想要开发出稳定可靠的通信框架却并非易事,原因如下：1)NIO的类库和API繁杂,使用麻烦,你需要熟练掌握Selector、ServerSocketChannelSocketChannel、ByteBuffer等。2)需要具备其他的额外技能做铺垫,例如熟悉Java多线程编程。这是因为NIO编程涉及到...
Java分布式框架netty之NIO框架区别分析
weixin_34294649的博客
10-25 366
Netty概述：1、netty是基于Java NIO的网络应用框架，client-server框架2、Netty是一个高性能、异步事件驱动的NIO框架，它提供了对TCP、UDP和文件传输的支持，作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。3、作为当前最流行的NIO框架，Netty在...
基于netty搭建websocket，实现消息的主动推送
qq_36861290的博客
05-29 1383
netty的核心架构 官网给出的底层示意图： 项目结构 代码结构（简单的springboot +maven项目） pom文件（netty版本 - 4.1.43.Final） 代码展示 WebSocketServer服务类 package com.netty.websocket.netty; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.c.
Netty入门教程——认识Netty
Pannahouse的博客
01-19 7179
Netty 什么是Netty？ Netty 是一个利用 Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架。 Netty 是一个广泛使用的 Java 网络编程框架（Netty 在 2011 年获得了Duke’s Choice Award，见https://www.java.net/dukeschoice/2011）。它活跃和成长于用户社区，像大型公司 F
深入浅出Websocket（二）分布式Websocket集群
weixin_34032792的博客
03-28 3181
前言 最近在构建两个系统的实时通信部分，总结一下所学。 这是一个系列文章，暂时主要构思四个部分 深入浅出Websocket（一）Websocket协议 深入浅出Websocket（二）分布式Websocket集群 深入浅出Websocket（三）分频道的Websocket（分析socket.io源码以及ws-wrapper) 正文 这个是我在造的玩具的一个简单架构图。将实时通信部分给抽离出来作...
一份websocket分布式消息推送系统的构建指南
weixin_41229818的博客
10-22 1826
前言 你还在羡慕别人成熟的推送系统么？ 你想定制自己的推送系统么？ 你有内网推送的需求而不能使用外网推送产品的困扰么？ 文章将向你介绍研究分布式推送的过程与心得（本人呕心沥血打造…），希望看完文章的你能有所收获。 通过这个标题点进来就默认你对websocket有了基本的了解，如果你不知道，这里有个很好的答案websocket是什么。 如果你不想听我bb，完整项目传送门(给个star支持一下…3...
Netty之心跳检测（可应用在分布式架构）
Howinfun的博客
08-01 1373
        这次继续上一篇说到的心跳检测          我们使用Socket通信一般经常会处理多个服务器之间的心跳检测，一般来讲我们去维护服务器集群，肯定要有一台或者N台服务器主机（Master），然后还应该有N台（Slave），那么我们的主机肯定要时时刻刻知道自己下面的从服务器的各方面情况，然后进行实时监控的功能，这个在分布式架构里叫做心跳检测或者是心跳监控。最佳处理方案还是觉得是使用...
航空公司客户满意度数据转换与预测分析Power BI案例研究
最新发布
11-16
内容概要：本文档介绍了航空公司的业务分析案例研究，涵盖两个主要部分：a) 使用SSIS进行数据转换，b) 利用RapidMiner进行预测分析。这两个任务旨在通过改善客户满意度来优化业务运营。数据来源包括多个CSV文件，如flight_1.csv、flight_2.csv、type.csv、customer.csv 和 address.csv。第一部分要求学生创建事实表、客户维度表和时间维度表，并描述整个数据转换流程。第二部分则需要利用RapidMiner开发两种不同的模型（如决策树和逻辑回归）来预测客户满意度，并完成详细的报告，其中包括执行摘要、预测分析过程、重要变量解释、分类结果、改进建议和伦理问题讨论。 适合人群：适用于对数据科学和商业分析有一定基础的学生或专业人士。 使用场景及目标：本案例研究用于教学和评估，帮助学员掌握数据转换和预测建模的技术方法，提高客户满意度和业务绩效。目标是通过实际操作加深对相关工具和技术的理解，并能够将其应用于实际业务中。 其他说明：此作业占总评的40%，截止时间为2024年10月25日16:00。
Netty内存管理与特性解析-高效NIO框架
"本文主要介绍了Netty作为一款高效、强大的NIO通信框架，其在内存管理策略上的...Netty通过其丰富的功能特性和高效的内存管理策略，成为了现代分布式系统中广泛使用的NIO通信框架，极大地提升了开发效率和系统性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值