io-4-netty-入门程序

最新推荐文章于 2024-08-11 16:30:34 发布
最新推荐文章于 2024-08-11 16:30:34 发布
阅读量214 收藏 1
点赞数
分类专栏： io 文章标签： netty io nio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_ygy/article/details/75331580
版权

netty入门小程序

server
public class TestNettyServer {

    public static void main(String[] args) {
        int port = 8888 ;
        try {
            new TestNettyServer().bind(port);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    private  void bind( int port) throws InterruptedException {
        //reactor线程组
        //用于服务端接受客户端连接
        EventLoopGroup boosGroup=new NioEventLoopGroup();
        //进行socketChannel 读写
        EventLoopGroup workGroup=new NioEventLoopGroup();
        try {
            // netty 服务端启动类
            ServerBootstrap serverBootstrap=new ServerBootstrap();
            serverBootstrap.group(boosGroup, workGroup)
                    //创建服务端
                    .channel(NioServerSocketChannel.class)
                    //设置tcp参数
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    //处理io事件
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new ChannelInboundHandlerAdapter() {

                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                    //super.channelRead(ctx, msg);
                                    ByteBuf buf = (ByteBuf)msg;
                                    // 创建域buf中可读字节数相同大小的数组
                                    byte[] req=new byte[buf.readableBytes()];
                                    //将缓冲区可读字节复制到req数组中
                                    buf.readBytes(req);
                                    System.out.println(" the time server receiver request :" + new String(req, "utf-8"));
                                    ByteBuf resp=Unpooled.copiedBuffer(new Date(System.currentTimeMillis()).toLocaleString().getBytes());
                                    //写回客户端
                                    ctx.write(resp);
                                }

                                @Override
                                public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
                                    //super.channelReadComplete(ctx);
                                    //刷新到缓冲数组中
                                    ctx.flush();
                                }

                                @Override
                                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                                    super.exceptionCaught(ctx, cause);
                                    ctx.close();
                                }
                            });
                        }
                    });
            //绑定端口，同步等待
            ChannelFuture future = serverBootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        }finally {
            //释放线程池资源
            boosGroup.shutdownGracefully();
            workGroup.shutdownGracefully();

        }

    }
}
//输出
//the time server receiver request : tell me the time
client
public class TestNettyClient {

    public static void main(String[] args) throws InterruptedException {
        //客户端工作线程组
        EventLoopGroup clienGroup=new NioEventLoopGroup();
        //客户端netty服务启动
        Bootstrap bootstrap=new Bootstrap();
        try {
            bootstrap.group(clienGroup)
                    //客户端通道
                    .channel(NioSocketChannel.class)
                    //设置可选参数
                    .option(ChannelOption.TCP_NODELAY, true)
                    //处理io事件
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new ChannelInboundHandlerAdapter() {

                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                    //super.channelRead(ctx, msg);
                                    ByteBuf buf=(ByteBuf) msg;
                                    // 创建域buf中可读字节数相同大小的数组
                                    byte[] req=new byte[buf.readableBytes()];
                                    //将缓冲区可读字节复制到req数组中
                                    buf.readBytes(req);
                                    System.out.println(" client receive resp from server that the time is  :" + new String(req, "utf-8"));
                                }

                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                    super.channelActive(ctx);
                                    //发送请求
                                    byte[] bytes=" tell me the time ".getBytes();
                                    ByteBuf buf=Unpooled.buffer(bytes.length);
                                    buf.writeBytes(bytes);
                                    ctx.writeAndFlush(buf);
                                }

                                @Override
                                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                                    super.exceptionCaught(ctx, cause);
                                    ctx.close();  //异常关闭资源
                                }
                            });
                        }
                    });
            ChannelFuture future=bootstrap.connect("127.0.0.1", 8888).sync();
            future.channel().closeFuture().sync();
        }finally {
            clienGroup.shutdownGracefully();
        }
    }
}
//输出
//client receive resp from server that the time is  :2017-7-21 0:23:54

Tcp粘包/拆包

    tcp在传输数据时，可能会拆分为多个包进行发送，也可能会将多个小包合并为一个大包发送。
    解决：
    1.消息定长发送；
    2.在包尾增加回车换车符进行分割
    3.将消息分为消息头和消息体，消息头中包含表示消息总长度的字段。
server
public class TestTcpServer {

    public static void main(String[] args) {
        int port=8888;
        try {
            new TestTcpServer().bind(port);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    private void bind(int port) throws InterruptedException {
        //reactor线程组
        //用于服务端接受客户端连接
        EventLoopGroup boosGroup=new NioEventLoopGroup();
        //进行socketChannel 读写
        EventLoopGroup workGroup=new NioEventLoopGroup();
        //记录客户端请求次数
        AtomicInteger atomicInteger=new AtomicInteger(0);
        try {
            // netty 服务端启动类
            ServerBootstrap serverBootstrap=new ServerBootstrap();
            serverBootstrap.group(boosGroup, workGroup)
                    //创建服务端
                    .channel(NioServerSocketChannel.class)
                    //设置tcp参数
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    //处理io事件
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            //换行解码器
                            socketChannel.pipeline(). addLast(new LineBasedFrameDecoder(1024));
                            //直接将接受对象转化为String类型
                            socketChannel.pipeline().addLast(new StringDecoder());
                            //增加处理器
                            socketChannel.pipeline().addLast(new ChannelInboundHandlerAdapter() {

                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                    super.channelRead(ctx, msg);
                                    //ByteBuf buf=(ByteBuf) msg;
                                     创建域buf中可读字节数相同大小的数组
                                    //byte[] req=new byte[buf.readableBytes()];
                                    将缓冲区可读字节复制到req数组中
                                    //buf.readBytes(req);
                                    String req = (String)msg ;
                                    System.out.println(" the time server receiver request :"
                                            + req
                                            +" ; the count = " +  atomicInteger.incrementAndGet() );
                                    String response=new Date(System.currentTimeMillis()).toLocaleString() + System.getProperty("line.separator");
                                    ByteBuf resp=Unpooled.copiedBuffer(response.getBytes());
                                    //写回客户端
                                    ctx.write(resp);
                                }

                                @Override
                                public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
                                    //super.channelReadComplete(ctx);
                                    //刷新到缓冲数组中
                                    ctx.flush();
                                }

                                @Override
                                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                                    super.exceptionCaught(ctx, cause);
                                    ctx.close();
                                }
                            });
                        }
                    });
            //绑定端口，同步等待
            ChannelFuture future=serverBootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } finally {
            //释放线程池资源
            boosGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}
//输出
...
 the time server receiver request : tell me the time  ; the count = 99
 the time server receiver request : tell me the time  ; the count = 100
client
public class TestTcpServer {

    public static void main(String[] args) {
        int port=8888;
        try {
            new TestTcpServer().bind(port);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    private void bind(int port) throws InterruptedException {
        //reactor线程组
        //用于服务端接受客户端连接
        EventLoopGroup boosGroup=new NioEventLoopGroup();
        //进行socketChannel 读写
        EventLoopGroup workGroup=new NioEventLoopGroup();
        //记录客户端请求次数
        AtomicInteger atomicInteger=new AtomicInteger(0);
        try {
            // netty 服务端启动类
            ServerBootstrap serverBootstrap=new ServerBootstrap();
            serverBootstrap.group(boosGroup, workGroup)
                    //创建服务端
                    .channel(NioServerSocketChannel.class)
                    //设置tcp参数
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    //处理io事件
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            //换行解码器
                            socketChannel.pipeline(). addLast(new LineBasedFrameDecoder(1024));
                            //直接将接受对象转化为String类型
                            socketChannel.pipeline().addLast(new StringDecoder());
                            //增加处理器
                            socketChannel.pipeline().addLast(new ChannelInboundHandlerAdapter() {

                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                    ////super.channelRead(ctx, msg);
                                    //ByteBuf buf=(ByteBuf) msg;
                                    //// 创建域buf中可读字节数相同大小的数组
                                    //byte[] req=new byte[buf.readableBytes()];
                                    ////将缓冲区可读字节复制到req数组中
                                    //buf.readBytes(req);
                                    String req = (String)msg ;
                                    System.out.println(" the time server receiver request :"
                                            + req
                                            +" ; the count = " +  atomicInteger.incrementAndGet() );
                                    String response=new Date(System.currentTimeMillis()).toLocaleString() + System.getProperty("line.separator");
                                    ByteBuf resp=Unpooled.copiedBuffer(response.getBytes());
                                    //写回客户端
                                    ctx.write(resp);
                                }

                                @Override
                                public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
                                    //super.channelReadComplete(ctx);
                                    //刷新到缓冲数组中
                                    ctx.flush();
                                }

                                @Override
                                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                                    super.exceptionCaught(ctx, cause);
                                    ctx.close();
                                }
                            });
                        }
                    });
            //绑定端口，同步等待
            ChannelFuture future=serverBootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } finally {
            //释放线程池资源
            boosGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}
//输出
client receive resp from server that the time is  :2017-7-21 15:47:33 ; count  = 98
 client receive resp from server that the time is  :2017-7-21 15:47:33 ; count  = 99     
 client receive resp from server that the time is  :2017-7-21 15:47:33 ; count  = 100
Liberal_夜不黑
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty--菜鸟入门--Netty组件
Wonder__的博客
01-13 1979
本人刚刚接触Netty，所以如果有不正确的地方，希望大家积极指出并一起讨论～～ Channel----Socket EventLoop----用于控制流、多线程处理、并发 ChannelFuture----异步通知 1.Channel、EventLoop、ChannelFuture 1.1 Channel接口 Netty中的Channel所提供的API，大大降低了使用Socket的复杂...
Java Netty-入门教程.pdf
06-25
### Java Netty 入门教程知识点详解 #### 1. Netty 概览 ##### 1.1 Netty 是什么？ Netty 是一款基于 Java 的高性能网络应用框架，支持多种协议，包括但不限于 HTTP、FTP、SMTP 等，并且特别擅长处理 TCP 和 UDP ...
Netty4-Netty入门-模型理论
weixin_47409774的博客
06-23 236
Netty 对 JDK 自带的 NIO 的 API 进行了封装 工作原理图 黄色的框表示对象， 蓝色的框表示线程 白色的框表示方法(API) 模型特点问题分析基于 I/O 复用模型：多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象等待，无需阻塞等待所有连接。当某个连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理Reactor 对应的叫法: 1. 反应器模式 2. 分发者模式(Dispatcher) 3. 通知者模式(notifier) 2) 基于线程池复用线程资源：
Netty-IO模型
XZB119211的博客
11-15 685
Netty-IO模型
Netty框架入门学习--第一个Netty程序 hello world
return
03-19 570
作为netty学习的第一个博客内容，很简单，就是直接用netty开发一个简单的服务端，客户端发送一个请求，服务端返回一个hello world。 开始之前呢，需要安装好idea，gradle，然后通过idea创建一个project，如图，然后一步一步往下点就可以了，当然你用eclipse或者使用maven依赖的方式也是可以的。 配置build.gradle 创建好project之后呢，你就可...
Netty(1)-BIO、NIO与Netty入门
程序员不鸣的博客
02-02 445
文章目录一.BIO下的client-server通信模式二.NIO下的通信模式三.Netty入门1. 什么是Netty2.Netty的实际应用3.Netty入门Demo 一.BIO下的client-server通信模式 BIO即Blocking IO，同步阻塞式IO，在BIO的通信模式下， 「一个线程只能在一个accept、read或write方法中阻塞，对应着一条IO连接线路」 以下程序即BI...
netty入门--helloworld程序
小尘_OnMyWay的博客
04-04 294
首先给出最简单的CS架构通信的netty程序，实现了客户端向服务器端写入helloworld的功能。 服务器端的代码如下： package com.throne.netty.test1; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.c
netty入门-4 Channel与ChannelFuture
保存我对一些技术的思考
07-23 1130
老师这部分是Channel与ChannelFuture一起讲解使用，仅仅讲述了最基本的方法。对于ChannelFuture的状态，偏内部机制的部分没有讲解。且在紧接着的下部分讲解Future与Promise时也没有说到。所以我打算这篇先按课程中的讲解，把最基本的使用摆上来。在下一篇对比分析Netty的Future与Promise时再考虑是否扩展偏底层的部分（我是初学者，扩展还需要自己看书或者找文章看，虽然已经看过了，但是写出来不免还是要费些时间精力的）。
Netty-入门篇
S1124654的博客
06-27 1248
Netty-入门篇
uni-app关于WebSocket与Netty后端的记录
weixin_44268792的博客
11-12 2373
所使用到API的基本介绍 作者对于Netty的学习也是刚刚入门,前后端联调花了两三天时间,于是赶快记录下来 Uni-App WebSocket API 更多API参考Uni-App官网 uni.connectSocket(OBJECT) 创建一个 WebSocket 连接 参数名 类型 必填 说明 url String 是 服务器接口地址 success Funct...
netty-learning-example：Netty实践学习案例，见微知著！带着你的心，跟着教程。我相信你行欧
02-03
是一个致力于创造高性能网络应用程序的成熟的IO框架 相比较与直接使用剧烈的Java IO API，您不需要先成为网络专家就可以基于Netty去构建复杂的网络应用 业界常⻅的涉及到网络通信的相关中间件大部分基于Netty实现...
Netty大纲-同步netty专栏
07-07
3. **Netty入门** - **概述**：Netty由JBOSS创始人Jochen Meskel开发，它具有高性能、低延迟、易用性等优点，广泛应用于分布式系统、游戏服务器、RPC框架等领域。 - **HelloWorld**：Netty的基本使用包括服务器端...
Netty-讲义.zip
10-09
Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。这个“Netty 讲义.zip”压缩包包含了一系列关于 Netty 的学习资料，主要分为四个部分：入门、进阶、NIO 和...
Netty+maven的入门程序
08-03
在本入门程序中，我们将深入探讨如何结合 Maven 和 Eclipse 创建一个简单的 Netty 项目。 首先，让我们了解 Maven。Maven 是一个项目管理和综合工具，它通过提供一组规则和标准化的构建过程来简化 Java 项目的构建...
手写简易版rpc框架
weixin_64704029的博客
08-11 286
简易版的rpc框架实现思路
【Netty】netty接收、读、写整体过程源码解析
最新发布
日拱一卒，不期速成！
08-11 578
【Netty】netty接收、读、写整体过程源码解析
Netty学习笔记01--出入站处理器顺序
罗曼蒂克在消亡
08-10 321
出入站处理器的执行顺序相关注意事项
Netty高性能数据结构
努力分享一些干货内容，纯干货，没有一点水
08-07 793
它的基本思路是在哈希表中发生冲突时，线性地探测哈希表中的下一个位置来寻找空闲的存储位置。时间轮算法将时间分割成一个个固定大小的时间片，并将任务安排到相应的时间片上，从而优化了定时任务的管理。类型的无锁队列，允许多个线程同时提交任务，而由单个事件循环线程处理这些任务。它通过将定时任务分配到轮盘上的不同槽位来避免高频率的任务调度开销，这种设计主要用于处理大量的定时任务。所谓的高性能数据结构是指，那些在特定场景下优化了性能和效率的数据结构，通常能够提供更快的操作速度、更低的内存消耗或更高的并发处理能力。
Java异步IO框架：Netty快速入门与架构解析
异步IO允许应用程序在等待数据准备就绪时执行其他任务，而不是阻塞等待。Netty基于NIO（非阻塞IO）库，提供了更高级别的抽象，使得开发者可以更容易地构建高并发、低延迟的网络应用。在Netty中，IO操作是异步的，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值