Java NIO socket编程实例

最新推荐文章于 2022-12-24 17:37:58 发布
转载 最新推荐文章于 2022-12-24 17:37:58 发布 · 443 阅读 · 0
文章标签：

#java #nio #socket #编程 #实例

晚上学习了下Java 的 NIO Socket编程，写了下面这个小程序，包括服务器端与客户端。实现的功能为客户端向服务器端发送随即数目的消息，服务器端一条一条的回应。消息内容保存在talks.properties文件中，内容为：


Hi=Hi
Bye=Bye
床前明月光=疑是地上霜
举头望明月=低头思故乡
少小离家老大回=乡音无改鬓毛衰
天王盖地虎=宝塔镇河妖
我是甲=我是乙
我是客户端=我是服务器
我是周星驰=我是周润发


客户端会随即发送“=”左边的消息，服务器端会回应客户端“=”右边的消息。如果客户端想断开连接，会向服务器发送一个"Bye"，然后服务器会回应一个"Bye“。收到服务器端的"Bye"后，客户端会断开连接。


当然，java的properties文件不接受中文内容，你需要native2ascii一下。talks.properties 的实际文件内容为：


Hi=Hi
Bye=Bye
\u5E8A\u524D\u660E\u6708\u5149=\u7591\u662F\u5730\u4E0A\u971C
\u4E3E\u5934\u671B\u660E\u6708=\u4F4E\u5934\u601D\u6545\u4E61
\u5C11\u5C0F\u79BB\u5BB6\u8001\u5927\u56DE=\u4E61\u97F3\u65E0\u6539\u9B13\u6BDB\u8870
\u5929\u738B\u76D6\u5730\u864E=\u5B9D\u5854\u9547\u6CB3\u5996
\u6211\u662F\u7532=\u6211\u662F\u4E59
\u6211\u662F\u5BA2\u6237\u7AEF=\u6211\u662F\u670D\u52A1\u5668
\u6211\u662F\u5468\u661F\u9A70=\u6211\u662F\u5468\u6DA6\u53D1




看下服务器端的代码。此例中的服务器端只有一个主线程，用于selector操作，并处理多个客户端的消息。在常规的socket编程中，每个客户端都需要单独开一个线程，效率比较低。代码为：


package helloweenpad;


import java.io.FileInputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.util.Iterator;
import java.util.Properties;


public class MyFirstNIOServer {


public static final int PORT = 12315;


protected Selector selector;
protected Charset charset = Charset.forName("UTF-8");
protected CharsetEncoder charsetEncoder = charset.newEncoder();
protected CharsetDecoder charsetDecoder = charset.newDecoder();


protected Properties talks = new Properties();


int clientCount;


public MyFirstNIOServer() throws Exception {


talks.load(new FileInputStream("E:\\talk.properties"));


selector = Selector.open();


ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.socket().bind(new InetSocketAddress(PORT)); // port
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);// register


p("Server localhost:" + PORT + " started. waiting for clients. ");


while (true) {
   // selector 线程。select() 会阻塞，直到有客户端连接，或者有消息读入
   selector.select();
   Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
   while (iterator.hasNext()) {


    SelectionKey selectionKey = iterator.next();
    iterator.remove(); // 删除此消息


    // 并在当前线程内处理。（为了高效，一般会在另一个线程中处理此消息，例如使用线程池等）
    handleSelectionKey(selectionKey);
   }
}


}


public void handleSelectionKey(SelectionKey selectionKey) throws Exception {


if (selectionKey.isAcceptable()) {


   // 有客户端进来
   clientCount++;


   ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectionKey.channel();
   SocketChannel socketChannel = serverSocketChannel.accept();
   socketChannel.configureBlocking(false);
   Socket socket = socketChannel.socket();


   // 立即注册一个 OP_READ 的SelectionKey, 接收客户端的消息
   SelectionKey key = socketChannel.register(selector, SelectionKey.OP_READ);
   key.attach("第 " + clientCount + " 个客户端 [" + socket.getRemoteSocketAddress() + "]: ");


   p(key.attachment() + "\t[connected] =========================================");


} else if (selectionKey.isReadable()) {


   // 有消息进来


   ByteBuffer byteBuffer = ByteBuffer.allocate(100);
   SocketChannel socketChannel = (SocketChannel) selectionKey.channel();


   try {
    int len = socketChannel.read(byteBuffer);


    // 如果len>0，表示有输入。如果len==0, 表示输入结束。需要关闭 socketChannel
    if (len > 0) {


     byteBuffer.flip();
     String msg = charsetDecoder.decode(byteBuffer).toString();


     // 根据客户端的消息，查找到对应的输出
     String newMsg = talks.getProperty(msg);
     if (newMsg == null)
      newMsg = "Sorry? I don't understand your message. ";


     // UTF-8 格式输出到客户端，并输出一个'n'


     socketChannel.write(charsetEncoder.encode(CharBuffer.wrap(newMsg + "\n")));
     p(selectionKey.attachment() + "\t[recieved]: " + msg + " ----->\t[send]: " + newMsg);


    } else {
     // 输入结束，关闭 socketChannel
     p(selectionKey.attachment() + "read finished. close socketChannel. ");
     socketChannel.close();
    }


   } catch (Exception e) {


    // 如果read抛出异常，表示连接异常中断，需要关闭 socketChannel
    e.printStackTrace();


    p(selectionKey.attachment() + "socket closed? ");
    socketChannel.close();
   }


} else if (selectionKey.isWritable()) {
   p(selectionKey.attachment() + "TODO: isWritable() ???????????????????????????? ");
} else if (selectionKey.isConnectable()) {
   p(selectionKey.attachment() + "TODO: isConnectable() ????????????????????????? ");
} else {
   p(selectionKey.attachment() + "TODO: else. ");
}


}


public static void p(Object object) {
System.out.println(object);
}


public static void main(String[] args) throws Exception {
new MyFirstNIOServer();
}


}


再看下客户端代码。这个客户端使用了常规的socket编程，没有使用NIO。是否使用NIO对另一方是透明的，对方看不见，也不关心。无论使用NIO还是使用常规socket，效果都是一样的，只是NIO的效率要高一些。代码为：


package helloweenpad;


import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Properties;
import java.util.Random;


public class MyFirstNIOClientTest extends Thread {


public static final String HOST = "localhost";
public static final int PORT = 12315;


boolean exist = false;


Properties talks = new Properties();
Random random = new Random();
String[] keys;


int messageCount = 0;


public void run() {


try {


   // 对话内容
   talks.load(new FileInputStream("E:\\talk.properties"));


   // 客户端发送 "=" 左边的内容
   keys = new String[talks.size()];
   talks.keySet().toArray(keys);


   Socket socket = new Socket(HOST, PORT);


   OutputStream ous = socket.getOutputStream();
   InputStream ins = socket.getInputStream();


   // 接收线程，接收服务器的回应
   RecieverThread reciever = new RecieverThread(ins);
   reciever.start();


   while (!exist) {


    messageCount++;


    // 选择一个随机消息
    String msg = chooseMessage();


    synchronized (ins) {


     // 发送给服务器端
     ous.write(msg.getBytes("UTF-8"));


     System.out.println("[send]\t" + messageCount + ": " + msg);


     // 然后等待接收线程
     ins.wait();
    }


    if (msg.equals("Bye")) {
     break;
    }
   }


   ins.close();
   ous.close();
   socket.close();


} catch (Exception e) {
   e.printStackTrace();
}


}


public String chooseMessage() {


int index = random.nextInt(keys.length);
String msg = keys[index];


// 如果 10 次就选中 Bye，则重新选择，为了使对话内容多一些
if (messageCount < 10 && msg.equalsIgnoreCase("Bye")) {
   return chooseMessage();
}


return msg;
}


// 接收线程
class RecieverThread extends Thread {
private InputStream ins;


public RecieverThread(InputStream ins) {
   this.ins = ins;
}


@Override
public void run() {


   try {
    String line = null;


    BufferedReader r = new BufferedReader(new InputStreamReader(
      ins, "UTF-8"));


    // readLine()会阻塞，直到服务器输出一个 '\n'
    while ((line = r.readLine()) != null) {


     System.out.println("[Recieved]: " + line);


     synchronized (ins) {
      // 接收到服务器的消息，通知下主线程
      ins.notify();
     }
     if (line.trim().equals("Bye")) {
      exist = true;
      break;
     }
    }
   } catch (Exception e) {
    e.printStackTrace();
   }
}


}


public static void main(String[] args) throws Exception {


// 开三个客户端线程
for (int i = 0; i < 3; i++) {
   try {
    new MyFirstNIOClientTest().start();
   } catch (Exception e) {
    e.printStackTrace();
   }
}


}
}


=============================================================================


服务器端的输出：


Server localhost:12315 started. waiting for clients.
第 1 个客户端 [/127.0.0.1:1890]: [connected] =========================================
第 2 个客户端 [/127.0.0.1:1865]: [connected] =========================================
第 3 个客户端 [/127.0.0.1:1866]: [connected] =========================================
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: 床前明月光 -----> [send]: 疑是地上霜
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: 我是周星驰 -----> [send]: 我是周润发
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: 少小离家老大回 -----> [send]: 乡音无改鬓毛衰
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: 床前明月光 -----> [send]: 疑是地上霜
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: 我是客户端 -----> [send]: 我是服务器
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: 举头望明月 -----> [send]: 低头思故乡
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: 床前明月光 -----> [send]: 疑是地上霜
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: 举头望明月 -----> [send]: 低头思故乡
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: 我是甲 -----> [send]: 我是乙
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: 我是周星驰 -----> [send]: 我是周润发
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: 举头望明月 -----> [send]: 低头思故乡
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: 床前明月光 -----> [send]: 疑是地上霜
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: 床前明月光 -----> [send]: 疑是地上霜
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: 床前明月光 -----> [send]: 疑是地上霜
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: Hi -----> [send]: Hi
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: 举头望明月 -----> [send]: 低头思故乡
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: 举头望明月 -----> [send]: 低头思故乡
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: 少小离家老大回 -----> [send]: 乡音无改鬓毛衰
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: 我是甲 -----> [send]: 我是乙
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: 床前明月光 -----> [send]: 疑是地上霜
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: 我是客户端 -----> [send]: 我是服务器
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: Hi -----> [send]: Hi
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: Hi -----> [send]: Hi
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: 我是周星驰 -----> [send]: 我是周润发
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: 我是周星驰 -----> [send]: 我是周润发
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: 举头望明月 -----> [send]: 低头思故乡
第 2 个客户端 [/127.0.0.1:1865]: [recieved]: Bye -----> [send]: Bye
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: Hi -----> [send]: Hi
第 2 个客户端 [/127.0.0.1:1865]: read finished. close socketChannel.
第 1 个客户端 [/127.0.0.1:1890]: [recieved]: Bye -----> [send]: Bye
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: 我是客户端 -----> [send]: 我是服务器
第 1 个客户端 [/127.0.0.1:1890]: read finished. close socketChannel.
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: 我是客户端 -----> [send]: 我是服务器
第 3 个客户端 [/127.0.0.1:1866]: [recieved]: Bye -----> [send]: Bye
第 3 个客户端 [/127.0.0.1:1866]: read finished. close socketChannel.


客户端的输出：


[send] 1: 我是周星驰
[send] 1: 少小离家老大回
[Recieved]: 乡音无改鬓毛衰
[send] 2: 床前明月光
[Recieved]: 疑是地上霜
[send] 3: 我是客户端
[Recieved]: 我是服务器
[Recieved]: 疑是地上霜
[Recieved]: 我是周润发
[Recieved]: 低头思故乡
[send] 2: 举头望明月
[Recieved]: 疑是地上霜
[send] 3: 床前明月光
[send] 1: 床前明月光
[send] 2: 举头望明月
[Recieved]: 低头思故乡
[Recieved]: 我是乙
[send] 4: 我是甲
[Recieved]: 我是周润发
[send] 5: 我是周星驰
[send] 3: 床前明月光
[send] 6: 床前明月光
[send] 4: 举头望明月
[Recieved]: 低头思故乡
[send] 5: 床前明月光
[Recieved]: 疑是地上霜
[Recieved]: 疑是地上霜
[Recieved]: 疑是地上霜
[Recieved]: Hi
[send] 4: Hi


[Recieved]: 低头思故乡
[send] 5: 举头望明月
[Recieved]: 低头思故乡




[Recieved]: 低头思故乡
[send] 6: 举头望明月




[send] 7: 少小离家老大回

[s


http://yangguangfu.iteye.com/blog/774194

java nio 实现socket
09-27
java nio 实现socketjava nio 实现socketjava nio 实现socketjava nio 实现socketjava nio 实现socket
Java Socket编程实例（四）- NIO TCP实践
09-02
在Java网络编程中，Socket API提供了两种模型：传统的阻塞I/O（BIO）和非阻塞I/O（NIO）。本实例主要关注NIO在TCP中的应用，它允许更高效的资源管理和处理多个连接，特别适合高并发场景。我们将探讨以下几个关键知识...
Java NIO socket编程实例 （转）
11-28 215
Java代码   晚上学习了下Java 的 NIO Socket编程，写了下面这个小程序，包括服务器端与客户端。实现的功能为客户端向服务器端发送随即数目的消息，服务器端一条一条的回应。消息内容保存在talks.properties文件中，内容为：      Hi=Hi   Bye=Bye   床前明月光=疑是地上霜   举头望明月=低头思故乡   少小离家老大回=乡...
java nio 编程
chunguo.wang
02-06 160
转自：http://yangguangfu.iteye.com/blog/774194 [code="java"]Java代码 晚上学习了下Java 的 NIO Socket编程，写了下面这个小程序，包括服务器端与客户端。实现的功能为客户端向服务器端发送随即数目的消息，服务器端一条一条的回应。消息内容保存在talks.properties文件中，内容为： Hi=Hi ...
java之socket编程（NIO）
我想月薪过万的博客
08-20 813
效果展示 原理分析 NIO: 非阻塞型 IO 自从 jdk 1.4 之后，增加了 nio 库，支持非阻塞型 IO 操作 代码展示 package NIO; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Arr
Java NIO Socket通信
02-28 432
一 套接字通道 1. 阻塞式套接字通道     与Socket和ServerSocket对应，NIO提供了SocketChannel和ServerSocketChannel对应，这两种通道同时支持一般的阻塞模式和更高效的非阻塞模式。     客户端通过SocketChannel.open()方法打开一个Socket通道，如果此时提供了SocketAddress参数，则会自动开始连
nio.rar_NIO_NIO-socket_java nio_java 实例_java.nio
09-19
标题“nio.rar_NIO_NIO-socket_java nio_java 实例_java.nio”表明这个压缩包包含了一个关于Java NIO的实例，特别是关于NIO套接字（Socket）的编程示例。NIO套接字是Java NIO库中用于网络通信的关键组件，它们允许...
Java Socket编程实例（五）- NIO UDP实践
09-02
Java Socket编程中的NIO（非阻塞I/O）在UDP通信中的应用主要涉及到高效的数据传输和并发处理。本文将深入探讨如何使用NIO与UDP结合，实现一个简单的回显服务器，即UDPEchoSelectorProtocol。 首先，我们来看一下`...
深入解析Java NIO网络编程实例教程
Java中的Socket编程主要用于实现网络通信，是构建客户端-服务端模型的基础。 - **网络编程**：网络编程是指开发能够在网络上进行通信的应用程序的过程。它通常涉及到网络协议的使用，如TCP/IP，以及客户端和服务器...
Java NIO Socket编程实践：服务器与客户端多线程通讯示例
这可能意味着本例的代码和逻辑最初来源于一个在线资源或者是一个开源项目，该资源或项目为我们提供了讨论和学习Java NIO的实例和讨论。 ### 总结 本例的核心在于展示如何使用Java NIO API创建一个可以同时处理多个...
java nio socket 例子_Java NIO socket编程实例
weixin_32153867的博客
02-13 307
晚上学习了下Java 的 NIO Socket编程，写了下面这个小程序，包括服务器端与客户端。实现的功能为客户端向服务器端发送随即数目的消息，服务器端一条一条的回应。消息内容保存在talks.properties文件中，内容为：Hi=HiBye=Bye床前明月光=疑是地上霜举头望明月=低头思故乡少小离家老大回=乡音无改鬓毛衰天王盖地虎=宝塔镇河妖我是甲=我是乙我是客户端=我是服务器我是周星驰=我是...
Java NIO Socket编程实例
北冥冰皇专栏
05-29 1580
各I/O模型优缺点 BIO通信模型 BIO主要的问题在于每当有一个新的客户端请求接入时，服务端必须创建一个新的线程处理新接入的客户端链路，一个线程只能处理一个客户端连接 线程池I/O编程 假如所有可用线程都被阻塞，后续I/O都将在队列中排队 线程池采用阻塞队列实现，队列积满之后，后续入队列操作将被阻塞，新的客户端请求被拒绝，发生大量连接超时 NIO编程 缓冲区Buffer 每一种J...
java nio编程实例_Java Socket编程实例（四）- NIO TCP实践
weixin_31995467的博客
02-16 290
一、回传协议接口和tcp方式实现：1.接口：import java.nio.channels.selectionkey;import java.io.ioexception;public interface echoprotocol {void handleaccept(selectionkey key) throws ioexception;void handleread(selectionke...
java NIO Socket 总结
此鸟不鸣
05-20 290
对于服务器 socketChannel （ServerSocketChannel），唯一（也只能）关心的操作是 OP_ACCEPT（表示一个新的客户端连接）。 一般一个线程应可以共享一个 Buffer 。 在没有客户端请求时，Selector.select() 将一直堵塞。应该将此做为唯一的堵塞时刻（在 I/0 Socket 中，在读数据时也会堵塞），做为服务器一般会无限循环此条件。 在自 ...
java IO、NIO、AIO详解
weixin_34026484的博客
05-14 235
2019独角兽企业重金招聘Python工程师标准>>> ...
java基于NIO的socket编程实例
u014627099的博客
01-14 337
        众所周知，java的NIO模块想要传输数据需要依赖缓冲区和通道，二者缺一不可。         补充一下缓冲区（buf）的几个基本方法：         1.allocate()：分配一个指定大小的缓冲区。         2.put()：向buf里写数据。         3.get()：从buf里读数据。         4.flip()：将缓冲区从写模式切换到读模式...
基于NIO模型的Java Socket传统编程
JavaBoy王皓
04-26 636
​ 这张是2014年在拉卜楞寺拍摄的，僧人们下早课。红袍加身不可脱，这是其中一位僧人给我和基友担当向导时说的，他7岁从青海来学习佛法，因为家里还有一个哥哥，两个男孩的话弟弟会被送去佛学院出家，所以他被送出来了，现在已经26了，将来可以选择回家乡附近的寺庙工作，也可以留在这所佛学院或寺里继续工作，其他记不太住了，只记得当时我用的iphone4，他用的iphone5s。 ...
Java Socket实现NIO通信
在路上
12-24 2603
手写NIO通信,其实并不复杂
【网络编程socket】java NIO编程示例以及流程详解
m0_45406092的博客
12-18 1328
参考： 《java NIO示例以及流程详解》
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值