java nio 编程

最新推荐文章于 2022-12-24 17:37:58 发布
最新推荐文章于 2022-12-24 17:37:58 发布
阅读量124 收藏
点赞数
分类专栏： java 文章标签： java nio socket编程 多线程
转自：http://yangguangfu.iteye.com/blog/774194 

Java代码  
晚上学习了下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
lykke2012
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java nio 实现socket
09-27
java nio 实现socketjava nio 实现socketjava nio 实现socketjava nio 实现socketjava nio 实现socket
Java NIO 网络编程初探
12-22
Java NIO 网络编程初探 1. Java NIO Java 1.4 版本添加了一个新的IO API，称为NIO（New IO）。NIO拥有所有IO的功能，但是操作方法却完全不一样。NIO支持面向缓冲区的、基于通道的IO操作。能够更加高效的进行IO操作。...
Java NIO socket编程实例 （转）
11-28 165
Java代码   晚上学习了下Java 的 NIO Socket编程，写了下面这个小程序，包括服务器端与客户端。实现的功能为客户端向服务器端发送随即数目的消息，服务器端一条一条的回应。消息内容保存在talks.properties文件中，内容为：      Hi=Hi   Bye=Bye   床前明月光=疑是地上霜   举头望明月=低头思故乡   少小离家老大回=乡...
java之socket编程（NIO）
我想月薪过万的博客
08-20 727
效果展示 原理分析 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 380
一 套接字通道 1. 阻塞式套接字通道     与Socket和ServerSocket对应，NIO提供了SocketChannel和ServerSocketChannel对应，这两种通道同时支持一般的阻塞模式和更高效的非阻塞模式。     客户端通过SocketChannel.open()方法打开一个Socket通道，如果此时提供了SocketAddress参数，则会自动开始连
java nio socket 例子_Java NIO socket编程实例
weixin_32153867的博客
02-13 257
晚上学习了下Java 的 NIO Socket编程，写了下面这个小程序，包括服务器端与客户端。实现的功能为客户端向服务器端发送随即数目的消息，服务器端一条一条的回应。消息内容保存在talks.properties文件中，内容为：Hi=HiBye=Bye床前明月光=疑是地上霜举头望明月=低头思故乡少小离家老大回=乡音无改鬓毛衰天王盖地虎=宝塔镇河妖我是甲=我是乙我是客户端=我是服务器我是周星驰=我是...
java网络编程NIO视频教程
最新发布
09-12
### Java网络编程NIO视频教程知识点汇总 #### 1. Java NIO-课程简介 - **主要内容**：简述...通过以上内容的学习，开发者可以全面掌握Java NIO编程的相关技术和最佳实践，为开发高性能网络应用程序打下坚实的基础。
Java NIO英文高清原版
11-15
Java NIO，全称为Non-Blocking Input/Output（非阻塞输入/输出），是Java平台中用于替代标准I/O（BIO）模型的一种新机制。...学习和理解Java NIO以及Netty的使用，对于提升Java网络编程的能力至关重要。
Java NIO 高性能编程
04-25
Java NIO 深入探讨了 1.4 版的 I/O 新特性，并告诉您如何使用这些特性来极大地提升您所写的Java 代码的执行效率。这本小册子就程序员所面临的有代表性的 I/O 问题作了详尽阐述，并讲解了如何才能充分利用新的 I/O ...
java NIO socket聊天室
12-17
使用NIO socket不需要多线程来处理多个连接的请求，效率非常高 可以作为NIO socket入门的例子，Reactor模式，重点理解key.attach， jar文件里包含了源代码 1，运行server.bat启动服务器，可以打开编辑，修改端口号 2，运行client.bat启动客户端，可以打开编辑，ip，和端口号 3，自己发送的信息，自己是看不到的，运行多个客户端，其他的客户端可以看得到的 4，修改封装http做成短连接处理，就是一个小型的webserver，或者结合java2D和robot做远程监控 5，封装自己的协议可以做成自己需要的服务器端程序，
java IO、NIO、AIO详解
weixin_34026484的博客
05-14 197
2019独角兽企业重金招聘Python工程师标准>>> ...
java nio编程实例_Java Socket编程实例（四）- NIO TCP实践
weixin_31995467的博客
02-16 245
一、回传协议接口和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 245
对于服务器 socketChannel （ServerSocketChannel），唯一（也只能）关心的操作是 OP_ACCEPT（表示一个新的客户端连接）。 一般一个线程应可以共享一个 Buffer 。 在没有客户端请求时，Selector.select() 将一直堵塞。应该将此做为唯一的堵塞时刻（在 I/0 Socket 中，在读数据时也会堵塞），做为服务器一般会无限循环此条件。 在自 ...
java基于NIO的socket编程实例
u014627099的博客
01-14 281
        众所周知，java的NIO模块想要传输数据需要依赖缓冲区和通道，二者缺一不可。         补充一下缓冲区（buf）的几个基本方法：         1.allocate()：分配一个指定大小的缓冲区。         2.put()：向buf里写数据。         3.get()：从buf里读数据。         4.flip()：将缓冲区从写模式切换到读模式...
基于NIO模型的Java Socket传统编程
JavaBoy王皓
04-26 582
​ 这张是2014年在拉卜楞寺拍摄的，僧人们下早课。红袍加身不可脱，这是其中一位僧人给我和基友担当向导时说的，他7岁从青海来学习佛法，因为家里还有一个哥哥，两个男孩的话弟弟会被送去佛学院出家，所以他被送出来了，现在已经26了，将来可以选择回家乡附近的寺庙工作，也可以留在这所佛学院或寺里继续工作，其他记不太住了，只记得当时我用的iphone4，他用的iphone5s。 ...
Java Socket实现NIO通信
在路上
12-24 2403
手写NIO通信,其实并不复杂
【网络编程socket】java NIO编程示例以及流程详解
m0_45406092的博客
12-18 1049
参考： 《java NIO示例以及流程详解》
Java Socket NIO
weixin_30784141的博客
03-27 121
服务端： public class NIOServer { private static final String HOST = "localhost"; private static final int PORT = 10086; public static void main(String[] args) { ServerSocketC...
Java NIO编程入门指南：提升I/O效率与实战应用
《Java NIO编程指南》是由Ron Hitchens撰写，裴小星翻译的一本IT专业书籍，专为希望深入了解Java NIO（New Input/Output）技术的开发者设计。该书出版于2002年8月，由O'Reilly出版社发行，其ISBN为0-596-00288-2。书...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值