利用Java NIO 实现client端，支持自动重连

Java NIO 实现client端，相比较于Server端的实现，相对简单，如果要支持自动重新连接功能，就需要有线程同步的概念。以下代码实现了自动重新连接的功能，增加了一个具体的连接管理类Manager。

package com.sof.nio;

import java.io.IOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sof.bas.Config;
import com.sof.exe.Client;

public class Manager implements Runnable {
	private static Logger logger = LoggerFactory.getLogger(Client.class);
	public boolean connstate = false;
	public String ip = Config.getInstance().getStringValue("ip");
	public int port = Config.getInstance().getIntValue("port");

	public void setestablished() {
		connstate = true;
	}

	public void setdisconnect() {
		connstate = false;
	}

	public boolean getconnstate() {
		return connstate;
	}

	public void run() {
		while (true) {
			Reactor reactor = null;
			try {
				reactor = new Reactor(ip, port, this);
				reactor.connecttoserver();
				logger.error("connect to server sucessful " + reactor.serveraddress.toString());
			} catch (IOException ex) {
				logger.error("connect to server unsucessful " + reactor.serveraddress.toString());
				continue;
			}

			while (getconnstate()) {
				try {
					synchronized (this) {
						this.wait();
						logger.debug("got a news about disconnection and reconnect to server" +  reactor.serveraddress.toString());
					}
				} catch (InterruptedException e) {
					logger.debug(e.getMessage());
				}
			}
		}
	}
}

 

package com.sof.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.SocketChannel;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.sof.bas.Bytes2util;
import com.sof.bas.Util2Bytes;

public class Reactor implements Runnable {
	private static Logger logger = LoggerFactory.getLogger(Reactor.class);

	public Manager manager;
	final Selector selector;
	final SocketChannel socket;

	public SelectionKey sk;
	public InetSocketAddress serveraddress;

	static final int MESSAGE_LENGTH_HEAD = 4;
	private byte[] head = new byte[4];
	private int bodylen = -1;
	private int sequence = 0;

	public boolean done = true;

	public Reactor(String ip, int port, Manager manager) throws IOException {
		this.manager = manager;
		selector = Selector.open();
		socket = SocketChannel.open();
		socket.configureBlocking(true);
		serveraddress = new InetSocketAddress(ip, port);
	}

	public boolean connecttoserver() throws IOException {
		boolean result = false;
		socket.connect(serveraddress);
		result = true;
		new Thread(this).start();
		manager.setestablished();

		socket.configureBlocking(false);
		sk = socket.register(selector, 0);
		sk.interestOps(SelectionKey.OP_READ);
		selector.wakeup();

		return result;
	}

	public void run() {
		try {
			while (done) {
				logger.debug("selector is waitting  event....");
				selector.select();
				Set<SelectionKey> keys = selector.selectedKeys();
				if (keys.size() == 0) {
					logger.debug("nothing happened");
					continue;
				}

				for (SelectionKey key : keys) {
					if (key.isReadable()) {
						logger.debug("Readable event happened");
						readdata();
					} else if (key.isWritable()) {
						logger.debug("Writeable event happened");
					} else {
						logger.debug("others event happened");
					}
				}
				keys.clear();
			}
			logger.debug("thread exit");
		} catch (IOException ex) {
			logger.error(ex.getMessage());
		}
	}

	public void readdata() {
		try {
			read();
		} catch (IOException ex) {
			try {
				logger.debug("disconnection event happened");
				socket.close();
				synchronized (manager) {
					manager.setdisconnect();
					manager.notifyAll();
					done = false;
				}
			} catch (IOException e) {
				logger.error(e.getMessage());
			}
			sk.cancel();
		}

	}

	public void read() throws IOException {
		ByteBuffer input = ByteBuffer.allocate(1024 * 10000);
		socket.read(input);
		input.flip();
		sk.interestOps(SelectionKey.OP_READ);

		while (input.remaining() > 0) {
			if (bodylen < 0) {
				if (input.remaining() >= MESSAGE_LENGTH_HEAD) {
					input.get(head, 0, 4);
					bodylen = Util2Bytes.bytes2bigint(head);

				} else {
					break;
				}
			} else if (bodylen > 0) {
				if (input.remaining() >= bodylen) {

					byte[] body = new byte[bodylen];
					input.get(body, 0, bodylen);
					sequence++;
					byte[] headandbody = new byte[MESSAGE_LENGTH_HEAD + bodylen];
					System.arraycopy(head, 0, headandbody, 0, head.length);
					System.arraycopy(body, 0, headandbody, head.length,
							body.length);
					MsgBean message = new MsgBean(sequence, headandbody, socket);
					Process.getInstance().queue.put(message);
					bodylen = -1;

				} else {
					break;
				}
			} else if (bodylen == 0) {
				sequence++;
				byte[] headandbody = new byte[MESSAGE_LENGTH_HEAD + bodylen];
				System.arraycopy(head, 0, headandbody, 0, head.length);
				MsgBean message = new MsgBean(sequence, headandbody, socket);
				Process.getInstance().queue.put(message);
				bodylen = -1;
			}
		}
	}
}