netty 点对点聊天程序

已于 2024-05-09 15:46:18 修改
阅读量3.2k 收藏 6
点赞数 3
文章标签： 开发语言
于 2017-08-17 18:17:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzhiquan_1025/article/details/77337658
版权

使用最新Netty实现一个简单的聊天程序

package com.anxpp.im.server;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
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 io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;

import java.io.IOException;
import java.util.Scanner;

import com.anxpp.im.common.IMConfig;
import com.anxpp.im.common.IMMessage;
import com.anxpp.im.common.MsgPackDecode;
import com.anxpp.im.common.MsgPackEncode;
import com.anxpp.im.server.handler.ServerHandler;
public class Server implements Runnable,IMConfig{
    ServerHandler serverHandler = new ServerHandler();
    public static void main(String[] args) throws IOException{
        new Server().start();
    }
    public void start() throws IOException{
        new Thread(this).start();
        runServerCMD();
    }
    /**启动服务端控制台
     * @throws IOException */
    private void runServerCMD() throws IOException {
        //服务端主动推送消息
        int toID = 1;
        IMMessage message = new IMMessage(
                APP_IM,
                CLIENT_VERSION,
                SERVER_ID,
                TYPE_MSG_TEXT,
                toID,
                MSG_EMPTY);
        @SuppressWarnings("resource")
        Scanner scanner = new Scanner(System.in);
        do{
            message.setMsg(scanner.nextLine());
        }
        while (serverHandler.sendMsg(message));
    }
    public void run() {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG, 1024)
//                  .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast("frameDecoder", new LengthFieldBasedFrameDecoder(65536, 0, 2, 0, 2));
                            ch.pipeline().addLast("msgpack decoder",new MsgPackDecode());
                            ch.pipeline().addLast("frameEncoder", new LengthFieldPrepender(2));
                            ch.pipeline().addLast("msgpack encoder",new MsgPackEncode());
                            ch.pipeline().addLast(serverHandler);
                        }
                    }); 
            ChannelFuture f = b.bind(SERVER_PORT).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}


2.

package com.anxpp.im.server.handler;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import java.io.IOException;
import com.anxpp.im.common.IMMessage;
import com.anxpp.im.common.OnlineUser;
import com.anxpp.im.server.config.BaseConfig;
@ChannelHandler.Sharable
public class ServerHandler extends ChannelInboundHandlerAdapter implements BaseConfig{
    private ChannelHandlerContext ctx;
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        System.err.println("服务端Handler创建...");
        super.handlerAdded(ctx);
    }
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.err.println("channelInactive");
        super.channelInactive(ctx);
    }
    /**
     * tcp链路建立成功后调用
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        this.ctx = ctx;
        System.err.println("有客户端连接："+ctx.channel().remoteAddress().toString());
    }
    /**
     * 发送消息
     */
    public boolean sendMsg(IMMessage msg) throws IOException {
        System.err.println("服务器推送消息:"+msg);
        ctx.writeAndFlush(msg);
        return msg.getMsg().equals("q") ? false : true;
    }
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws IOException {
        System.err.println("服务器接收到消息:"+msg);
        IMMessage message = (IMMessage)msg;
        if(OnlineUser.get(message.getReceiveId())==null){
            OnlineUser.put(message.getUid(), ctx);
        }
        ChannelHandlerContext c = OnlineUser.get(message.getReceiveId());
        if(c==null){
            message.setMsg("对方不在线！");
            OnlineUser.get(message.getUid()).writeAndFlush(message);
        }
        else
            c.writeAndFlush(message);
    }
    /**
     * 异常处理
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        System.err.println("与客户端断开连接:"+cause.getMessage());
        cause.printStackTrace();
        ctx.close();
    }
}

3

package com.anxpp.im.common;
public interface IMConfig {
    /**客户端配置*/
    int     CLIENT_VERSION = 1;         //版本号
    /**服务端配置*/
    String  SERVER_HOST = "127.0.0.1";  //服务器IP
    int     SERVER_PORT = 9090;         //服务器端口
    /**消息相关*/
    int     SERVER_ID   = 0;            //表示服务器消息
    byte    APP_IM = 1;         //即时通信应用ID为1
    byte    TYPE_CONNECT = 0;   //连接后第一次消息确认建立连接和发送认证信息
    byte    TYPE_MSG_TEXT = 1;  //文本消息
    String  MSG_EMPTY = "";     //空消息
}

4.

package com.anxpp.im.common;

import org.msgpack.annotation.Message;

@Message
public class IMMessage {
    //应用ID
    private byte appId;
    //版本号
    private int version;
    //用户ID
    private int uid;
    //消息类型    0:登陆    1：文字消息
    private byte msgType;
    //接收方
    private int receiveId;
    //消息内容
    private String msg;
    public IMMessage() {}
    /**
     * 构造方法
     * @param appId     应用通道
     * @param version   应用版本
     * @param uid       用户ID
     * @param msgType   消息类型
     * @param receiveId 消息接收者
     * @param msg       消息内容
     */
    public IMMessage(byte appId, int version, int uid, byte msgType, int receiveId, String msg) {
        this.appId = appId;
        this.version = version;
        this.uid = uid;
        this.msgType = msgType;
        this.receiveId = receiveId;
        this.msg = msg;
    }
    public byte getAppId() {
        return appId;
    }
    public void setAppId(byte appId) {
        this.appId = appId;
    }
    public int getVersion() {
        return version;
    }
    public void setVersion(int version) {
        this.version = version;
    }
    public int getUid() {
        return uid;
    }
    public void setUid(int uid) {
        this.uid = uid;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public byte getMsgType() {
        return msgType;
    }
    public void setMsgType(byte msgType) {
        this.msgType = msgType;
    }
    public int getReceiveId() {
        return receiveId;
    }
    public void setReceiveId(int receiveId) {
        this.receiveId = receiveId;
    }
    @Override
    public String toString() {
        return "appId:"+this.appId+",version:"+this.version+",uid:"+this.uid+",msgType:"+this.msgType+",receiveId:"+this.receiveId+",msg:"+this.msg;
    }
}

5.

package com.anxpp.im.common;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageDecoder;
import java.util.List;
import org.msgpack.MessagePack;
/**
 * 解码工具
 */
public class MsgPackDecode extends MessageToMessageDecoder<ByteBuf>{
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
        final int length = msg.readableBytes();
        final byte[] array = new byte[length];
        msg.getBytes(msg.readerIndex(), array, 0, length);
        out.add(new MessagePack().read(array,IMMessage.class));
    }
}


6.

package com.anxpp.im.common;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import java.io.IOException;
import org.msgpack.MessagePack;
/**
 * 编码工具
 */
public class MsgPackEncode extends MessageToByteEncoder<IMMessage>{
    @Override
    protected void encode(ChannelHandlerContext ctx, IMMessage msg, ByteBuf out) throws IOException {
        out.writeBytes(new MessagePack().write(msg));
    }
}


7.

package com.anxpp.im.common;
import io.netty.channel.ChannelHandlerContext;
import java.util.HashMap;
/**
 * 在线用户表
 * @author Administrator
 *
 */
public class OnlineUser {
    //用户表
    private static HashMap<Integer, ChannelHandlerContext> onlineUser = new HashMap<Integer, ChannelHandlerContext>();
    public static void put(Integer uid, ChannelHandlerContext uchc){
        onlineUser.put(uid, uchc);
    }
    public static void remove(Integer uid){
        onlineUser.remove(uid);
    }
    public static ChannelHandlerContext get(Integer uid){
        return onlineUser.get(uid);
    }
}


8,。

package com.anxpp.im.client;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
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 io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;

import java.io.IOException;
import java.util.Scanner;


import com.anxpp.im.client.handler.ClientHandler;
import com.anxpp.im.common.IMConfig;
import com.anxpp.im.common.IMMessage;
import com.anxpp.im.common.MsgPackDecode;
import com.anxpp.im.common.MsgPackEncode;
public class Client implements Runnable,IMConfig {
    public static int UID = 8889;
    public static int toID = 8888;
    private ClientHandler clientHandler = new ClientHandler();
    public static void main(String[] args) throws IOException{
        new Client().start();
    }
    public void start() throws IOException{
        new Thread(this).start();
        runServerCMD();
    }
    public void sendMsg(IMMessage msg) throws IOException {
        clientHandler.sendMsg(msg);
    }
    /**启动客户端控制台*/
    private void runServerCMD() throws IOException {
        IMMessage message = new IMMessage(
                APP_IM,
                CLIENT_VERSION,
                UID,
                TYPE_MSG_TEXT,
                toID,
                MSG_EMPTY);
        @SuppressWarnings("resource")
        Scanner scanner = new Scanner(System.in);
        do{
            message.setMsg(scanner.nextLine());
        }
        while (clientHandler.sendMsg(message));
    }
    @Override
    public void run() {
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast("frameDecoder", new LengthFieldBasedFrameDecoder(65536, 0, 2, 0, 2));
                    ch.pipeline().addLast("msgpack decoder",new MsgPackDecode());
                    ch.pipeline().addLast("frameEncoder", new LengthFieldPrepender(2));
                    ch.pipeline().addLast("msgpack encoder",new MsgPackEncode());
                    ch.pipeline().addLast(clientHandler);
                }
            });
            ChannelFuture f = b.connect(SERVER_HOST, SERVER_PORT).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}

9.

package com.anxpp.im.client.handler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.io.IOException;

import com.anxpp.im.client.Client;
import com.anxpp.im.common.IMConfig;
import com.anxpp.im.common.IMMessage;
public class ClientHandler extends ChannelInboundHandlerAdapter implements IMConfig{
    private ChannelHandlerContext ctx;
    /**
     * tcp链路简历成功后调用
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("成功连接服务器");
        this.ctx = ctx;
        IMMessage message = new IMMessage(
                APP_IM,
                CLIENT_VERSION,
                Client.UID,
                TYPE_CONNECT,
                SERVER_ID,
                MSG_EMPTY);
        sendMsg(message);
    }
    /**
     * 发送消息
     * @param msg
     * @return
     * @throws IOException 
     */
    public boolean sendMsg(IMMessage msg) throws IOException {
        System.out.println("client:" + msg);
        ctx.channel().writeAndFlush(msg);
        return msg.getMsg().equals("q") ? false : true;
    }
    /**
     * 收到消息后调用
     * @throws IOException 
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws IOException {
        IMMessage m = (IMMessage)msg;
        System.out.println(m.getUid() + ":" + m.getMsg());
    }
    /**
     * 发生异常时调用
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        System.err.println("与服务器断开连接:"+cause.getMessage());
        ctx.close();
    }
}

10 代码结构



 

skeletons321
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
使用Netty构建一个基于WebSocket的聊天室服务器
06-21
使用Netty构建一个基于WebSocket的聊天室服务器。可以使多个用户使用浏览器可以同时进行相互通信。 程序逻辑： 1、客户端发送一个消息； 2、该消息将被广播到所有其他连接的客户端 服务端启动后，浏览器输入http://localhost:9999
【SpringBoot框架篇】18.使用Netty加websocket实现在线聊天功能
热门推荐
皓亮君的博客
09-12 1万+
使用netty加websocket实现在线聊天功能
Netty通过多种协议实现IM通信
最新发布
u012903034的博客
05-22 446
Netty是一个异步事件驱动的网络应用框架，主要用于构建高性能的协议服务器和客户端。Netty极大地简化了TCP和UDP socket服务器的编程。本文介绍了Netty在IM通信中使用的三种协议：TCP、UDP和WebSocket。通过对比三种协议的使用场景和特点，展示了如何控制协议包的大小以及如何进行编解码。通过完整的服务端和客户端实现代码，展示了如何在Netty中实现这三种协议的IM通信。Netty强大的功能和灵活性使其成为构建高性能IM系统的理想选择。
Netty实现简易聊天室的功能
天瑕的博客
05-05 2458
使用Netty来实现一个聊天室是很容易的，当有客户端连接服务端的时候，在服务端的channelActive方法里面即可感应到。这里的解决方案是发送每条数据的时候，将数据的长度一并发送，比如可以选择每条数据的前4位是数据的长度，应用层处理时可以根据长度来判断每条数据的开始和结束。同理，channelInactive是该客户端断开服务端时会回调的方法，在里面给其他客户端发一条“下线了”的信息即可。如果数据长度不够length，就等待下一次数据过来，取数据的时候也只取length长度的数据。
使用Netty实现IM消息聊天
qq_38273070的博客
08-23 483
后端netty，前端websocket，实现im消息聊天
Netty实现简单的双向通信（聊天）
qq_52072614的博客
11-30 1039
好了这就是具体的实现了，有什么不对或者可以跟好的地方可以评论指出。
springboot+netty点对点即时通讯、聊天
02-25
在本项目中，"springboot+netty点对点即时通讯、聊天" 是一个利用Spring Boot和Netty构建的实时通信应用，旨在实现用户之间的高效、低延迟的对话功能。以下将详细介绍该项目所涉及的关键技术和知识点。 1. **Spring...
基于Netty的Android点对点聊天软件-源码
04-17
本资源提供的是一个基于Netty框架开发的Android点对点聊天软件的源代码。Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。它在Java NIO（非阻塞I/O）的基础上...
基于netty+websocket的在线聊天室
07-03
在构建一个基于Netty+WebSocket的在线聊天室时，我们需要深入了解这两个核心技术以及它们与SpringBoot、Freemarker和Layui等其他技术的整合。以下是对这些知识点的详细阐述： 1. **Netty**: Netty是一个高性能、...
netty实现多人聊天室，有gui界面
11-07
为了实现聊天室的多人通信，开发者可能采用了发布/订阅模式或者点对点的消息传递机制。发布/订阅模式下，服务器作为消息的中介，接收来自每个客户端的消息并转发给所有其他客户端。点对点则需要服务器帮助转发消息，...
java点对点聊天（非阻塞式网络编程）
08-24
Java点对点聊天系统是基于非阻塞式网络编程实现的一种通信方式，它允许两个或多个用户通过互联网直接交换信息，而无需通过中央服务器作为中介。这种技术在现代分布式系统和实时通信应用中广泛使用，如VoIP服务、即时...
netty3.5.2实现点对点、点对多的聊天demo
09-07
本demo是基于netty3.5.2开发的在对象传输上实现的局域网聊天的一个小小socketTcp网络通信测试用例，通信是通过服务器作中转的，网上也有大神说可以通过在客户端实现服务端功能和客户端功能，这样就不用中转这一过程，demo在关键代码处给出了注释，如果是在两台不同ip的机子测试的话，请修改Client类中的链接地址。
用netty实现聊天
leese233的博客
05-17 929
用netty实现聊天
使用 Netty 实现点对点的通信
实践求真知
05-28 389
一服务端 1主程序 package netty.socket; 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.NioServerSocke..
Netty--聊天业务
Kaka_csdn14的博客
07-05 1819
推荐 了解 消息推送中的已读消息和未读消息设计问题 站内信问题难点 Netty websocket 实现简单聊天功能的相关
基于Netty的分布式聊天系统
weixin_44909963的博客
04-23 3661
基于Netty的分布式聊天系统 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 第一章：基于Netty的分布式聊天系统 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录基于Netty的分布式聊天系统前言一、IM系统架构的探讨二、使用步骤1.引入库2.读入数据总结 前言 IM 全称是『Instant Messaging』，中文名是即时通讯。在这个高度信息化的移动互联网时代，生活中 IM 类产品已经成为必备品，比较有名的如钉钉、微信、QQ 等以 IM 为核心功能
[小项目]-netty实现聊天功能
惜暮
01-12 1万+
Netty是一个Java的NIO客户端服务端框架可以快速的开发网络应用程序，比如客户端和服务端的协议，大大简化了网络程序的开发过程。我们知道Netty的整体架构主要由3部分组成：缓冲(buffer)、通道(channel)、事件模型(event model)。所有的高级也行都构建于这三个组件之上。下面我们基于这个架构实现一个简单的网络聊天功能。 1.环境： JDK 7 Maven3
基于netty实现简单的聊天
Alaskan_Husky的博客
11-24 1012
这些组件共同构成了Netty的核心架构，使其成为一个强大、灵活、可扩展的网络编程框架。Netty的设计理念主要围绕着事件驱动、非阻塞、可重用的组件，使得它适用于构建高性能、可靠性强的网络应用程序。创建两个EventLoopGroup，一个用于处理连接的事件，另一个用于处理已经接受的连接的事件。通过这种方式，你可以添加自己的业务逻辑处理器，实现具体的通信需求。它们是Netty的启动类，负责配置和启动Netty应用。在项目中引入Netty的相关依赖，通常通过构建工具（如Maven或Gradle）来管理。
Java IO流之Netty实现聊天通信功能
上善若泪
03-15 1074
点击了解 IO流之IO,NIO和AIO讲解Netty是一个相当优秀的通信框架，大多数的顶级开源框架中都有Netty的身影。应用过程中，它最核心的东西叫handler，我们可以简单理解它为消息处理器。收到的消息和出去的消息都会经过一系列的handler加工处理。收到的消息我们叫它入站消息，发出去的消息我们叫它出站消息，因此handler又分为出站handler和入站handler。收到的消息只会被入站handler处理，发出去的消息只会被出站handler处理。
java实现一对一聊天netty
10-20
Java实现一对一聊天Netty是一种基于NIO的客户端/服务器框架，用于快速开发可维护的高性能协议服务器和客户端。Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。Netty...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值