`
warnerhit
  • 浏览: 123566 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

使用SocketChannel的NIO客户机服务器通信示例。(转)

阅读更多

 这只是长征路上的一小步,以后还有待改进。

NIO Selector示意图:


客户端代码:

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;


/**
 * NIO TCP 客户端
 * 
 * @date    2010-2-3
 * @time    下午03:33:26
 * 
@version 1.00
 
*/
public class TCPClient{
  
// 信道选择器
  private Selector selector;
  
  
// 与服务器通信的信道
  SocketChannel socketChannel;
  
  
// 要连接的服务器Ip地址
  private String hostIp;
  
  
// 要连接的远程服务器在监听的端口
  private int hostListenningPort;
  
  
/**
   * 构造函数
   * 
@param HostIp
   * 
@param HostListenningPort
   * 
@throws IOException
   
*/
  
public TCPClient(String HostIp,int HostListenningPort)throws IOException{
    
this.hostIp=HostIp;
    
this.hostListenningPort=HostListenningPort;   
    
    initialize();
  }
  
  
/**
   * 初始化
   * 
@throws IOException
   
*/
  
private void initialize() throws IOException{
    
// 打开监听信道并设置为非阻塞模式
    socketChannel=SocketChannel.open(new InetSocketAddress(hostIp, hostListenningPort));
    socketChannel.configureBlocking(
false);
    
    
// 打开并注册选择器到信道
    selector = Selector.open();
    socketChannel.register(selector, SelectionKey.OP_READ);
    
    
// 启动读取线程
    new TCPClientReadThread(selector);
  }
  
  
/**
   * 发送字符串到服务器
   * 
@param message
   * 
@throws IOException
   
*/
  
public void sendMsg(String message) throws IOException{
    ByteBuffer writeBuffer
=ByteBuffer.wrap(message.getBytes("UTF-16"));
    socketChannel.write(writeBuffer);
  }
  
  
public static void main(String[] args) throws IOException{
    TCPClient client
=new TCPClient("192.168.0.1",1978);
    
    client.sendMsg(
"你好!Nio!醉里挑灯看剑,梦回吹角连营");
  }
}


客户端读取线程代码:
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

public class TCPClientReadThread implements Runnable{
  
private Selector selector;
  
  
public TCPClientReadThread(Selector selector){
    
this.selector=selector;
    
    
new Thread(this).start();
  }
  
  
public void run() {
    
try {
      
while (selector.select() > 0) {
        
// 遍历每个有可用IO操作Channel对应的SelectionKey
        for (SelectionKey sk : selector.selectedKeys()) {
          
          
// 如果该SelectionKey对应的Channel中有可读的数据
          if (sk.isReadable()) {
            
// 使用NIO读取Channel中的数据
            SocketChannel sc = (SocketChannel) sk.channel();
            ByteBuffer buffer 
= ByteBuffer.allocate(1024);
            sc.read(buffer);
            buffer.flip();
            
            
// 将字节转化为为UTF-16的字符串   
            String receivedString=Charset.forName("UTF-16").newDecoder().decode(buffer).toString();
            
            
// 控制台打印出来
            System.out.println("接收到来自服务器"+sc.socket().getRemoteSocketAddress()+"的信息:"+receivedString);
            
            
// 为下一次读取作准备
            sk.interestOps(SelectionKey.OP_READ);
          }
          
          
// 删除正在处理的SelectionKey
          selector.selectedKeys().remove(sk);
        }
      }
    } 
catch (IOException ex) {
      ex.printStackTrace();
    }   
  }
}


服务器端代码:
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;

/**
 * TCP服务器端 
 * 
 * @date    2010-2-3
 * @time    上午08:39:48
 * 
@version 1.00
 
*/
public class TCPServer{
  
// 缓冲区大小
  private static final int BufferSize=1024;
  
  
// 超时时间,单位毫秒
  private static final int TimeOut=3000;
  
  
// 本地监听端口
  private static final int ListenPort=1978;
  
  
public static void main(String[] args) throws IOException{
    
// 创建选择器
    Selector selector=Selector.open();
    
    
// 打开监听信道
    ServerSocketChannel listenerChannel=ServerSocketChannel.open();
    
    
// 与本地端口绑定
    listenerChannel.socket().bind(new InetSocketAddress(ListenPort));
    
    
// 设置为非阻塞模式
    listenerChannel.configureBlocking(false);
    
    
// 将选择器绑定到监听信道,只有非阻塞信道才可以注册选择器.并在注册过程中指出该信道可以进行Accept操作
    listenerChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    
// 创建一个处理协议的实现类,由它来具体操作
    TCPProtocol protocol=new TCPProtocolImpl(BufferSize);
    
    
// 反复循环,等待IO
    while(true){
      
// 等待某信道就绪(或超时)
      if(selector.select(TimeOut)==0){
        System.out.print(
"独自等待.");
        
continue;
      }
      
      
// 取得迭代器.selectedKeys()中包含了每个准备好某一I/O操作的信道的SelectionKey
      Iterator<SelectionKey> keyIter=selector.selectedKeys().iterator();
      
      
while(keyIter.hasNext()){
        SelectionKey key
=keyIter.next();
        
        
try{
          
if(key.isAcceptable()){
            
// 有客户端连接请求时
            protocol.handleAccept(key);
          }
          
          
if(key.isReadable()){
            
// 从客户端读取数据
            protocol.handleRead(key);
          }
          
          
if(key.isValid() && key.isWritable()){
            
// 客户端可写时
            protocol.handleWrite(key);
          }
        }
        
catch(IOException ex){
          
// 出现IO异常(如客户端断开连接)时移除处理过的键
          keyIter.remove();
          
continue;
        }
        
        
// 移除处理过的键
        keyIter.remove();
      }
    }
  }
}

协议接口代码:
import java.io.IOException;
import java.nio.channels.SelectionKey;

/**
 * TCPServerSelector与特定协议间通信的接口
 * 
 * @date    2010-2-3
 * @time    上午08:42:42
 * 
@version 1.00
 
*/
public interface TCPProtocol{
  
/**
   * 接收一个SocketChannel的处理
   * 
@param key
   * 
@throws IOException
   
*/
  
void handleAccept(SelectionKey key) throws IOException;
  
  
/**
   * 从一个SocketChannel读取信息的处理
   * 
@param key
   * 
@throws IOException
   
*/
  
void handleRead(SelectionKey key) throws IOException;
  
  
/**
   * 向一个SocketChannel写入信息的处理
   * 
@param key
   * 
@throws IOException
   
*/
  
void handleWrite(SelectionKey key) throws IOException;
}

协议实现类代码:
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Date;

/**
 * TCPProtocol的实现类
 * 
 * @date    2010-2-3
 * @time    上午08:58:59
 * 
@version 1.00
 
*/
public class TCPProtocolImpl implements TCPProtocol{
  
private int bufferSize;
  
  
public TCPProtocolImpl(int bufferSize){
    
this.bufferSize=bufferSize;
  }

  
public void handleAccept(SelectionKey key) throws IOException {
    SocketChannel clientChannel
=((ServerSocketChannel)key.channel()).accept();
    clientChannel.configureBlocking(
false);
    clientChannel.register(key.selector(), SelectionKey.OP_READ,ByteBuffer.allocate(bufferSize));
  }

  
public void handleRead(SelectionKey key) throws IOException {
    
// 获得与客户端通信的信道
    SocketChannel clientChannel=(SocketChannel)key.channel();
    
    
// 得到并清空缓冲区
    ByteBuffer buffer=(ByteBuffer)key.attachment();
    buffer.clear();
    
    
// 读取信息获得读取的字节数
    long bytesRead=clientChannel.read(buffer);
    
    
if(bytesRead==-1){
      
// 没有读取到内容的情况
      clientChannel.close();
    }
    
else{
      
// 将缓冲区准备为数据传出状态
      buffer.flip();
      
      
// 将字节转化为为UTF-16的字符串   
      String receivedString=Charset.forName("UTF-16").newDecoder().decode(buffer).toString();
      
      
// 控制台打印出来
      System.out.println("接收到来自"+clientChannel.socket().getRemoteSocketAddress()+"的信息:"+receivedString);
      
      
// 准备发送的文本
      String sendString="你好,客户端. @"+new Date().toString()+",已经收到你的信息"+receivedString;
      buffer
=ByteBuffer.wrap(sendString.getBytes("UTF-16"));
      clientChannel.write(buffer);
      
      
// 设置为下一次读取或是写入做准备
      key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
    }
  }

  
public void handleWrite(SelectionKey key) throws IOException {
    
// do nothing
  }
}

 

 

http://www.blogjava.net/longturi/archive/2010/02/03/311820.html

分享到:
评论
1 楼 chinesejie 2012-11-07  
同学,您的程序有bug,我帮你调了几天了,终于搞定。
用nio写的server这段。
while (passlen>=0) {    
                        clientBuffer.flip();   
                        fileOut.write(clientBuffer.array(), 0, passlen);  
                        passlen = channel.read(clientBuffer); 
                    }

应嘎是这样的逻辑:
while (passlen>=0) {  
if(passlen!=0) { 
                        clientBuffer.flip();
}  
                        fileOut.write(clientBuffer.array(), 0, passlen);  
                        passlen = channel.read(clientBuffer); 
                    }   
这样传大文件也不会错了。

相关推荐

    Java-NIO非阻塞服务器示例.docx

    本资源主要讲解了Java-NIO非阻塞服务器的示例,通过使用Java-NIO包来实现非阻塞的服务器端模式。下面是从代码中提取的知识点: 一、Java-NIO包简介 Java-NIO(New I/O)包是Java 1.4版本中引入的新IO处理机制,...

    JavaNIO非阻塞服务器示例.pdf

    在这个Java NIO非阻塞服务器示例中,我们看到如何使用Mina2.0框架来构建一个简单的服务器。 首先,让我们了解NIO的基本概念。传统的Java IO基于流和字节缓冲区,采用阻塞I/O模型,即当一个操作(如读或写)进行时,...

    Java NIO非阻塞服务器示例.docx

    这个简单的NIO服务器示例展示了如何使用Java NIO进行非阻塞I/O通信,但实际的生产环境中,通常会使用更高级的框架,如Apache Mina或Netty,它们提供了更丰富的功能和更高的性能优化。Apache Mina是一个轻量级、高...

    nio入门文档及示例代码

    2. **网络通信示例**:展示如何使用SocketChannel和ServerSocketChannel进行客户端和服务器端的双向通信。 3. **选择器使用示例**:如何创建和使用选择器,以及处理选择器返回的事件。 通过这些示例,你可以深入...

    java SocketChannel通信实例

    `SocketSelectorServer`和`SocketSelectorClient`是源代码文件,它们展示了如何使用SocketChannel和Selector实现服务器端和客户端的通信。服务器端通常会创建一个Selector,然后注册SocketChannel,监听客户端的连接...

    NIO实现客户端之间通信

    在本文中,我们将深入探讨如何使用NIO实现客户端之间的通信,并通过一个中心服务器进行消息的转发。 首先,我们来看通道。通道是NIO中的数据传输路径,它可以连接到硬件设备、文件系统或其他服务。例如,...

    采用NIO实现一个Socket服务器

    本篇将基于给定的标题“采用NIO实现一个Socket服务器”来详细阐述如何使用NIO进行Socket服务端的开发。 首先,理解NIO的核心概念: 1. **通道(Channel)**:通道是连接到I/O设备的途径,可以读取或写入数据。常见的...

    nio 服务器/客户端模式

    在NIO服务器/客户端模式中,我们将会探讨如何利用NIO构建高效的通信系统。 首先,让我们了解NIO的基本组件: 1. **通道(Channels)**:通道是数据传输的途径,类似于流。NIO提供多种通道,如SocketChannel、...

    NIO 服务器客户端例子

    2. **缓冲区(Buffers)**:NIO使用缓冲区进行数据读写,如`ByteBuffer`。客户端通常需要创建缓冲区,写入数据,然后调用`channel.write(buffer)`发送。 3. **读取响应**:客户端也需要注册到选择器,关注读事件,...

    基于java NIO的socket通信demo

    在这个“基于java NIO的socket通信demo”中,我们将探讨如何使用NIO进行服务器和客户端的Socket通信,并解决通信过程中的字符集乱码问题。 首先,我们来看`NioServer.java`。这个文件中包含了一个基于NIO的服务器端...

    使用NIO方式完成简单的通信

    本教程将介绍如何使用NIO来实现简单的通信,包括消息头和消息体的设计。 首先,我们需要了解NIO的基本组件。NIO的核心类包括`Selector`、`Channel`和`Buffer`。`Selector`用于监控多个`Channel`的事件,如读写就绪...

    java nio示例代码

    这些示例通常会包含简单的读写文件、服务器端与客户端的通信以及多路复用的使用,帮助初学者快速理解NIO的工作原理和实际应用。在学习过程中,你可以逐步深入,从基础的Buffer操作到复杂的Selector机制,掌握Java ...

    nio socket编程java代码示例,客户端发送消息,服务端接收

    本示例将详细解析如何使用Java的非阻塞I/O(NIO)实现Socket通信,包括客户端发送消息和服务器端接收消息的过程。 首先,理解NIO(Non-blocking Input/Output)的概念至关重要。NIO与传统的IO模型不同,它提供了对...

    Nio非阻塞socket通信demo

    Java NIO(New IO)是Java 1.4版本引入的一种新的I/O API,它提供了非阻塞式的I/O操作,极大地提高了Java处理I/O的能力。...通过这个示例,你可以深入理解NIO在Socket通信中的工作原理,并学习如何在实际项目中应用。

    基于JavaNIO的非阻塞通信的研究与实现

    ### 基于Java NIO的非阻塞通信的研究与实现 #### 摘要 本文探讨了Java NIO(New I/O)框架中的非阻塞通信机制,并对其原理及应用进行了深入研究。NIO是一种现代I/O处理方法,通过引入缓冲区、通道和选择器等新概念...

    Java NIO实现多个客户端之间的消息互发,客户端与服务器完整代码

    在给定的项目中,"client"包可能包含了C++客户端的源代码,实现了与Java NIO服务器的通信。而"sensor"包可能是Java NIO的一部分,专门负责接收来自客户端的消息,并进行处理和转发。由于没有提供具体的源代码,我们...

    NIO原生API示例

    本文将深入探讨NIO原生API的示例,基于提供的"ServerImpCopy.java"文件名,我们可以推测这是一个关于服务器端NIO实现的示例代码。 在Java NIO中,核心组件包括通道(Channels)、缓冲区(Buffers)和选择器...

    java nio服务器

    标题中的“java nio服务器”指的是使用Java NIO API构建的网络服务器,这种服务器设计模式通常被称为多路复用或非阻塞I/O服务器。NIO的核心组件包括通道(Channels)、缓冲区(Buffers)和选择器(Selectors)。下面...

    JAVA NIO 异步通信客户端

    JAVA NIO(非阻塞I/O)是一种在Java平台中用于高效处理I/O...在压缩包中的`JavaNioTamplateClient`可能是实现以上概念的一个示例代码,通过阅读和理解这个模板,你可以更好地学习和实践JAVA NIO异步通信客户端的开发。

    基于事件的 NIO 多线程服务器

    "nioserver"很可能是一个基础的NIO服务器实现,它可能包含了ServerSocketChannel、SocketChannel、ByteBuffer等关键组件的使用,展示了如何接收和发送数据。而"timeserver"可能是一个时间服务器,用于向客户端发送...

Global site tag (gtag.js) - Google Analytics