Netty使用例子 - @by_TWJ

已于 2024-03-13 15:26:25 修改
阅读量788 收藏 21
点赞数 22
分类专栏： java 文章标签： java
于 2024-03-07 19:57:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010101252/article/details/136544323
版权

Netty使用

Netty使用

  • Netty编写HTTP
  • Netty编写HTTPS
  • Netty编写WebSocket
  • Netty编写序列化数据

代码： gitee仓库

1、编码器/解码器

1.1、HTTP编码器/解码器

在这里插入图片描述

1.2、WebSocket编码器/解码器

在这里插入图片描述

1.3、序列化数据编码器/解码器

  1. JDK 序列化
    在这里插入图片描述

  2. JBoss Marshalling 序列化

在这里插入图片描述

  1. Protocol Buffers 序列化

在这里插入图片描述

2、编写例子

构建Netty例子的包

这里使用gradle

    implementation 'io.netty:netty-all:4.1.107.Final'

2.1、Netty编写HTTP服务

创建一个HTTP服务，接收JSON请求，并返回JSON数据

java代码

例子1、

public class NettyHttpServer {
    public static void main(String[] args) {

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup eventGroup = new NioEventLoopGroup();
        new ServerBootstrap()
                .group(bossGroup,eventGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer(){
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        ch.pipeline().addLast(new HttpServerCodec());
//                        ch.pipeline().addLast(new HttpClientCodec());
                        ch.pipeline().addLast(new HttpObjectAggregator(65535));
                        ch.pipeline().addLast(new SimpleChannelInboundHandler<FullHttpRequest>(){
                            @Override
                            protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest fullHttpRequest) throws Exception {
                                // 处理请求信息，并返回json数据
                                String result = requestMappingHandle(fullHttpRequest);

                                ByteBuf byteBuf = Unpooled.wrappedBuffer(result.getBytes(StandardCharsets.UTF_8));
                                FullHttpResponse fullHttpResponse = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK,byteBuf);
                                fullHttpResponse.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/json;charset=UTF-8");
                                fullHttpResponse.headers().set(HttpHeaderNames.CONTENT_LENGTH, byteBuf.readableBytes());

                                ctx.writeAndFlush(fullHttpResponse).addListener(ChannelFutureListener.CLOSE);
                            }
                        });
                    }


                })
                .bind(8080)
        ;

    }

    private static String requestMappingHandle(FullHttpRequest fullHttpRequest) {

        ByteBuf byteBuf = fullHttpRequest.content();

        System.out.println("HTTP METHOD："+fullHttpRequest.method().name());
        System.out.println("HTTP URI："+fullHttpRequest.uri());
        System.out.println(HttpHeaderNames.CONTENT_TYPE+"："+fullHttpRequest.headers().get(HttpHeaderNames.CONTENT_TYPE));
        System.out.println("接收JSON:\n"+byteBuf.toString(CharsetUtil.UTF_8));
        return "{\"content\": \"测试 ，返回请求body\"}";
    }
}

2.2、Netty编写HTTPS（SSL）服务

编写ssl服务，只需要在 channelPipline 上添加ch.pipeline().addLast(“ssl”, new SslHandler(engine)) 即可。

java代码
public class NettyHttpSSLServer {
    public static void main(String[] args) throws CertificateException, SSLException {

        // Configure SSL. 这里使用自签名的SSL，用来测试
        final SslContext sslCtx = ServerUtil.buildSslContext();


        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup eventGroup = new NioEventLoopGroup();
        new ServerBootstrap()
                .group(bossGroup,eventGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer(){
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        SSLEngine engine = sslCtx.newEngine(ch.alloc());
                        ch.pipeline().addLast("ssl", new SslHandler(engine));
//                        ch.pipeline().addLast("ssl", sslCtx.newHandler(ByteBufAllocator.DEFAULT));
                        ch.pipeline().addLast(new HttpServerCodec());
                        ch.pipeline().addLast(new HttpObjectAggregator(65535));

                        ch.pipeline().addLast(new SimpleChannelInboundHandler<FullHttpRequest>(){
                            @Override
                            protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest fullHttpRequest) throws Exception {
                                // 处理请求信息，并返回json数据
                                String result = requestMappingHandle(fullHttpRequest);

                                ByteBuf byteBuf = Unpooled.wrappedBuffer(result.getBytes(StandardCharsets.UTF_8));
                                FullHttpResponse fullHttpResponse = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK,byteBuf);
                                fullHttpResponse.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/json;charset=UTF-8");
                                fullHttpResponse.headers().set(HttpHeaderNames.CONTENT_LENGTH, byteBuf.readableBytes());

                                ctx.writeAndFlush(fullHttpResponse).addListener(ChannelFutureListener.CLOSE);
                            }
                        });
                    }


                })
                .bind(8080)
        ;

    }

    private static String requestMappingHandle(FullHttpRequest fullHttpRequest) {

        ByteBuf byteBuf = fullHttpRequest.content();

        System.out.println("HTTP METHOD："+fullHttpRequest.method().name());
        System.out.println("HTTP URI："+fullHttpRequest.uri());
        System.out.println(HttpHeaderNames.CONTENT_TYPE+"："+fullHttpRequest.headers().get(HttpHeaderNames.CONTENT_TYPE));
        System.out.println("接收JSON:\n"+byteBuf.toString(CharsetUtil.UTF_8));
        return "{\"content\": \"测试 ，返回请求body\"}";
    }
}




/**
 * 证书生成
 */
public final class ServerUtil {

    // 启动的时候通过 -Dssl=true 来切换是否使用ssl
    private static final boolean SSL = System.getProperty("ssl") != null;

    private ServerUtil() {
    }

    public static SslContext buildSslContext() throws CertificateException, SSLException {
        if (!SSL) {
            return null;
        }
        // 自签名的证书
        SelfSignedCertificate ssc = new SelfSignedCertificate();
        return SslContextBuilder
                .forServer(ssc.certificate(), ssc.privateKey())
                .build();
    }
}

2.3、Netty编写WebSocket服务

2.3.1、普通的websocket服务

请求地址： ws://127.0.0.1:8080/websocket

public class WebSocketServer {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup eventGroup = new NioEventLoopGroup();
        new ServerBootstrap()
                .group(bossGroup,eventGroup)
                .channel(NioServerSocketChannel.class)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new WebSocketServerChannelInitializer())
                .bind(8080).sync()
                .channel().closeFuture().sync()
        ;
    }
}

@Slf4j
public class WebSocketServerChannelInitializer extends ChannelInitializer<Channel> {



    @Override
    protected void initChannel(Channel ch) throws Exception {
        ch.pipeline().addLast(
                new HttpServerCodec(),
                new HttpObjectAggregator(65536),
                new WebSocketServerProtocolHandler("/websocket"),
                new TextFrameHandler(),
                new BinaryFrameHandler(),
                new ContinuationFrameHandler()

        );
    }

    private class TextFrameHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {

            log.info("TextFrameHandler {}",msg.text());
        }
    }

    private class BinaryFrameHandler extends SimpleChannelInboundHandler<BinaryWebSocketFrame> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, BinaryWebSocketFrame msg) throws Exception {
            log.info("BinaryFrameHandler {}",2);
        }
    }

    private class ContinuationFrameHandler extends SimpleChannelInboundHandler<ContinuationWebSocketFrame> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, ContinuationWebSocketFrame msg) throws Exception {
            log.info("ContinuationFrameHandler {}",3);
        }
    }
}
2.3.2、聊天室websocket服务

请求地址： ws://127.0.0.1:8080/ws

ChannelConfigs、ChatServer、ChatServerChannelInitializer、HttpRequestHandler(http服务，跳过websocket服务)

1. ChannelConfigs.java

public class ChannelConfigs {
    /**
     * 定义一个channel组，管理所有的channel * GlobalEventExecutor.INSTANCE 是全局的事件执行器，是一个单例
     */
    private  static ChannelGroup channelGroup;

    /**
     * 存放用户与Chanel的对应信息，用于给指定用户发送消息
     */
    private static ConcurrentHashMap<String, Channel> userChannelMap = new ConcurrentHashMap<>();

    private static Object object = new Object();
    /**
     * 获取channel组
     */
    public static ChannelGroup getChannelGroup() {
        if(channelGroup==null){
            synchronized (object){
                if(channelGroup==null){
                    channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
                    return channelGroup;
                }else{
                    return channelGroup;
                }
            }
        }else{
            return channelGroup;
        }
    }

    /**
     * 获取用户channel map
     */
    public static ConcurrentHashMap<String, Channel> getUserChannelMap() {
        return userChannelMap;
    }
}

2. ChatServer.java

public class ChatServer {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup eventGroup = new NioEventLoopGroup();
        new ServerBootstrap()
                .group(bossGroup,eventGroup)
                .channel(NioServerSocketChannel.class)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ChatServerChannelInitializer())
                .bind(8080).sync()
                .channel().closeFuture().sync()
        ;
    }
}

3. ChatServerChannelInitializer.java


public class ChatServerChannelInitializer extends ChannelInitializer<Channel> {

    @Override
    protected void initChannel(Channel ch) throws Exception {
        ch.pipeline().addLast(
                new HttpServerCodec(),
                new ChunkedWriteHandler(),
                new HttpObjectAggregator(65536),
                new HttpRequestHandler("/ws"),
                new WebSocketServerProtocolHandler("/ws"),
                new TextWebSocketFrameHandler()

        );
    }

    public class TextWebSocketFrameHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> { //1
        private final ChannelGroup group;

        public TextWebSocketFrameHandler() {
            group = ChannelConfigs.getChannelGroup();
        }

        @Override
        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {    //2
            if (evt == WebSocketServerProtocolHandler.ServerHandshakeStateEvent.HANDSHAKE_COMPLETE) {

                ctx.pipeline().remove(HttpRequestHandler.class);    //3

                group.writeAndFlush(new TextWebSocketFrame("Client " + ctx.channel() + " joined"));//4

                group.add(ctx.channel());    //5
            } else {
                super.userEventTriggered(ctx, evt);
            }
        }

        @Override
        public void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
            group.writeAndFlush(msg.retain());    //6
        }
    }


}

4. HttpRequestHandler.java

public class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {    //1
    private final String wsUri;
    private static final File INDEX;

    static {
        URL location = HttpRequestHandler.class.getProtectionDomain().getCodeSource().getLocation();
        try {
            String path = location.toURI() + "index.html";
            path = !path.contains("file:") ? path : path.substring(5);
            INDEX = new File(path);
        } catch (URISyntaxException e) {
            throw new IllegalStateException("Unable to locate index.html", e);
        }
    }

    public HttpRequestHandler(String wsUri) {
        this.wsUri = wsUri;
    }

    @Override
    public void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
        if (wsUri.equalsIgnoreCase(request.getUri())) {
            ctx.fireChannelRead(request.retain());                    //2
        } else {
            if (HttpHeaders.is100ContinueExpected(request)) {
                send100Continue(ctx);                                //3
            }

            RandomAccessFile file = new RandomAccessFile(INDEX, "r");//4

            HttpResponse response = new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.OK);
            response.headers().set(HttpHeaders.Names.CONTENT_TYPE, "text/html; charset=UTF-8");

            boolean keepAlive = HttpHeaders.isKeepAlive(request);

            if (keepAlive) {                                        //5
                response.headers().set(HttpHeaders.Names.CONTENT_LENGTH, file.length());
                response.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
            }
            ctx.write(response);                    //6

            if (ctx.pipeline().get(SslHandler.class) == null) {        //7
                ctx.write(new DefaultFileRegion(file.getChannel(), 0, file.length()));
            } else {
                ctx.write(new ChunkedNioFile(file.getChannel()));
            }
            ChannelFuture future = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);            //8
            if (!keepAlive) {
                future.addListener(ChannelFutureListener.CLOSE);        //9
            }
        }
    }

    private static void send100Continue(ChannelHandlerContext ctx) {
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE);
        ctx.writeAndFlush(response);
    }

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

2.4、Netty编写序列化

2.4.1、使用Protobuf序列化

引入的包
这里使用gradle构建


    implementation 'com.google.protobuf:protobuf-java:4.26.0-RC3'
    implementation 'com.google.protobuf:protobuf-java-util:4.26.0-RC3'
java代码

Student.proto

//未指定则使用proto2
syntax = "proto2";

//生成 proto 文件所在包路径
package com.wxw.notes.protobuf.proto;

//生成 proto 文件所在包路径
option java_package = "bean.proto";

//生成 proto 文件名
option java_outer_classname="StudentProto";

message Student{
  //自身属性
  optional string name = 1;
  optional int32 age = 2;
  optional string classes = 3;
}

NettyProtocolBuffersServer.java 服务端

public class NettyProtocolBuffersServer {
    public static void main(String[] args) throws CertificateException, SSLException, InterruptedException {



        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup eventGroup = new NioEventLoopGroup();
        new ServerBootstrap()
                .group(bossGroup,eventGroup)
                .channel(NioServerSocketChannel.class)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();

                        Protobuf 的编码器和解码器
                        pipeline.addLast(new ProtobufVarint32FrameDecoder());
                        pipeline.addLast(new ProtobufDecoder(StudentProto.Student.getDefaultInstance()));
                        pipeline.addLast(new ProtobufVarint32LengthFieldPrepender());
                        pipeline.addLast(new ProtobufEncoder());

                        pipeline.addLast(new SimpleChannelInboundHandler<StudentProto.Student>() {
                            @Override
                            protected void channelRead0(ChannelHandlerContext ctx, StudentProto.Student msg) throws Exception {
                                System.out.println("name:"+msg.getName());
                                System.out.println("age:"+msg.getAge());
                                System.out.println("classes:"+msg.getClasses());
                                StudentProto.Student student = StudentProto.Student.newBuilder()
                                        .setAge(100)
                                        .setClasses("北京市西城区")
                                        .setName("大江东去浪淘尽")
                                        .build();
                                ctx.writeAndFlush(student);

                            }
                        });

                    }
                })
                .bind(8080).sync()
                .channel().closeFuture().sync()
        ;
//        System.out.println("Server start at port : " + "8080");

    }


}

NettyProtocolBuffersClient.java 客户端

public class NettyProtocolBuffersClient {
    public static void main(String[] args) throws CertificateException, SSLException, InterruptedException {


        startServer();

    }

    private static void startServer() {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup(1);
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup)
                    .channel(NioSocketChannel.class) // 这里通道是客户端通道，而不是服务端的NioServerSocketChannel
                    .handler(new ChannelInitializer<Channel>(){

                        @Override
                        protected void initChannel(Channel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();

                            //Protobuf 的编码器和解码器
                            pipeline.addLast(new ProtobufVarint32FrameDecoder());
                            pipeline.addLast(new ProtobufDecoder(StudentProto.Student.getDefaultInstance()));
                            pipeline.addLast(new ProtobufVarint32LengthFieldPrepender());
                            pipeline.addLast(new ProtobufEncoder());

                            pipeline.addLast(new SimpleChannelInboundHandler<StudentProto.Student>() {
                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                    System.out.println("连通后，发送消息");

                                    StudentProto.Student student = StudentProto.Student.newBuilder()
                                            .setAge(28)
                                            .setClasses("高三")
                                            .setName("张三")
                                            .build();
                                    ctx.channel().writeAndFlush(student);
                                }

                                @Override
                                protected void channelRead0(ChannelHandlerContext ctx, StudentProto.Student msg) throws Exception {
                                    System.out.println("接收消息");
                                    System.out.println("name:" + msg.getName());
                                    System.out.println("age:" + msg.getAge());
                                    System.out.println("classes:" + msg.getClasses());

                                    ctx.channel().close().addListener((ChannelFutureListener) future -> {
                                        if (future.isSuccess()) {
                                            // Channel关闭成功
                                            System.out.println("Channel关闭成功");
                                        } else {
                                            // Channel关闭失败
                                            System.out.println("Channel关闭失败");
                                        }
                                    });
                                }
                            });
                        }
            });
            //与对应的url建立连接通道
            ChannelFuture channelFuture = bootstrap.connect("localhost",8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

3、tomcat与Netty对比

我们了解了Netty，他的性能更强，那么我们是否可以替代tomcat呢？
实际上tomcat也有基于NIO的优化，并且还有个APR模型，那我们何必用Netty替代tomcat呢。

4.1、tomcat

参考文章：Tomcat的BIO、NIO、APR模式对比与性能测试结果

tomcat支持三种运行模式

  • BIO 阻塞式(tomcat7以下默认)
  • NIO 非阻塞式(tomcat8及以上默认, springboot默认)
  • APR(Apache Portable Runtime)

APR：Tomcat将以JNI(Java Native Interface)的形式调用Apache HTTP服务器的核心动态链接库来处理文件读取或网络传输操作，从而大大提高Tomcat对静态文件的处理性能。Tomcat apr是在Tomcat上运行高并发应用的首选模式。

3.2、tomcat与Netty区别

tomcat 是使用Http协议通讯的，它是一个容器。
Netty 是一个异步事件驱动的网络应用框架，可以使用自定义协议，或者用已有的Http协议等。

相关文章

u010101252
关注
专栏目录
netty 使用示例
weixin_43931625的博客
05-21 438
netty 使用示例
netty-tcnative-2.0.27.Final-SNAPSHOT-linux-aarch_64.jar
09-30
在使用netty做 openssl 中使用 netty-tcnative-boringssl-static 在 linux-x86_64/osx-x86_64/windows-x86_64 分别对cpu 不同平台支持，但是在鲲鹏arm 处理上缺没有相关支持，导致在arm64 服务器上，没法运行比如 ...
Netty官方 入门示例详解
最新发布
2401_83641314的博客
03-30 304
总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！
netty简单实例
03-24
博客文章对应的源代码，只是简单的使用，属于入门级别
netty各种例子
09-14
基于netty各种例子。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Netty使用实例
11-15 704
http://javacrazyer.iteye.com/blog/1748198 贴上两个自己写好的例子，以便备注，以下两个例子基于netty-3.5.7.Final.jar用Junit进行测试   第一个例子：简单的发送字符串，接收字符串“Hello, World”   Java代码   package com.wujintao.netty;
Netty实例几则
weixin_30466421的博客
05-01 196
Netty实例几则 Netty是基于JDK NIO的网络框架 简化了NIO编程, 不用程序自己维护selector, 将网络通信和数据处理的部分做了分离 多用于做底层的数据通信, 心跳检测(keepalived) 1. 数据通信 1.1 Hello World public class Server { pub...
netty-transport-native-epoll-4.1.15.Final-linux-x86_64.jar
02-26
java运行依赖jar包
netty-transport-native-kqueue-4.1.15.Final-osx-x86_64.jar
02-26
java运行依赖jar包
netty-transport-native-epoll-4.1.36.Final-linux-x86_64.jar
02-26
java运行依赖jar包
netty-spring-mvc-master.rar_netty_netty spring_netty4 spring_s
09-21
在实际的项目中，`netty-spring-mvc-master`可能包含了以下目录结构： - `src/main/java`: 存放Java源代码，包括Netty的服务器端代码、Spring的配置类以及业务逻辑类。 - `src/main/resources`: 存放Spring的配置...
Netty系列-简单示例
长青树呀
12-05 687
还是实现发送命令到服务端获取时间的功能，这里是Netty实现。对比之前的java nio实现的方式，Netty封装的还是非常简洁。同时单纯的对比Netty的Server和Client也能看出有许多相似之处。
netty入门实例
weixin_34015566的博客
07-16 84
TimeServer.java package netty.timeserver.server; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty....
Netty简单示例
书香水墨
07-19 1362
一、
使用netty开发简单样例
infi
03-16 1635
Server端代码： EchoServer.java package com.zhuyun.test; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty
netty入门示例
Little_fxc的博客
05-11 1036
前言 现在，我们开始编写一个最简单的Netty示例，在这之前我们先熟悉一下最基本的编码实现步骤！ Netty实现通信的步骤：（客户端与服务器端基本一致） 创建两个的NIO线程组，一个专门用于网络事件处理（接受客户端的连接），另一个则进行网络通信读写。 创建一个ServerBootstrap对象，配置Netty的一系列参数，例如接受传出数据的缓存大小等等。 创建一个实际处理数据的类ChannelInitializer，进行初始化的准备工作，比如设置接受传出数据的字符集、格式、已经实际处理数据的接口。 绑定端
Netty入门实例
星之空
06-22 801
最近读了许多基于Netty的代码，发现Netty实在是网络通信开发的不二之选，值得深入学习。它的性能和可靠性已经有许多应用实践的背书，单从代码来讲，也是极简洁优雅的。 本文提供一个完整入门实例，实现一个简单的客户端和服务器通信的例子：客户端发送数据到服务端，服务端稍微加工然后再发送回客户端。后面也简单提了下出现粘包拆包问题的原因，以及通过Netty编码解码器解决该问题的思路。 目录 目录...
Netty开发的例子
杨杨的博客
10-30 739
一个Echo开发的例子的服务器端口public class EchoServer { //具体的连接方法如下 public void bind(int port) throws Throwable{ //创建一个线程组 NioEventLoopGroup parent=new NioEventLoopGroup(); NioEventL
netty-websocket-spring-boot-starter的@Event
05-24
@Event 是 netty-websocket-spring-boot-starter 中的一个注解，用于标记一个方法为事件处理方法。当 WebSocket 接收到消息时，会触发对应的事件，并调用被 @Event 注解的方法进行处理。 @Event 注解有两个属性： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值