netio.java

这是我们专业的课程设计

package Commen;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.ByteBuffer;

public class NetIO {
	private InputStream reader;
	private OutputStream writer;
	private BufferStream readBuffer;

	public NetIO(Socket socket) {
		try {
			reader = socket.getInputStream();
			writer = socket.getOutputStream();
			readBuffer = new BufferStream(65536);
		} catch (Exception ex) {
			System.out.println(ex);
		}
	}

	public boolean CanRead() {
		boolean ret = false;
		try {
			ret = reader.available() != 0;
		} catch (Exception ex) {
			System.out.println(ex);
		}
		return ret;
	}

	public String ReadString() {
		byte[] temp = ReadBytes();
		return new String(temp);
	}

	public byte[] ReadBytes() {
		try {
			byte[] head = new byte[4];
			byte[] ret;
			synchronized (reader) {
				reader.read(head, 0, 4);
				int length = BytesToInt(head);
				// System.out.println(length);
				ret = new byte[length];
				reader.read(ret, 0, length);
			}
			return ret;
		} catch (Exception ex) {
			System.out.println(ex);
			return null;
		}
	}

	public void WriteStream(byte[] data) {
		if (data == null)
			return;
		try {
			ByteBuffer byteBuffer = ByteBuffer.wrap(data);
			byte[] buffer = new byte[1024];
			int length;
			synchronized (writer) {
				while (byteBuffer.remaining() > 0) {
					length = byteBuffer.remaining() > buffer.length ? buffer.length
							: byteBuffer.remaining();
					byteBuffer.get(buffer, 0, length);
					writer.write(buffer, 0, length);
				}
			}
		} catch (Exception ex) {
			System.out.println(ex);
		}
	}

	public byte[] ReadStream() {
		try {
			int count;
			byte[] buffer = new byte[1024];
			synchronized (reader) {
				while (CanRead()) {
					count = reader.read(buffer, 0, buffer.length);
					readBuffer.puts(buffer, 0, count);
				}
			}
			return readBuffer.gets();
		} catch (Exception ex) {
			ex.printStackTrace();
			return null;
		}
	}

	public void WriteString(String str) {
		byte[] buffer = str.getBytes();
		WriteBytes(buffer);

	}

	public void WriteBytes(byte[] data) {
		if (data == null)
			return;
		try {
			int length = data.length;
			byte[] head = IntToBytes(length);
			ByteBuffer buffer = ByteBuffer.allocate(data.length + head.length);
			buffer.put(head);
			buffer.put(data);
			synchronized (writer) {
				writer.write(buffer.array());
			}
		} catch (Exception ex) {
			System.out.println(ex + "xxxx");
			ex.printStackTrace();
		}
	}

	public void Close() {
		try {
			writer.close();
			reader.close();
		} catch (Exception ex) {
			System.out.println(ex);
		}
	}

	private byte[] IntToBytes(int i) {
		byte[] ret = new byte[4];
		int rest = i;
		ret[0] = (byte) ((rest / (255 * 255 * 255)) - 128);
		rest = rest - (ret[0] + 128) * (255 * 255 * 255);
		ret[1] = (byte) ((rest / (255 * 255)) - 128);
		rest = rest - (ret[1] + 128) * (255 * 255);
		ret[2] = (byte) ((rest / (255)) - 128);
		rest = rest - (ret[2] + 128) * (255);
		ret[3] = (byte) (rest - 128);
		return ret;
	}

	private int BytesToInt(byte[] b) {
		int ret = 0;
		ret = ret + (b[0] + 128) * (255 * 255 * 255);
		ret = ret + (b[1] + 128) * (255 * 255);
		ret = ret + (b[2] + 128) * (255);
		ret = ret + (b[3] + 128);
		return ret;
	}
}