(六) socket·NIO socket 实现 控制台 一问一答式聊天

已于 2022-11-13 11:54:04 修改
阅读量567 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Socket 文章标签： NIO socket 聊天 一问一答
于 2019-02-23 13:09:03 首次发布
文章发表1周内为内容优化高峰期，后续会根据认知迭代继续做完善补充。
本文链接：https://blog.youkuaiyun.com/bestcxx/article/details/86774944
本文介绍如何使用 Java NIO Socket 在控制台实现一问一答式的聊天功能，详细解析服务端与客户端的代码逻辑，展示如何通过 Selector 处理多个连接，以及如何在不使用多线程的情况下进行交互。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

前言

基于(五) socket·NIO socket 的基本介绍中对 NIO socket 的介绍，本文实现在控制台一问一答式的聊天。

代码

控制台打印过程将体现服务端和客户端采取的措施。
代码逻辑可以看注释。
如果使用多线程的话，服务端和客户端可以不限制次序的聊天，本文没有使用多线程，便于理解 NIO socket 的交互流程
服务器端和客户端都是通过运行 main 方法启动

NIO socket 服务端

NIO socket 服务端支持非 NIO socket 服务的请求

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.channels.spi.SelectorProvider;
import java.util.*;

/**
 * @Title: Socket Server
 * @Description: NIO Socket
 * @Author: WuJie
 */
public class NioSocketServer {
    private final static String CHARSET="UTF8";//设置编码格式
    private static Selector selector=null;//nio Selector

    public static void main(String [] args){
        NioSocketServer nioSocketServer=new NioSocketServer();
        nioSocketServer.startServer();//启动服务器，等待客户端访问
        if(selector!=null){
            nioSocketServer.handle(selector);//处理客户端的请求
        }else{
            System.out.println("error 2,服务端启动失败");
        }
    }

    /**
     * 启动服务器
     */
    public void startServer(){

        try{
            selector=SelectorProvider.provider().openSelector();//初始化 nio Selector
            selector.select(1000);//阻塞 selector 1000 毫秒，非必须

            //Channel 多线程安全、支持异步关闭
            //初始化服务端 SocketChannel
            ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
            //设置服务端端口
            serverSocketChannel.bind(new InetSocketAddress(10000));
            //非阻塞模式，否则就不是NIO了
            serverSocketChannel.configureBlocking(false);
			//将服务端 Channel 注册到 Selector,感兴趣事件为 准备接受访问
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务端已启动,服务器端字符编码格式为"+CHARSET+",等待客户端的访问：");
        }catch(IOException e){
            System.out.println("error 1,获取 Selector 失败"+e);
        }
    }

    /**
     * 处理客户端的请求与交互
     * @param selector
     */
    public void handle(Selector selector){
        try{
            for(;;){//服务端始终处于启动状态
                int keyNumbers=selector.select();//获取已注册 channel 数量
                if(keyNumbers>0){//如果已注册 channel 数量>0,则开始处理
                    Set<SelectionKey> selectionKeySet=selector.selectedKeys();//获取 selector 中已注册 channel 的 SelectionKey 集合

                    Iterator iterable=selectionKeySet.iterator();//准备遍历 selectionKeySet，处理其对应的 channel
                    while(iterable.hasNext()){
                        SelectionKey selectionKey=(SelectionKey)iterable.next();
                        iterable.remove();//Removes from the underlying collection the last element returned by this iterator (optional operation)

                        if(selectionKey.isAcceptable()){//接受客户端请求
                            acceptable(selectionKey);//TODO 可以使用多线程
                        }else if(selectionKey.isReadable()&&selectionKey.isValid()){//读取客户端传输的数据
                            readable(selectionKey);//TODO 可以使用多线程
                        }else if(selectionKey.isWritable()&&selectionKey.isValid()) {//返回给客户端信息
                            writable(selectionKey);//TODO 可以使用多线程
                        }

                    }
                }else{
                    continue;
                }
            }

        }catch(IOException e){
            System.out.println("error 3,获取 Selector 已注册 Channel 数量失败"+e);
        }

    }

    /**
     * 处理客户端请求
     * 将客户单 channel 注册到 selector
     * @param selectionKey
     */
    private static void acceptable(SelectionKey selectionKey){
        try{
            System.out.println("可接收--------------开始");

            //获取客户端请求
            SocketChannel clientChannel=((ServerSocketChannel) selectionKey.channel()).accept();
            clientChannel.configureBlocking(false);

            Map map=new HashMap<String,String>();//可以将该map连同 channel 一起注册到 selector,map可以携带附属信息
            map.put("demo","没啥用，就是为了表示可以携带一些额外信息，selectionKey  可以获取");

            clientChannel.register(selector, SelectionKey.OP_READ,map);
            System.out.println("【selectionKey.isAcceptable()=true，从select 获取 服务端channel ，从这个channel 获取客户端 channel，向 selector 注册 客户端 channel,感兴趣事件为 OP_READ】");
            System.out.println("可接收--------------结束");
            System.out.println();
        }catch(ClosedChannelException e1){
            System.out.println("error 4,将客户端请求 channel 注册到 selector 失败"+e1);
        }catch (IOException e2){
            System.out.println("error 5,获取客户端请求失败"+e2);
        }
    }

    /**
     * 处理可读的channel
     * 读取客户端发送的信息
     * @param selectionKey
     */
    private static void readable(SelectionKey selectionKey){
        try{
            System.out.println("可读--------------开始");

            SocketChannel clientChannel=(SocketChannel) selectionKey.channel();//根据key获取channel
            ByteBuffer byteBuffer= ByteBuffer.allocate(1024); //准备 1k 的缓冲区
            int len=clientChannel.read(byteBuffer);//将channel 内容写入缓存 byteBuffer
            //System.out.println("byteBuffer.remaining()="+byteBuffer.remaining()+";len="+len);

            if(len==-1){//如果没有信息传入，说明客户端可能中断连接，则关闭这个客户端channel
                try{
                    clientChannel.close();
                    selector.wakeup();//唤起其他channel
                    System.out.println("line 133,客户端已关闭:"+clientChannel.socket().getRemoteSocketAddress());
                    System.out.println("可读--------------结束");
                    //continue;
                    return;
                }catch(Exception e){
                    System.out.println("error 6,关闭客户端 channel 失败"+e);
                    System.out.println("可读--------------结束");
                    //continue;
                    return;
                }

            }
            byteBuffer.flip();//调用flip之后，读写指针指到缓存头部，并且设置了最多只能读出之前写入的数据长度(而不是整个缓存的容量大小)。

            //初始化一个 缓存区可读长度的数组
            byte[] bytes=new byte[byteBuffer.remaining()];

            byteBuffer.get(bytes,0,byteBuffer.remaining());
            byteBuffer.clear();

            System.out.println("客户端传入信息:"+new String(bytes,CHARSET));

            selectionKey.interestOps(SelectionKey.OP_WRITE);//将该 selectionKey 感兴趣事件修改为 写事件，准备向客户端返回数据
            System.out.println("【(selectionKey.isReadable()&&selectionKey.isValid())=true ,已经读取完毕客户端channel 中的buffer信息，将 客户端 channel 感兴趣事件修改为 OP_WRITE】");
            System.out.println("可读--------------结束");
            System.out.println();
        }catch(IOException e){
            System.out.println("error 7,出错了");
        }
    }

    /**
     * 处理可写的channel
     * 向客户端发送信息，该信息从控制台输入
     * @param selectionKey
     */
    private static void writable(SelectionKey selectionKey){
        try{
            System.out.println("可写--------------开始");

            SocketChannel clientChannel=(SocketChannel) selectionKey.channel();//获取对应的客户端 channel

            Scanner scanner=new Scanner(System.in);//从控制台输入返回给客户端的信息
            String response=scanner.nextLine()+System.getProperty("line.separator");

            int len=clientChannel.write(ByteBuffer.wrap(response.getBytes(CHARSET)));
            if(len==-1){
                try{
                    clientChannel.close();
                    selector.wakeup();
                    System.out.println("line 182,客户端已关闭:"+clientChannel.socket().getRemoteSocketAddress());
                    System.out.println("可写--------------结束");
                    //continue;
                    return ;
                }catch(Exception e){
                    System.out.println("error 8"+e);
                    System.out.println("可写--------------结束");
                    //continue;
                    return ;
                }
            }

            selectionKey.interestOps(SelectionKey.OP_READ);//将感兴趣事件修改为 可读
            selector.wakeup();//唤醒其他key

            System.out.println("[(selectionKey.isWritable()&&selectionKey.isValid())=true ,服务端返回客户端信息结束, 将客户端的 channel 感兴趣事件修改为 OP_READ】");
            System.out.println("可写--------------结束");
            System.out.println();
        }catch(UnsupportedEncodingException e){
            System.out.println("error 9,字符格式不被支持"+e);
        }catch(IOException e2){
            System.out.println("error 10"+e2);
        }
    }
}
NIO socket 客户端

NIO socket 客户端可以请求非 NIO socket 服务端

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.util.*;

/**
 * @Title:Socket Client
 * @Description: NIO Socket
 * @Author: WuJie
 */
public class NioSocketClient {
    private final static String CHARSET="UTF8";//设置编码格式
    private static Selector selector=null;//nio Selector

    public static void main(String [] args){
        NioSocketClient nioSocketClient=new NioSocketClient();
        nioSocketClient.connectedServer();//启动客户端，并向服务端发起连接请求
        if(selector!=null){
            nioSocketClient.handle(selector);//处理和服务器端的交互
        }else{
            System.out.println("error 2,服务端启动失败");
        }
    }

    /**
     * 处理客户端与服务器端的交互
     */
    public void connectedServer(){
        try{
            selector= SelectorProvider.provider().openSelector();//初始化 nio Selector
            selector.select(1000);//阻塞 selector 1000 毫秒，非必须

            //Channel 多线程安全、支持异步关闭
            //初始化 客户端 SocketChannel
            SocketChannel clientChannel=SocketChannel.open();
            //非阻塞模式，否则就不是NIO了
            clientChannel.configureBlocking(false);
            //连接服务端
            clientChannel.connect(new InetSocketAddress("127.0.0.1",10000));
            //将 clientChannel 注册到selector,感兴趣事件为连接
            clientChannel.register(selector,SelectionKey.OP_CONNECT);

            System.out.println("客户端已启动,客户端字符编码格式为"+CHARSET+",等待取得和服务器端的连接：");
        }catch(IOException e){
            System.out.println("error 1,获取 Selector 失败"+e);
        }
    }

    /**
     * 处理和服务器端的交互
     * @param selector
     */
    public void handle(Selector selector){
        try{
            for(;;){//客户端始终处于启动状态
                int keyNumbers=selector.select();//获取已注册 channel 数量
                if(keyNumbers>0){//如果已注册 channel 数量>0,则开始处理
                    Set<SelectionKey> selectionKeySet=selector.selectedKeys();//获取 selector 中已注册 channel 的 SelectionKey 集合

                    Iterator iterable=selectionKeySet.iterator();//准备遍历 selectionKeySet，处理其对应的 channel
                    while(iterable.hasNext()){
                        SelectionKey selectionKey=(SelectionKey)iterable.next();
                        iterable.remove();//Removes from the underlying collection the last element returned by this iterator (optional operation)

                        if(selectionKey.isConnectable()){//可以连接上服务器端
                            connectable(selectionKey);//TODO 可以使用多线程
                        }else if(selectionKey.isReadable()&&selectionKey.isValid()){//读取服务端传输的数据
                            readable(selectionKey);//TODO 可以使用多线程
                        }else if(selectionKey.isWritable()&&selectionKey.isValid()) {//返回给服务端信息
                            writable(selectionKey);//TODO 可以使用多线程
                        }

                    }
                }else{
                    continue;
                }
            }

        }catch(IOException e){
            System.out.println("error 3,获取 Selector 已注册 Channel 数量失败"+e);
        }
    }

    /**
     * 处理可连接的channel
     * 取得和服务端的连接，向服务端发送信息，该信息从控制台输入
     * @param selectionKey
     */
    private static void connectable(SelectionKey selectionKey){
        try{
            System.out.println("可连接服务端--------------开始");

            SocketChannel clientChannel=(SocketChannel)selectionKey.channel();//获取对应的客户端 channel
            if(clientChannel.isConnectionPending()){//如果正在连接，则完成连接
                clientChannel.finishConnect();//当 channel 的 socket 连接上后，返回true
            }
            //开始写操作
            Scanner scanner=new Scanner(System.in);//从控制台输入发送给服务端的信息
            String response=scanner.nextLine()+System.getProperty("line.separator");

            int len=clientChannel.write(ByteBuffer.wrap(response.getBytes(CHARSET)));
            if(len==-1){
                try{
                    clientChannel.close();
                    selector.wakeup();
                    System.out.println("line 122,服务端已关闭:"+clientChannel.socket().getRemoteSocketAddress());
                    System.out.println("可连接服务端--------------结束");
                    //continue;
                    return ;
                }catch(Exception e){
                    System.out.println("error 4"+e);
                    System.out.println("可连接服务端--------------结束");
                    //continue;
                    return ;
                }
            }

            selectionKey.interestOps(SelectionKey.OP_READ);//将感兴趣事件修改为 可读
            selector.wakeup();//唤醒其他key

            System.out.println("[(selectionKey.isConnectable()=true ,客户端连接服务端并发送信息结束, 将客户端的 channel 感兴趣事件修改为 OP_READ】");
            System.out.println("可连接服务端--------------结束");
            System.out.println();
        }catch(UnsupportedEncodingException e){
            System.out.println("error 5,字符格式不被支持"+e);
        }catch(IOException e2){
            System.out.println("error 6"+e2);
        }

    }

    /**
     * 处理可读的channel
     * 读取客户端发送的信息
     * @param selectionKey
     */
    private static void readable(SelectionKey selectionKey){
        try{
            System.out.println("可读--------------开始");

            SocketChannel clientChannel=(SocketChannel) selectionKey.channel();//根据key获取channel
            ByteBuffer byteBuffer= ByteBuffer.allocate(1024); //准备 1k 的缓冲区
            int len=clientChannel.read(byteBuffer);//将channel 内容写入缓存 byteBuffer
            //System.out.println("byteBuffer.remaining()="+byteBuffer.remaining()+";len="+len);

            if(len==-1){//如果没有信息传入，说明客户端可能中断连接，则关闭这个客户端channel
                try{
                    clientChannel.close();
                    selector.wakeup();//唤起其他channel
                    System.out.println("line 160,服务端已关闭:"+clientChannel.socket().getRemoteSocketAddress());
                    System.out.println("可读--------------结束");
                    //continue;
                    return;
                }catch(Exception e){
                    System.out.println("error 7,关闭客户端 channel 失败"+e);
                    System.out.println("可读--------------结束");
                    //continue;
                    return;
                }

            }
            byteBuffer.flip();//调用flip之后，读写指针指到缓存头部，并且设置了最多只能读出之前写入的数据长度(而不是整个缓存的容量大小)。

            //初始化一个 缓存区可读长度的数组
            byte[] bytes=new byte[byteBuffer.remaining()];

            byteBuffer.get(bytes,0,byteBuffer.remaining());
            byteBuffer.clear();

            System.out.println("服务端传入信息:"+new String(bytes,CHARSET));

            selectionKey.interestOps(SelectionKey.OP_WRITE);//将该 selectionKey 感兴趣事件修改为 写事件，准备向客户端返回数据
            System.out.println("【(selectionKey.isReadable()&&selectionKey.isValid())=true ,已经读取完毕服务端channel 中的buffer信息，将 客户端 channel 感兴趣事件修改为 OP_WRITE】");
            System.out.println("可读--------------结束");
            System.out.println();
        }catch(IOException e){
            System.out.println("error 8,出错了");
        }
    }

    /**
     * 处理可写的channel
     * 向服务端发送信息，该信息从控制台输入
     * @param selectionKey
     */
    private static void writable(SelectionKey selectionKey){
        try{
            System.out.println("可写--------------开始");

            SocketChannel clientChannel=(SocketChannel) selectionKey.channel();//获取对应的客户端 channel

            Scanner scanner=new Scanner(System.in);//从控制台输入返回给客户端的信息
            String response=scanner.nextLine()+System.getProperty("line.separator");

            int len=clientChannel.write(ByteBuffer.wrap(response.getBytes(CHARSET)));
            if(len==-1){
                try{
                    clientChannel.close();
                    selector.wakeup();
                    System.out.println("line 210,服务端已关闭:"+clientChannel.socket().getRemoteSocketAddress());
                    System.out.println("可写--------------结束");
                    //continue;
                    return ;
                }catch(Exception e){
                    System.out.println("error 9"+e);
                    System.out.println("可写--------------结束");
                    //continue;
                    return ;
                }
            }

            selectionKey.interestOps(SelectionKey.OP_READ);//将感兴趣事件修改为 可读
            selector.wakeup();//唤醒其他key

            System.out.println("[(selectionKey.isWritable()&&selectionKey.isValid())=true ,可会淡返回服务端信息结束, 将客户端的 channel 感兴趣事件修改为 OP_READ】");
            System.out.println("可写--------------结束");
            System.out.println();
        }catch(UnsupportedEncodingException e){
            System.out.println("error 9,字符格式不被支持"+e);
        }catch(IOException e2){
            System.out.println("error 10"+e2);
        }
    }
}
控制台信息
服务端
服务端已启动,服务器端字符编码格式为UTF8,等待客户端的访问：
可接收--------------开始
【selectionKey.isAcceptable()=true，从select 获取 服务端channel ，从这个channel 获取客户端 channel，向 selector 注册 客户端 channel,感兴趣事件为 OP_READ】
可接收--------------结束

可读--------------开始
客户端传入信息:第一次请求

【(selectionKey.isReadable()&&selectionKey.isValid())=true ,已经读取完毕客户端channel 中的buffer信息，将 客户端 channel 感兴趣事件修改为 OP_WRITE】
可读--------------结束

可写--------------开始
请一次回复
[(selectionKey.isWritable()&&selectionKey.isValid())=true ,服务端返回客户端信息结束, 将客户端的 channel 感兴趣事件修改为 OP_READ】
可写--------------结束

可读--------------开始
客户端传入信息:第二次请求

【(selectionKey.isReadable()&&selectionKey.isValid())=true ,已经读取完毕客户端channel 中的buffer信息，将 客户端 channel 感兴趣事件修改为 OP_WRITE】
可读--------------结束

可写--------------开始
第二次回复
[(selectionKey.isWritable()&&selectionKey.isValid())=true ,服务端返回客户端信息结束, 将客户端的 channel 感兴趣事件修改为 OP_READ】
可写--------------结束
客户端
客户端已启动,客户端字符编码格式为UTF8,等待取得和服务器端的连接：
可连接服务端--------------开始
第一次请求
[(selectionKey.isConnectable()=true ,客户端连接服务端并发送信息结束, 将客户端的 channel 感兴趣事件修改为 OP_READ】
可连接服务端--------------结束

可读--------------开始
服务端传入信息:请一次回复

【(selectionKey.isReadable()&&selectionKey.isValid())=true ,已经读取完毕服务端channel 中的buffer信息，将 客户端 channel 感兴趣事件修改为 OP_WRITE】
可读--------------结束

可写--------------开始
第二次请求
[(selectionKey.isWritable()&&selectionKey.isValid())=true ,可会淡返回服务端信息结束, 将客户端的 channel 感兴趣事件修改为 OP_READ】
可写--------------结束

可读--------------开始
服务端传入信息:第二次回复

【(selectionKey.isReadable()&&selectionKey.isValid())=true ,已经读取完毕服务端channel 中的buffer信息，将 客户端 channel 感兴趣事件修改为 OP_WRITE】
可读--------------结束
延伸

http://ifeve.com/java-nio-all/
http://ifeve.com/selectors/#Selecting

BAT 大厂Java 面试题集锦之核心篇附参考答案
AI天才研究院
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
圆你的大厂梦!字节跳动Java高频面试题真题:一/二/三面+常见问题
Java_supermanNO1的博客
12-30 1791
本文转载自：圆你的大厂梦!字节跳动Java高频面试题真题:一/二/三面+常见问题 目录 技术一面（算法） 技术二面 技术三面 JAVA开发技术面试中可能问到的问题 面试注意点 一、字节跳动技术一面（算法） Java 的 16 进制与字符串的相互转换函数 JAVA 时间格式化处理 将毫秒转化为日期 文本的倒序输出 判断一个数字是奇数还是偶数 用Hibernate 实现分页 35 选 7 彩...
java socket编程之实现客户端和服务器通讯一问一答
信徒博客
04-11 4357
环境 1、一台电脑 2、开启两个myeclipse进行通信 通讯思路 1、客户端使用socket，绑定服务器的IP地址和端口号就可以连接服务器 2、客户端可以通过socket的输入流输出流方法对服务器进行读取和写入 3、服务器使用ServerSocket,开始监听，server.accept(); 这个方法是阻塞的，只有有客户端连接上，才会往下执行 4、server.acc...
Java Socket实现一问一答
weixin_44219293的博客
11-07 588
客户端： package ClientServer; import java.io.*; import java.net.Socket; public class Client { public static void main(String[] args) throws Exception { try { //新建socket Socket soc = new Socket("127.0.0.1",6666
Android socket通信: 一问一答，一问多答客户端网络请求工具类的实现
u014303273的博客
06-19 1009
由于单片机不是系统级开发，性能有限，因此在与单片机进行数据通信，通常实现十分复杂。 协议：单片机通常只采用字节流协议方式实现，如果需要传递字符，字符必须为ASCCII编码。 通信方式：socket长连接,串口，usb，蓝牙等通信方式 数据交互方式：一问一答，一问多答,数据推送 我这里采用MINA作为长连接通信框架，可以支持socket以及串口通信。. package com.le
NIO Socket实现聊天
全栈行动派的博客
06-27 250
package com.lc.test.test04; import java.nio.ByteBuffer; import java.nio.channels.ClosedChannelException; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.SocketChannel; import java.util.Scanner; /** * @.
（三）socket·socket 实现 控制台 一问一答式聊天
༺ bestcxx的专栏 ༻
02-08 822
文章目录前言在 IDE 实现一问一答式聊天代码服务端客户端效果跨越局域网实现远程访问本地 前言 socket 是全双工传输模式，在不启用多线程的情况下，这种功效并不能立即体现出来，即客户端发送-服务端接收-服务端发送-客户端接收需要有序进行。 在 IDE 实现一问一答式聊天 如果你有一个程序员朋友，懂一点 Java 开发，恰巧他/她的电脑安装有 eclipse 或者 idea ，那么可以借助...
基于IO、NIO、Netty的Java网络程序（实现服务端与客户端通信）
YouthBlood9的博客
12-17 2797
录一、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
spring + spring mvc + tomcat 面试题（史上最全）下篇
javalingyu的博客
04-16 596
场景1：单例的setter注入 这种注入方式应该是spring用的最多的，代码如下： @Service publicclass TestService1 { @Autowired private TestService2 testService2; public void test1() { } } @Service publicclass TestService2 { @Autowired private TestService1 testSer
130道Java面试题及答案整理
weixin_45987961的博客
10-19 990
文章到这里就结束了~最后自我介绍一下，老猿13年上海交大毕业，去过华为、百度、阿里等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。自己不成体系的自学效率很低又漫长，而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。
NIO-Socket实现简易聊天室
weixin_47796247的博客
11-16 226
3.创建Selector选择器，并将通道注册到选择器上边，设置关系事件---》新链接。6.2:将通道的数据写入到缓冲区(buffer)当中。5.3:通道设置完成,将关系事件设置为读取。1.创建NI0通道,并且绑定端口。5.1:建立和客户端连接的通道。5.2:通道设置为非阻塞。4.循环监听通道的事件。6.1:获取客户端通道。5.监听到新连接事件。
java nio简单示例：实现客户端与服务器一问一答
小楼夜听雨的博客
04-27 600
运行效果 开启多个客户端 服务端效果： 客户端效果： 当一个客户端断开连接： 代码 因为代码中有注释，我就直接贴上来了 服务端： package com.dayrain.server; import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.nio.ByteBuffer; import java.nio.channels.*
Nio Socket 连接
weixin_30608503的博客
09-10 118
首先介绍一下几个辅助类 辅助类SerializableUtil，这个类用来把java对象序列化成字节数组，或者把字节数组反序列化成java对象。 [java] view plain copy package com.googlecode.garbagecan.test.socket; import java.io.ByteArrayInputStream; imp...
Java NIO基于控制台的多人聊天室
坐看云起时_雨宣
11-28 267
闲来无事写了个基于NIO的聊天室项目，费话不说了，直接贴代码吧。 Server端代码如下： package com.xz.helloworld.nettyt.nio.im; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.ch...
Socket实现服务器和客户端（手把手教会）
最新发布
dont worry about it的博客
01-22 4万+
Socket 编程是一种用于在网络上进行通信的编程方法，以下代码可以实现在不同主机之间传输数据。使用 recv 函数从客户端接收数据，使用 send 函数向客户端发送数据。解决分包、粘包问题-------------使用 close 函数关闭连接的套接字。使用 close 函数关闭连接的套接字。
TCP协议下---客户端与服务端一问一答聊天
AaronWang0920的博客
09-09 1160
package cn.itcast.tcp;import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.InetAddress; import java.net.Socket
java实现单线程客户端与服务器端一问一答方式对话
yuanzhun2345的专栏
02-05 2217
本程序直接在住线程运行，实现一问一答模式下的Socket编程的简单实现，下次有时间我会将多线程结合到Socket编程来实现，此程序仅做参考，有什么有问题的地方还请大家指正 服务器端代码如下： import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.IOException;
（五）socket·NIO socket 的基本介绍
༺ bestcxx的专栏 ༻
12-02 735
文章目录前言Java 的 IO 和 NIONIO 中的两个概念——Channel 和参考资料 前言 在网络通信中，服务器端需要接收客户端传递的信息并进行处理，如果在接收信息的同时服务器端智能等待IO，显然会造成服务器资源的浪费，也可能造成服务的阻塞。所以本文介绍NIO 并在 Socket 通信中加以实践运用。 Java 的 IO 和 NIO Java 的 IO 是阻塞的，简单说就是一个线程在...
java用socket和serversocket实现一对一聊天（java实现简单的TCP聊天程序）
小询的博客
08-03 3万+
在上次发表类似文章的基础上做了一点手脚，这次可以直接运行两个控制台，不用再去用telnet IP端口了，这个可以直接在eclipse分别执行服务器端类和客户端类，然后在客户端和服务端上进行交互。更为方便。我的代码实现如下： 首先我的文件结构是 在ServerDemo.java中编写以下代码： package com.jiaxun.net; import java.io.IOExce
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值