netty之Socket多客户端连接

最新推荐文章于 2024-07-10 11:19:53 发布
最新推荐文章于 2024-07-10 11:19:53 发布
阅读量6.5k 收藏 3
点赞数 1
分类专栏： netty 文章标签： socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010342008/article/details/79052090
版权

netty 聊天服务端

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class MyChatServer {

    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        ServerBootstrap bootstrap = new ServerBootstrap();

        bootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).childHandler(new MyChatServerInitializer());

        try {
            ChannelFuture channelFuture = bootstrap.bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;


/**
 * @author fengchuanbo
 */
public class MyChatServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new DelimiterBasedFrameDecoder(4096, Delimiters.lineDelimiter()));
        pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
        pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
        pipeline.addLast(new MyChatServerHandler());
    }
}
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

public class MyChatServerHandler extends SimpleChannelInboundHandler<String> {

    private static final ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        Channel channel = ctx.channel();
        channelGroup.forEach(ch -> {
            if (ch != channel){
                ch.writeAndFlush(channel.remoteAddress() + " 发送的消息：" + msg + "\n");
            }else{
                ch.writeAndFlush("【自己】" + msg + "\n");
            }
        });
    }

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

    // 通道建立事件
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        channelGroup.writeAndFlush("服务器 - " + channel.remoteAddress() + "加入\n");
        channelGroup.add(channel);
    }

    // 通道活跃事件
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        System.out.println(channel.remoteAddress() + "上线了");
    }

    // 通道不活跃事件
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        System.out.println(channel.remoteAddress() + "下线了");
    }

    // 通道被移除事件
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        channelGroup.writeAndFlush("服务器 - " + channel.remoteAddress() + "离开\n");
        // 移出(netty会自动执行，不写也行)
        channelGroup.remove(channel);
        System.out.println(channelGroup.size());
    }
}

netty 聊天客户端

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class MyChatClient {

    public static void main(String[] args) {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class).handler(new MyChatClientInitializer());

        try {
            Channel channel = bootstrap.connect("localhost", 8899).sync().channel();
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            // 循环读取控制台输入信息
            for (;;){
                channel.writeAndFlush(reader.readLine() + "\n");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

public class MyChatClientInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new DelimiterBasedFrameDecoder(4096, Delimiters.lineDelimiter()));
        pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
        pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
        pipeline.addLast(new MyChatClientHandler());
    }
}
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class MyChatClientHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(msg);
    }
}
```## netty 聊天服务端





<div class="se-preview-section-delimiter"></div>

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class MyChatServer {

public static void main(String[] args) {
    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workerGroup = new NioEventLoopGroup();

    ServerBootstrap bootstrap = new ServerBootstrap();

    bootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).childHandler(new MyChatServerInitializer());

    try {
        ChannelFuture channelFuture = bootstrap.bind(8899).sync();
        channelFuture.channel().closeFuture().sync();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }finally {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

}






<div class="se-preview-section-delimiter"></div>

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

/**
* @author fengchuanbo
*/
public class MyChatServerInitializer extends ChannelInitializer {

@Override
protected void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    pipeline.addLast(new DelimiterBasedFrameDecoder(4096, Delimiters.lineDelimiter()));
    pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
    pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
    pipeline.addLast(new MyChatServerHandler());
}

}






<div class="se-preview-section-delimiter"></div>

import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

public class MyChatServerHandler extends SimpleChannelInboundHandler {

private static final ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
    Channel channel = ctx.channel();
    channelGroup.forEach(ch -> {
        if (ch != channel){
            ch.writeAndFlush(channel.remoteAddress() + " 发送的消息：" + msg + "\n");
        }else{
            ch.writeAndFlush("【自己】" + msg + "\n");
        }
    });
}

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

// 通道建立事件
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    channelGroup.writeAndFlush("服务器 - " + channel.remoteAddress() + "加入\n");
    channelGroup.add(channel);
}

// 通道活跃事件
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    System.out.println(channel.remoteAddress() + "上线了");
}

// 通道不活跃事件
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    System.out.println(channel.remoteAddress() + "下线了");
}

// 通道被移除事件
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    channelGroup.writeAndFlush("服务器 - " + channel.remoteAddress() + "离开\n");
    // 移出(netty会自动执行，不写也行)
    channelGroup.remove(channel);
    System.out.println(channelGroup.size());
}

}






<div class="se-preview-section-delimiter"></div>

## netty 聊天客户端





<div class="se-preview-section-delimiter"></div>

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class MyChatClient {

public static void main(String[] args) {
    EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
    Bootstrap bootstrap = new Bootstrap();
    bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class).handler(new MyChatClientInitializer());

    try {
        Channel channel = bootstrap.connect("localhost", 8899).sync().channel();
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        // 循环读取控制台输入信息
        for (;;){
            channel.writeAndFlush(reader.readLine() + "\n");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

}






<div class="se-preview-section-delimiter"></div>

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

public class MyChatClientInitializer extends ChannelInitializer {

@Override
protected void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    pipeline.addLast(new DelimiterBasedFrameDecoder(4096, Delimiters.lineDelimiter()));
    pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
    pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
    pipeline.addLast(new MyChatClientHandler());
}

}






<div class="se-preview-section-delimiter"></div>

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class MyChatClientHandler extends SimpleChannelInboundHandler {

@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
    System.out.println(msg);
}

}
“`

天雨之梦
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty- 服务端和客户端的创建
qq_45126604的博客
07-06 565
Netty私有协议栈 Netty协议栈用于内部各模块之间的通信，它基于TCP/IP协议栈，是一个类HTTP协议的应用层协议栈，相比于传统的标准协议栈，它更加轻巧、灵活和实用。 Netty节点并没有服务端和客户端的区分，谁先发起连接，谁就作为客户端，另一方作为服务端。一个Netty节点即可以作为客户端连接另一个Netty节点，又可以作为服务端被其他节点连接。 协议族的功能:用于业务内部各模块之间的消息交互和服务调用。 基于Netty的NIO通信框架，提供高性能的异步通信能力: 提供消息的编解码框架，可以实
第 5 篇 : 多节点Netty服务端(可扩展)
qiezi__的博客
05-14 987
前面消息互发以及广播都是单机就可以完成测试, 但实际场景中客户端的连接数量很大, 那就需要有一定数量的服务端去支撑, 所以准备虚拟机测试。
netty创建tcp服务端+客户端
最新发布
Paddy哥
07-10 383
java netty tcp创建和发送
netty-聊天服务器
godme
01-20 1136
服务端 ServerMain public class ChatServerMain { public static void main(String[] args) throws InterruptedException { NioEventLoopGroup bossGroup = new NioEventLoopGroup(); NioEventLoo...
4 Netty多客户端连接与通信
qq_42641261的博客
10-27 1253
1 Netty多客户端连接与通信 前言 上篇写到netty的socket简单的例子，这里将上篇的例子改一改，来分析多客户端 连接与通信的情况。下面还是直接上代码。 1.1 服务端 1.1.1 MyServer package netty.server; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.EventLoopGroup; impo
Netty整合Socket客户端长链接
qq_39912230的博客
11-11 1163
创建客户端连接 import com.alibaba.fastjson.JSONObject; import com.lianfu.smartparking.controller.ThreadServerSocket; import io.netty.bootstrap.Bootstrap; import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.Sock
Netty-SocketIO多路复用
weixin_30292843的博客
11-07 1132
概念 namespace 和room的概念其实用来同一个服务端socket多路复用的。namespace，room和socketio的关系如下: 每一个socket（每一个客户端）会属于某一个room，如果没有指定，那么会有一个default的room。这个room又会属于某个namespace，如果没有指定，那么就是默认的namespace /。 广播 socketIO广播的时候是以names...
spring boot 整合的netty 实现的socket的服务端和客户端
05-08
以下将详细讲解如何实现Spring Boot整合Netty的Socket服务端和客户端。 首先，我们来看服务端的实现。在`netty_server`项目中，我们需要创建一个`ServerBootstrap`实例，它是Netty服务器的核心。通过`...
基于netty编写的socket服务端
12-05
这里的`NioServerSocketChannel`是Netty提供的用于监听客户端连接的服务器套接字通道，`MyBusinessHandler`是我们自定义的业务处理器，它会处理每个新建立的连接。 在`MyBusinessHandler`中，我们可以实现对客户端...
NettySocket同步数据获取实现
10-13
1. **NettySocket同步数据获取**： 在Netty中，我们创建一个ServerBootstrap实例来配置服务器，并设置一个处理器Pipeline，用于处理进来的连接和消息。然后，我们调用bind方法启动服务器并等待客户端连接。当接收到...
netty-socket实时在线人数统计
09-19
在实时在线人数统计的场景下，Netty可以作为底层通信层，处理客户端连接、数据传输和断开连接等事件。 **WebSocket** WebSocket是一种在客户端和服务器之间建立长连接的协议，允许双向通信。相较于HTTP，WebSocket...
Web聊天室(基于Netty的WebSocket服务器)
01-20
基于Netty编写的WebSocket服务器，前端为Web界面，可以实现一个简单的聊天室的功能，纯文字。（～.～），赚点积分，我要下载的三个文件一共要150的积分(|||.|||)。具体的讲解在我的博客里，全部的代码也在我的博客里，没有积分的直接去博客也能得到全部代码：https://blog.csdn.net/qq_37437983/article/details/86557730
使用Netty构建一个基于WebSocket的聊天室服务器
06-21
使用Netty构建一个基于WebSocket的聊天室服务器。可以使多个用户使用浏览器可以同时进行相互通信。 程序逻辑： 1、客户端发送一个消息； 2、该消息将被广播到所有其他连接的客户端 服务端启动后，浏览器输入http://localhost:9999
基于netty分布式聊天室
04-04
客户端与服务端连接 客户端处理服用户输入，发送消息到服务端 高性能序列化（Protobuf） 服务端自动注册到注册中心（Zookeeper） 实现Server端分布式 分布式部署 消息群发 路由端转发消息 客户端上下线处理 服务端宕机，客户端重连处理 未来扩展方向 下载直接可以用
Android使用Netty网络框架实践（客户端、服务端）
10-21
Netty是一个异步事件驱动的网络应用程序框架，它为高性能、高可用性的网络服务器和客户端提供了一种简单易用的方式。本实践将详细介绍如何在Android环境中使用Netty进行客户端和服务端的通信。 首先，我们需要理解...
008 netty实践_多客户端连接服务器通信
诸般世界
12-05 887
实际生产中多客户端连接服务器通信是常用应用，多客户端连接一个服务器端，多客户端连接多个服务器； package com.cc.netty.best.multi.connection; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.Channel; import io.netty.chann...
netty聊天服务器搭建
weixin_39168678的博客
01-24 935
服务端的代码 public class WebsocketServer { private Channel channel; private final EventLoopGroup bossGroup = new NioEventLoopGroup(); private final EventLoopGroup workerGroup = new NioEventL
Netty学习(2):客户端和服务端的连接通讯（socket）
保暖透气大裤衩LeoLee的博客
08-24 974
概述 在上一节学习中，我们了解到了Netty作为HTTP服务端是怎么建立的，请求的执行流程是怎么样的，对Netty作为HTTP服务端的能力有了一个初步的认识，这一帖主要来学习一下基于Netty框架的客户端与服务端的长连接通讯。 示例 socket服务端与之前作为HTTP服务端的建立基本一致，都遵循如下流程： 建立接收和处理的线程组 使用ServerBootstrap绑定处理器并启动 建立连接并调用initChannel方法初始化各种处理器 package com.leolee.netty.se
服务器端如何管理很多个客户端的socket连接？
YEYUANGEN的专栏
09-22 7570
问：我想请问大家一个问题，当一个服务器端面临成千上万个客户端的连接，在完成端口后，服务器程序如何管理这成千上万个客户端的连接，保证正常的通讯？ 不会是有一万个客户端，就建立一万个线程来保证服务器处理客户端的数据吧！ 答： 1）用完成端口 2）线程有限，因此使用线程池，逐个处
使用NETTY实现一个客户端连接类，实现心跳机制
06-01
好的，我可以为您提供一个简单的示例代码，用于使用Netty实现客户端连接类，同时实现心跳机制。示例代码如下： ```java import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelFuture; import io....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值