Netty（一）创建简单的Echo Server & Client

最新推荐文章于 2023-12-27 19:46:29 发布
最新推荐文章于 2023-12-27 19:46:29 发布
阅读量648 收藏 1
点赞数
文章标签： netty java
原文链接：https://segmentfault.com/a/1190000017053730
版权

Netty简介

Netty的核心组件：

  • Channel
  • 回调
  • Future
  • 事件和ChannelHandler

Channel
Channel可以看做是传入（入站）或者传出（出站）数据的载体，，可以被打开或者关闭，连接或者断开连接；

回调
一个回调其实就是一个方法，一个指向已经被提供给另外一个方法的方法的引用。这使得接受回调的方法可以在适当的时候调用前者。当一个回调被触发时，相关的事件可以被一个interface-ChannelHandler的实现处理。

Future
Future提供了另一种在操作完成时通知应用程序的方式。这个对象可以看做是一个异步操作的结果的占位符，它将在未来的某个时刻完成，并提供对其结果的访问。
ChannelFuture提供了额外几个方法，使得我们能够注册一个或者多个ChannelFutureListener实例。由ChannelFutureListener实例提供的通知机制消除了手动检查对应的操作是否完成的必要。

事件和 ChannelHandler
Netty使用不同的事件来通知我们状态的改变或者是操作的状态。这使得我们能够基于已经发生的事件来触发适当的动作。每个事件都可以被分发给ChannelHandler类中的某个用户实现的方法。

创建Maven工程

整个项目的目录结构如下：

clipboard.png

echo-parent的 pom文件

<?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.nasuf.echo</groupId>
    <artifactId>echo-parent</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

    <modules>
        <module>../echo-client</module>
        <module>../echo-server</module>
    </modules>

    <properties>
        <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> <!-- Use 'netty-all' for 4.0 or above -->
            <version>4.1.10.Final</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
            </plugin>
            <plugin>
                <artifactId>maven-failsafe-plugin</artifactId>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

echo-server的 pom文件

<?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>echo-parent</artifactId>
        <groupId>com.nasuf.echo</groupId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../echo-parent/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>echo-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>com.echo.server.handler.EchoServer</mainClass>
                    <arguments>
                        <argument>${echo-server.port}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

echo-client的 pom文件

<?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>echo-parent</artifactId>
        <groupId>com.nasuf.echo</groupId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../echo-parent/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>echo-client</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>com.echo.client.handler.EchoClient</mainClass>
                    <arguments>
                        <argument>${echo-server.hostname}</argument>
                        <argument>${echo-server.port}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

然后来构建 echo-client 和 echo-server

EchoServer
EchoServerHandler
package com.echo.server.handler;

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

// @Sharable标示一个ChannelHandler可以被多个Channel安全共享
@Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        System.out.println(
                "Server received: " + in.toString(CharsetUtil.UTF_8));
        // 将接收到的消息写给发送者，即客户端，而不冲刷出站消息        
        ctx.write(in);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // 将未决消息冲刷到远程节点，并且关闭该Channel
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)
            .addListener(ChannelFutureListener.CLOSE);
    }

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

}

所谓“未决消息（pending message）”指的是目前暂存于ChannelOutboundBuffer中的消息，在下一次调用flush()或者writeAndFlush()方法时将会尝试写出到套接字。

EchoServer
package com.echo.server.handler;

import java.net.InetSocketAddress;

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;

public class EchoServer {
    
    private final int port;
    
    public EchoServer(int port) {
        this.port = port;
    }
    
    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
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(serverHandler);
                    }
                });
            // 此处绑定服务器，并等待绑定完成。对sync()方法的调用将导致当前Thread阻塞，直到绑定完成
            ChannelFuture f = b.bind().sync();
            // 由于调用了sync()方法，程序将会阻塞等待，直到服务器的Channel关闭
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }
    
    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();
    }

}

总结：

  • EchoServerHandler实现了业务逻辑
  • main()方法引导了服务器；

引导过程如下：

  • 创建一个ServerBoostrap的实例以引导和绑定服务器；
  • 创建并分配一个NioEventLoopGroup实例以进行事件的处理，如接受新连接以及读、写数据；
  • 指定服务器绑定本地的InetSocketAddress；
  • 使用一个EchoServerHandler的实例初始化每一个新Channel；
  • 调用ServerBootstrap.bind()方法以绑定服务器；

EchoClient

Echo客户端将会：

  • 连接到服务器；
  • 发送一个或多个消息；
  • 对于每个消息，等待并接收从服务器返回的相同的消息；
  • 关闭连接
EchoClientHandler
package com.echo.client.handler;

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) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", CharsetUtil.UTF_8));
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
        System.out.println("Client received: " + in.toString(CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
    
}
EchoCleint
package com.echo.client.handler;

import java.net.InetSocketAddress;

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;

public class EchoClient {
    
    private final String host;
    private final int port;
    
    public EchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }
    
    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();
    }
    
    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
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new EchoClientHandler());
                }
                 
             });
            ChannelFuture f = b.connect().sync();
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }

}

总结：

  • 为初始化客户端，创建了一个Bootstrap实例；
  • 为进行事件处理分配了一个NioEventLoopGroup实例，其中事件处理包括创建新的连接以及处理入站和出站数据；
  • 为服务器连接创建了一个InetSocketAddress实例；
  • 当连接被建立时，一个EchoClientHandler实例会被安装到（该Channel的）ChannelPipeline中；
  • 在一切都设置完成后，调用Bootstrap.connect()方法连接到远程节点；

运行测试

进入到echo-parent目录下执行：

mvn clean package

然后分别在服务端和客户端执行：

mvn exec:java

可以在服务端看到：

$ mvn exec:java
[INFO] Scanning for projects...
[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] Building echo-server 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- exec-maven-plugin:1.6.0:java (default-cli) @ echo-server ---

在客户端看到：

$ mvn exec:java
[INFO] Scanning for projects...
[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] Building echo-client 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- exec-maven-plugin:1.6.0:java (default-cli) @ echo-client ---
Client received: Netty rocks!
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.903 s
[INFO] Finished at: 2018-11-18T20:54:08+08:00
[INFO] Final Memory: 11M/309M
[INFO] ------------------------------------------------------------------------

客户端执行完毕并退出，回到服务端窗口可以看到信息如下：

Server received: Netty rocks!
《Netty实战》第二章
weixin_34380781
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Netty理论与实践（一） netty入门之创建echo服务器
HO1_K的博客
07-10 522
介绍基础的理论知识：网络协议TCP/UDP、netty简介和依赖、netty核心类介绍 然后进入开发实战，对服务端和客户端的开发流程和实现做了详细描写
echoServer回显服务器
yitian881112的专栏
11-02 967
例如，一个服务器处理十万以上的通道，如果一个通道都新建很多重复的Handler实例，就需要上十万以上重复的Handler实例，这就会浪费很多宝贵的空间，降低了服务器的性能。不过，可以肯定的是，第一个入站处理器的channelRead方法的msg实参类型，绝对是ByteBuf类型，因为它是Netty读取到的ByteBuf数据包。显而易见，@Sharable共享的业务处理器，如果需要操作的数据不仅仅是局部变量，则需要进行线程的同步控制，以保证操作是线程层面安全的。这一步很简单，直接复用前面的msg实例即可。
C Liunx实现EchoServer非阻塞服务端（TPC协议）
最新发布
sthudy的博客
12-27 534
C Liunx实现EchoServer非阻塞服务端。
Netty EchoServer 和 EchoClient 实现
Chdaring的博客
01-11 725
EchoServer.java public class EchoServer { private final int port; public EchoServer(int port) { this.port = port; } public static void main(String[] args) throws Exception { if (arg...
基于netty的echo server和echo client
A_D_wocaoni的专栏
04-05 367
既然学了netty自然需要实验下，自然自己就简单实验下。 这个是简版的，所以比较粗糙。 [code="java"] package study.netty; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import io.netty.bootstrap.ServerBootstrap; import...
SocketIO-NettyClient&Server.zip
07-16
- 本示例可能展示了如何使用Netty创建一个简单的TCP服务器和客户端，它们通过自定义处理器交换消息。实际项目中，这些基础可以扩展到更复杂的场景，如WebSocket、HTTP服务器、RPC框架等。 通过学习和实践这个示例...
netty android Client + server
03-15
Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。在Android平台上，使用Netty可以构建高效、可靠的网络通信应用，尤其是在需要处理大量并发连接时。本项目提供...
netty http client & server
08-04
而在 "netty-http-client" 文件中，包含了一个简单的 HTTP 客户端示例，演示了如何向服务器发送请求并接收响应。 总的来说，Netty 提供了强大而灵活的工具来构建 HTTP 客户端和服务器，无论是对于学习网络编程，...
利用netty实现Modbus TCP client/server
04-09
利用netty实现Modbus TCP client/server READ COILS | 0x01 READ DISCRETE INPUTS | 0x02 READ HOLDING REGISTERS | 0x03 READ INPUT REGISTERS | 0x04 WRITE SINGLE COIL | 0x05 WRITE SINGLE REGISTER | 0x06 ...
echoServer(按行读取版本)
02-27
使用recv_peek实现按行读取readline(只能用于socket)
EchoClient EchoServer 客户 服务器程序
03-16
EchoClient EchoServer 客户 服务器程序 通过TCPIP协议完成网络信息传递
echoserver多进程版
02-26
　　我们的echo服务器最大的缺点就是无法支持多客户连接,即使客户端能够连接到服务器上,服务器也不为该客户做服务,(直接没什么反应),虽然链接是有的(也就是说,客户端是已经连接到服务器上的了,但是服务器就是不搭理你....)
Netty5 echo server练习
nobody
07-06 1585
Netty5的架构比Netty4的架构及代码上都有很多的改进，看起来很清晰。         下面的根据管网例子改进的Echo Server例子代码。        代码中增加的有netty自带的hander，LineBasedFrameDecoder主要解决网络传输的粘包/拆包问题。StringDecoder和StringEncoder主要解决netty ByteBuf和string之间的转
Netty-EchoServer回显服务器的案例
qq1010234991的博客
11-25 543
文章目录EchoServer回显服务器的实践案例服务器端功能服务器端需要掌握的知识codeNettyEchoServerHandler处理器回显服务器处理的逻辑客户端NettyEchoClientNettyEchoClientHandler处理器 EchoServer回显服务器的实践案例 服务器端 功能 从服务器端读取客户端输入的数据，然后将数据直接回显示在Console控制台 服务器端需要掌...
基于echo例子的netty4通信总结
流子的专栏
01-30 3433
在netty4源码分析系列文章中分别详细介绍了echo例子中涉及到网络通讯的每一个环节，本文对echo例子中服务端和客户端依次发生的步骤做个总结：   服务端依次发生的步骤 建立服务端监听套接字ServerSocketChannel，以及对应的管道pipeline；启动boss线程，将ServerSocketChannel注册到boss线程持有的selector中，并将注册返回的sele
[Go WebSocket] 你的第一个Go WebSocket服务: echo server
Hull Qin
09-13 4577
如果你想实现WebSocket，基于压测数据，强烈建议你用Go！本文手把手教你实现一个echo服务，很适合用于新手入门！每一行代码都有详细注释。
Echo server
lemonxuexue的专栏
09-18 1445
Echo server就是那种提供回显服务的程序，就是收到什么，然后就发送什么的程序。 事件模型socket里面是有select机制，ACE也提供了这种方式。概念:Event_Handler:有事件来临的时候的处理器Reactor:事件管理，负责管理Event_Hanlde和分发事件Acceptor负责连接Event_Handle,Reactor和Sock_Acceptor代码:#if
攻防世界逆向高手题之echo-server
沐一 · 林 的博客
10-25 684
攻防世界逆向高手题之echo-server 继续开启全栈梦想之逆向之旅~ 这题是攻防世界逆向高手题的handcrafted-pyc . . 下载附件，照例扔入exeinfope中查看信息： . . 32位ELF文件无壳，照例运行下一程序，查看主要回显信息。但是如上图一样，我的是Kali，所以有报错libcrypto.so.1.0.0缺失，但是我没有ubuntu，所以我只能结合别人的资料静态直接分析了： . . 照例扔入32位IDA中分析伪代码，有main函数看main函数： 因为前面修改后调

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值