netty 核心科技

洪宏鸿

于 2023-04-19 00:01:45 发布

阅读量506

点赞数

分类专栏： java基础文章标签：科技 java 开发语言 netty 学习提纲

本文链接：https://blog.csdn.net/HongZeng_CSDN/article/details/130233991

版权

java基础专栏收录该内容

76 篇文章 1 订阅

订阅专栏

netty 不要虚就是干

介绍一下 netty由来, 解决什么问题, 主要功能,优势劣势

Netty是一个高性能、异步、事件驱动的NIO框架，用于开发网络应用程序，如协议服务器和客户端。它由Java编写，主要用于解决Java网络编程中的各种问题，特别是在性能、可扩展性和灵活性方面。

由来：
Netty起源于2004年，当时它被称为JBoss Netty。它是为了解决JBoss
Remoting框架中的性能问题而创建的。随着时间的推移，Netty逐渐发展成为一个独立的项目，并在许多其他项目和组织中得到广泛应用。

解决的问题：

提高网络应用程序性能：通过使用非阻塞I/O和高效的内存管理，Netty显著提高了网络应用程序的吞吐量和响应时间。
简化网络编程：Netty提供了高级抽象，如Channel、ChannelHandler、ChannelPipeline等，使得网络编程变得更简单、更清晰。
高度可扩展：Netty支持多种协议，如HTTP、WebSocket、Google Protocol Buffers等，可以方便地扩展以支持自定义协议。
内存管理：Netty提供了零拷贝和内存池等特性，有效地减少了内存分配和垃圾回收的开销。

主要功能：

异步事件驱动：基于Java NIO，提供了非阻塞I/O操作，可处理大量并发连接。
灵活的协议支持：支持多种协议（如HTTP、WebSocket、SSL/TLS等），并可轻松扩展以支持自定义协议。
易于使用的API：提供了简洁的API，简化了网络编程，减少了样板代码。
高性能：通过优化内存使用和高效的事件处理，提供了高性能的网络通信。

优势：

高性能：Netty的非阻塞I/O和高效内存管理提供了优秀的性能表现。
易于使用：Netty的API设计简洁，易于理解和使用。
可扩展性：支持多种协议，可以方便地扩展以支持自定义协议。
社区支持：Netty拥有活跃的社区和良好的文档支持，方便用户学习和使用。

劣势：

学习曲线：虽然Netty的API易于使用，但对于初学者来说，理解事件驱动和异步编程模型可能需要一定的时间。
重量级：与轻量级的网络库相比，Netty可能会显得更为复杂和庞大。

总的来说，Netty是一个非常强大、灵活且高性能的网络编程框架，适用于构建各种类型的网络应用程序。

Netty入门示例

接下来，我们将在Spring Boot项目中创建一个简单的Netty入门示例。我们将创建一个简单的TCP服务器，用于接收来自客户端的消息并将消息回显给客户端。

首先，在Spring Boot项目中添加Netty的依赖：


<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.72.Final</version>
</dependency>

创建一个EchoServer类，用于启动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.springframework.stereotype.Component;

@Component
public class EchoServer {

    private final int port;

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

    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) {
                    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();
        }
    }
}

创建一个EchoServerHandler类，用于处理客户端的消息：

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        ctx.writeAndFlush(in);
    }

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

在Spring Boot的主类中启动Netty服务器：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class NettyExampleApplication {

    public static void main(String[] args) throws InterruptedException {
        ConfigurableApplicationContext context = SpringApplication.run(NettyExampleApplication.class, args);
        int port = 8081; // 您可以选择任意端口号  
        EchoServer echoServer = new EchoServer(port);
        echoServer.start();
    }
}

现在，当您启动Spring
Boot应用程序时，Netty服务器将在指定的端口上启动。您可以使用任何TCP客户端连接到此服务器并发送消息，服务器将返回相同的消息作为回显。以下是一个简单的TCP客户端示例，您可以在同一项目中创建一个类来测试刚刚创建的Netty服务器：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class EchoClient {

    public static void main(String[] args) throws Exception {
        String host = "localhost";
        int port = 8081; // 与服务器相同的端口号  

        Socket socket = new Socket(host, port);
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
        String userInput;
        System.out.println("输入要发送的消息：");
        while ((userInput = stdIn.readLine()) != null) {
            out.println(userInput);
            System.out.println("服务器回显: " + in.readLine());
            System.out.println("输入要发送的消息：");
        }
        socket.close();
        in.close();
        out.close();
        stdIn.close();
    }
}

运行上面的EchoClient类后，您将看到控制台提示输入要发送的消息。输入任何消息并按Enter键发送，您将看到服务器的回显消息。

这就是一个简单的Spring
Boot中的Netty入门示例。在实际应用中，您可以根据需要对服务器进行定制，例如添加SSL/TLS支持、自定义协议处理器等。Netty提供了丰富的功能和灵活性，使得它成为构建复杂网络应用程序的理想选择。

既然 netty 可以作为一个服务器, 那么有没有必要结合 springboot 的呢? springboot什么时候会有默认内嵌容器?

结合Spring Boot和Netty有其优势，尤其是在构建高性能的微服务和网络应用程序时。Spring
Boot提供了许多便利的特性，如依赖管理、自动配置、健康检查、度量等，这些特性可以简化应用程序的开发和部署过程。而Netty作为一个高性能的网络编程框架，可以实现高吞吐量、低延迟的通信。

当您创建一个基于Spring Boot的Web应用程序时，Spring Boot会默认提供一个内嵌的Servlet容器。对于Spring Boot
2.x版本，默认的内嵌容器是Tomcat。同时，您还可以选择使用其他Servlet容器，如Jetty或Undertow。内嵌容器的主要优势在于简化了开发和部署流程，您无需单独安装和配置Servlet容器，只需运行一个可执行的JAR文件即可。

Spring Boot并没有默认内嵌Netty作为容器。然而，您可以使用Spring Boot与Netty的结合方案，如Spring WebFlux。Spring
WebFlux是一个基于响应式编程模型的非阻塞Web框架，它可以与Netty一起使用以提供高性能的异步处理。在这种情况下，Spring
Boot将使用Netty作为内嵌的服务器。

总之，将Netty与Spring Boot结合使用可以充分利用两者的优势。Spring
Boot提供了简化开发和部署的特性，而Netty则提供了高性能的网络通信能力。如果您的应用程序需要高性能和可扩展性，那么结合Spring
Boot和Netty是一个值得考虑的方案。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class NettyExampleApplication {

public static void main(String[] args) throws InterruptedException {        ConfigurableApplicationContext context = SpringApplication.run(NettyExampleApplication.class, args);  
    int port = 8081; // 您可以选择任意端口号  
    EchoServer echoServer = new EchoServer(port);        echoServer.start();    }}

这个例子看起来也没把 springboot 跟 netty 很好的结合起来呀?

您是对的，这个例子中，Netty服务器在Spring Boot应用程序中仅仅作为一个独立的组件运行，并没有充分利用Spring
Boot的功能。要更好地将Netty与Spring Boot结合使用，您可以将Netty的部分组件作为Spring Bean进行配置，并利用Spring Boot的依赖注入功能。

以下是一个更好地将Netty与Spring Boot结合的示例：

修改EchoServer类，使其成为一个Spring Bean：

import org.springframework.stereotype.Component;

@Component
public class EchoServer {

    private final int port;

    public EchoServer(@Value("${netty.port}") int port) {
        this.port = port;
    }

    public void start() throws InterruptedException {        ...}
}

注意：这里我们使用了@Component注解，并将端口号通过构造函数注入。

在application.properties中添加Netty服务器的端口配置：

netty.port=8081

修改NettyExampleApplication类，使用依赖注入将EchoServer注入到应用程序中：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class NettyExampleApplication {

    @Autowired
    private EchoServer echoServer;

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(NettyExampleApplication.class, args);
        NettyExampleApplication app = context.getBean(NettyExampleApplication.class);
        app.startNettyServer();
    }

    public void startNettyServer() {
        try {
            echoServer.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这个修改后的示例更好地展示了如何将Netty与Spring Boot结合使用。我们将Netty服务器配置为一个Spring Bean，并通过依赖注入将其注入到Spring
Boot应用程序中。当然，这只是一个简单的示例，实际应用中，您可能需要根据业务需求对Netty进行更多的定制和配置。

netty 框架现实中有什么具体的成功应用案例吗?

Netty是一个非常流行且高性能的NIO框架，广泛应用于分布式系统、RPC框架和大型互联网公司的基础设施中。以下是一些Netty在实际生产环境中的成功应用案例：

腾讯 : 腾讯的很多核心业务，包括即时通讯、在线游戏、文件传输等都采用了Netty作为底层通信框架。
阿里巴巴 : 阿里巴巴的分布式服务框架Dubbo和服务治理组件Nacos都采用了Netty作为底层通信框架。Netty在阿里巴巴的各类分布式服务中发挥着关键作用。
Apache Cassandra : Apache Cassandra是一个高度可扩展且高性能的分布式NoSQL数据库，其底层通信框架就是基于Netty实现的。
Elasticsearch : Elasticsearch是一个分布式搜索和分析引擎，广泛应用于大数据处理和实时日志分析。Elasticsearch的底层通信也使用了Netty。
Netflix : 作为全球著名的流媒体公司，Netflix在其内部的服务调用和通信组件中广泛应用了Netty。
Play Framework : Play是一个用于构建高性能的Web应用程序的框架，其底层HTTP服务器Akka HTTP采用了Netty作为通信基础设施。

这些案例仅仅是Netty众多应用中的一部分。Netty作为一个高性能、可扩展且成熟的NIO框架，已经被许多业界著名的公司和开源项目所采用。

netty核心概念最常用板块的学习提纲

Netty简介

Netty的历史与背景
Netty解决的问题及其在实际项目中的应用场景
Netty的优势与特点

Netty核心概念

Channel, ChannelPipeline, ChannelHandlerContext
ChannelHandler, ChannelInboundHandler, ChannelOutboundHandler
ByteBuf（Netty中的字节缓冲区）

Netty线程模型

EventLoop, EventLoopGroup
EventExecutor, EventExecutorGroup
与Java NIO的对比

Netty传输

NIO, OIO（阻塞IO）, Epoll, Kqueue等传输类型
ServerBootstrap, Bootstrap（客户端）
ServerSocketChannel, SocketChannel
ChannelInitializer

编解码器（Codecs）

ByteToMessageDecoder, MessageToByteEncoder
LengthFieldBasedFrameDecoder, LengthFieldPrepender
StringDecoder, StringEncoder
Protobuf编解码器

实际应用案例与实战

Echo服务器与客户端
HTTP服务器（使用HttpServerCodec, HttpObjectAggregator等）
WebSocket服务器
RPC框架基础实现

Netty性能优化

ByteBuf的内存管理与池化
事件循环分组（bossGroup与workerGroup）
无锁化设计与并发优化

Netty集成

与Spring Boot的集成
使用Netty实现自定义协议

按照以上提纲逐步学习，从基础概念到实际应用案例，您将更好地理解并掌握Netty的核心知识。在学习过程中，建议动手实践各种示例，以加深对Netty的理解和应用能力。

1. Netty简介

Netty的历史与背景 ：
Netty起源于2004年，最初名为JBoss
Network，是一个高性能、可扩展的网络应用框架。它的目的是为了简化网络编程，提高开发者在创建复杂的TCP/IP协议应用时的生产力。随着版本的迭代，Netty逐渐成为了网络编程领域的优秀框架。
Netty解决的问题及其在实际项目中的应用场景 ：
Netty解决了Java NIO在易用性、性能和可扩展性方面的挑战。它广泛应用于分布式系统、RPC框架、负载均衡器、消息队列、代理服务器、游戏服务器等场景。
Netty的优势与特点 ：
高性能：Netty充分利用了Java NIO的特性，提供了零拷贝、异步非阻塞IO等高性能实现；
易用性：Netty提供了丰富的抽象和组件，简化了网络编程的复杂性；
可扩展性：通过灵活的处理器链和编解码器，用户可以轻松地实现自定义的协议和功能；
安全：Netty提供了对SSL/TLS的支持，保证数据传输的安全性。

2. Netty核心概念

Channel ：代表了一个连接，如TCP连接或UDP通道。它是数据传输的载体，可以进行读写操作。
ChannelPipeline ：一个Channel关联的处理器链，负责处理Channel的各种事件。
ChannelHandlerContext ：处理器上下文，为处理器提供了操作ChannelPipeline的接口。

示例：创建一个简单的TCP服务器

EventLoopGroup bossGroup=new NioEventLoopGroup(1);
        EventLoopGroup workerGroup=new NioEventLoopGroup();
        try{
        ServerBootstrap b=new ServerBootstrap();b.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>(){@Override public void initChannel(SocketChannel ch)throws Exception{ch.pipeline().addLast(new MyChannelInboundHandler());}});
        ChannelFuture f=b.bind(8080).sync();f.channel().closeFuture().sync();}finally{
        bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}

3. Netty线程模型

EventLoop ：事件循环，负责处理Channel上的所有事件，如连接、数据读写等。
EventLoopGroup ：事件循环组，负责管理一组EventLoop。

在上面的示例中，我们创建了两个EventLoopGroup：bossGroup和workerGroup。bossGroup负责处理连接请求，workerGroup负责处理连接上的数据读写。

4. Netty传输数据的处理

ByteBuf ：Netty的字节缓冲区，是它处理数据的核心组件。ByteBuf提供了丰富的API，以便用户方便地操作字节数据。
ChannelHandler ：处理器，负责处理ChannelPipeline中的事件。用户可以自定义ChannelHandler，以实现具体的业务逻辑。
ChannelInboundHandler ：处理入站事件的处理器，如读取数据、连接建立等。
ChannelOutboundHandler ：处理出站事件的处理器，如写数据、关闭连接等。

示例：创建一个自定义的ChannelInboundHandler

public class MyChannelInboundHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        try {
            System.out.println("Received message: " + in.toString(CharsetUtil.UTF_8));
        } finally {
            ReferenceCountUtil.release(msg);
        }
    }
}

5. Netty编解码器

编解码器 ：负责将字节数据与对象之间进行转换。Netty提供了丰富的编解码器，如基于长度的解码器、基于行的解码器等。
自定义编解码器 ：用户可以自定义编解码器，以支持自定义的数据格式和协议。编解码器需要实现MessageToMessageDecoder
和MessageToMessageEncoder接口。

示例：创建一个自定义的编解码器

public class MyDecoder extends MessageToMessageDecoder<ByteBuf> {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
        int length = in.readableBytes();
        byte[] bytes = new byte[length];
        in.readBytes(bytes);
        out.add(new String(bytes, CharsetUtil.UTF_8));
    }
}

public class MyEncoder extends MessageToMessageEncoder<String> {
    @Override
    protected void encode(ChannelHandlerContext ctx, String msg, List<Object> out) {
        out.add(Unpooled.copiedBuffer(msg, CharsetUtil.UTF_8));
    }
}

6. Netty与其他框架的整合

Netty可以与其他框架整合，如Spring Boot、gRPC等。通过整合，用户可以更方便地搭建高性能、可扩展的网络应用。

通过以上内容，您应该对Netty的基本概念、功能和使用方法有了一个初步的了解。接下来，您可以深入学习Netty的源码和官方文档，以便在实际项目中更好地应用Netty。

7. Netty性能调优

Netty作为高性能的网络框架，提供了一些性能调优的配置选项，以帮助用户在不同的场景下实现最佳性能。

内存池化 ：Netty支持内存池化，以减少内存分配和回收的开销。通过使用PooledByteBufAllocator，用户可以实现内存池化。
零拷贝 ：Netty支持零拷贝技术，以减少不必要的数据拷贝。通过FileRegion和CompositeByteBuf，用户可以实现零拷贝发送和接收数据。
多线程 ：Netty支持多线程模型，通过调整EventLoopGroup和Channel的配置，用户可以实现不同的线程模型，如单线程、多线程等。
配置优化 ：用户可以通过调整底层TCP参数，如接收缓冲区大小、发送缓冲区大小等，来优化网络性能。

8. Netty应用案例

以下是一些使用Netty实现的典型应用案例：

HTTP服务器 ：Netty可以用于构建高性能的HTTP服务器，支持HTTP/1.x、HTTP/2等协议。
RPC框架 ：Netty可以用于实现自定义的RPC框架，如gRPC等。
代理服务器 ：Netty可以用于构建代理服务器，如HTTP代理、SOCKS代理等。
游戏服务器 ：Netty可以用于构建实时游戏服务器，支持各种游戏协议。

通过以上内容，您已经对Netty的核心概念、功能和使用方法有了更深入的了解。继续探索Netty的高级功能和特性，将有助于您在实际项目中更好地应用Netty。

Netty核心概念

1. ByteBuf

ByteBuf是Netty中的字节缓冲区。与Java NIO中的ByteBuffer类似，但提供了更强大且易用的功能。ByteBuf
可以动态调整内部字节数组的大小，并提供了各种读写操作方法。

示例：创建一个ByteBuf，并向其中写入数据。

ByteBuf buf=Unpooled.buffer(8);
        buf.writeInt(42);
        buf.writeFloat(3.14f);

2. Channel

Channel是Netty中的通道，代表一个连接。Channel
提供了读取数据、写入数据和关闭连接的方法。Netty支持多种类型的通道，如NioSocketChannel、NioServerSocketChannel等。

示例：在ChannelHandler中向Channel写入数据。

public class MyChannelHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        ctx.write(in);
    }
}

3. ChannelPipeline

ChannelPipeline是Netty中的处理器管道，负责处理Channel中的数据。ChannelPipeline包含多个ChannelHandler
，数据会按照ChannelHandler的顺序依次处理。

示例：在ChannelInitializer中添加ChannelHandler到ChannelPipeline。

public class MyChannelInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new MyChannelHandler());
    }
}

4. ChannelHandler

ChannelHandler是Netty中的处理器接口，负责处理ChannelPipeline中的数据。用户可以通过实现ChannelHandler接口来处理自定义的业务逻辑。

示例：实现一个ChannelInboundHandlerAdapter，处理接收到的数据。

public class MyChannelHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Received: " + in.toString(CharsetUtil.UTF_8));
        in.release();
    }
}

5. EventLoopGroup

EventLoopGroup是Netty中的事件循环组，负责管理EventLoop。EventLoop是一个单线程执行器，负责处理Channel
的事件。EventLoopGroup用于将Channel注册到一个或多个EventLoop上。

示例：创建一个EventLoopGroup，并使用它启动一个ServerBootstrap。

EventLoopGroup bossGroup=new NioEventLoopGroup(1);
        EventLoopGroup workerGroup=new NioEventLoopGroup();
        ServerBootstrap bootstrap=new ServerBootstrap();
        bootstrap.group(bossGroup,workerGroup)
        .channel(NioServerSocketChannel.class).childHandler(new MyChannelInitializer());ChannelFuture f=bootstrap.bind(8080).sync();

6. ChannelFuture

ChannelFuture是Netty中的通道操作的异步结果。用户可以通过ChannelFuture的监听器来处理操作的完成、成功或失败

7. EventLoopGroup

EventLoopGroup是Netty中的事件循环组，负责管理EventLoop。通常，我们会创建两个EventLoopGroup
，一个用于处理连接请求（通常称为bossGroup），另一个用于处理已接受的连接上的IO操作（通常称为workerGroup）。

示例：创建两个EventLoopGroup。

EventLoopGroup bossGroup=new NioEventLoopGroup(1);
        EventLoopGroup workerGroup=new NioEventLoopGroup();

8. EventLoop

EventLoop是Netty中的事件循环，负责处理Channel的事件。一个EventLoop绑定到一个线程上，并处理绑定到它的所有Channel
的IO操作。因此，一个EventLoop可以被多个Channel共享，以实现线程复用。

示例：通过Channel获取EventLoop。

Channel channel=...;
        EventLoop eventLoop=channel.eventLoop();

9. 任务队列

EventLoop中有两个任务队列：tasks和scheduledTasks。tasks用于存放普通任务，scheduledTasks
用于存放定时任务。EventLoop会在一个无限循环中，依次处理这两个任务队列中的任务。

示例：向EventLoop添加一个任务。

EventLoop eventLoop=...;
        eventLoop.execute(new Runnable(){
@Override public void run(){System.out.println("Task executed in EventLoop");}});

10. SingleThreadEventExecutor

SingleThreadEventExecutor是EventLoop的一个实现，它将一个EventLoop绑定到一个线程上。这样可以确保Channel
上的IO操作在同一个线程中执行，从而避免了多线程同步的问题。

示例：创建一个NioEventLoopGroup，它的EventLoop是基于SingleThreadEventExecutor的。

EventLoopGroup workerGroup=new NioEventLoopGroup();

Netty线程模型

Netty的线程模型是基于Reactor模式的，其中EventLoopGroup负责管理事件循环，EventLoop负责处理Channel
上的IO操作。通过将一个EventLoop绑定到一个线程上，Netty实现了高效的线程复用，从而提高了性能。

示例：使用EventLoopGroup和EventLoop启动一个Netty服务器。

EventLoopGroup bossGroup=new NioEventLoopGroup(1);
        EventLoopGroup workerGroup=new NioEventLoopGroup();
        ServerBootstrap bootstrap=new ServerBootstrap();
        bootstrap.group(bossGroup,workerGroup)
        .channel(NioServerSocketChannel.class).childHandler(new MyChannelInitializer());ChannelFuture f=bootstrap.bind(8080).sync();

通过这些示例，您可以了解Netty线程模型的基本概念和使用方法。在实际应用中，您可以根据具体需求调整EventLoopGroup
和EventLoop的

1. Channel

Channel是Netty中的基本抽象，表示一个连接。Netty支持多种传输协议，每种协议都有一个特定的Channel
实现。例如，NioSocketChannel表示基于Java NIO的TCP连接。

示例：创建一个NioSocketChannel。

NioSocketChannel channel=new NioSocketChannel();

2. ChannelPipeline

ChannelPipeline是与Channel相关联的处理器链。当Channel处理事件（如读取数据、写入数据）时，ChannelPipeline
会将事件传递给其中的ChannelHandler进行处理。通过将不同的ChannelHandler添加到ChannelPipeline，可以实现复杂的处理逻辑。

示例：向ChannelPipeline添加一个ChannelHandler。

ChannelPipeline pipeline=channel.pipeline();
        pipeline.addLast(new MyChannelHandler());

3. ChannelHandler

ChannelHandler是Netty中的处理器接口，用于处理ChannelPipeline中的事件。ChannelHandler
有两个主要子接口：ChannelInboundHandler和ChannelOutboundHandler。ChannelInboundHandler
用于处理入站事件，如读取数据；ChannelOutboundHandler用于处理出站事件，如写入数据。

示例：创建一个ChannelInboundHandler，打印接收到的数据。

public class MyChannelHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Received: " + in.toString(CharsetUtil.UTF_8));
        in.release();
    }
}

4. ChannelHandlerContext

ChannelHandlerContext是ChannelHandler的上下文对象，用于访问与ChannelHandler相关联的Channel、ChannelPipeline
和其他ChannelHandler。ChannelHandlerContext还提供了用于触发事件的方法，如fireChannelRead()和write()。

示例：使用ChannelHandlerContext向ChannelPipeline中的下一个ChannelHandler传递事件。

@Override
public void channelRead(ChannelHandlerContext ctx,Object msg){
        System.out.println("MyChannelHandler received: "+msg);ctx.fireChannelRead(msg);}

5. ChannelFuture

ChannelFuture是Netty中的异步操作结果。当执行一个异步操作（如连接、绑定、写入数据）时，Netty会返回一个ChannelFuture
。用户可以通过ChannelFuture的监听器来处理操作的完成、成功或失败。

示例：添加一个ChannelFutureListener，监听连接操作的结果。

ChannelFuture future=channel.connect(new InetSocketAddress("localhost",8080));
        future.addListener(new ChannelFutureListener(){
@Override public void operationComplete(ChannelFuture future){if(future.isSuccess()){System.out.println("Connection established");}else{System.out.println("Connection failed");}}});

通过这些示例，您可以了解Netty传输的基本概念和使用方法。在实际应用中，您需要根据需求选择合适的Channel实现、配置`Channel

Netty传输

在Netty中，传输是指数据在网络中传输的方式。Netty支持多种传输类型，如NIO、OIO（阻塞IO）、Epoll、Kqueue等。下面我们将针对这些要点进行详细介绍。

4.1 NIO, OIO（阻塞IO）, Epoll, Kqueue等传输类型

Netty支持多种传输类型，包括：

NIO：Java NIO（非阻塞IO）是一种高性能的IO模型，适用于高并发场景。它通过使用Selector和非阻塞SocketChannel实现多路复用。
OIO（阻塞IO）：传统的Java IO模型，适用于简单的客户端-服务器模型。每个连接使用一个线程进行读写操作，容易导致线程资源耗尽。
Epoll：Linux平台上的高性能IO模型，基于Linux内核的epoll实现。它可以处理大量并发连接，且不受Java NIO的限制。
Kqueue：BSD平台（如macOS）上的高性能IO模型，基于BSD内核的kqueue实现。类似于Epoll，但仅适用于BSD平台。

4.2 ServerBootstrap, Bootstrap（客户端）

在Netty中，ServerBootstrap和Bootstrap是用于配置和启动服务器端和客户端的类。

ServerBootstrap：用于配置和启动服务器端。
Bootstrap：用于配置和启动客户端。

示例：

// 配置和启动服务器端  
ServerBootstrap serverBootstrap=new ServerBootstrap();
        serverBootstrap.group(bossGroup,workerGroup)
        .channel(NioServerSocketChannel.class).childHandler(new MyChannelInitializer());ChannelFuture serverFuture=serverBootstrap.bind(serverPort).sync();

// 配置和启动客户端  
        Bootstrap clientBootstrap=new Bootstrap();
        clientBootstrap.group(workerGroup)
        .channel(NioSocketChannel.class).handler(new MyChannelInitializer());ChannelFuture clientFuture=clientBootstrap.connect(serverHost,serverPort).sync();

4.3 ServerSocketChannel, SocketChannel

在Netty中，ServerSocketChannel和SocketChannel是用于表示服务器端和客户端连接的抽象类。

ServerSocketChannel：表示服务器端的连接，用于监听和接受客户端连接。
SocketChannel：表示客户端的连接，用于向服务器端发送和接收数据。

4.4 ChannelInitializer

ChannelInitializer
是一个特殊的ChannelInboundHandler，用于在ChannelPipeline中添加和配置ChannelHandler。当一个新的连接建立时，ChannelInitializer
会自动调用initChannel()方法，从而完成ChannelPipeline的配置。

示例：

public class MyChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new MyProtocolDecoder());
        pipeline.addLast(new MyProtocolEncoder());
        pipeline.addLast(new MyProtocolHandler());
    }
}

以上是对Netty传输相关概念的详细介绍

编解码器

1. 编解码器概念

编解码器（Codecs）是将数据从一种格式转换为另一种格式的组件。在Netty中，编解码器主要用于将字节流与应用程序对象之间进行互相转换。编解码器通常由两部分组成：编码器（将应用程序对象转换为字节流）和解码器（将字节流转换为应用程序对象）。

2. ByteToMessageDecoder

ByteToMessageDecoder是一个抽象类，用于实现字节流到对象的解码器。要实现自定义的解码器，需要继承ByteToMessageDecoder
并覆盖decode()方法。

示例：实现一个简单的Integer解码器。

public class IntegerDecoder extends ByteToMessageDecoder {

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
        if (in.readableBytes() >= 4) {
            out.add(in.readInt());
        }
    }
}

3. MessageToByteEncoder

MessageToByteEncoder是一个抽象类，用于实现对象到字节流的编码器。要实现自定义的编码器，需要继承MessageToByteEncoder
并覆盖encode()方法。

示例：实现一个简单的Integer编码器。

public class IntegerEncoder extends MessageToByteEncoder<Integer> {

    @Override
    protected void encode(ChannelHandlerContext ctx, Integer msg, ByteBuf out) {
        out.writeInt(msg);
    }
}

4. CombinedChannelDuplexHandler

CombinedChannelDuplexHandler
是一个双向处理器，可以将解码器和编码器组合在一起。这样，可以将解码器和编码器作为一个处理器添加到ChannelPipeline中。

示例：将IntegerDecoder和IntegerEncoder组合在一起。

CombinedChannelDuplexHandler<Integer, ByteBuf> combinedHandler=new CombinedChannelDuplexHandler<>(new IntegerDecoder(),new IntegerEncoder());

5. LengthFieldBasedFrameDecoder

LengthFieldBasedFrameDecoder是一个通用的解码器，用于处理基于长度字段的协议。它可以解决TCP流的拆包和粘包问题。

示例：创建一个LengthFieldBasedFrameDecoder。

int maxFrameLength=1024;
        int lengthFieldOffset=0;
        int lengthFieldLength=4;
        int lengthAdjustment=0;
        int initialBytesToStrip=4;

        LengthFieldBasedFrameDecoder frameDecoder=new LengthFieldBasedFrameDecoder(
        maxFrameLength,lengthFieldOffset,lengthFieldLength,lengthAdjustment,initialBytesToStrip);

通过这些示例，您可以了解Netty编解码器的基本概念和使用方法。在实际应用中，您需要根据需求实现自定义的编解码器，以处理不同的数据格式和协议。

实际应用案例与实战

1. 聊天室应用

一个常见的Netty应用实例是构建一个简单的聊天室。在这个聊天室中，多个客户端可以连接到服务器并发送消息。所有连接到服务器的客户端都将收到其他客户端发送的消息。

服务器

public class ChatServer {
    private int port;

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

    public void start() throws InterruptedException {
        ServerBootstrap bootstrap = new ServerBootstrap();
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChatServerInitializer());
            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

客户端

public class ChatClient {
    private String host;
    private int port;

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

    public void start() throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap().group(group).channel(NioSocketChannel.class).handler(new ChatClientInitializer());
            Channel channel = bootstrap.connect(host, port).sync().channel();
            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                channel.writeAndFlush(in.readLine() + "\r\n");
            }
        } finally {
            group.shutdownGracefully();
        }
    }
}

2. HTTP服务器

构建一个简单的HTTP服务器，接收HTTP请求并返回HTTP响应。

服务器

public class HttpServer {
    private int port;

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

    public void start() throws InterruptedException {
        ServerBootstrap bootstrap = new ServerBootstrap();
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new HttpServerInitializer());
            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

3. 文件上传服务器

构建一个文件上传服务器，接收客户端上传的文件并将其保存到服务器的文件系统中。

服务器

public class FileUploadServer {
    private int port;

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

    public void start() throws InterruptedException {
        ServerBootstrap bootstrap = new ServerBootstrap();
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new FileUploadServerInitializer());
            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

客户端

public class FileUploadClient {
    private String host;
    private int port;

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

    public void start(String filePath) throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap().group(group).channel(NioSocketChannel.class).handler(new FileUploadClientInitializer());
            Channel channel = bootstrap.connect(host, port).sync().channel();
            File file = new File(filePath);
            RandomAccessFile raf = new RandomAccessFile(file, "r");
            long fileLength = raf.length();
            FileUploadFile fileUploadFile = new FileUploadFile();
            fileUploadFile.setFile(file);
            fileUploadFile.setFileLength(fileLength);
            fileUploadFile.setLastModifyTime(file.lastModified());
            channel.writeAndFlush(fileUploadFile);
            channel.closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

以上示例展示了几个典型的Netty应用案例。在实际应用中，还可以根据具体业务需求对这些案例进行扩展和优化。Netty的灵活性和高性能使其成为构建各种网络应用的理想选择。

Netty性能优化

Netty性能优化

在实际应用中，为了提高性能，可以对Netty进行一些优化。下面我们将详细讲述一些常用的优化方法。

6.1 减少内存分配与回收

避免频繁地创建和销毁对象，可以减少内存分配和回收的开销。在Netty中，可以使用ByteBuf池来实现这一点。ByteBuf池可以通过PooledByteBufAllocator创建。

示例：

// 创建一个新的PooledByteBufAllocator实例  
PooledByteBufAllocator allocator=new PooledByteBufAllocator();

// 通过PooledByteBufAllocator创建一个新的ByteBuf  
        ByteBuf buffer=allocator.buffer(1024);

6.2 使用直接内存

直接内存可以减少堆内存与操作系统之间的数据拷贝次数。在Netty中，可以通过UnpooledByteBufAllocator创建直接内存。

示例：

// 创建一个新的UnpooledByteBufAllocator实例  
UnpooledByteBufAllocator allocator=new UnpooledByteBufAllocator(true);

// 通过UnpooledByteBufAllocator创建一个新的ByteBuf  
        ByteBuf buffer=allocator.buffer(1024);

6.3 优化线程模型

根据实际需求和硬件资源，合理地配置线程数和线程池大小可以提高系统性能。例如，可以根据CPU核心数调整NioEventLoopGroup的线程数。

示例：

// 获取CPU核心数  
int cpuCores=Runtime.getRuntime().availableProcessors();

// 创建一个NioEventLoopGroup实例，线程数为CPU核心数的两倍  
        EventLoopGroup group=new NioEventLoopGroup(cpuCores*2);

6.4 优化TCP参数

根据网络条件和业务需求，合理地配置TCP参数可以提高性能。例如，可以启用TCP_NODELAY以减少延迟，增加SO_SNDBUF和SO_RCVBUF以提高吞吐量。

示例：

// 创建一个新的ServerBootstrap实例  
ServerBootstrap bootstrap=new ServerBootstrap();

// 设置TCP参数  
        bootstrap.option(ChannelOption.TCP_NODELAY,true)
        .option(ChannelOption.SO_SNDBUF,32*1024).option(ChannelOption.SO_RCVBUF,32*1024);

6.5 减少GC压力

减少垃圾回收（GC）压力可以提高系统性能。在Netty中，可以通过合理地配置ByteBuf和对象池来实现这一点。

示例：

// 创建一个新的PooledByteBufAllocator实例，缓存内存的最大容量为256MB，缓存的最大空闲时间为2分钟  
PooledByteBufAllocator allocator=new PooledByteBufAllocator(true,256*1024*1024,2*60*1000);

以上是一些常用的Netty性能优化方法。在实际应用中，可以根据具体需求和场景对

Netty集成

Netty集成：使用Netty实现自定义协议

在某些场景下，我们可能需要使用Netty实现自定义的协议。这通常涉及到以下几个方面：

7.1 自定义协议的编解码器

首先，我们需要实现自定义协议的编解码器。编解码器用于将字节流转换为Java对象，以及将Java对象转换为字节流。在Netty中，可以通过实现ByteToMessageDecoder
和MessageToByteEncoder接口来实现自定义的编解码器。

示例：

public class MyProtocolDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {        // 在这里实现协议的解码逻辑  
    }
}

public class MyProtocolEncoder extends MessageToByteEncoder<MyProtocolMessage> {
    @Override
    protected void encode(ChannelHandlerContext ctx, MyProtocolMessage msg, ByteBuf out) throws Exception {        // 在这里实现协议的编码逻辑  
    }
}

7.2 自定义协议的处理器

接下来，我们需要实现自定义协议的处理器。处理器用于处理解码后的Java对象。在Netty中，可以通过继承ChannelInboundHandlerAdapter
或SimpleChannelInboundHandler类来实现自定义的处理器。

示例：

public class MyProtocolHandler extends SimpleChannelInboundHandler<MyProtocolMessage> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MyProtocolMessage msg) throws Exception {        // 在这里实现协议的处理逻辑  
    }
}

7.3 配置自定义协议的Pipeline

最后，我们需要配置自定义协议的Pipeline。Pipeline用于将编解码器和处理器组合在一起。在Netty中，可以通过实现ChannelInitializer
接口来配置自定义的Pipeline。

示例：

public class MyProtocolChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new MyProtocolDecoder());
        pipeline.addLast(new MyProtocolEncoder());
        pipeline.addLast(new MyProtocolHandler());
    }
}

7.4 启动Netty服务器

现在我们已经实现了自定义协议的编解码器、处理器和Pipeline，接下来需要启动Netty服务器。

示例：

public class MyProtocolServer {
    public static void main(String[] args) throws InterruptedException {
        int port = 8080;
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new MyProtocolChannelInitializer());
            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

以上示例展示了如何使用Netty实现自定义协议。

洪宏鸿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
netty 核心科技

Netty是一个高性能、异步、事件驱动的NIO框架，用于开发网络应用程序，如协议服务器和客户端。它由Java编写，主要用于解决Java网络编程中的各种问题，特别是在性能、可扩展性和灵活性方面。由来：Netty起源于2004年，当时它被称为JBoss Netty。它是为了解决JBossRemoting框架中的性能问题而创建的。随着时间的推移，Netty逐渐发展成为一个独立的项目，并在许多其他项目和组织中得到广泛应用。
复制链接

扫一扫