使用Netty构建一个多线程服务器与客户端(一)

最新推荐文章于 2023-09-30 12:55:53 发布
最新推荐文章于 2023-09-30 12:55:53 发布
阅读量709 收藏 1
点赞数
分类专栏： netty 文章标签： netty channel socket服务器 多线程
发此篇博客的目的是,如果有网络通讯方面的大牛看到,希望能给与一些指导.

我相信很多人都能用netty开发出自己的客户端和服务器,但是,此服务器和客户端的可重用性有多高呢?我一直想弄个性能还算不错,然后其他人在此架构上做简单的命令处理即可.

开发这个服务器和客户端的原因是正是如此,也可以说是一个简单的网络平台.让其具备一定的2次开发功能.

以下代码只是一个初步是设想,有兴趣的朋友我们可以一起讨论讨论.

如果你完全不了解netty,请先自己学习一下.^_^,因为我也是菜鸟,无法解释那么多的类是干什么的.^_^

关于netty的下载和其他个jar请自行下载

首先是服务器的初步实现.因为Netty是基于事件的,再加上其无阻塞的特性.我们必须要牢记:

数据发送后,代码不会被阻塞,而是顺序运行,也就是说,做了一件事件后,这件事情不一定已经成功,所以我们不能在下一行代码中百分百的确定其已经发送到了对方,因此,你会发行其很多方法都会返回一个"Future".只要注意到这一点,Netty的使用难度就不是很大了.

(一)handler处理篇
首先,是handler,初次接触netty的朋友要注意,handler不是一个单例.即每个channel下都会有自己的一个handler实例. 


public class ServerHandler extends SimpleChannelUpstreamHandler {

    private static final Logger logger = Logger.getLogger(
            ServerHandler.class.getName());
    private final ThreadLocal<Boolean> COMMAND_FLAG = new ThreadLocal<Boolean>();
    private final ServerChannelGroup serverChannelGroup = ServerChannelGroup.newInstance();

    @Override
    public void handleUpstream(ChannelHandlerContext ctx, ChannelEvent e)
            throws Exception {
        if (e instanceof ChannelStateEvent) {
            logger.log(Level.INFO, "Channel state changed: {0}", e);
        }
        super.handleUpstream(ctx, e);
    }

    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
            throws Exception {
        System.out.println(this);
        String request = (String) e.getMessage();
        //如果接受到客户端发送的bye指令,那么就给客户端回复一个bye指令,客户端接受到后,主动关闭连接
        //服务器端通过ChannelFutureListener.CLOSE,当它认为客户端已经接受到服务器发送的bye后,也主动关闭连接
        if (request.toLowerCase().equals("bye")) {
            ChannelFuture future = e.getChannel().write("bye\r\n");
            future.addListener(ChannelFutureListener.CLOSE);
        } else {
            //以下是我初步解析客户端发送过来的数据,然后决定处理方式
            RecevieData receivedaData = MessageDecoder.decode(request);
            if (null != receivedaData) {
                //服务器第5版
                if (VersionCode.V5.equals(receivedaData.getVersion())) {
                    //然后判断命令是否存在
                    for (String s : CommandCode.COMMANDS) {
                        if (s.equals(receivedaData.getActionType())) {
                            COMMAND_FLAG.set(true);
                            if (s.equals(CommandCode.KEEP_ALIVE)) {
                                serverChannelGroup.addChannel(e.getChannel());
                            }
                            break;
                        } else {
                            COMMAND_FLAG.set(false);
                        }
                    }
                    if (COMMAND_FLAG.get()) {
                        COMMAND_FLAG.set(false);
                        //将这个命令传递给下一个handler来处理.
                        //这里的"下一个handler"即为用户自己定义的处理handler
                        ctx.sendUpstream(e);
                    } else {
                        e.getChannel().write(MessageEncoder.encode(receivedaData, StatusCode.NOT_FOUND, StatusCode.NOT_FOUND_TEXT));
                    }
                } else {
                    //版本错误
                    e.getChannel().write(MessageEncoder.encode(receivedaData, StatusCode.VERSION_NOT_SUPPORTED, StatusCode.VERSION_NOT_SUPPORTED_TXET));
                }
            } else {
                //如果格式错误,那么直接返回
                e.getChannel().write(MessageEncoder.encode(receivedaData, null, null));
            }
        }

    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
            throws Exception {
        logger.log(Level.WARNING, "Server side Unexpected exception from downstream.",
                e.getCause());
        e.getChannel().close();
        ListenerManager.getListener(ConnectClosedByPeerListener.class).connectClosedByPeer(e.getCause());
    }
}


在上面这个handler中,我使用了ctx.sendUpstream(e);来处理,个人觉得此处为了要实现执行运行时代码,也可以使用接口等方式.但既然netty提供了sendUpstream 的方法,我们用这个岂不是更方便^_^

下面是使用SSL连接的handler 

public class ServerSSLHandler extends SimpleChannelUpstreamHandler {

    private static final Logger logger = Logger.getLogger(
            ServerSSLHandler.class.getName());
    private final ThreadLocal<Boolean> COMMAND_FLAG = new ThreadLocal<Boolean>();
    private final ServerChannelGroup serverChannelGroup = ServerChannelGroup.newInstance();

    @Override
    public void handleUpstream(ChannelHandlerContext ctx, ChannelEvent e)
            throws Exception {
        if (e instanceof ChannelStateEvent) {
            logger.log(Level.INFO, "Channel state changed: {0}", e);
        }
        super.handleUpstream(ctx, e);
    }

    @Override
    public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)
            throws Exception {
        //ssl握手
        SslHandler sslHandler = ctx.getPipeline().get(SslHandler.class);
        sslHandler.handshake();
    }

    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
            throws Exception {
        System.out.println(this);
        String request = (String) e.getMessage();
        //如果接受到客户端发送的bye指令,那么就给客户端回复一个bye指令,客户端接受到后,主动关闭连接
        //服务器端通过ChannelFutureListener.CLOSE,当它认为客户端已经接受到服务器发送的bye后,也主动关闭连接
        if (request.toLowerCase().equals("bye")) {
            ChannelFuture future = e.getChannel().write("bye\r\n");
            future.addListener(ChannelFutureListener.CLOSE);
        } else {
            //以下是我初步解析客户端发送过来的数据,然后决定处理方式
            RecevieData receivedaData = MessageDecoder.decode(request);
            if (null != receivedaData) {
                //服务器第5版
                if (VersionCode.V5.equals(receivedaData.getVersion())) {
                    //然后判断命令是否存在
                    for (String s : CommandCode.COMMANDS) {
                        if (s.equals(receivedaData.getActionType())) {
                            COMMAND_FLAG.set(true);
                            if (s.equals(CommandCode.KEEP_ALIVE)) {
                                serverChannelGroup.addChannel(e.getChannel());
                            }
                            break;
                        } else {
                            COMMAND_FLAG.set(false);
                        }
                    }
                    if (COMMAND_FLAG.get()) {
                        COMMAND_FLAG.set(false);
                        //将这个命令传递给下一个handler来处理.
                        //这里的"下一个handler"即为用户自己定义的处理handler
                        ctx.sendUpstream(e);
                    } else {
                        e.getChannel().write(MessageEncoder.encode(receivedaData, StatusCode.NOT_FOUND, StatusCode.NOT_FOUND_TEXT));
                    }
                } else {
                    //版本错误
                    e.getChannel().write(MessageEncoder.encode(receivedaData, StatusCode.VERSION_NOT_SUPPORTED, StatusCode.VERSION_NOT_SUPPORTED_TXET));
                }
            } else {
                //如果格式错误,那么直接返回
                e.getChannel().write(MessageEncoder.encode(receivedaData, null, null));
            }
        }

    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
            throws Exception {
        logger.log(Level.WARNING, "Server side Unexpected exception from downstream.",
                e.getCause());
        e.getChannel().close();
        ListenerManager.getListener(ConnectClosedByPeerListener.class).connectClosedByPeer(e.getCause());
    }
}


关于SSL连接需要用到的一些其他东西,稍后在介绍

当我们有了2个handler后,当然就是要把他们添加到我们的Pipeline中 

public class ServerPipelineFactory implements
        ChannelPipelineFactory {

    public ChannelPipeline getPipeline() {
        ChannelPipeline pipeline = pipeline();
        ServerConfig config = ServerConfig.getInstance();
        try {
            if (config.ssl()) {
                SSLEngine engine =
                        SecureSslContextFactory.getServerContext().createSSLEngine();
                //说明是服务器端SslContext
                engine.setUseClientMode(false);
                pipeline.addLast("ssl", new SslHandler(engine));
            }

            //此Decoder可以自动解析一句以\r\n结束的命令,我为了方便,也用了这个Decoder
            //使用这个Decoder,我不用刻意发送命令长度用于解析,只要没有收到\r\n说明数据还
            //没有发送完毕.这个Decoder会等到收到\r\n后调用下个handler
            pipeline.addLast("framer", new DelimiterBasedFrameDecoder(
                    8192, Delimiters.lineDelimiter()));
            //字串解码,可以自己设置charset
            pipeline.addLast("decoder", new StringDecoder());
            //字串编码,可以自己设置charset
            pipeline.addLast("encoder", new StringEncoder());

            if (config.ssl()) {
                //如果开启了SSL,那么使用sslhandler
                pipeline.addLast("sslhandler", new ServerSSLHandler());
            } else {
                //如果没有开启SSL,那么使用普通handler
                pipeline.addLast("handler", new ServerHandler());
            }
            //遍历配置文件中的服务器handler,将其添加进Pipeline链中
            for (Element e : config.handler()) {
                pipeline.addLast(e.attribute(e.getQName("id")).getValue().trim(),
                        (ChannelHandler) Class.forName(e.attribute(e.getQName("class")).getValue().trim()).newInstance());
            }
        } catch (DocumentException ex) {
            Logger.getLogger(ServerPipelineFactory.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
        } catch (InstantiationException ex) {
            Logger.getLogger(ServerPipelineFactory.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(ServerPipelineFactory.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(ServerPipelineFactory.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
        }
        return pipeline;
    }
}


下面是xml处理类 

public class ServerConfig {

    private static final String HOST = "host";
    private static final String PORT = "port";
    private static final String HANDLER = "handler";
    private static final String CLIENTHANDLER = "clienthandler";
    private static final String SSL = "ssl";
    private static final ServerConfig SERVER_CONFIG = new ServerConfig();
    private static final String XML_PATH = "lib/server.xml";
    private static final SAXReader SAR_READER = new SAXReader();

    private ServerConfig() {
        super();
    }

    public String host() throws DocumentException {
        return this.rootElement().element(HOST).getTextTrim().trim();
    }

    public int port() throws DocumentException {
        return Integer.parseInt(this.rootElement().element(PORT).getTextTrim().trim());
    }

    public boolean ssl() throws DocumentException {
        return Integer.parseInt(this.rootElement().element(SSL).getTextTrim().trim()) == 1 ? true : false;
    }

    public List<Element> handler() throws DocumentException {
        return this.rootElement().elements(HANDLER);
    }

     public List<Element> clienthandler() throws DocumentException {
        return this.rootElement().elements(CLIENTHANDLER);
    }

    private Element rootElement() throws DocumentException {
        return SAR_READER.read(new File(XML_PATH)).getRootElement();
    }

    public static ServerConfig getInstance() {
        return SERVER_CONFIG;
    }
}


server.xml,放到lib下即可,注意其中的handler 以及clienthandler 项,如果你新建了自己的handler,那么需要在此xml中配置一下. 

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

<root>
    <!-- 配置主机地址 -->
    <host>127.0.0.1</host>
    <!-- 配置服务端口 -->
    <port>8080</port>
    <!-- 是否启用ssl,1为启用,0为停用 -->
    <ssl>0</ssl>

    <!--服务器业务handler -->
    <handler id="timeHandler" class="com.chinatenet.nio.server.handler.ServerTimeHandler" />

    <!--客户端业务handler -->
    <clienthandler id="timeHandler" class="com.chinatenet.nio.client.handler.ClientTimeHandler" />
</root>


到此,一个简单的可扩展handler的服务器雏形就出来了

下面,我们添加一个自定义的服务器处理handler进来 

public class ServerTimeHandler extends SimpleChannelUpstreamHandler {

    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        RecevieData receivedaData = MessageDecoder.decode((String) e.getMessage());
        if (CommandCode.GET_TIME.equals(receivedaData.getActionType())
                || CommandCode.KEEP_ALIVE.equals(receivedaData.getActionType())) {
            if (VersionCode.V5.equals(receivedaData.getVersion())) {
                //回复客户端后,即可进行自己的业务.当然.这里可以根据需要,看
                //是先回复再处理还是等处理结果出来后,将结果返回客户端
                e.getChannel().write(MessageEncoder.encode(receivedaData, StatusCode.OK,
                        System.currentTimeMillis() / 1000 + ""));
            } else {
                //版本错误
                e.getChannel().write(MessageEncoder.encode(receivedaData, StatusCode.VERSION_NOT_SUPPORTED,
                        StatusCode.VERSION_NOT_SUPPORTED_TXET));
            }
        } else {
            //如果不是此handler处理的命令,那么流下去
            ctx.sendUpstream(e);
        }
    }

}


最后测试一下 

public class Server {

    public static void main(String[] args) throws DocumentException {
        ServerBootstrap bootstrap = new ServerBootstrap(
                new NioServerSocketChannelFactory(
                Executors.newCachedThreadPool(),
                Executors.newCachedThreadPool()));

        bootstrap.setPipelineFactory(new ServerPipelineFactory());

        //因为我要用到长连接
        bootstrap.setOption("child.tcpNoDelay", true);
        bootstrap.setOption("child.keepAlive", true);

        ServerConfig config = ServerConfig.getInstance();
        bootstrap.bind(new InetSocketAddress(Integer.valueOf(config.port())));
    }
}


总结:在整个服务器编码中,刚开始会遇到"远程主机强迫关闭了一个现有的连接。"等这类错误,最后修改成"相互告知对方我要关闭了"再进行关闭就可以了.

最后再完善一下异常处理即可.

[url]http://www.nptpark.com[/url]
sz_147258
关注
专栏目录
netty中的多线程应用
09-30
netty中的多线程并发应用，
netty5多线程编程
12-25
netty5深入源码解析多线程编程，netty5高性能并发编程的首选
Netty学习：搭建一个简单的Netty服务
永远的VC的专栏
06-06 610
Netty学习：搭建一个简单的Netty服务 Netty 是一个基于 JAVA NIO 类库的异步通信框架，它的架构特点是：异步非阻塞、基于事件驱动、高性能、高可靠性和高可定制性。换句话说，Netty是一个NIO框架，使用它可以简单快速地开发网络应用程序，比如客户端和服务端的协议。Netty大大简化了网络程序的开发过程比如TCP和UDP的 Socket的开发。Netty 已逐渐成为 ...
netty3升级到4后由于线程模型的变化引起的问题
yine的专栏
09-10 2741
1｜Netty的特点 Netty入门比较简单，主要原因有如下几点： Netty的API封装比较简单，将复杂的网络通信通过BootStrap等工具类做了二次封装，用户使用起来比较简单；Netty源码自带的Demo比较多，通过Demo可以很快入门；Netty社区资料、相关学习书籍也比较多，学习资料比较丰富。 但是很多入门之后的Netty学习者遇到了很多困惑，例如不知道
使用Netty构建一个多线程服务器与客户端
Huang_Sun的博客
06-19 7207
首先是服务器的初步实现.因为Netty是基于事件的,再加上其无阻塞的特性.我们必须要牢记:  数据发送后,代码不会被阻塞,而是顺序运行,也就是说,做了一件事件后,这件事情不一定已经成功,所以我们不能在下一行代码中百分百的确定其已经发送到了对方,因此,你会发行其很多方法都会返回一个"Future".只要注意到这一点,Netty的使用难度就不是很大了.  (一)handler处理篇  首
使用Netty4实现多线程的消息分发
04-25
在本文中，我们将深入探讨如何利用 Netty 4 实现多线程的消息分发，这对于构建分布式系统、游戏服务器或者任何需要高效处理并发连接的应用尤其重要。 一、Netty 框架简介 Netty 是由 JBoss 提供的一个开源项目，它...
使用 netty实现一个简单的聊天室
最新发布
02-01
Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。在这个“使用 Netty 实现一个简单的聊天室”的项目中，我们将深入理解 Netty 的核心概念和组件，以及如何利用...
使用Netty搭建服务端和客户端过程详解
08-25
Reactor模式是指在单个线程中处理多个客户端的连接请求，以提高服务器的性能和可扩展性。 在Netty中，我们可以使用NioEventLoopGroup来管理线程池的创建和销毁。NioEventLoopGroup是一个线程组，用于管理多个...
java socket tcpip多线程网络通信服务器客户端
05-16
在“java socket tcpip多线程网络通信服务器客户端”这个主题中，我们将深入探讨如何使用Java Socket实现基于TCP/IP协议的多线程服务器和客户端通信。 TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的...
Netty多线程处理机制
mousever的专栏
07-19 1076
技术点描述 本文主要研究NioServerSocketChannelFactory类和NioDatagramChannelFactory类, 以及这两个类的各自作用。     由于基于pipelineFactory的线程池的配置已在前一节（Netty中execution包功能详解 ）中做了详细说明，而channelFactory中的线程池的配置并未做说明，本文档重点阐述channe
netty技术文档，socket技术 多线程
06-15
netty的简介，netty是一种socket技术，实现长连接，此技术更加成熟1
netty3.5.2实现点对点、点对多的聊天demo
09-07
本demo是基于netty3.5.2开发的在对象传输上实现的局域网聊天的一个小小socketTcp网络通信测试用例，通信是通过服务器作中转的，网上也有大神说可以通过在客户端实现服务端功能和客户端功能，这样就不用中转这一过程，demo在关键代码处给出了注释，如果是在两台不同ip的机子测试的话，请修改Client类中的链接地址。
基于Netty实现一个服务端/客户端通信demo
猿上生活
07-12 2203
原创不易，转载请注明出处 文章目录前言demo程序编写maven的pom依赖服务端程序客户端程序测试总结 前言 本文主要是使用netty这个高性能网络通信框架写一个服务端、客户端通信的demo，体验下基于netty的网络编程是什么样子的，在此之前需要有java nio基础，毕竟netty就是封装的java nio，写完之后介绍一下netty核心组件底层运行原理。 demo程序编写 maven的pom依赖 <dependency> <groupId>io.netty&lt.
Netty学习系列3—解析netty架构与多线程运用
qq_43432744的博客
09-30 526
Acceptor 接收到客户端TCP连接请求处理完成后(可能包括介入认证等), 将新创建的SocketChannel注册到I/O线程池(sub reactor线程池) 的某个I/O线程上, 由它负责SocketChannel的读写和辩解码工作. Acceptor线程池只用于客户端的登录、握手和安全认证, 一旦链路建立成功, 就将链路注册到后段subReactor线程池的I/O线程上, 由I/O线程负责后续的I/O操作.从架构层面看, 一个NIO线程确实可以完成起承担的职责。
java多线程框架 netty_谈谈Netty的线程模型
weixin_39760721的博客
02-28 192
一、前言Netty是一个异步、基于事件驱动的网络应用程序框架，其对 Java NIO进行了封装，大大简化了 TCP 或者 UDP 服务器的网络编程。Netty 的简易和快速开发并不意味着由它开发的程序将失去可维护性或者存在性能问题，它的设计参考了许多协议的实现，比如 FTP，SMTP，HTTP 和各种二进制和基于文本的传统协议，因此 Netty 成功的实现了兼顾快速开发，性能，稳定性，灵活性为一体...
java多线程tcp断线重连_如何学好 Netty 来修炼 Java 内功？
weixin_39946274的博客
11-25 123
Netty 是目前最流行的一款高性能 Java 网络编程框架，它被广泛使用在中间件、直播、社交、游戏等领域。目前，许多知名的开源软件也都将 Netty 用作网络通信的底层框架，如 Dubbo、RocketMQ、Elasticsearch、Hbase 等。其实在互联网大厂（阿里、腾讯、美团等）的中高级 Java 开发面试中，也经常会问到涉及 Netty 核心技术原理的问题，比如：Netty 的高性能...
Netty学习——一个聊天的案例实现（多线程）
zzhou——blog
02-21 2615
文章目录1 项目介绍 一个聊天app2 Netty 介绍与相关基础知识2.1 Netty 介绍2.2 BIO、NIO、AIO 介绍与区别2.3 Netty Reactor 模型 - 单线程模型、多线程模型、主从多线程模型介绍2.3.1 单线程模型（足浴店的老板工人都是同一个人）2.3.2 Reactor 多线程模型（足浴店有一个接待的，好多个技师）2.3.3 Reactor 主从多线程模型（足...
netty创建并启动新线程流程分析
我是兴锅的博客
01-20 958
本文主要分享服务端ServerSocketChannel所绑定的NioEventLoop的线程的创建过程 在服务端启动流程中当执行到注册操作时，会判断当前线程是否是ServerSocketChannel所绑定的NioEventLoop中的线程，如果不是的话，会将注册操作封装成一个线程任务交给NioEventLoop中的线程去执行，相关代码如下所示： @Override public final v...
netty线程模型
XY的专栏
03-13 110
1）传统的线程模型采用阻塞IO模型，每个连接都需要独立的线程完成数据的读取，处理，结果数据返回 当并发量足够大，就会创建大量的线程，耗费资源，而且是阻塞的，如果当前线程没有数据读取，就会一直阻塞，占用资源 2）netty的线程模型基于IO复用，多个连接共用一个阻塞对象；基于线程池复用线程资源，netty的线程模型叫做Reactor模型， Reactor模型的主要组成有Reactor线程、h...
Netty入门：构建NIO服务器与客户端
相比传统的阻塞I/O，非阻塞I/O允许多个操作同时进行，而不会因为一个操作等待数据而阻塞整个线程。这解决了传统Java I/O中线程数量受限和资源消耗大的问题。Netty通过其高级API简化了NIO的使用，使得开发者能够专注...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值