NIO通信例子

服务端代码

package net.nio;

import java.io.ByteArrayOutputStream;
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;
public class MyServer {

    /** 
     * @Title: 使用NIO实现Socket通信服务器端 
     * @Description: TODO(这里用一句话描述这个方法的作用) 
     * @param @param args    设定文件 
     * @return void    返回类型 
     * @throws 
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Selector selector = null;
        ServerSocketChannel serverSocketChannel = null;
        try
        {
            //开启IO多路复用轮询
            selector = Selector.open();
            serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.configureBlocking(false);//必须配置为非阻塞
            serverSocketChannel.socket().setReuseAddress(true);//设置当连接处于超时状态时，是否允许新的连接使用旧的连接端口
            serverSocketChannel.socket().bind(new InetSocketAddress(10000));//绑定服务器本地地址和端口
            //在多路复用轮询器上注册操作
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("server is ready.............");
            while(selector.select()>0){
                //取得就绪操作
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                while(it.hasNext()){
                    SelectionKey readyKey = it.next();
                    it.remove();
                    execute((ServerSocketChannel)readyKey.channel());
                }
            }
            System.out.println("server is over.............");
        }catch (IOException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally{
            try {
                selector.close();
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage(),e);
            }
            try {
                serverSocketChannel.close();
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage(),e);
            }
        }
        
    }
    /***/
    private static void execute(ServerSocketChannel serverSocketChannel)throws IOException{
        SocketChannel socketChannel = null;
        try{
            //收到客户端请求信息
            socketChannel = serverSocketChannel.accept();
            RequestObject requestObject = receiveData(socketChannel);
            System.out.println("receive from Client:"+requestObject.toString());
            //发生响应信息到客户端
            ResponseObject responseObject = new ResponseObject("response for "+requestObject.getName(),
                    "response for "+requestObject.getValue());
            sendData(socketChannel,responseObject);
        }finally{
            socketChannel.close();
        }
    }
    private static RequestObject receiveData(SocketChannel socketChannel)throws IOException{
        RequestObject requestObject = null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        try{
            byte[] bytes;
            int size = 0;
            while((size=socketChannel.read(buffer))>=0){
                //反转指针，由写状态到读状态
                buffer.flip();
                bytes = new byte[size];
                buffer.get(bytes);
                bos.write(bytes);
                buffer.clear();
            }
            bytes = bos.toByteArray();
            Object result = ClassUtil.bytes2Object(bytes);
            requestObject = (RequestObject)result;
        }finally{
            bos.close();
        }
        return requestObject;
    }
    private static void sendData(SocketChannel socketChannel,ResponseObject responseObject)throws IOException{
        byte[] bytes = ClassUtil.object2Bytes(responseObject);
        ByteBuffer buffer = ByteBuffer.wrap(bytes);
        socketChannel.write(buffer);
    }
}

客户端调用代码

package net.nio;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class MyClient {

    /** 
     * @Title: NIO客户端，发生消息 
     * @Description: 启动100个线程给服务端发消息
     * @param @param args    设定文件 
     * @return void    返回类型 
     * @throws 
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i=0;i<100;i++){
            final int idx = i;
            new Thread(new MyRunnable(idx)).start();
        }
    }

}
class MyRunnable implements Runnable{

    private final int idx;
    public MyRunnable(int idx){
        this.idx = idx;
    }
    @Override
    public void run() {
        SocketChannel socketChannel = null;
        try{
            //连接服务器
            socketChannel = SocketChannel.open();
            SocketAddress remoteAddress = new InetSocketAddress("127.0.0.1",10000);
            socketChannel.connect(remoteAddress);
            //发送请求
            RequestObject requestObject = new RequestObject("request_"+idx,"request_"+idx);
            sendData(socketChannel,requestObject);
            //接收响应
            ResponseObject responseObject = receiveData(socketChannel);
            System.out.println("reveive from server:"+responseObject.toString());
            
        }catch (IOException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally{
            try {
                socketChannel.close();
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage(),e);
            }
        }
        
    }
    private void sendData(SocketChannel socketChannel,RequestObject requestObject)throws IOException{
        byte[] bytes = ClassUtil.object2Bytes(requestObject);
        ByteBuffer buffer = ByteBuffer.wrap(bytes);
        socketChannel.write(buffer);
        //结束输出
        socketChannel.socket().shutdownOutput();
    }
    private ResponseObject receiveData(SocketChannel socketChannel)throws IOException{
        ResponseObject responseObject = null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try{
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            byte[] bytes;
            int size=0;
            while((size=socketChannel.read(buffer))>=0){
                buffer.flip();
                bytes = new byte[size];
                buffer.get(bytes);
                bos.write(bytes);
                buffer.clear();
            }
            bytes = bos.toByteArray();
            responseObject = (ResponseObject) ClassUtil.bytes2Object(bytes);
            //结束读入
            socketChannel.socket().shutdownInput();
        }finally{
            bos.close();
        }
        
        return responseObject;
    }
}

工具类

package net.nio;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 操作class的工具类，包括序列化，反序列化，获取类信息
 * */
public class ClassUtil {
    //用于缓存类的Field信息
    private static ConcurrentHashMap<String, List<Field>> classFieldMap = new ConcurrentHashMap<String,List<Field>>();
    //用于缓存类的Field信息
    private static ConcurrentHashMap<String,Method[]> classMethodMap = new ConcurrentHashMap<String,Method[]>();
    /**
     * 序列化
     * @param object 需要序列化的对象
     * */
    public static byte[] object2Bytes(Object object){
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = null;
        try{
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
        }catch(IOException e){
            throw new RuntimeException(e.getMessage(),e);
        }finally{
            try {
                if(oos!=null)
                    oos.close();
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage(),e);
            }
        }
        return baos.toByteArray();
    }
    /**
     * 反序列化
     * @param bytes 需要反序列化成对象的字节数组
     * */
    public static Object bytes2Object(byte[] bytes){
        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = null;
        try{
            ois = new ObjectInputStream(bis);
            Object object = ois.readObject();
            return object;
        }catch(IOException e){
            throw new RuntimeException(e.getMessage(),e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally{
            if(ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    throw new RuntimeException(e.getMessage(),e);
                }
            }
        }
    }
}

ResponseObject和RequestObject就是简单的java bean，因为字数研制，就不给出了。

转载于:https://my.oschina.net/sharkbobo/blog/269085