基于NIO的Socket通信

一、NIO模式的基本原理:

服务端:

  首先,服务端打开一个通道(ServerSocketChannel),并向通道中注册一个通道调度器(Selector);然后向通道调度器注册感兴趣的事件SelectionKey(如:OP_ACCEPT),接着就可以使用通道调度器(Selector)轮询通道(ServerSocketChannel)上注册的事件,并进行相应的处理。

客户端:

客户端在请求与服务端通信时,也可以像服务器端一样注册感兴趣的事件(比服务端少了SelectionKey.OP_ACCEPT事件),并通过轮询来处理指定的事件,而不必阻塞。

服务端和客户端各自维护一个通道调度器(Selector)对象,该对象能检测一个或多个通道 (channel) 上的事件。我们以服务端为例,如果服务端的selector上注册了读事件,某时刻客户端给服务端发送了一些数据,NIO的服务端会在selector中添加一个读事件。服务端的处理线程会轮询地访问selector,如果访问selector时发现有感兴趣的事件到达,则处理这些事件,如果没有感兴趣的事件到达,则处理线程会一直阻塞直到感兴趣的事件到达为止。

二、基于NIO的简单Socket通信实例

服务端:

package cn.nio;

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 *
 * @author*/
public class NIOServer {
    //通道调度器
    private Selector selector;

    /**
     * 获得一个ServerSocket通道,并对该通道做一些初始化的工作
     * @param port  绑定的端口号
     * @throws IOException
     */
    public void initServer(int port) throws IOException {
        // 获得一个ServerSocket通道
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        // 设置通道为非阻塞
        serverChannel.configureBlocking(false);
        // 将该通道对应的ServerSocket绑定到port端口
        serverChannel.socket().bind(new InetSocketAddress(port));
        // 获得一个通道调度器
        this.selector = Selector.open();
        //将通道调度器和该通道绑定,并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后,
        //当该事件到达时,selector.select()会返回,如果该事件没到达selector.select()会一直阻塞。
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    }

    /**
     * 采用轮询的方式监听selector上是否有需要处理的事件,如果有,则进行处理
     * @throws IOException
     */
    @SuppressWarnings("unchecked")
    public void listen() throws IOException {
        System.out.println("server start success");
        // 轮询访问selector
        while (true) {
            //当注册的事件到达时,方法返回;否则,该方法会一直阻塞
            selector.select();
            // 获得selector中选中的项的迭代器,选中的项为注册的事件
            Iterator ite = this.selector.selectedKeys().iterator();
            while (ite.hasNext()) {
                SelectionKey key = (SelectionKey) ite.next();
                // 删除已选的key,以防重复处理
                ite.remove();
                // 客户端请求连接事件
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key
                            .channel();
                    // 获得和客户端连接的通道
                    SocketChannel channel = server.accept();
                    // 设置成非阻塞
                    channel.configureBlocking(false);

                    //在这里可以给客户端发送信息哦
                    channel.write(ByteBuffer.wrap(new String("send a message to client").getBytes()));
                    //在和客户端连接成功之后,为了可以接收到客户端的信息,需要给通道设置读的权限。
                    channel.register(this.selector, SelectionKey.OP_READ);

                    // 获得了可读的事件
                } else if (key.isReadable()) {
                        read(key);
                }

            }

        }
    }
    /**
     * 处理读取客户端发来的信息 的事件
     * @param key
     * @throws IOException
     */
    public void read(SelectionKey key) throws IOException{
        // 服务器可读取消息:得到事件发生的Socket通道
        SocketChannel channel = (SocketChannel) key.channel();
        // 创建读取的缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(10);
        channel.read(buffer);
        byte[] data = buffer.array();
        String msg = new String(data).trim();
        System.out.println("received message from client:"+msg);
        ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
        channel.write(outBuffer);// 将消息回送给客户端
    }

    /**
     * 启动服务端测试
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        NIOServer server = new NIOServer();
        server.initServer(8000);
        server.listen();
    }

}

客户端:

  1 package com.nio;
  2
  3 import java.io.IOException;
  4 import java.net.InetSocketAddress;
  5 import java.nio.ByteBuffer;
  6 import java.nio.channels.SelectionKey;
  7 import java.nio.channels.Selector;
  8 import java.nio.channels.SocketChannel;
  9 import java.util.Iterator;
 10
 11 /**
 12  *
 13  * @author 14  */
 15 public class NIOClient {
 16     //通道调度器
 17     private Selector selector;
 18
 19     /**
 20      * 获得一个Socket通道,并对该通道做一些初始化的工作
 21      * @param ip 连接的服务器的ip
 22      * @param port  连接的服务器的端口号
 23      * @throws IOException
 24      */
 25     public void initClient(String ip,int port) throws IOException {
 26         // 获得一个Socket通道
 27         SocketChannel channel = SocketChannel.open();
 28         // 设置通道为非阻塞
 29         channel.configureBlocking(false);
 30         // 获得一个通道调度器
 31         this.selector = Selector.open();
 32
 33         // 客户端连接服务器,其实方法执行并没有实现连接,需要在listen()方法中调
 34         //用channel.finishConnect();才能完成连接
 35         channel.connect(new InetSocketAddress(ip,port));
 36         //将通道调度器和该通道绑定,并为该通道注册SelectionKey.OP_CONNECT事件。
 37         channel.register(selector, SelectionKey.OP_CONNECT);
 38     }
 39
 40     /**
 41      * 采用轮询的方式监听selector上是否有需要处理的事件,如果有,则进行处理
 42      * @throws IOException
 43      */
 44     @SuppressWarnings("unchecked")
 45     public void listen() throws IOException {
 46         // 轮询访问selector
 47         while (true) {
 48             selector.select();
 49             // 获得selector中选中的项的迭代器
 50             Iterator ite = this.selector.selectedKeys().iterator();
 51             while (ite.hasNext()) {
 52                 SelectionKey key = (SelectionKey) ite.next();
 53                 // 删除已选的key,以防重复处理
 54                 ite.remove();
 55                 // 连接事件发生
 56                 if (key.isConnectable()) {
 57                     SocketChannel channel = (SocketChannel) key
 58                             .channel();
 59                     // 如果正在连接,则完成连接
 60                     if(channel.isConnectionPending()){
 61                         channel.finishConnect();
 62
 63                     }
 64                     // 设置成非阻塞
 65                     channel.configureBlocking(false);
 66
 67                     //在这里可以给服务端发送信息哦
 68                     channel.write(ByteBuffer.wrap(new String("send a  message to server").getBytes()));
 69                     //在和服务端连接成功之后,为了可以接收到服务端的信息,需要给通道设置读的权限。
 70                     channel.register(this.selector, SelectionKey.OP_READ);
 71
 72                     // 获得了可读的事件
 73                 } else if (key.isReadable()) {
 74                         read(key);
 75                 }
 76
 77             }
 78
 79         }
 80     }
 81     /**
 82      * 处理读取服务端发来的信息 的事件
 83      * @param key
 84      * @throws IOException
 85      */
 86     public void read(SelectionKey key) throws IOException{
 87         //和服务端的read方法一样
 88     }
 89
 90
 91     /**
 92      * 启动客户端测试
 93      * @throws IOException
 94      */
 95     public static void main(String[] args) throws IOException {
 96         NIOClient client = new NIOClient();
 97         client.initClient("localhost",8000);
 98         client.listen();
 99     }
100
101 }
时间: 2024-10-14 21:09:05

基于NIO的Socket通信的相关文章

[java]基于UDP的Socket通信Demo

java课编程作业:在老师给的demo的基础上实现客户端发送数据到服务器端,服务器端接受客户端后进行数据广播. 整体功能类似于聊天室,代码部分不是太难,但是在本机测试的时候出现这样的问题: 服务端通过将每一个Socket客户端的IP存入Set集合,每次接受到数据后都向当前所有的IP转发.但是本机演示的时候所有开的ChatClient客户端都是同一IP,怎么测试呢? 解决办法就是本机测试时候服务端向多个不同的端口转发就好了,这样跑起来的客户端是在不同端口上进行监听的(只是为了实现广播,实际应用下还

recv原理、高阶版黏包解决方案、基于UDP的socket通信

recv原理.高阶版黏包解决方案.基于UDP的socket通信 recv原理 源码解释: Receive up to buffersize bytes from the socket. 接收来自socket缓冲区的字节数据, For the optional flags argument, see the Unix manual. 对于这些设置的参数,可以查看Unix手册. When no data is available, block untilat least one byte is av

基于Java NIO的Socket通信

Java NIO模式的Socket通信,是一种同步非阻塞IO设计模式,它为Reactor模式实现提供了基础. 下面看看,Java实现的一个服务端和客户端通信的例子. NIO模式的基本原理描述如下: 服务端打开一个通道(ServerSocketChannel),并向通道中注册一个选择器(Selector),这个选择器是与一些感兴趣的操作的标识(SelectionKey,即通过这个标识可以定位到具体的操作,从而进行响应的处理)相关联的,然后基于选择器(Selector)轮询通道(ServerSock

基于android的Socket通信

一.Socket通信简介 Android与服务器的通信方式主要有两种,一是Http通信,一是Socket通信.两者的最大差异在于,http连接使用的是“请求—响应方式”,即在请求时建立连接通道,当客户端向服务器发送请求后,服务器端才能向客户端返回数据.而Socket通信则是在双方建立起连接后就可以直接进行数据的传输,在连接时可实现信息的主动推送,而不需要每次由客户端想服务器发送请求. 那么,什么是socket?Socket又称套接字,在程序内部提供了与外界通信的端口,即端口通信.通过建立sock

基于TCP的Socket通信

这里的例程跟前面"基于TCP的Socket"类似,前面是客户端给服务器端发信息,这里是服务器端给客户端发信息 TCP通信模式: TCP/IP通信协议是一种可靠的网络协议,它在通信的两端各建立一个Socket,从而在通信两端之间形成网络虚拟链路. 一旦建立了虚拟的网络链路,两端的程序就可以通过虚拟链路进行通信. Java使用Socket对象来代表两端的通信接口,并通过Socket产生I/O流来进行网络通信. SimpleServer.java  服务器程序,不需要建立Android项目,

Java Socket应用(五)——编程实现基于 TCP 的 Socket 通信

转载请注明:http://blog.csdn.net/uniquewonderq 思路: 服务器段的测试代码如下: : package com.test; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socke

Linux下基于select的socket通信

select函数介绍: int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval *timeout); /*参数列表 int maxfdp是一个整数值,是指集合中所有文件描述符的范围,即所有文件描述符的最大值加1,不能错!在Windows中这个参数的值无所谓,可以设置不正确. fd_set *readfds是指向fd_set结构的指针,这个集合中应该包括文件描述符,我们是要监视这些

基于多线程的TCP socket通信经典案例

服务器端 package com.thinkvenus.study.socket; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.net.Socket; /** *

Android基础入门教程——7.6.2 基于TCP协议的Socket通信(1)

Android基础入门教程--7.6.2 基于TCP协议的Socket通信(1) 标签(空格分隔): Android基础入门教程 本节引言: 上一节的概念课枯燥无味是吧,不过总有点收获是吧,本节开始我们来研究基于TCP协议的Socket 通信,先来了解下Socket的概念,以及Socket通信的模型,实现Socket的步骤,以及作为Socket服务 端与客户端的两位各做要做什么事情!好的,我们由浅入深来扣这个Socket吧! 1.什么是Socket? 2.Socket通信模型: Socket通信