Netty学习记录第一篇---如何使用IDEA创建你的第一款Netty程序

最新推荐文章于 2024-07-05 16:18:51 发布
最新推荐文章于 2024-07-05 16:18:51 发布
阅读量1.5k 收藏 5
点赞数 2
文章标签： Netty Java IDEA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43801935/article/details/86495682
版权

如何使用IDEA创建你的第一款Netty程序

本系列主要记录笔者在学习Netty过程中的一些心得体会，其中关于Netty部分的资料主要参考书籍《Netty 实战(Netty In Action)》(Norman Maurer 及Marvin Allen Wolfthal 著 何品 译)，在这里感谢作者为我们写了这么一本方便学习的书，对于有需要的读者可以自行去购买正版书籍。

本文主要讲解如何使用IDEA构建Maven项目及详细记录第一款Netty程序的实现过程。

1、使用IDEA搭建项目框架

小白说明：
本文虽包含了IDEA构建项目的详细过程，但不保证涵盖读者需要的所有常用操作，若读者想详细了解IDEA的更多使用方法，可以参看笔者分享的此链接，里面附有IDEA详细使用教程PDF版
链接：https://pan.baidu.com/s/1vnw4x9DjX8gYU5cRFPReyw 提取码：9Pq9

1.1 创建一个空白项目

首先选择Create New Project在这里插入图片描述
选择Empty Project用来存放项目
在这里插入图片描述

给项目起一个名字，点击Finish
在这里插入图片描述
完成的界面如图，此时我们就成功创建了一个空的项目作为最外层的容器。
在这里插入图片描述
接下来我们分析一下要实现的程序，我们的小程序是要实现这样一个功能，有一个服务器和一个客户端，客户端连接服务器并向服务器发送一条消息，接着服务器将从客户端收到的消息在返回给客户端。
之所以做这样一个小程序，主要目的是为了让读者先从简单的实践中感受一下Netty构建应用程序的逻辑，对Netty有一个初步的认识。
从上面的描述中我们很容易想到的是在这个项目里我们需要两个模块，一个服务器一个客户端，所以我们需要构件一个聚合工程，此处笔者在聚合工程之上还创建了一个父工程，意在向读者展示IDEA中如何创建父子工程及父工程同聚合工程的联系与区别。

1.2 创建一个父工程
创建父工程的详细步骤如下所示：
在这里插入图片描述
这里我们选择创建一个Maven项目
在这里插入图片描述
填写项目的ArtifactId
在这里插入图片描述
自定义自己电脑上安装的Maven相关设置
在这里插入图片描述
设置模块名字
在这里插入图片描述
创建好的工程结构下图：
在这里插入图片描述
在这里笔者习惯删除用不到的文件，修改及配置pom文件后的结构如下图所示：
在这里插入图片描述
xml文件的配置如下：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>com.ian</groupId>
  <artifactId>parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <junit.version>4.12</junit.version>
    <netty.version>4.1.32.Final</netty.version>
  </properties>

  <dependencyManagement>

    <dependencies>

      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
        <scope>test</scope>
      </dependency>

      <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>${netty.version}</version>
      </dependency>

    </dependencies>

  </dependencyManagement>

  <build>

    <finalName>${project.artifactId}</finalName>

    <plugins>

      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>1.6.0</version>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.22.1</version>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
        <version>2.22.1</version>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>

    </plugins>

  </build>

至此我们的父工程就创建好了。

1.3 创建一个聚合工程
接下来我们来进入正题创建一个聚合工程，创建过程如下所示：
在这里插入图片描述
同样设置一下ArtifactId

小白说明
注意这里笔者将Add as module to 选择为了none，Parent为parent，意思为此工程继承至父工程但和父工程不是聚合关系
在这里插入图片描述
和父工程一样设置
在这里插入图片描述设置模块名字在这里插入图片描述创建好的工程如图，同样也删去了不用的文件及配置了pom文件
在这里插入图片描述
xml文件配置如下：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <artifactId>parent</artifactId>
        <groupId>com.ian</groupId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../Parent/pom.xml</relativePath>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>manager</artifactId>
    <packaging>pom</packaging>

    <modules>
        <module>Client</module>
        <module>Server</module>
    </modules>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <echo-server.hostname>localhost</echo-server.hostname>
        <echo-server.port>9999</echo-server.port>
    </properties>

    <dependencies>

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
        </dependency>

    </dependencies>
    
</project>

此时聚合工程就创建好啦。

1.4 创建服务器子工程
创建服务器子工程的步骤如下：
在这里插入图片描述
设置ArtifactId，注意此处Add as module to就不是none了，因为服务器子工程同manager是聚合关系
在这里插入图片描述
配置同父工程一样
在这里插入图片描述
设置模块名字
在这里插入图片描述
创建好的工程如下：
在这里插入图片描述
xml文件配置如下：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <artifactId>manager</artifactId>
        <groupId>com.ian</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <artifactId>server</artifactId>

    <build>

        <plugins>

            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>run-server</id>
                        <goals>
                            <goal>java</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <mainClass>nia.echo.EchoServer</mainClass>
                    <arguments>
                        <argument>${echo-server.port}</argument>
                    </arguments>
                </configuration>
            </plugin>

        </plugins>

    </build>

</project>

至此服务器子工程就搭建好啦，最后我们来搭建客户端子工程。

1.5 创建客户端工程
创建客户端工程的步骤如下所示：
在这里插入图片描述
和前面类似
在这里插入图片描述
设置ArtifactId
在这里插入图片描述
配置同父工程一样
在这里插入图片描述
设置工程名字
在这里插入图片描述
创建好的工程结构如下：
在这里插入图片描述
xml文件配置如下：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <artifactId>manager</artifactId>
        <groupId>com.ian</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>

    <artifactId>client</artifactId>

    <build>

        <plugins>

            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>run-client</id>
                        <goals>
                            <goal>java</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <mainClass>nia.echo.EchoClient</mainClass>
                    <arguments>
                        <argument>${echo-server.hostname}</argument>
                        <argument>${echo-server.port}</argument>
                    </arguments>
                </configuration>
            </plugin>

        </plugins>
        
    </build>

</project>

至此客户端工程也搭建完成啦，接下来我们就要正式开始写代码实现我们的第一个基于Netty的小程序啦！

2、编写客户端服务器代码

2.1 编写服务器代码

所有Netty服务器都需要以下两部分

1.至少一个ChannelHandler,该组件实现了服务器对从客户端接受的数据的处理，即它的业务逻辑。
2.引导，这是配置服务器的启动代码。至少它会将服务器绑定到它要监听连接请求的端口上。

接下来我们来编写Echo服务器，代码如下所示：

package nia.echo;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

@Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
	
	//对于每一个传入的消息都要调用
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server received: " + in.toString(CharsetUtil.UTF_8));
        ctx.write(in);
    }

	//通知ChannelInboundHandler最后一次对channelRead()的调用时当前批量读取中的最后一条消息
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
    }

	//在读取操作期间，有异常抛出时会调用
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

接下来我们来编写引导服务器，代码如下所示：

package nia.echo;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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 java.net.InetSocketAddress;

public class EchoServer {
    private final int port;

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

    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.println("Usage: " + EchoServer.class.getSimpleName() + " <port>");
            return;
        }
        int port = Integer.parseInt(args[0]);
        new EchoServer(port).start();
    }

    public void start() throws Exception {
        final EchoServerHandler serverHandler = new EchoServerHandler();
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(group).channel(NioServerSocketChannel.class).localAddress(new InetSocketAddress(port)).childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(serverHandler);
                }
            });
            ChannelFuture f = b.bind().sync();
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }
}

至此服务器端的代码我们就编写完成啦，接下来编写客户端代码。

2.2 编写客户端代码

客户端主要做如下几个事情：
1.连接到服务器
2.发送一个或者多个消息
3.对于每个消息，等待并接收从服务器发回的相同的消息
4.关闭连接

客户端同样也是业务逻辑和引导两部分，首先我们来编写客户端，代码如下：

package nia.echo;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;

@Sharable
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
	//在到服务器的连接已经建立之后将被调用
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks", CharsetUtil.UTF_8));
    }
    
	//当从服务器接收到一条消息时被调用
    @Override
    public void channelRead0(ChannelHandlerContext ctx, ByteBuf in) {
        System.out.println("Client received: " + in.toString(CharsetUtil.UTF_8));
    }

	//在处理过程中引发异常时被调用
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

接下来编写引导客户端，代码如下：

package nia.echo;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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 java.net.InetSocketAddress;

public class EchoClient {
    private final String host;
    private final int port;

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

    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class).remoteAddress(new InetSocketAddress(host,port)).handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new EchoClientHandler());
                }
            });
            ChannelFuture f = b.connect().sync();
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 2) {
            System.err.println("Usage: " + EchoClient.class.getSimpleName() + "<host> <port>");
            return;
        }
        String host = args[0];
        int port = Integer.parseInt(args[1]);
        new EchoClient(host,port).start();
    }
}

至此代码的编写就全部完成啦。

3、构建和运行代码

要构建客户端和服务器，首先我们将命令行切换到如下目录下，执行mvn clean package 指令
在这里插入图片描述
如看到类似下图的界面代表所有的项目都已经成功被构建
在这里插入图片描述
接着我们开启两个终端分别切换到Server和Client目录下，在服务器终端执行mvn exec:java指令，成功后如图，然后在客户端终端执行mvn exec:java指令，会看到如下图所示内容，服务器显示收到客户端发送的消息Netty rocks，客户端显示收到服务器返回的同样的信息
在这里插入图片描述
这个时候如果关闭服务器终端再次在客户端终端执行mvn exec:java指令会如下图所示，提示连接失败，因为客户端尝试连接服务器运行在localhost:9999上但是服务器已经停止了，所以在客户端触发了我们编写的exceptionCaught方法打印了如下信息。
在这里插入图片描述
至此我们的第一个Netty小程序就完成啦。

后面的系列会不定期更新~

写文章不易喜欢就点个赞吧~

无眠丶
关注
【学习IntelliJ IDEA】6、idea下创建netty项目
jiezhang656的专栏
11-23 875
首先感谢https://blog.csdn.net/chen_xi_hao/article/details/79431756这个文章的作者。 对于tcp server的开发还算有点基础，但是因为是刚接触idea和netty，所以不熟悉，所以先搭个大概内容出来，一步一步做。 下面分几部分来进行吧。 一、Netty是啥 Netty是一款用于快速开发高性能的网络应用程序的Java框架。它封装了...
Netty实战（二）第一个Netty程序
一起学习一起进步~
05-16 458
即使是对于这么少量的数据，channelRead0()方法也可能会被调用两次，第一次使用一个持有 3 字节的 ByteBuf（Netty 的字节容器），第二次使用一个持有 2 字节的 ByteBuf。如同在 EchoServerHandler（3.1中的代码示例）中所示，记录 Throwable，关闭 Channel，在这个场景下，终止到服务器的连接。引导客户端类似于引导服务器，不同的是，客户端是使用主机和端口参数来连接远程地址，也就是这里的 Echo 服务器的地址，而不是绑定到一个一直被监听的端口。
用Idea搭建简单的Netty服务器
Mr_wilson_liu的博客
03-22 1917
本文使用netty自定义了一个http协议的服务器。 1.创建一个maven项目，在pom.xml文件中导入依赖并刷新 <!-- https://mvnrepository.com/artifact/io.netty/netty-all --> <dependency> <groupId>io.netty</groupId>...
Netty学习（Netty入门）
最新发布
real_rookie的博客
07-05 882
Future就是在线程之间传递结果的一个容器，是被动的获取结果，由执行完任务的线程给予的结果，没有暴露主动赋予结果的方法@Slf4j//1.创建线程池//2.提交任务@Overridelog.debug("执行计算");return 50;});//3.祝线程通过future获取结果，get是阻塞等待方法log.debug("等待结果");log.debug("结果{}",future.get());
IDEA 快速搭建Netty项目
qq_37421018的博客
02-20 9202
网上有很多方式搭建Netty项目，但是都很繁琐，而且不够详细，然后这里列一下最简单的创建方式。 一、新建项目： File-&gt;New-&gt;Project: 然后新建maven项目，不知道maven的可以参考如下链接，其中对后面的项目结构也有说明： https://www.cnblogs.com/whgk/p/7112560.html 填名称和项目标签，示例如下： 填...
构建Netty的第一个服务器Hello Netty
清欢Viki的博客
08-05 159
概述 使用主从线程模型搭建服务器 构建一对主从线程组 定义服务器启动类 为服务器设置Channel(每一个客户端需要在服务端注册一个channel数据通道) 设置处理从线程池 的助手类初始化器(处理子线程组助手类handler) 监听启动和关闭服务器 步骤 绑定8088端口，采用不指定路由的方式，即所有访问localhost:8088的路由都能返回Hello Netty(比如loc...
《跟闪电侠学Netty》开篇：Netty是什么？
weixin_39214481的博客
01-09 613
在开始了解Netty是什么之前，我们先来回顾一下，如果我们需要实现一个客户端与服务端通信的程序，使用传统的IO编程，应该如何来实现？ IO编程 我们简化下场景：客户端每隔两秒发送一个带有时间戳的"hello world"给服务端，服务端收到之后打印。 为了方便演示，下面例子中，服务端和客户端各一个类，把这两个类拷贝到你的IDE中，先后运行 IOServer.java 和IOClient.ja...
netty-netty-4.1.27.Final:netty-netty-4.1.27.Final netty 4.1.27.Final
03-24
解决方法很简单：第一种方法：文件->设置...-->构建，执行，部署->编译器-> Java编译器设置相应模块的目标字节码版本的合适版本（跟你jdk版本一致），这里我改成1.8版本的。 第二种办法：最外层的pom.xml把这个...
Netty入门（四） --- 编码和解码，Netty的handler调用机制，TCP粘包和拆包原理和解决
化身强盗的博客
01-25 1059
文章目录七、Google Protobuf7.1 编码和解码简介7.2 Netty本身的编解码机制和问题分析7.3 Protobuf基本介绍7.4 Protobuf发送单对象7.5 Protobuf发送多对象八、Netty编解码器和handler调用机制8.1 基本说明8.2 编解码器基本原理8.3 Netty的handler链调用机制8.4 一些简单的解码器8.4.1 ByteToMessageDecoder 解码器8.4.2 ReplayingDecoder解码器8.4.3 其他的编解码器九、TCP粘包
Netty-基于Netty实现RPC-仿Dubbo
CodeDabaicai的博客
02-05 239
1、什么是RPC RPC，英文全称是Remote Procedure Call，翻译过来就是远程过程调用。 作为一个计算机通信协议，运行在计算机A的程序调用另一台计算机B上的子程序就像调用本地方法一样方便，而这两个程序是分布在不同的服务器上的 RPC远程过程调用图示： 其中Client就是RPC服务的消费者，Server就是服务提供者，通过上图可以看到完整的调用关系 RPC就是将以上的步骤全部封装起来，用户直接使用，而不用关心使用细节，部署后直接能像使用本地方法一样使用远程程序 2、设计一个RPC
Idea+springboot+netty打包执行测试
05-17
【标题】"Idea+springboot+netty打包执行测试" 涉及到的是一个集成开发环境(IntelliJ IDEA，简称Idea)、Spring Boot和Netty的项目打包与运行流程。这是一个常见的Java微服务开发场景，其中Spring Boot用于构建后端...
Netty在IDEA中搭建HelloWorld服务端并对Netty执行流程与重要组件进行介绍示例代码.rar
09-15
Netty在IDEA中搭建HelloWorld服务端并对Netty执行流程与重要组件进行介绍示例代码；Netty在IDEA中搭建HelloWorld服务端并对Netty执行流程与重要组件进行介绍示例代码
Netty 官方例子
06-20
将netty官方提供的例子运用idea工具整理出来并可以运行
IntelliJ idea 新建项目并导入netty
热门推荐
Voctex
03-03 1万+
前言 笔者的主要技能是移动端开发，eclipse和android studio这两个工具都很熟手，android是以java为基础的，但是笔者基本不涉及java项目。最近接触了一个项目是基于netty4进行开发的，开发环境是IntelliJ idea，虽然对android studio很熟手，但是接触了idea，还是发现有点不一样的，为了多接触java项目，所以做做笔记。 流程 1、新建...
《一个菜鸟游戏服务端的学习之路》第一章 IDEA中Netty框架的导入和简单使用
高冷颜的博客
09-23 1746
IDEA中Netty框架的导入和简单使用 一个netty的小demo，主要学习netty的导入，如何启动一个netty程序，如何监听客户端连接时间、如何对客户端发来的数据进行解析。
Idea+maven+springboot项目搭建系列--2 整合Netty完成客户端&服务器端消息收发
拽着尾巴的鱼儿的博客
06-01 2225
code 比较简单，在服务端的处理器中，首先将接收到的字符串解析成一个 JSONObject 对象。客户端的code 基本和服务端一致，客户端接收了服务端的回写数据并进行了打印，其中@DependsOn(“webNettyServer”) 告诉spring 在装载客户端的bean 时，先要去装载服务端的bean；前言：Netty 作为主流的nio 通信模型应用相当广泛，本文在spring-boot 项目中集成Netty，并实现客户端以及服务器端消息的接收和发送；
IntelliJ IDEA 创建 Maven Web 项目（NettyDemo）
Σ匰身ァ貴豬
11-21 1927
1. 新建工程 File -&gt; New -&gt; Project 第一次使用时，可能需要下载 archetype webapp 的插件。 2. 工程建立成功 3. pom.xml 配置文件 ① &lt;packaging&gt;war&lt;/packaging&gt;，如果pom中配置了这个，Aritifaces就会有下面的两个war ② po...
Idea中编译Netty源码
了不起的盖茨比的博客
08-09 1832
今天我们来说说在Idea中如何编译Netty源码，因为之前我们介绍了Netty的使用方式，我们学一样的东西，不单单要会怎么用，我们还有知道它的原理。知道一个东西的原理，最好的方式就是阅读源码。所以我们今天来编译Netty的源码。 笔者的开发环境如下： idea版本：2020.02 netty版本：netty-4.1.51.Final 首先我们要先去GitHub上下载对应的源码，具体地址：Netty源码，我们这儿的下载方式有很多种，笔者采用的方式就是直接下载，当然也是可以用命令git clone将源码给克隆
Netty在IDEA中搭建HelloWorld服务端并对Netty执行流程与重要组件进行介绍
BADAO_LIUMANG_QIZHI的博客
09-15 1362
场景 什么是Netty Netty 是一个利用 Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架。 Netty 是基于 Java NIO 的异步事件驱动的网络应用框架，使用 Netty 可以快速开发网络应用，Netty 提供了高层次的抽象来简化 TCP 和 UDP 服务器的编程，但是你仍然可以使用底层的 API。 Netty 的内部实现是很复杂的，但是 Netty 提供了简单易用的API从网络处理代码中解耦业务逻辑。Netty 是完全基于 NIO 实现
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值