netty5简单例子，快速入门

最新推荐文章于 2025-05-07 15:01:46 发布
最新推荐文章于 2025-05-07 15:01:46 发布
阅读量288 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Netty 文章标签： netty java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_37390956/article/details/79982316

添加maven引用：

<!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>5.0.0.Alpha2</version>
</dependency>

1，discard丢弃服务   接收到数据后只做处理不做回应


package nettyStudy;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;

public class DisCardServerHandler extends ChannelHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            ByteBuf in = (ByteBuf) msg;
            System.out.println(in.toString(CharsetUtil.UTF_8));
        } finally {
            ReferenceCountUtil.release(msg);
        }
    }

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



package nettyStudy;

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;

public class DiscardServer {
    private int port;

    public DiscardServer(int port) {
        super();
        this.port = port;
    }

    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        System.out.println("准备运行端口:" + port);
        try {
            ServerBootstrap b = new ServerBootstrap();
            b = b.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 f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0){
            port = Integer.parseInt(args[0]);
        }
        else{
            port = 8080;
        }
        new DiscardServer(port).run();
        System.out.println("server:run()");
    }
}

2，echo响应服务


package nettyStudy;

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;

public class ResponseServer {
    private int port;

    public ResponseServer(int port) {
        super();
        this.port = port;
    }

    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        System.out.println("准备运行端口:" + port);
        try {
            ServerBootstrap b = new ServerBootstrap();
            b = b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new ResponseServerHandler());
                        }
                    })
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true);
            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0){
            port = Integer.parseInt(args[0]);
        }
        else{
            port = 8080;
        }
        new ResponseServer(port).run();
        System.out.println("server:run()");
    }
}



package nettyStudy;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;

public class ResponseServerHandler extends ChannelHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        System.out.println(in.toString(CharsetUtil.UTF_8));
        ctx.write(msg);
    }
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

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

3，时间协议的服务


package nettyStudy;

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;

public class TimeServer {
    private int port;

    public TimeServer(int port) {
        super();
        this.port = port;
    }

    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        System.out.println("准备运行端口:" + port);
        try {
            ServerBootstrap b = new ServerBootstrap();
            b = b.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 f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0){
            port = Integer.parseInt(args[0]);
        }
        else{
            port = 8080;
        }
        new TimeServer(port).run();
        System.out.println("server:run()");
    }
}


package nettyStudy;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;

import java.util.Scanner;

public class TimeClientHandler extends ChannelHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("server:" + in.toString(CharsetUtil.UTF_8));
        System.out.println("输入应答server的信息:");
        Scanner cin = new Scanner(System.in);
        String content = cin.nextLine();
        final ByteBuf bb = ctx.alloc().buffer();
        bb.writeBytes(content.getBytes());
        final ChannelFuture f = ctx.writeAndFlush(bb);
        f.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                System.out.println("发送成功");
            }
        });
    }

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


package nettyStudy;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class TimeClient {
    public static void main(String[] args) throws InterruptedException {
        String host = "127.0.0.1";
        int port = 8080;
        EventLoopGroup workergroup = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(workergroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new TimeClientHandler());
                }
            });

            ChannelFuture f = b.connect(host, port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workergroup.shutdownGracefully();
        }
    }
}


import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;

import java.util.Scanner;

public class TimeServerHandler extends ChannelHandlerAdapter {
    @Override
    public void channelActive(final ChannelHandlerContext ctx) throws Exception {
        Scanner cin = new Scanner(System.in);
        System.out.println("请输入发送的消息:");
        String name = "Hello " + cin.nextLine();
//        String name = "hello world";
        final ByteBuf time = ctx.alloc().buffer(4);
        time.writeBytes(name.getBytes());
        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 channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            ByteBuf in = (ByteBuf) msg;
            System.out.println("client:" + in.toString(CharsetUtil.UTF_8));
        } finally {
            ReferenceCountUtil.release(msg);
        }
    }

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

Netty——简单的入门代码示例
共勉
02-21 1742
一个非常简单的Netty入门示例，简简单单搞定服务端和客户端的通信
Java NIO框架Netty（二）netty5例子，代码详解
lichch的博客
11-21 2980
这是一个netty快速入门的例子,也是我的学习笔记，比较简单，翻译于官方的文档整理后把所有代码注释放在每一行代码中间，简单明了地介绍一些基础的用法。首页这是基于netty5的例子，如果需要使用请依赖netty5的包。maven引用方式<dependency> <groupId>io.netty</groupId> <artifactId>netty-all</arti
Netty5入门3个简单例子
12-01
Netty5入门3个简单例子，让你快速入门，一个服务端、客户端，以及一个参考的网站地址；Netty5是个优秀稳定高效的java服务器框架，特别适用于java游戏服务器快速开发！
3个netty5的例子，简单介绍netty的用法
热门推荐
tjbsl的博客
04-01 2万+
3个netty5的例子，简单介绍netty的用法
Netty5完整例子
09-10
Netty5完整例子,里面包含编码，解码，心跳处理等，代码可用。 例子的内容是：服务端启动,客户端启动,客户端连接服务器后服务器发一个Message的对象给客户端，客户端接受并打印Message里边的内容。编解码的处理为：消息长度[int] + 消息内容[byte[]]。心跳设置的是读写空闲都是10秒[自己定]
netty5入门教程
weixin_34023982的博客
03-17 100
1、Netty是什么？   本质：JBoss做的一个Jar包   目的：快速开发高性能、高可靠性的网络服务器和客户端程序   优点：提供异步的、事件驱动的网络应用程序框架和工具 通俗的说：一个好使的处理Socket的东东 2、Netty的异步事件驱动模型主要涉及到下面几个核心的概念   Channel：表示一个与socket关联的通道  ChannelPipeline： 管道，一个Channel拥...
netty5完整配置实例
08-16
由于netty各个版本之间差异较大，这里整理了一下各个版本的包及样例，使用了maven工程，将各个版本需要的最简jar文件已配置完全，可以在些基础上进行正式项目的开发。
netty的入门经典例子的使用
03-31
这个“netty的入门经典例子的使用”很可能是为了引导初学者了解和掌握 Netty 的基本用法和核心概念。下面将详细阐述 Netty 的基础知识及其在实际应用中的关键点。 首先，Netty 提供了一个高度可定制的事件驱动的...
netty官方例子
12-11
Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。这个“netty官方例子”压缩包提供了一系列的...同时，这些例子也适用于初学者入门，帮助他们快速上手Netty框架。
1.3.1Netty 快速入门
Albert_Richard的博客
11-27 395
Netty 快速入门 下面枚举所有的 Netty 应用程序的基本构建模块，包括客户端和服务器。 BOOTSTRAP Netty 应用程序通过设置 bootstrap（引导）类的开始，该类提供了一个 用于应用程序网络层配置的容器。 CHANNEL 底层网络传输 API 必须提供给应用 I/O操作的接口，如读，写，连接，绑定等等。对于我们来说，这是结构几乎总是会成为一个“socket”。 N
Netty入门（一）：零基础“HelloWorld”详细图文步骤
weixin_33674976的博客
10-31 4392
因为接下来的项目要用到netty,所以就了解一下这个程序，奈何网上的教程都是稍微有点基础的，所以，就写一篇对于netty零基础的，顺便也记录一下。   先扔几个参考学习的网页：  netty 官方API： http://netty.io/4.1/api/index.html netty 中文指南：https://waylau.com/netty-4-user-guide/   （来自个人）   关...
最新Netty5快速入门及实例（视频+源码+笔记）
qq_43713423的博客
11-22 1165
Netty5快速入门及实例视频教程（视频+源码+笔记） 课程目录： 01、第一课NIO 1、传统的socket分析 2、NIO的代码分析 3、网上对于NIO的一些疑惑 02、第二课netty服务端 1、netty服务端helloWorld入门~1 2、netty服务端入门补充~1 03、第三课netty客户端 1、Netty客户端入门~1 04、第四课netty线...
Netty5 案例讲解
蹊源的奇思妙想的博客
07-03 2305
Netty5 案例讲解 分布式框架中通常使用Netty3.x 游戏服务器通常使用Netty4.x、Netty5.x(4、5相差不多，与3相差比较大) Netty5使用对象池取代线程池 服务端 public class Server { public static void main(String[] args) { //服务类 ServerBootstrap b...
netty的快速入门
weixin_43785508的博客
03-12 944
pom的依赖 <dependencies> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.66.Final</version> </dependency> </d
Netty快速入门
最新发布
zhenlong_qu的博客
05-07 917
1、添加netty依赖版本：4.1.25.Final2、创建ChatServer通过前面启动、调用HTTP请求可以看到，这是因为自定义的助手类，接收请求太宽泛了，导致都打印出来了这里做个优化。
Netty5基础应用：快速构建服务端与客户端示例
“Netty5例子”、“Netty5入门”和“Netty例子”强调了这些例子是针对Netty5版本，面向初学者进行学习的素材。 从文件名称列表“说明.txt”、“NettyNioTest”、“SocketClient”中，可以推测出该压缩包中包含了三...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值