java 基础之--nio 网络编程

在传统的Java 网络编程中，对于客户端的每次连接，对于服务器来说，都要创建一个新的线程与客户端进行通讯，这种频繁的线程的创建，对于服务器来说，是一种巨大的损耗，在Java 1.4 引入Java nio 引入了 selector channel buffer 对此操作进行重新的定义：

服务端：

package com.java.baseknowledge.net;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.Set;

public class NioService {
    //store userMap
    public static  Map<Integer,SocketChannel> userMap =new HashMap<>();
    public static void main(String[] args) throws Exception {

        //selector object
        Selector selector  =Selector.open();
        //serversocketchannel object is listening client accept
        ServerSocketChannel serverSocket =ServerSocketChannel.open();
        //Adjusts this channel's blocking mode.
        serverSocket.configureBlocking(false);

        serverSocket.bind(new InetSocketAddress(9099));
        //在selector中register channel
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);

        while(true) {
            //block method event listening,this method is perform when event is touch;
            selector.select();
            //get selection-key set
            Set<SelectionKey> selectedKeys = selector.selectedKeys();

            selectedKeys.forEach((keys->{
                //judge selectionkey mode
                if(keys.isAcceptable()) {
                    try {
                    ServerSocketChannel channel = (ServerSocketChannel)keys.channel();
                    //obtain socketchannel
                    SocketChannel accept = channel.accept();
                    accept.configureBlocking(false);
                    //regist selector,listening read event
                    accept.register(selector, SelectionKey.OP_READ);
                    userMap.put(new Random().nextInt()*new Random().nextInt(), accept);

                    }
                    catch(Exception e ) {
                        e.printStackTrace();
                    }
                }

                else if(keys.isReadable()) {
                    //obtain socketchannel
                    try {
                    SocketChannel channel = (SocketChannel)keys.channel();
                    System.out.println(channel);
                    ByteBuffer by = ByteBuffer.allocate(2048);
                    channel.read(by);

                    userMap.forEach((k,v)->{

                        by.rewind();
                        if(v!=channel) {
                            try {
                                v.write(by);
                            } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                    });

                    }
                    catch(Exception e) {}

                }
                selectedKeys.clear();

            }));

        }

    }

}

客户端：

package com.java.baseknowledge.net;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * chat  client
 * @author Administrator
 *
 */
public class JavaNioClient {

    public static void main(String[] args) throws Exception {

        //建立Selector
        Selector selector =Selector.open();
        SocketChannel socketChannel=SocketChannel.open();
        //设置非阻塞
        socketChannel.configureBlocking(false);

        socketChannel.register(selector, SelectionKey.OP_CONNECT);

        socketChannel.connect(new InetSocketAddress("127.0.0.1", 9099));

        while(true) {
            selector.select();

            Set<SelectionKey> setionkey =selector.selectedKeys();

            for(SelectionKey kk :setionkey) {
                if(kk.isConnectable()) {
                    //从selectionkey 获取socketChannel
                    SocketChannel socket=(SocketChannel)kk.channel();
                    //手动建立连接
                    if(socket.isConnectionPending()) {
                        socket.finishConnect();
                        //写数据
                        ByteBuffer byteB = ByteBuffer.allocate(1024);
                        byteB.put((System.currentTimeMillis()+"连接ok").getBytes());
                        byteB.flip();
                        socket.write(byteB);
                        //jdk1.5 线程池
                        ExecutorService exe =Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());

                        exe.submit(new Thread() {

                            @Override
                            public void run() {
                                while(true) {
                                    String msg=null;
                                byteB.clear();
                                //标准键盘输入
                                BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
                                try {
                                     msg =br.readLine();
                                     ByteBuffer bytec = ByteBuffer.allocate(1024);
                                     bytec.put(msg.getBytes());
                                     bytec.flip();
                                     socket.write(bytec);
                                } catch (IOException e) {

                                    e.printStackTrace();
                                }
                                }
                            }
                        });
                    }

                    socket.register(selector, SelectionKey.OP_READ);
                }
                else if(kk.isReadable())  {

                    //从selectionkey 获取socketChannel
                    SocketChannel socket=(SocketChannel)kk.channel();
                    ByteBuffer by =ByteBuffer.allocate(1024);
                    int a=socket.read(by);
                    //if(a>0) {
                    String receive =new String(by.array());
                    System.out.println(receive);
                    //}
                }

                setionkey.clear();
            }

        }

    }

}