【IDEA】基于IO、NIO、Netty的TCP网络聊天程序

最新推荐文章于 2024-03-15 13:54:59 发布
最新推荐文章于 2024-03-15 13:54:59 发布
阅读量649 收藏 4
点赞数
分类专栏： 计算机网络 Java 文章标签： 网络 tcp/ip intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YangMax1/article/details/121791873
版权

目录

一、IO实现TCP聊天程序

1. IO简介

  1. 服务端阻塞点
server.accept();获取套接字的时候
inputStream.read(bytes);输入流读取数据的时候
  1. 传统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tomcat底层用的就是socket,用完就会关掉线程，因此不会出现线程一直被占用的情况，支持处理多个客户端连接。
    （1）单线程情况下只能有一个客户端（一个线程维护一个连接，也就是一个socket客户连接）线程一直被占用。
    （2）用线程池可以有多个客户端连接，但是非常消耗性能(用此案城池，就是老tomcat原理，只不过是用完后就释放)

2. IO实现网络程序

  • 新建两个java项目（一个Server端，一个client端）
    在这里插入图片描述
  • Server端代码编写
package com.company;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.io.InputStream;
import java.net.Socket;

public class Main {

    public static void main(String[] args)  throws IOException {
        //创建客户端的Socket对象(SevereSocket)
        //ServerSocket (int port)创建绑定到指定端口的服务器套接字
        ServerSocket ss = new ServerSocket(50000);

        //Socket accept()侦听要连接到此套接字并接受他
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("数据是：" + data);

        //释放资源
        s.close();
        ss.close();
    }
}

在这里插入图片描述

  • Client端代码编写
package com.company;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class Main {

    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象
        //Socket (InetAddress adress,int port)创建流套接字并将其连接到指定IP地址的指定端口号
//		Socket s=new Socket(InetAddress.getByName("192.168.224.1"), 10000);
        //Socket (String host,int port)创建流套接字并将其连接到指定主机的指定端口号
        Socket s=new Socket("127.0.0.1", 50000);

        //获取输出流，写数据
        //OutputStream getOutputStream();返回此套接字的输出流
        OutputStream os=s.getOutputStream();
        os.write("hello,tcp".getBytes());

        //释放资源
        s.close();
    }
}

在这里插入图片描述

3. 运行测试

在这里插入图片描述
测试成功。

二、NIO实现TCP聊天程序

1. NIO简介

  1. NIO特点
      NIO单线程模型，采用selector管理的轮询查询模式，selector每隔一段时间都去看一下client端有没有产生需要处理的消息（客户端连接请求、客户端发送数据请求、客户端下载数据请求），也就是说selector会同时管理client端的连接和通道内client端的读、写请求。
      NIO单线程模型：采用selector管理的轮询查询模式，selector每隔一段时间都去看一下client端有没有产生需要处理的消息（客户端连接请求、客户端发送数据请求、客户端下载数据请求），也就是说selector会同时管理client端的连接和通道内client端的读、写请求。

  2. NIO与IO的主要区别
    在这里插入图片描述

2. NIO实现网络程序

  • 新建两个java项目（一个Server端，一个client端）
    在这里插入图片描述
  • Server端代码编写
package com.company;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class Main {

    //网络通信IO操作，TCP协议，针对面向流的监听套接字的可选择通道（一般用于服务端）
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;

    /*
     *开启服务端
     */
    public void start(Integer port) throws Exception {
        serverSocketChannel = ServerSocketChannel.open();
        selector = Selector.open();
        //绑定监听端口
        serverSocketChannel.socket().bind(new InetSocketAddress(port));
        //设置为非阻塞模式
        serverSocketChannel.configureBlocking(false);
        //注册到Selector上
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        startListener();
    }
    private void startListener() throws Exception {
        while (true) {
            // 如果客户端有请求select的方法返回值将不为零
            if (selector.select(1000) == 0) {
                System.out.println("current not exists task");
                continue;
            }
            // 如果有事件集合中就存在对应通道的key
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            // 遍历所有的key找到其中事件类型为Accept的key
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if (key.isAcceptable())
                    handleConnection();
                if (key.isReadable())
                    handleMsg(key);
                iterator.remove();
            }
        }
    }
    /**
     * 处理建立连接
     */
    private void handleConnection() throws Exception {
        SocketChannel socketChannel = serverSocketChannel.accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
    }
    /*
     * 接收信息
     */
    private void handleMsg(SelectionKey key) throws Exception {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer attachment = (ByteBuffer) key.attachment();
        channel.read(attachment);
        System.out.println("current msg: " + new String(attachment.array()));
    }

    public static void main(String[] args) throws Exception {
        Main myServer = new Main();
        myServer.start(8888);
    }
}

在这里插入图片描述

  • Client端代码编写
package com.company;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class Main {

    public static void main(String[] args) throws Exception {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);

        // 连接服务器
        if (!socketChannel.connect(new InetSocketAddress("127.0.0.1", 8888))) {
            while (!socketChannel.finishConnect()) {
                System.out.println("connecting...");
            }
        }
        //发送数据
        String str = "hello netty";
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        socketChannel.write(byteBuffer);
        System.in.read();
    }
}

在这里插入图片描述

3. 运行测试

在这里插入图片描述
测试成功。

三、Netty实现TCP聊天程序

1. Netty简介

  1. Netty定义
     Netty 是一个基于NIO的客户、服务器端编程框架。
  2. Netty特点
    （1）使用Netty 可以确保你快速和简单的开发出一个网络应用。
    （2）Netty 是一个吸收了多种协议的实现经验，包括FTP，SMTP，HTTP，各种二进制，文本协议，并经过相当精心设计的项目。
    （3）Netty在保证程序易于开发的同时，还保证了应用的高性能，稳定性和伸缩性。

2. Netty实现网络程序

  • 新建两个java项目（一个Server端，一个client端），并导入jar包
    在这里插入图片描述
    • Server端代码编写
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.net.InetSocketAddress;

/**
 *
 */
public class Server {

    private int port;

    public static void main(String[] args){
        new Server(18080).start();
    }

    public Server(int port) {
        this.port = port;
    }

    public void start() {
        /**
         * 创建两个EventLoopGroup，即两个线程池，boss线程池用于接收客户端的连接，
         * 一个线程监听一个端口，一般只会监听一个端口所以只需一个线程
         * work池用于处理网络连接数据读写或者后续的业务处理（可指定另外的线程处理业务，
         * work完成数据读写）
         */
        EventLoopGroup boss = new NioEventLoopGroup(1);
        EventLoopGroup work = new NioEventLoopGroup();
        try {
            /**
             * 实例化一个服务端启动类，
             * group（）指定线程组
             * channel（）指定用于接收客户端连接的类，对应java.nio.ServerSocketChannel
             * childHandler（）设置编码解码及处理连接的类
             */
            ServerBootstrap server = new ServerBootstrap()
                    .group(boss, work).channel(NioServerSocketChannel.class)
                    .localAddress(new InetSocketAddress(port))
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast("decoder", new StringDecoder())
                                    .addLast("encoder", new StringEncoder())
                                    .addLast(new HelloWorldServerHandler());
                        }
                    });
            //绑定端口
            ChannelFuture future = server.bind().sync();
            System.out.println("server started and listen " + port);
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            boss.shutdownGracefully();
            work.shutdownGracefully();
        }
    }

    public static class HelloWorldServerHandler extends ChannelInboundHandlerAdapter {

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("HelloWorldServerHandler active");
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("server channelRead..");
            System.out.println(ctx.channel().remoteAddress()+"->Server :"+ msg.toString());
            ctx.write("server write"+msg);
            ctx.flush();
        }
    }
}

在这里插入图片描述

  • Client端代码编写
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 *
 */
public class Client {
    private static final String HOST = "localhost";
    private static final int PORT= 18080;

    public static void main(String[] args){
        new Client().start(HOST, PORT);
    }

    public void start(String host, int port) {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap client = new Bootstrap().group(group).channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true).handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast("decoder", new StringDecoder())
                                    .addLast("encoder", new StringEncoder())
                                    .addLast(new HelloWorldClientHandler());
                        }
                    });
            ChannelFuture future = client.connect(host, port).sync();
            future.channel().writeAndFlush("Hello Netty Server ,I am a netty client");
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();

        }

    }

    public static class HelloWorldClientHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("HelloWorldClientHandler Active");
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("HelloWorldClientHandler read Message:"+msg);
        }
    }
}

在这里插入图片描述

3. 运行测试

在这里插入图片描述
测试成功！

四、总结

  本文对IO、NIO、Netty的进行了简单介绍，并分别基于IO、NIO、Netty编写了TCP网络聊天程序。

五、参考

https://blog.csdn.net/junseven164/article/details/121714791?spm=1001.2014.3001.5501

Max_Shy
关注
专栏目录
IDEA TCP传输
weixin_47389461的博客
04-28 1165
idea实现信息传输 客户端 import java.io.IOException; import java.io.OutputStream; import java.net.InetAddress; import java.net.Socket; public class TcpClient1 { public static void main(String[] args) { ...
基于IO、NIO、Netty的Java网络程序（TCP的聊天程序）
weixin_46129506的博客
12-09 696
目录一、IO1.IO的特点2.基于IO的java网络程序二、NIO1.NIO的简介2.基于NIO的java程序三、Netty1.netty介绍2.基于Netty的java网络程序四、总结参考资料 一、IO 1.IO的特点 1.服务端阻塞点 server.accept();获取套接字的时候 inputStream.read(bytes);输入流读取数据的时候 2.传统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tomcat底层用的就是socket,用完就会关掉线程，因
Netty 实现TCP群聊系统
mister_Wei的博客
01-03 375
好久没写博客了，2020第一篇博客！ Netty 我这边就不多加说明了，同步非阻塞典型的NIO架构 不过Netty在原有的NIO基础上进行了封装，操作更加简便。 Selector Channel Buffer 这些组件概念我也不去啰嗦。 单Selector 单线程，单Selector多线程，主从Selector多线程 为什么说这一点，因为Netty就是根据主从Selector多线程演变过来...
Socket.io在线聊天室
糖糖小菜鸟前端er
04-28 1322
转载自：http://blog.fens.me/nodejs-socketio-chat/ 由于项目需要一个群组聊天室，遂找到一个非常好的demo，以下为转载全文： 目录 socket.io介绍 服务器端和客户端通信设计 服务器端实现 客户端实现 完整案例代码 1. socket.io介绍 socket.io一个是基于Nodejs架构体系的，支持webso
使用netty实现简单tcp服务端
qq_36532060的博客
11-01 1786
一个简单的用netty实现的tcp连接服务端
java结合NIO实现的聊天程序
caizedong的专栏
02-20 1879
ChatClient： import java.net.*; import java.nio.*; import java.nio.channels.*; import java.nio.charset.*; import java.awt.*; import java.awt.event.*; public class ChatClient { private SocketChannel s
基于IO、NIO、Netty的Java网络程序（实现服务端与客户端通信）
YouthBlood9的博客
12-17 2718
录一、IO Java网络聊天程序1.1 IO 介绍1.1.1 简介1.1.2 传统IO特点1.1.3 原理图1.2 IDEA新建Java项目1.3 代码1.4 运行结果二、NIO Java网络聊天程序2.1 NIO 介绍2.1.1 简介2.1.2 NIO的特点2.1.3 NIO的通信步骤2.1.4 原理图2.1.5 IO与NIO的主要区别2.2 新建项目2.3 代码2.4 运行结果三、Netty Java网络程序3.1 Netty 介绍3.1.1 简介3.1.2 特点3.1.3 Netty通信的步骤3.2
分别基于IO、NIO、Netty的Java网络程序
qq_45874317的博客
12-17 103
一、Netty入门 1、传统IO与NIO NIO即New IO，这个库是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，NIO主要用到的是块，所以NIO的效率要比IO高很多。在Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。 1、传统IO特点 1.服务端阻塞点 server.accept();获取套接字的时候 inputStream.read(bytes);输入流读取数据的时候 2.传统socket是短连接，可以做短连接服务器
基于IO/NIO/Netty的Client/Server的java程序实现
hh444565的博客
12-19 301
一、IO实现 （一）IO介绍 1.传送IO特点 （1）服务端阻塞点 server.accept();获取套接字的时候 inputStream.read(bytes);输入流读取数据的时候 （2）传统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tomcat底层用的就是socket,用完就会关掉线程，因此不会出现线程一直被占用的情况，支持处理多个客户端连接 单线程情况下只能有一个客户端（一个线程维护一个连接，也就是一个socket客户连接）线程一直被占用。 用...
Java IO流之Netty实现聊天通信功能
最新发布
上善若泪
03-15 1572
点击了解 IO流之IO,NIO和AIO讲解Netty是一个相当优秀的通信框架，大多数的顶级开源框架中都有Netty的身影。应用过程中，它最核心的东西叫handler，我们可以简单理解它为消息处理器。收到的消息和出去的消息都会经过一系列的handler加工处理。收到的消息我们叫它入站消息，发出去的消息我们叫它出站消息，因此handler又分为出站handler和入站handler。收到的消息只会被入站handler处理，发出去的消息只会被出站handler处理。
基于nio的简易聊天室
09-11
基于nio 简易聊天室的服务端 客户端，有界面
TCP连接测试工具_强烈推荐！
08-24
软件名字叫“TCPUDPDbg”，是一个TCP和UDP协议的网络连接测试工具，支持服务器模式和客户端模式，支持多连接，可同时对多路网络连接进行操作，支持发送汉字，支持十六进制发送和接收方式。非常好用，强烈推荐！
Netty一个端口支持tcp和websocket
09-29
同一个端口支持tcp和websocket 这样就不需要开两个端口了
socket测试调试工具
02-11
SocketTool.exe是个非常经典的软件，测试端口和网络很方便 对程序测试很有帮助 做socket程序，测试起来非常方便 好用简单的嵌入式网络调试工具·集成TCP/IP协议，全透明传输
Netty(十七) - Netty入门实例（TCP）
yangxshn的博客
02-24 305
一、实例要求 1）、使用IDEA创建Netty项目 2）、Netty服务器在6668端口监听，客户端能发送消息给服务器：“Hello，服务器” 3）、服务器可以回复消息给客户端：“Hello，客户端” 4）、目的：对Netty线程模型有一个初步认识，便于理解Netty模型理论 5）、说明：创建Maven项目，并引入Netty包 ...
【学习IntelliJ IDEA】5、java开发TCP Server之开端
jiezhang656的专栏
11-22 828
首先，因为新的平台是在idea上面开发的，开发的需求有如下： 1、需要接入多个通信协议（多个客户，不同的通信协议，不同的报文格式，对于这个如何处理）； 2、需要处理并发事件； 前期准备： 1、java下有什么开源框架？netty？ 2、如何处理粘包问题？ 3、关于同步、异步问题：并发，这几个概念如何理解？ 4、Netty是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维...
用“IDEA”和“Eclipse”搭建TCP局域网聊天通讯
蓝途职业教育学员互动分享专区
04-13 474
周一好！ 给大家介绍两款Java后台开发常用到的IDE,可⽀持后台基本的开发，包含前端HTML,CSS,JS开发，也可以⽤用来从事安卓方向开发的软件。 IDEA 全称 IntelliJ IDEA，是java编程语言开发的集成环境。IntelliJ在业界被公认为最好的java开发工具，尤其在智能代码助手、代码自动提示、重构、J2EE支持、各类版本工具(git、svn等)、JUnit、CVS整合、代码...
Java基础 —— P16.网络编程 (入门) - IDEA
czting_的博客
06-01 294
导学 1.网络编程； 2.UDP通信程序； 3.TCP通信程序； 一、网络编程： · 概述：  1.计算机网络；    指在不同地理位置的客户端通过通信线连接起来，在网络操作系统、网络管理系统、通信协议管理和协调下，实现资源共享和信息传递的计算机系统；  2.网络编程   指在网络通信协议下，实现网络互联的不同计算机上运行的程序间可以进行的数据交换；   · 网络编程三要素：  1.IP地址   IP地址是标识号，想让网络中的两台设备相互通信，就必须为计算机指定一个标识号；  2.端口   用于区分
网络通信编程——IDEA中Java和Spring使用入门
羚漆的博客
01-14 592
目录酱一、IDEA下载二、IDEA使用以传统JAVA方式写一个Hello World的方法以Spring方法写一个Hello World的方法三、总结参考文献 一、IDEA下载 官网下载：https://www.jetbrains.com/idea/download/#section=windows 百度网盘：https://pan.baidu.com/s/1UezRURf89qdnMho2qi2iUw [提取码]：wehm 二、IDEA使用 以传统JAVA方式写一个Hello World的方法 f
使用Netty NIO重构Java聊天室
"java基于netty NIO的简单聊天室的实现" 本文将深入探讨如何使用Java的Netty框架实现一个基于NIO的简单聊天室。Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的网络服务。在本文中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值