最近在看java nio，模仿别人写了一个，用于学习研究下。没有操作页面，每个客户端另起一个线程来接收消息，client3发送消息时，其他的客户端都能接收到消息
1、服务端
public class ChatService {
private Selector selector;
private Charset charset = Charset.forName("UTF-8");
private SelectionKey service = null;
private boolean ISRUN = true;
public ChatService() {
try {
selector = Selector.open();
ServerSocketChannel ssc = ServerSocketChannel.open();
SocketAddress sa = new InetSocketAddress(9999);
ssc.socket().bind(sa);
ssc.configureBlocking(false);
service = ssc.register(selector, SelectionKey.OP_ACCEPT);
} catch (IOException e) {
e.printStackTrace();
}
}
public void service() {
try {
while(ISRUN) {
if(selector.select()>0) {
Set<SelectionKey> kes = selector.selectedKeys();
Iterator<SelectionKey> iter = kes.iterator();
while(iter.hasNext()) {
SelectionKey sk = iter.next();
if(sk.isValid() && sk.isAcceptable()) {
iter.remove();
acceptable(sk);
}
if(sk.isValid() && sk.isReadable()) {
readable(sk);
}
if(sk.isValid() && sk.isWritable()) {
writable(sk);
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
public void acceptable(SelectionKey key) {
ServerSocketChannel ssc = (ServerSocketChannel)key.channel();
try {
SocketChannel sc = ssc.accept();
if(sc==null) {
return ;
}
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
} catch (Exception e) {
e.printStackTrace();
}
}
public void readable(SelectionKey key) {
SocketChannel sc = (SocketChannel)key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
try {
int num = sc.read(buffer);
if(num > 0) {
buffer.flip();
//CharBuffer cb = buffer.asCharBuffer();
String request = charset.decode(buffer).toString();
SocketAddress sa = sc.getRemoteAddress();
System.out.println("客户端信息:"+sa.toString());
System.out.println("服务端接收信息:"+request);
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> keysIter = keys.iterator();
while(keysIter.hasNext()) {
SelectionKey it = keysIter.next();
if(it!=service&&key!=it) { //出去service和自己
it.attach(request);
it.interestOps(it.interestOps()|SelectionKey.OP_WRITE);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void writable(SelectionKey key) {
try{
String tock = (String)key.attachment();
key.attach("");
SocketChannel sc = (SocketChannel)key.channel();
sc.write(charset.encode(tock));
key.interestOps(SelectionKey.OP_READ);
}catch(Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ChatService service = new ChatService();
service.service();
}
2、客户端1
public class ClientC1 {
private SocketChannel sc = null;
private Charset charset = Charset.forName("UTF-8");
private boolean ISRUN = true;
public ClientC1() {
try {
sc = SocketChannel.open();
sc.configureBlocking(false);
InetAddress address = InetAddress.getLocalHost();
InetSocketAddress isa = new InetSocketAddress(address, 9999);
sc.connect(isa);
} catch (Exception e) {
e.printStackTrace();
}
}
public void sendMessage(String message) {
try {
System.out.println("aa:");
while(!sc.finishConnect()) {}
sc.write(charset.encode(message));
} catch (IOException e) {
e.printStackTrace();
}
}
public void receive() {
try {
//while(!sc.finishConnect()){};
System.out.println("接收消息");
while(ISRUN) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
StringBuffer sb = new StringBuffer();
while(sc.read(buffer)>0) {
buffer.flip();
sb.append(buffer.array());
buffer.flip();
}
String str = sb.toString();
if(str!=null&&!"".equals(str)) {
System.out.println("客户端接收信息:"+sb.toString());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public class ReceiveThread implements Runnable {
@Override
public void run() {
try {
while(ISRUN) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
StringBuffer sb = new StringBuffer();
while(sc.read(buffer)>0) {
buffer.flip();
sb.append(charset.decode(buffer));
buffer.flip();
}
String str = sb.toString();
if(str!=null&&!"".equals(str)) {
System.out.println("客户端接收信息:"+sb.toString());
}
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
public void close() {
}
public static void main(String[] args) {
ClientC1 c1 = new ClientC1();
c1.sendMessage("hello client 1");
//c1.receive();
new Thread(c1.new ReceiveThread()).start();
}
}
3、客户端2
public class Client2 {
private SocketChannel sc = null;
private Charset charset = Charset.forName("UTF-8");
private boolean ISRUN = true;
public Client2() {
try {
sc = SocketChannel.open();
sc.configureBlocking(false);
InetAddress address = InetAddress.getLocalHost();
InetSocketAddress isa = new InetSocketAddress(address, 9999);
sc.connect(isa);
} catch (Exception e) {
e.printStackTrace();
}
}
public void sendMessage(String message) {
try {
System.out.println("aa:");
while(!sc.finishConnect()) {}
sc.write(charset.encode(message));
//sc.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void receive() {
try {
//while(!sc.finishConnect()){};
while(ISRUN) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
StringBuffer sb = new StringBuffer();
while(sc.read(buffer)>0) {
buffer.flip();
sb.append(buffer.array());
buffer.flip();
}
String str = sb.toString();
if(str!=null&&!"".equals(str)) {
System.out.println("客户端接收信息:"+sb.toString());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public class ReceiveThread implements Runnable {
@Override
public void run() {
try {
while(ISRUN) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
StringBuffer sb = new StringBuffer();
while(sc.read(buffer)>0) {
buffer.flip();
sb.append(charset.decode(buffer));
buffer.flip();
}
String str = sb.toString();
if(str!=null&&!"".equals(str)) {
System.out.println("客户端接收信息:"+sb.toString());
}
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
public void close() {
}
public static void main(String[] args) {
Client2 c2 = new Client2();
c2.sendMessage("hello client 2_1");
new Thread(c2.new ReceiveThread()).start();
}
}
3、客户端3
public class Client3 {
private SocketChannel sc = null;
private Charset charset = Charset.forName("UTF-8");
private boolean ISRUN = true;
public Client3() {
try {
sc = SocketChannel.open();
sc.configureBlocking(false);
InetAddress address = InetAddress.getLocalHost();
InetSocketAddress isa = new InetSocketAddress(address, 9999);
sc.connect(isa);
} catch (Exception e) {
e.printStackTrace();
}
}
public void sendMessage(String message) {
try {
System.out.println("aa:");
while(!sc.finishConnect()) {}
sc.write(charset.encode(message));
//sc.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void receive() {
try {
//while(!sc.finishConnect()){};
while(ISRUN) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
StringBuffer sb = new StringBuffer();
while(sc.read(buffer)>0) {
buffer.flip();
sb.append(buffer.array());
buffer.flip();
}
String str = sb.toString();
if(str!=null&&!"".equals(str)) {
System.out.println("客户端接收信息:"+sb.toString());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public class ReceiveThread implements Runnable {
@Override
public void run() {
try {
while(ISRUN) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
StringBuffer sb = new StringBuffer();
while(sc.read(buffer)>0) {
buffer.flip();
sb.append(charset.decode(buffer));
buffer.flip();
}
String str = sb.toString();
if(str!=null&&!"".equals(str)) {
System.out.println("客户端接收信息:"+sb.toString());
}
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Client3 client3 = new Client3();
client3.sendMessage("hello client 3");
}
}
相关推荐
本项目"基于nio的简易聊天室"旨在通过NIO技术实现一个简单的聊天室服务端和客户端，其特点是有图形用户界面（GUI）供用户交互。 NIO的核心组件包括通道（Channels）、缓冲区（Buffers）和选择器（Selectors）。在这...
Java NIO（Non-blocking Input/Output）是一种在...在设计聊天服务器时，利用NIO可以有效地处理大量并发用户，降低CPU压力，提高系统整体性能。同时，单线程模型简化了并发控制的复杂性，使得程序更易于理解和维护。
在Java编程领域，NIO（Non-blocking Input/Output）是一种重要的I/O模型，与传统的阻塞I/O（BIO）模型相比，它提供了更高效的数据传输能力，特别适合于高并发、低延迟的网络应用，如聊天室。在这个基于NIO的聊天室...
- 聊天室系统可能运用了观察者模式，让服务器端能广播消息给所有在线用户。 - 可能还使用了工厂模式来创建通道和缓冲区，以及单例模式管理选择器。 9. **测试与调试** - 对聊天室的功能进行单元测试，确保消息的...
在这个“java nio聊天室源码”项目中，我们可以看到如何使用NIO构建一个实时、高效的多人在线聊天应用。 首先，我们要理解Java NIO的基本概念。NIO包括以下关键组件： 1. **通道（Channels）**：通道是数据传输的...
在本项目"基于NIO的Java聊天室2"中，我们深入探讨了如何利用Java的非阻塞I/O（New Input/Output，NIO）框架来实现一个多人在线聊天室。NIO是一种高效的I/O模型，它允许程序在不阻塞主线程的情况下处理输入和输出操作...
在这个“Java NIO 学习 聊天室程序”项目中，我们将深入探讨NIO如何用于创建一个聊天室程序。这个程序可能包含以下几个关键部分： 1. **服务器端**：服务器端使用NIO的ServerSocketChannel监听客户端连接。当新的...
使用NIO socket不需要多线程来处理多个连接的请求，效率非常高 可以作为NIO socket入门的例子，Reactor模式，重点理解key.attach， jar文件里包含了源代码 1，运行server.bat启动服务器，可以打开编辑，修改端口号 ...
基于NIO的多线程聊天系统，代码很少，很经典，51CTO网站上的代码。有登陆和聊天界面。代码结构层次清晰，系统只有6个类。
在这个基于NIO非阻塞的Java聊天demo中，我们将会看到如何利用NIO实现一个支持单聊和群聊的应用。 首先，NIO的核心组件包括Channel、Buffer、Selector和Pipe。在传统的IO模型中，数据是从流的一端流向另一端，而在...
UDP NIO聊天系统是一种利用Java的非阻塞I/O（Non-blocking Input/Output，NIO）和用户数据报协议（User Datagram Protocol, UDP）来构建的通信应用。在这个系统中，服务器端和客户端通过UDP进行数据交换，实现聊天...
服务端程序基于javaNIO,客户端程序基于旧IO,读完<<javaNIO>>后,导入eclipse即可运行,支持多人在线聊天,上下线通知.PS:非GUI程序,毕竟javaSwing用的少,不懂的地方大家可以一起讨论,评论必回!
这个"JAVA NIO 聊天室程序"是一个实践项目，旨在帮助开发者理解如何利用NIO技术来实现一个多人在线聊天应用。 1. **NIO基础** - NIO与传统的BIO（Blocking I/O）模型最大的区别在于，NIO不是阻塞式的，当没有数据...
在实际开发中，NIO常用于网络编程，如服务器端的开发，特别是需要处理大量并发连接的情况，如聊天服务器、游戏服务器等。Java NIO库提供了多种实现，如`java.nio.channels`包下的各种Channel和Selector类，以及`java...
NIO聊天室的实现是学习和理解NIO机制的一个实用示例。在这个项目中，我们将探讨如何使用NIO构建一个简单的聊天室，分为客户端和服务器端。 **NIO基础** NIO（New Input/Output）与传统的IO（Block IO）的主要区别...
假设我们正在开发一个简单的聊天服务器，用户可以连接到服务器并通过服务器相互发送消息。在这种情况下，我们可以利用Selector来监听多个客户端连接上的读写事件。当一个客户端发送消息时，Selector会通知我们哪个...
如果需要管理数千个并发的连接，每一个连接只发送较少的数据（比如聊天服务器），使用 NIO 来实现会比较有优势。如果需要同时保持很多到其他服务器的连接，比如 P2P 网络，使用单线程来管理所有的出口连接会比较有...
- 高并发服务器：例如聊天室、游戏服务器，NIO的非阻塞特性使得服务器能同时处理大量客户端连接。 - 大文件传输：NIO的缓冲区机制减少了内存复制，提高了大文件的读写效率。 - 流量控制：NIO可以通过选择器实现...
基于NIO编写的聊天室，命令行运行，分server，client，config三个包，分别存放服务器端，客户端，以及一些端口信息的配置类。