网络编程_IO_Netty

最新推荐文章于 2024-06-25 17:48:46 发布
最新推荐文章于 2024-06-25 17:48:46 发布
阅读量108 收藏 1
点赞数
分类专栏： IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15764943/article/details/89640227
版权

网络编程_IO_Netty

依赖pom.xml

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

源码

启动入口

/**
 * Netty Server
 * 
 * @author vander
 *
 */
public class WebSocketNettyServer {
    public static void main(String[] args) {
        // 创建两个线程池
        NioEventLoopGroup mainGrp = new NioEventLoopGroup(); // 主线程池
        NioEventLoopGroup subGrp = new NioEventLoopGroup(); // 从线程池

        try {
            // 创建Netty服务器启动对象
            ServerBootstrap serverBootstrap = new ServerBootstrap();

            // 初始化服务器启动对象
            serverBootstrap
                    // 指定使用上面创建的两个线程池
                    .group(mainGrp, subGrp)
                    // 指定Netty通道类型
                    .channel(NioServerSocketChannel.class)
                    // 指定通道初始化器用来加载当Channel收到事件消息后，
                    // 如何进行业务处理
                    .childHandler(new WebSocketChannelInitializer());

            // 绑定服务器端口，以同步的方式启动服务器
            ChannelFuture future = serverBootstrap.bind(9090).sync();
            // 等待服务器关闭
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 优雅关闭服务器
            mainGrp.shutdownGracefully();
            subGrp.shutdownGracefully();
        }

    }
}

通道初始化器

/**
 * 通道初始化器
 * 用来加载通道处理器（ChannelHandler)
 */
public class WebSocketChannelInitializer extends ChannelInitializer<SocketChannel> {

    // 初始化通道
    // 在这个方法中去加载对应的ChannelHandler
    protected void initChannel(SocketChannel ch) throws Exception {
        // 获取管道，将一个一个的ChannelHandler添加到管道中
        ChannelPipeline pipeline = ch.pipeline();

        // 添加一个http的编解码器
        pipeline.addLast(new HttpServerCodec());
        // 添加一个用于支持大数据流的支持
        pipeline.addLast(new ChunkedWriteHandler());
        // 添加一个聚合器，这个聚合器主要是将HttpMessage聚合成FullHttpRequest/Response
        pipeline.addLast(new HttpObjectAggregator(1024 * 64));

        // 需要指定接收请求的路由
        // 必须使用以ws后缀结尾的url才能访问
        pipeline.addLast(new WebSocketServerProtocolHandler("/ws"));

        // 添加自定义的Handler
        pipeline.addLast(new ChatHandler());
    }
}

通道消息处理

/**
 * 消息处理
 * 
 * @author vander
 *
 */
public class ChatHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    // 用来保存所有的客户端连接
    private static ChannelGroup clients = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd hh:MM");

    // 当Channel中有新的事件消息会自动调用
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        // 当接收到数据后会自动调用

        // 获取客户端发送过来的文本消息
        String text = msg.text();
        System.out.println("接收到消息数据为：" + text);

        for (Channel client : clients) {
            // 将消息发送到所有的客户端
            client.writeAndFlush(new TextWebSocketFrame(sdf.format(new Date()) + ":" + text));
        }
    }

    // 当有新的客户端连接服务器之后，会自动调用这个方法
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        // 将新的通道加入到clients
        clients.add(ctx.channel());
    }
}

前段代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>在线聊天室</title>
</head>
<body>
    <input type="text" id="message">
    <input type="button" value="发送消息" onclick="sendMsg()">

    接收到的消息:
    <p id="server_message" style="background-color: #AAAAAA"></p>

    <script>
        var websocket = null;
        // 判断当前浏览器是否支持websocket
        if(window.WebSocket) {
            websocket = new WebSocket("ws://127.0.0.1:9090/ws");
            websocket.onopen = function() {
                console.log("建立连接.");
            }
            websocket.onclose = function() {
                console.log("断开连接");
            }
            websocket.onmessage = function(e) {
                console.log("接收到服务器消息:" + e.data);
                var server_message = document.getElementById("server_message");
                server_message.innerHTML += e.data + "<br/>";
            }
        }
        else {
            alert("当前浏览器不支持web socket");
        }
        function sendMsg() {
            var message = document.getElementById("message");
            websocket.send(message.value);
        }
    </script>
</body>
</html>

简单聊天应用

适用单节点，分布式部署可通过消息队列实现；

启动netty

/**
 * spring监听，启动netty服务器
 * 
 * @author vander
 *
 */
@Component
public class NettyListener implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private WebSocketServer websocketServer;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if(event.getApplicationContext().getParent() == null) {
            try {
                websocketServer.start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

@Component
public class WebSocketServer {

    private EventLoopGroup bossGroup;       // 主线程池
    private EventLoopGroup workerGroup;     // 工作线程池
    private ServerBootstrap server;         // 服务器
    private ChannelFuture future;           // 回调

    public void start() {
        future = server.bind(9001);
        System.out.println("netty server - 启动成功");
    }

    public WebSocketServer() {
        bossGroup = new NioEventLoopGroup();
        workerGroup = new NioEventLoopGroup();

        server = new ServerBootstrap();
        server.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new WebsocketInitializer());
    }
}

初始化

public class WebsocketInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();

        // ------------------
        // 用于支持Http协议
        // ------------------

        // websocket基于http协议，需要有http的编解码器
        pipeline.addLast(new HttpServerCodec());
        // 对写大数据流的支持
        pipeline.addLast(new ChunkedWriteHandler());
        // 添加对HTTP请求和响应的聚合器:只要使用Netty进行Http编程都需要使用
        // 对HttpMessage进行聚合，聚合成FullHttpRequest或者FullHttpResponse
        // 在netty编程中都会使用到Handler
        pipeline.addLast(new HttpObjectAggregator(1024 * 64));

        pipeline.addLast(new WebSocketServerProtocolHandler("/ws"));

        // 添加Netty空闲超时检查的支持
        // 1. 读空闲超时（超过一定的时间会发送对应的事件消息） 4s
        // 2. 写空闲超时  8s
        // 3. 读写空闲超时   12s
        pipeline.addLast(new IdleStateHandler(4, 8, 12));
        pipeline.addLast(new HearBeatHandler());
        
        // 添加自定义的handler
        pipeline.addLast(new ChatHandler());

    }
}

消息处理

/**
 * 处理消息的handler
 * TextWebSocketFrame: 在netty中，是用于为websocket专门处理文本的对象，frame是消息的载体
 */
public class ChatHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    // 用来保存所有的客户端连接
    private static ChannelGroup clients = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd hh:MM");

    // 当Channel中有新的事件消息会自动调用
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        // 当接收到数据后会自动调用

        // 获取客户端发送过来的文本消息
        String text = msg.text();
        System.out.println("接收到消息数据为：" + text);

        Message message = JSON.parseObject(text, Message.class);

        // 通过SpringUtil工具类获取Spring上下文容器
        ChatRecordService chatRecordService = SpringUtil.getBean(ChatRecordService.class);

        switch (message.getType()) {
            // 处理客户端连接的消息
            case 0:
                // 建立用户与通道的关联
                String userid = message.getChatRecord().getUserid();
                UserChannelMap.put(userid, ctx.channel());
                System.out.println("建立用户:" + userid + "与通道" + ctx.channel().id() + "的关联");
                UserChannelMap.print();
                break;
            // 处理客户端发送好友消息
            case 1:
                System.out.println("接收到用户消息");
                // 将聊天消息保存到数据库
                TbChatRecord chatRecord = message.getChatRecord();
                chatRecordService.insert(chatRecord);

                // 如果发送消息好友在线，可以直接将消息发送给好友
                Channel channel = UserChannelMap.get(chatRecord.getFriendid());
                if(channel != null) {
                    channel.writeAndFlush(new TextWebSocketFrame(JSON.toJSONString(message)));
                }
                else {
                    // 如果不在线，暂时不发送
                    System.out.println("用户" + chatRecord.getFriendid() + "不在线");
                }
                break;
            // 处理客户端的签收消息
            case 2:
                // 将消息记录设置为已读
                chatRecordService.updateStatusHasRead(message.getChatRecord().getId());
                break;
            case 3:
                // 接收心跳消息
                System.out.println("接收到心跳消息:" + JSON.toJSONString(message));
                break;
        }

    }

    // 当有新的客户端连接服务器之后，会自动调用这个方法
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        // 将新的通道加入到clients
        clients.add(ctx.channel());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        UserChannelMap.removeByChannelId(ctx.channel().id().asLongText());
        ctx.channel().close();
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("关闭通道");
        UserChannelMap.removeByChannelId(ctx.channel().id().asLongText());
        UserChannelMap.print();
    }
}

心跳处理

检测 Channel的心跳 Handler，客户端连接空闲检测和处理

public class HearBeatHandler extends ChannelInboundHandlerAdapter {
	//客户端一段时间没有动作会触发这个事件
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
    	
        if(evt instanceof IdleStateEvent) {
            IdleStateEvent idleStateEvent = (IdleStateEvent)evt;
            if(idleStateEvent.state() == IdleState.READER_IDLE) {
                System.out.println("读空闲事件触发...");
            }
            else if(idleStateEvent.state() == IdleState.WRITER_IDLE) {
                System.out.println("写空闲事件触发...");
            }
            else if(idleStateEvent.state() == IdleState.ALL_IDLE) {
                System.out.println("---------------");
                System.out.println("读写空闲事件触发");
                System.out.println("关闭通道资源");
                ctx.channel().close();
            }
        }
    }
}

存储所有用户通道

/**
 * 建立用户ID与通道的关联
 */
public class UserChannelMap {
    // 用户保存用户id与通道的Map对象
    private static Map<String, Channel> userChannelMap;

    static {
        userChannelMap = new HashMap<String, Channel>();
    }

    /**
     * 添加用户id与channel的关联
     * @param userid
     * @param channel
     */
    public static void put(String userid, Channel channel) {
        userChannelMap.put(userid, channel);
    }

    /**
     * 根据用户id移除用户id与channel的关联
     * @param userid
     */
    public static void remove(String userid) {
        userChannelMap.remove(userid);
    }

    /**
     * 根据通道id移除用户与channel的关联
     * @param channelId 通道的id
     */
    public static void removeByChannelId(String channelId) {
        if(!StringUtils.isNotBlank(channelId)) {
            return;
        }

        for (String s : userChannelMap.keySet()) {
            Channel channel = userChannelMap.get(s);
            if(channelId.equals(channel.id().asLongText())) {
                System.out.println("客户端连接断开,取消用户" + s + "与通道" + channelId + "的关联");
                userChannelMap.remove(s);
                break;
            }
        }
    }


    // 打印所有的用户与通道的关联数据
    public static void print() {
        for (String s : userChannelMap.keySet()) {
            System.out.println("用户id:" + s + " 通道:" + userChannelMap.get(s).id());
        }
    }

    /**
     * 根据好友id获取对应的通道
     * @param friendid 好友id
     * @return Netty通道
     */
    public static Channel get(String friendid) {
        return userChannelMap.get(friendid);
    }
}

消息实体类

/**
 * 消息记录
 * 
 * @author vander
 *
 */
public class TbChatRecord {
    private String id;

    private String userid;

    private String friendid;

    private Integer hasRead;

    private Date createtime;

    private Integer hasDelete;

    private String message;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id == null ? null : id.trim();
    }

    public String getUserid() {
        return userid;
    }

    public void setUserid(String userid) {
        this.userid = userid == null ? null : userid.trim();
    }

    public String getFriendid() {
        return friendid;
    }

    public void setFriendid(String friendid) {
        this.friendid = friendid == null ? null : friendid.trim();
    }

    public Integer getHasRead() {
        return hasRead;
    }

    public void setHasRead(Integer hasRead) {
        this.hasRead = hasRead;
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public Integer getHasDelete() {
        return hasDelete;
    }

    public void setHasDelete(Integer hasDelete) {
        this.hasDelete = hasDelete;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message == null ? null : message.trim();
    }
}


public class Message {
    private Integer type; // 消息类型
    private TbChatRecord chatRecord;    // 聊天消息
    private Object ext;  // 扩展消息字段

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
    }

    public TbChatRecord getChatRecord() {
        return chatRecord;
    }

    public void setChatRecord(TbChatRecord chatRecord) {
        this.chatRecord = chatRecord;
    }

    public Object getExt() {
        return ext;
    }

    public void setExt(Object ext) {
        this.ext = ext;
    }
}
平揽星尘
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何评价Netty封装的io_uring？
BUG_zhentan的博客
08-09 831
linux AIO 简史 在继续 io_uring 的旅行之前，让我们先回顾一下 linux 中的各种异步 IO，也就是 AIO。 1. glibc aio 官方地址：Perform I/O Operations in Parallel（官方文档用的字眼比较考究） glibc 是 GNU 发布的 libc 库，该库提供的异步 IO 被称为 glibc aio，在某些地方也被称为 posix aio。glibc aio 用多线程同步 IO 来模拟异步 IO，回调函数在一个单线程中执行。 该实现备受非
IO和Netty
jerryq的博客
02-20 123
BIO、NIO、AIO        BIO：一个连接一个线程。会对每个客户端连接分配一个线程。        NIO：一个请求一个线程。客户端的所有连接都注册到一个多路复用器上，多路复用器采用不断轮询的方式查询连接中是否有IO操作，当连接有IO操作才会启动一个线程进行处理。        AIO：一个有效请求一个线程。客户端的IO操作是由操作系统接收处理，处理完了才通知应用程序去启动线程处...
IO之NETTY（更新中）
每天一点点
05-18 513
近期在做充电桩项目，桩设备与系统之间的连接方式，一种是基于Socket协议，一种是Mqtt这种消息中间件的，当初为了快，直接用socket搞了个异步处理接收桩，在少量问题可能对系统不会有太大问题 可随着桩数量增加，就应该用更高效的框架了，比如netty。继IO整理之后，整理一篇关于Netty的文章。 1. Netty中的反应器模式实现 2. Bootstrap引导类 3. Channel通道 4. Handler业务处理器 ...
Netty学习（一）——基础组件
weixin_44630656的博客
06-25 811
Netty 是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端
Netty-IO模型
XZB119211的博客
11-15 723
Netty-IO模型
io.netty学习 （一）Netty入门
码灵的博客
06-19 2740
关于Netty的学习，最近看了不少有关视频和书籍，也收获不少，希望把我知道的分享给你们，一起加油，一起成长。前面我们对Java IOBIONIOAIO深入分析 Java IO （一）概述深入分析 Java IO （二）BIO深入分析 Java IO （三）NIO深入分析 Java IO （四）AIO本篇文章我们就开始对Netty来进行深入分析，首先我们来了解一下JAVA NIOAIO的不足之处。本篇文章主要讲解了 Netty 产生的背景、特点、核心组件及如何快速开启第一个 Netty 应用。
1.Netty之IO浅析
看水不是水
04-23 230
传统Socket 同步阻塞服务端： 采用while(true)方式，每个连接分配单独的线程的模型，之所以使用多线程是因为该模型同步阻塞的，当一个连接在处理I/O的时候，后续的请求是阻塞的。如果是单线程的话必然就挂死在那里，后续的请求无法进入；于是优化采取每个请求新建一个线程去处理。 稍微好点的是直接用线程池去接收请求，来减小线程池生命周期的开销。 这个模型最本质的问题在于，严重依赖于线程。但...
网络通信 netty_io
01-13
Netty的EventLoop（事件循环）和ChannelHandler（通道处理器）设计使得网络编程变得简单而高效。它支持多种I/O模型，包括NIO和AIO，并且可以根据具体需求自动选择最合适的模型。 Netty源码分析是理解其高性能背后的...
Netty_In_Action中文版.pdf
01-31
在本章中，作者首先介绍了 Netty 的基本概念和它为何成为网络编程的优选框架。 Netty 的核心优势在于其非阻塞 IO（Non-blocking IO）的设计，这与传统的阻塞 IO 形成了鲜明对比。阻塞 IO 在等待数据读写时会暂停...
读书笔记：Java网络编程IO、Netty.zip
最新发布
07-19
读书笔记：Java网络编程IO、Netty
网络编程之Netty
Strange_boy的博客
05-23 1018
原文链接 概述 Netty 是一个高性能、异步事件驱动的 NIO 框架 优点 1、高性能、高吞吐量、低延迟 2、使用方便，详细的Javadoc,用户指南和示例 3、社区活跃，版本迭代周期短 4、设计优雅，适用于各种传输类型的统一API阻塞和非阻塞Socket；基于灵活且可扩展的事件模型 线程模型介绍 目前的线程模型有：传统阻塞I/O服务模型、Reactor模型； 根据Reactor数量和处理资源线程的的数量不同，有3种形式： 1、单Reactor 2、单Reactor多线程 3、主从Reactor多线程
了解Netty，从IO开始
青鱼入云的博客
10-19 261
从0开始学习Netty，将io、socket、reactor等netty必备知识点一一讲清楚，方便理解netty的运行模式
Netty——高性能IO框架（1）
weixin_43932472的博客
09-26 389
是什么 Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients netty是在java的nio基础上的一个异步、基于事件驱动的高性能、高可用、开源、使用java编写的网络IO框架，实现原理是reactor的主从模式，开发者可以使用netty来快速搭建一个高
Netty深入浅出（无处不在的IO）
爪哇岛民工的博客
10-09 1081
从图中可以看出用户态与内核态的切换，那么什么是用户/内核态呢？这也是下面的内容。
io.netty学习（十五）Netty 编解码器
码灵的博客
06-27 2069
在前面文章中，我们分别对解码器和编码器进行了讨论。其实针对编码和解码，Netty 还提供了第三种方式，那就是编解码器。编解码器顾名思义，就是结合了编码和解码功能的程序。编解码器能够把入站和出站的数据和信息转换都放在同一个类中，对于某些场景来说显得更实用。Netty 提供了抽象的编解码器类，能把一些成对的解码器和编码器组合在一起，以此来提供对字节和消息都相同的操作。这些类实现了和接口。Netty 的编解码器抽象类主要有以下两种：（1）实现从字节到消息的编解码（（2）实现从消息到消息的编解码（
io.netty学习（十二）Netty 工作原理
码灵的博客
06-25 609
上一篇文章我们对 Reactor 模型进行了详细的讲解，下面我们就来探究一下 Netty 模型，Netty 采用的就是 主从 Reactor 多线程模型。本篇文章主要讲解了 Netty 的工作原理及简单应用。下节我们来讲解 Netty 的编解码。
快速入门Java NIO（Not I/O）的网络通信框架--Netty
qq_55272229的博客
01-14 1326
Netty 是一个异步(基于多线程)的、基于事件驱动(多路复用的那写事件驱动)的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端末尾练习 简记 c/s各组件结构/*** 可以简单记忆是这是一个二级的关系* 通道是双向连接通道,客户端和服务器端都可以进行处理* 服务器端使用的是ServerSocketChannel 而客户端是SocketChannel* eventloopgroup 是相当于封装了nio中的各个触发事件。
IO进化Netty_HelloWord
菜鸟先飞
09-04 2487
Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。 http://ifeve.com/netty5-user-guide/ 实现Netty通信如下步骤: 1.创建两个NIO的线程组，一个用于
Netty入门（二）——传统IO与NIO比较（二）
平凡之路无尽路的博客
06-23 1396
此博客是引用占小狼公众号的文章，讲解非常好，对初学者能够有非常好的认识。大家可关注该公众号。IO编程我们简化下场景：客户端每隔两秒发送一个带有时间戳的"hello world"给服务端，服务端收到之后打印。为了方便演示，下面例子中，服务端和客户端各一个类，把这两个类拷贝到你的IDE中，先后运行 IOServer.java和 IOClient.java可看到效果。下面是传统的IO编程中服务端实现IO...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值