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();
            }
            
        }
        
        
    }

}