Netty快速学习3-第一个测试实例

最新推荐文章于 2023-05-29 20:41:08 发布
最新推荐文章于 2023-05-29 20:41:08 发布
阅读量459 收藏
点赞数
分类专栏： Netty快速学习 文章标签： java netty echo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gzt19881123/article/details/124739945
版权

记录 netty 的 hello world 级实例代码

目录

说明

几乎所有的学习netty资料都是以一个 Echo 程序为开始，
所谓Echo程序 ：就是应答服务， 客户端传递什么消息 服务端原封不动的返回给客户端。

Echo程序包含 服务端代码 和 客户端代码， Netty的服务端客户端的代码几乎定死的框架结构。

服务端

启动主体程序 serverBootstrap

package org.example.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author admin
 */
public class EchoServer {

    static Logger logger = LoggerFactory.getLogger(EchoServer.class);
    private int port;

    public EchoServer(int port) {
        this.port = port;
    }

    /**
     * 启动流程
     */
    public void run() throws InterruptedException {

        //配置服务端线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new EchoServerHandler());
                        }
                    });

            logger.info(">>>>>>>>>>>Echo 服务端启动...");
            //绑定端口，同步等待成功
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();

            //等待服务端监听端口关闭
            channelFuture.channel().closeFuture().sync();
            logger.info(">>>>>>>>>>>Echo 服务端关闭！");

        } finally {

            //优雅退出，释放线程池
            workGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }


    public static void main(String[] args) throws InterruptedException {
        int port = 8081;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        }
        new EchoServer(port).run();
    }

}

服务端 Channel 处理器


package org.example.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.Charset;

/**
 * @author admin
 */
@ChannelHandler.Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
    static Logger logger = LoggerFactory.getLogger(EchoServerHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {

        ByteBuf data = (ByteBuf) msg;

        logger.info(">>>>>>>>>>>EchoServerHandle 收到数据: {}", data.toString(Charset.forName("GBK")));
        ctx.writeAndFlush(data);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        logger.info(">>>>>>>>>>>EchoServerHandle 接受完毕！");
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
        logger.info(">>>>>>>>>>>EchoServerHandle 关闭！");
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        logger.error(">>>>>>>>>>>EchoServerHandle 异常 ", cause);
        ctx.close();
    }


    @Override
    public void channelRegistered(ChannelHandlerContext ctx) {
        logger.info("EchoServerHandle channelRegistered");
    }

    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) {
        logger.info("EchoServerHandle channelUnregistered");
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        logger.info("EchoServerHandle channelActive");
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        logger.info("EchoServerHandle channelInactive");
    }
}

快速测试服务端

window 打开Dos命令行窗口：
输入 telnet localhost 8081 看是否能进入。
然后观察 后台服务端控制台日志信息：
在这里插入图片描述

此时 随便输入一个字母 例如：A 连接将中断，服务端控制台打印：

21:21:21.109 [nioEventLoopGroup-3-5] INFO org.example.netty.EchoServerHandler - >>>>>>>>>>>EchoServerHandle 收到数据: A
21:21:21.109 [nioEventLoopGroup-3-5] INFO org.example.netty.EchoServerHandler - >>>>>>>>>>>EchoServerHandle 接受完毕！
21:21:21.110 [nioEventLoopGroup-3-5] INFO org.example.netty.EchoServerHandler - >>>>>>>>>>>EchoServerHandle 关闭！
21:21:21.110 [nioEventLoopGroup-3-5] INFO org.example.netty.EchoServerHandler - EchoServerHandle channelInactive
21:21:21.110 [nioEventLoopGroup-3-5] INFO org.example.netty.EchoServerHandler - EchoServerHandle channelUnregistered

连接之所以立刻关闭，主要是因为，服务端设置了：

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        logger.info(">>>>>>>>>>>EchoServerHandle 接受完毕！");
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
        logger.info(">>>>>>>>>>>EchoServerHandle 关闭！");
    }

客户端

启动主体程序 bootstrap

package org.example.netty;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.InetSocketAddress;

public class EchoClient {
    static Logger logger = LoggerFactory.getLogger(EchoClient.class);
    private String host;

    private int port;

    public EchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws InterruptedException {

        EventLoopGroup group = new NioEventLoopGroup();
        try {

            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)

                    .channel(NioSocketChannel.class)

                    .remoteAddress(new InetSocketAddress(host, port))
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new EchoClientHandler());
                        }
                    });

            //连接到服务端，connect是异步连接，在调用同步等待sync，等待连接成功
            ChannelFuture channelFuture = bootstrap.connect().sync();
            logger.info(">>>>>>>>>>>Echo 客户端启动...");

            //阻塞直到客户端通道关闭
            channelFuture.channel().closeFuture().sync();
            logger.info(">>>>>>>>>>>Echo 客户端关闭！");
        } finally {
            //优雅退出，释放NIO线程组
            group.shutdownGracefully();
        }

    }

    public static void main(String[] args) throws InterruptedException {
        new EchoClient("127.0.0.1", 8081).start();
    }

}

客户端 Channel 处理器

package org.example.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.Charset;

/**
 * @author admin
 */
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    static Logger logger = LoggerFactory.getLogger(EchoClientHandler.class);

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) {

        logger.info(">>>>>>>>>>>EchoClientHandler 接受到数据: {}", msg.toString(Charset.forName("GBK")));

    }


    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        logger.info(">>>>>>>>>>>Active");
        ctx.writeAndFlush(Unpooled.copiedBuffer(
                "hello,这是客户端发出的echo消息", Charset.forName("GBK")));
    }


    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        logger.info(">>>>>>>>>>>EchoClientHandler channelReadComplete");
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        logger.error(">>>>>>>>>>>EchoClientHandler 异常 ", cause);
        ctx.close();
    }
}

快速测试客户端

运行客户端main方法：
客户端控制台打印：
在这里插入图片描述

同时服务端控制台打印：
在这里插入图片描述

简要说明 EventLoop

1个 EventLoop 类似一个线程，
1个 Channel 就是一个客户端和服务端的连接通道（看成一个TCP长连接）
1个EventLoop 可以服务多个Channel
1个Channel 只对应一个EventLoop

可以创建多个 EventLoop 来优化资源利用，也就是EventLoopGroup
EventLoopGroup 负责分配 EventLoop 到新创建的 Channel，里面包含多个EventLoop。

回顾一下多线程Reactor模型：
在这里插入图片描述

小时候的阳光
关注
专栏目录
Netty学习笔记 - 1 (带源码分析部分)
小小一只可乐猪
02-11 597
netty学习笔记，哔哩哔哩尚硅谷课程 韩老师主讲，笔记有4篇，很全面包含源码分析部分，结尾有相关文件 阿里云盘 欢迎下载。
netty学习笔记
qq_38777662的博客
08-12 685
io.netty PART1 Netty——异步和事件驱动 1.netty概述 Netty 是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器和客户端。 在网络编程领域，Netty是Java的卓越框架。它驾驭了Java高级API的能力，并将其隐藏在一个易于使用的API之后。Netty使你可以专注于自己真正感兴趣的——你的应用程序的独一无二的价值。 2.netty特性  非阻塞网络调用使得我们可以不必等待一个操作的完成。完全异步的 I/O 正是基于这个特性构建的，并且
Netty性能测试
11-12
从测试结果看，Netty性能是非常高的，在所有使用默认配置的情况下，单台服务器能够达到4万次请求解析，作为RPC框架是足够用的。
基于Netty的Comet测试及调优
freeway2000
08-02 401
  测试环境：   服务器 1台   OS: Red Hat Enterprise Linux Server release 5.4   CPU: 4xIntel(R) Xeon(R) CPU E5450 @ 3.00GHz   MEMORY:4G 客户端5台，配置同服务器 上述的测试环境都是采用的虚拟机，而且虚拟机性能不是很好，所以我主要是测连接数，其中有涉及到性能的地方不具...
Netty 一个简单的测试
YKenan的博客
05-26 1020
Netty 一个简单的测试1. 导包2. 测试类2. 初始化器3. 自定义助手类4. 自定义助手类 1. 导包 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.50.Final</version>
netty测试项目
qq_43147121的博客
04-23 238
今天学习了netty打算写一个小的测试程序，来练习一下怎么使用 首先我们打算写的是一个基于web的聊天室小程序让我们梳理一下 首先我们编写一个启动器这里我们采用的是主从多线程reactor模型 public class WebSocketServer{ public static void main(String[] args) throws InterruptedException { ...
Netty4.1实战-手写RPC框架.pdf
最新发布
03-26
##### 3.1 第一章：自定义配置XML - **目标**：定义一套自定义XML配置文件，以便更灵活地管理RPC服务的相关配置信息。 - **实现步骤**： 1. **定义XML Schema**：创建一个XML Schema文件（rpc.xsd），规定合法的...
netty:netty 实例
06-13
这个实例很可能是 Netty 框架的一个源码仓库，名为 "netty-master"，通常包含了 Netty 的核心组件、示例代码、测试用例以及相关的文档。 在深入探讨 Netty 的知识点之前，先来理解一下什么是框架。框架是一种半成品...
Netty学习一：官网文档翻译（4.x版本）
AnY11的专栏
12-07 2603
官网地址：https://netty.io/ Netty是一个异步事件驱动的网络应用框架用于快速开发可维护的高性能协议服务器和客户端。 Netty是一个NIO客户端服务器框架，它支持快速和容易地开发网络应用程序，如协议服务器和客户端。它极大地简化和流线型网络编程，如TCP和UDP套接字服务器。 “快速和简单”并不意味着最终的应用程序将受到可维护性或性能问题的影响。Netty经过精心设计，积累...
Netty测试记录
sky4160864的专栏
12-13 299
描述： 1.用netty+json做服务接收数据，模拟近似单一业务（接收入库，有则更新） 2.数据库mysql5.6:用到ON DUPLICATE KEY UPDATE 3.服务端CPU E5-2620（双处理器，每个处理器6核12线程） 内存16 系统server2007(32位) 4.客户端i7-6700K(4核8线程) 内存8G WIN10 5.网络42环保专网（客户端用的无线连接） 6.模...
netty(6)--单元测试
TOPsnap的博客
02-24 620
netty单元测试
Netty 入门 编写一个简单Echo服务器
小蜜蜂的博客
06-11 377
Echo 客户端和服务器之间的交互是非常简单的；在客户端建立一个连接之后，它会向服务器发送一个或多个消息，反过来，服务器又会将每个消息回送给客户端。虽然它本身看起来好像用处不大，但它充分地体现了客户端/服务器系统中典型的请求-响应交互模式。 通过同时实现客户端和服务器，我们将能够更加全面地理解 Netty 的 API，好了无需多言，直接上代码，开启netty之路吧。 服务端代码： 所...
Netty实战（九）单元测试
一起学习一起进步~
05-29 1203
单元测试的基本思想是：以尽可能小的区块测试代码，并且尽可能地和其他的代码模块以及运行时的依赖（如数据库和网络）相隔离。如果应用程序能通过测试验证每个单元本身都能够正常地工作，那么在出了问题时将可以更加容易地找出根本原因。ChannelHandler 是 Netty 应用程序的关键元素，所以彻底地测试它们应该是开发过程的一个标准部分。最佳实践要求你的测试不仅要能够证明实现是正确的，而且还要能够很容易地隔离那些因修改代码而突然出现的问题。这种类型的测试叫作单元测试。
Netty单元测试
大智制杖
03-17 223
感慨 一晃两年多了，自从刚开始给公司编写的几个网络模块，后来就没有在度使用的机会了。 讲解Netty的书籍有许多，其中《Netty实战》这本书比较经典，推荐大家用这本书入门。 概述 工欲善其事，必先利其器。 作为一个网络处理框架，如果没有脱离网络的单元测试，那么你要构建完整的一套代码，方能测试相应功能，是无法想象的。 ChannelHandler 是 Netty 应用程序的关键元素，无非就是处理输...
netty篇-单元测试
StivenYang
08-06 173
netty篇-单元测试
netty如何进行单元测试
weixin_30325071的博客
07-17 386
一种特殊的Channel 实现——EmbeddedChannel，它是Netty 专门为改进针对ChannelHandler 的单元测试而提供的。 将入站数据或者出站数据写入到EmbeddedChannel 中，然后检查是否有任何东西到达了ChannelPipeline 的尾端。以这种方式，你便可以确定消息是否已经被编码或者被解码过了，以及是否触发了任何的ChannelHandler 动作。 ...
java测试netty_《Netty官方文档》基准测试
weixin_30000407的博客
02-25 306
原文链接 译者：lijunshuNetty有一个模块叫’netty-microbench’，我们可以用他来执行一系列的微型基准测试。Netty-microbench是基于OpenJDK JMH构件的(HotSpot的推荐基准测试方案)。当你开始netty基准测试时，你不需要额外的依赖。运行基准测试你可以通过maven 命令行或者直接从IDE开始你的基准测试，如果以默认设置开始跑测试，你可以使用命...
Netty 单机百万连接测试
专注基础架构领域
04-24 1896
阻塞IO就是当应用程序向TCP缓冲区发起读取数据申请时，在内核数据没有准备好之前，应用程序会一致处于等待数据的状态，直到内核把数据准备好交给应用程序才结束。**术语描述：**在应用程序调用recvfrom读取数据时，其系统调用直到数据包到达别并且被复制到应用缓冲区中或者发生错误时才返回，此期间一致处于等待，进程从调用直到返回这段时间被阻塞的成为阻塞IO。
深入学习Netty第五版：Java NIO框架权威指南
第一部分“Getting Started”引导读者入门，介绍了Netty与Java NIO API的关系，以及如何构建第一个Netty应用，从基础开始构建对Netty的理解。 第二部分“Core Functions/Parts”深入探讨了Netty的关键组件： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值