|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package com.stevex.app.nio;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
public class CharsetHelper {
private static final String UTF_8 = "UTF-8";
private static CharsetEncoder encoder = Charset.forName(UTF_8).newEncoder();
private static CharsetDecoder decoder = Charset.forName(UTF_8).newDecoder();
public static ByteBuffer encode(CharBuffer in) throws CharacterCodingException{
return encoder.encode(in);
}
public static CharBuffer decode(ByteBuffer in) throws CharacterCodingException{
return decoder.decode(in);
}
} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
package com.stevex.app.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
public class XiaoNa {
private ByteBuffer readBuffer;
private Selector selector;
public static void main(String[] args){
XiaoNa xiaona = new XiaoNa();
xiaona.init();
xiaona.listen();
}
private void init(){
readBuffer = ByteBuffer.allocate(1024);
ServerSocketChannel servSocketChannel;
try {
servSocketChannel = ServerSocketChannel.open();
servSocketChannel.configureBlocking(false);
//绑定端口
servSocketChannel.socket().bind(new InetSocketAddress(8383));
selector = Selector.open();
servSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
} catch (IOException e) {
e.printStackTrace();
}
}
private void listen() {
while(true){
try{
selector.select();
Iterator ite = selector.selectedKeys().iterator();
while(ite.hasNext()){
SelectionKey key = (SelectionKey) ite.next();
ite.remove();//确保不重复处理
handleKey(key);
}
}
catch(Throwable t){
t.printStackTrace();
}
}
}
private void handleKey(SelectionKey key)
throws IOException, ClosedChannelException {
SocketChannel channel = null;
try{
if(key.isAcceptable()){
ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
channel = serverChannel.accept();//接受连接请求
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);
}
else if(key.isReadable()){
channel = (SocketChannel) key.channel();
readBuffer.clear();
/*当客户端channel关闭后，会不断收到read事件，但没有消息，即read方法返回-1
* 所以这时服务器端也需要关闭channel，避免无限无效的处理*/
int count = channel.read(readBuffer);
if(count > 0){
//一定需要调用flip函数，否则读取错误数据
readBuffer.flip();
/*使用CharBuffer配合取出正确的数据
String question = new String(readBuffer.array());
可能会出错，因为前面readBuffer.clear();并未真正清理数据
只是重置缓冲区的position, limit, mark，
而readBuffer.array()会返回整个缓冲区的内容。
decode方法只取readBuffer的position到limit数据。
例如，上一次读取到缓冲区的是"where", clear后position为0，limit为 1024，
再次读取“bye"到缓冲区后，position为3，limit不变，
flip后position为0，limit为3，前三个字符被覆盖了，但"re"还存在缓冲区中，
所以 new String(readBuffer.array()) 返回 "byere",
而decode(readBuffer)返回"bye"。
*/
CharBuffer charBuffer = CharsetHelper.decode(readBuffer);
String question = charBuffer.toString();
String answer = getAnswer(question);
channel.write(CharsetHelper.encode(CharBuffer.wrap(answer)));
}
else{
//这里关闭channel，因为客户端已经关闭channel或者异常了
channel.close();
}
}
}
catch(Throwable t){
t.printStackTrace();
if(channel != null){
channel.close();
}
}
}
private String getAnswer(String question){
String answer = null;
switch(question){
case "who":
answer = "我是小娜\n";
break;
case "what":
answer = "我是来帮你解闷的\n";
break;
case "where":
answer = "我来自外太空\n";
break;
case "hi":
answer = "hello\n";
break;
case "bye":
answer = "88\n";
break;
default:
answer = "请输入 who， 或者what， 或者where";
}
return answer;
}
} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
package com.stevex.app.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class Client implements Runnable{
private BlockingQueue<String> words;
private Random random;
public static void main(String[] args) {
//种多个线程发起Socket客户端连接请求
for(int i=0; i<10; i++){
Client c = new Client();
c.init();
new Thread(c).start();
}
}
@Override
public void run() {
SocketChannel channel = null;
Selector selector = null;
try {
channel = SocketChannel.open();
channel.configureBlocking(false);
//请求连接
channel.connect(new InetSocketAddress("localhost", 8383));
selector = Selector.open();
channel.register(selector, SelectionKey.OP_CONNECT);
boolean isOver = false;
while(! isOver){
selector.select();
Iterator ite = selector.selectedKeys().iterator();
while(ite.hasNext()){
SelectionKey key = (SelectionKey) ite.next();
ite.remove();
if(key.isConnectable()){
if(channel.isConnectionPending()){
if(channel.finishConnect()){
//只有当连接成功后才能注册OP_READ事件
key.interestOps(SelectionKey.OP_READ);
channel.write(CharsetHelper.encode(CharBuffer.wrap(getWord())));
sleep();
}
else{
key.cancel();
}
}
}
else if(key.isReadable()){
ByteBuffer byteBuffer = ByteBuffer.allocate(128);
channel.read(byteBuffer);
byteBuffer.flip();
CharBuffer charBuffer = CharsetHelper.decode(byteBuffer);
String answer = charBuffer.toString();
System.out.println(Thread.currentThread().getId() + "---" + answer);
String word = getWord();
if(word != null){
channel.write(CharsetHelper.encode(CharBuffer.wrap(word)));
}
else{
isOver = true;
}
sleep();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
finally{
if(channel != null){
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(selector != null){
try {
selector.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private void init() {
words = new ArrayBlockingQueue<String>(5);
try {
words.put("hi");
words.put("who");
words.put("what");
words.put("where");
words.put("bye");
} catch (InterruptedException e) {
e.printStackTrace();
}
random = new Random();
}
private String getWord(){
return words.poll();
}
private void sleep() {
try {
TimeUnit.SECONDS.sleep(random.nextInt(3));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void sleep(long l) {
try {
TimeUnit.SECONDS.sleep(l);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} |
相关推荐
JAVA NIO（非阻塞I/O）是一种在Java平台中用于高效处理I/O...在压缩包中的`JavaNioTamplateClient`可能是实现以上概念的一个示例代码，通过阅读和理解这个模板，你可以更好地学习和实践JAVA NIO异步通信客户端的开发。
在这个"NIO 服务器客户端例子"中，`TestServer.java`和`TestClient.java`分别代表服务器端和客户端的实现。 **NIO服务器端（TestServer.java）的关键知识点：** 1. **选择器（Selector）**：服务器通常会创建一个...
本教程将深入讲解如何使用Java NIO实现非阻塞服务端与客户端的通信。 1. **Java NIO基础** - **通道（Channels）**：NIO中的通道类似于传统IO的流，但它们可以同时读写，并且支持非阻塞操作。 - **缓冲区...
本资源主要讲解了Java-NIO非阻塞服务器的示例，通过使用Java-NIO包来实现非阻塞的服务器端模式。下面是从代码中提取的知识点： 一、Java-NIO包简介 Java-NIO（New I/O）包是Java 1.4版本中引入的新IO处理机制，...
这些示例通常会包含简单的读写文件、服务器端与客户端的通信以及多路复用的使用，帮助初学者快速理解NIO的工作原理和实际应用。在学习过程中，你可以逐步深入，从基础的Buffer操作到复杂的Selector机制，掌握Java ...
本文将通过一个对比实例，探讨一般Socket客户端与Mina NIO (Non-blocking I/O) Socket客户端的差异和特点，帮助开发者理解这两种技术在实际应用中的选择。 首先，普通Socket客户端基于BIO（Blocking I/O）模型，它...
这个简单的NIO服务器示例展示了如何使用Java NIO进行非阻塞I/O通信，但实际的生产环境中，通常会使用更高级的框架，如Apache Mina或Netty，它们提供了更丰富的功能和更高的性能优化。Apache Mina是一个轻量级、高...
NIO通过选择器实现多路复用，可以同时处理多个连接，这在高并发服务器中非常有用。例如，一个服务器可以监听多个SocketChannel，而无需为每个客户端连接创建一个新的线程，显著降低了线程创建和销毁的开销。 5. **...
本示例将详细解析如何使用Java的非阻塞I/O（NIO）实现Socket通信，包括客户端发送消息和服务器端接收消息的过程。 首先，理解NIO（Non-blocking Input/Output）的概念至关重要。NIO与传统的IO模型不同，它提供了对...
在本示例中，虽然没有直接使用Mina，但这个示例可以作为理解NIO和Mina的基础，你可以将这个基本的NIO服务器升级为使用Mina提供的高级功能，如更复杂的事件处理和协议编码解码。 总之，这个Java NIO非阻塞服务器示例...
在探讨如何使用Java NIO实现Socket通信之前，我们需要先理解NIO（Non-blocking I/O，非阻塞I/O）与传统阻塞I/O之间的区别。 **传统阻塞I/O模型**：在传统的Java IO编程中，当我们调用`read()`或`write()`方法时，...
在Java编程环境中，服务器与客户端的会话是网络通信的核心部分。这个会话通常涉及到一系列交互，使得服务器能够提供服务，而客户端则可以请求并接收这些服务。在本主题中，我们将深入探讨如何使用Java来建立和管理...
这个例子可能包含一个简单的Netty服务器和客户端实现，它们展示了如何利用NIO进行通信。在服务器端，首先会创建一个ServerBootstrap，然后设置通道工厂，通常使用NioServerSocketChannel。接着，配置管道（Pipeline...
Java NIO（New Input/Output）是Java标准库提供的一种I/O模型，它与传统的 Blocking I/O（BIO）模型不同，NIO提供了非阻塞的读写方式，提高了系统在处理大量并发连接时的效率。在这个“基于java NIO的socket通信demo...
以下是一个简单的客户端示例： ```java import java.io.*; import java.net.*; public class SimpleClient { public static void main(String[] args) throws IOException { String serverAddress = "localhost...
以下是一个简单的NIO服务器端实现步骤： 1. **初始化ServerSocketChannel**：使用`ServerSocketChannel.open()`方法创建ServerSocketChannel，并调用`bind()`方法绑定到指定端口。 2. **注册选择器**：通过`...
在这个Java NIO IM（即时通讯）服务器和客户端的示例中，我们将探讨如何利用NIO进行双向通信，并理解其背后的机制。 1. **NIO基础概念** - **通道（Channel）**：在NIO中，数据是通过通道进行传输的。通道类似于流...
为了更好地理解Java NIO的使用方式，下面我们通过简单的代码示例来展示如何实现一个基本的NIO服务端和客户端。 **服务端代码实现** ```java package cn.nio; import java.io.IOException; import java.net....
在这个“Java客户端服务器程序学习笔记”中，我们将深入探讨这一主题，包括如何设计、实现和交互这两个关键组件。 首先，客户端是用户与系统进行交互的部分，它发送请求到服务器并接收响应。服务器端则处理这些请求...