socket简单用例

　　Socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket，一个Socket由一个IP地址和一个端口号唯一确定。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 Socket是TCP/IP协议的一个十分流行的编程界面，但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

 

　　Socket通讯过程：服务端监听某个端口是否有连接请求，客户端向服务端发送连接请求，服务端收到连接请求向客户端发出接收消息，这样一个连接就建立起来了。客户端和服务端都可以相互发送消息与对方进行通讯。

 

　　Socket的基本工作过程包含以下四个步骤：

　　1、创建Socket；

　　2、打开连接到Socket的输入输出流；

　　3、按照一定的协议对Socket进行读写操作；

　　4、关闭Socket。

　　

　　以下是socket简单用例，包含客户端/服务器端实现。

package com.huatech.socket.constant;
/**
 * socket常量类
 * @author lh
 * @since 2017-06-04
 * @version 1.0
 *
 */
public final class SocketConstant {
	
	/**
	 * socket host
	 */
	public static final String HOST = "127.0.0.1";	
	
	/**
	 * socket port
	 */
	public static final int PORT = 2017;
	
	/**
	 * socket charset
	 */
	public static final String CHARSET = "gb2312";
	
	/**
	 * socket timeout 
	 */
	public static final int TIMEOUT = 5 * 1000;
	
	/**
	 * socket 头部长度字节数
	 */
	public static final int HEADER_LEN = 4;
	/**
	 * socket 头部长度格式
	 */
	public static final String  HEADER_LEN_FORMAT = "%04d";
	
	

}

 

package com.huatech.socket.client;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

import com.huatech.socket.constant.SocketConstant;

/**
 * tcp/ip工具
 * @author lh
 */
public class TcpClient {
	
	
	Socket sock = null;

	/**
	 * 默认构造函数
	 */
	public TcpClient() {
	
	}

	/**
	 * 关闭socket通讯
	 * 
	 * @return
	 */
	public void close() {
		try {
			if (sock != null) {
				sock.close();
				sock = null;
			}
		} catch (Exception e) {
		}
	}

	/**
	 * 建立socket连接
	 * 
	 * @param addr
	 *            socket服务器地址
	 * @param port
	 *            socket服务器端口
	 * @return
	 */
	public void call(String host, int port) throws Exception {
		try {
			sock = new Socket(host, port);
			sock.setSoTimeout(SocketConstant.TIMEOUT);
		} catch (Exception e) {
			//logger.error("TCP_ERROR:通讯失败,原因{}",e);
			throw new RuntimeException("TCP_ERROR:通讯失败,请检查请求地址及端口号");
		}
	}

	/**
	 * 发送包文，在报头存在的情况下，先发送报头数据，再发送报文长度数据<br>
	 * 报文长度的格式采用网络字节序，这里的实际长度以short限制为最大值(2字节)
	 * @param str
	 *            发送的包文内容,byte数组形式
	 * @return void - 无返回
	 */
	public void sendMsg(byte[] b) throws RuntimeException {
		try {
			OutputStream out = sock.getOutputStream();
			String sLen = String.format(SocketConstant.HEADER_LEN_FORMAT, b.length);
			out.write(sLen.getBytes(SocketConstant.CHARSET));
			out.write(b);
			out.flush();
		} catch (IOException e) {
			//logger.error("TCP_ERROR:发包失败{}",e);
			throw new RuntimeException("TCP_ERROR:发包失败");
		}
	}

	/**
	 * 接收应答包文，如果有报头，先读取报头，再读取长度部分<br>
	 * 报文长度的格式采用网络字节序，这里的实际长度以short限制为最大值(2字节)
	 * 
	 * @return byte[] - 收到的包文内容
	 */
	public byte[] recvMsg() {
		String recv = "";
		int tmpLen = 0;
		try {
			InputStream in = sock.getInputStream();
			byte[] bts = new byte[SocketConstant.HEADER_LEN];
			in.read(bts); // 获取包长

			String strLen = new String(bts);
			int len = Integer.parseInt(strLen);

			byte[] buf = new byte[len];
			while (true) {
				int iLen = in.read(buf); // 接收包体
				tmpLen += iLen;
				if (iLen == -1)
					break;
				byte[] tmp = new byte[iLen];
				System.arraycopy(buf, 0, tmp, 0, iLen);
				recv += new String(tmp, SocketConstant.CHARSET);
				if (tmpLen >= len)
					break;
			}
			return recv.getBytes();
		} catch (Exception e) {
			// logger.error("TCP_ERROR:接收数据超时{}",e);
			throw new RuntimeException("TCP_ERROR:接收数据超时");
		}
	}
	
	/**
	 * 发送请求
	 * @param host
	 * @param port
	 * @param data
	 * @return
	 */
	public String doSubmit(String host,int port,String data){
		TcpClient tcpClient = new TcpClient();
		try{
			//连接服务器
			tcpClient.call(host, port);
			//发送消息内容
			System.out.println("请求的报文: "+data);
			//logger.info("请求的data:{}",data);
			tcpClient.sendMsg(data.getBytes(SocketConstant.CHARSET));
			//发送完毕后接收
			byte[] resBytes = tcpClient.recvMsg();
			String result = new String(resBytes);
			//logger.info("返回的result:{}",result);
			System.out.println("返回的报文: "+result);
			return result;
		} catch (Exception e){
			//logger.error("bank通信异常：", e);
			throw new RuntimeException("通信异常");
		} finally{
			tcpClient.close();
		}
	}

}

 

package com.huatech.socket.server;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

import com.huatech.socket.constant.SocketConstant;
/**
 * TcpServer
 * @author lh
 *
 */
public class TcpServer {

	public void start(int port) {
		try {
			// 创建一个ServerSocket在 port 端口监听客户请求
			@SuppressWarnings("resource")
			ServerSocket serverSocket = new ServerSocket(port);
			while (true) {
				// 侦听并接受到此Socket的连接,请求到来则产生一个Socket对象，并继续执行
				Socket socket = serverSocket.accept();

				/** 获取客户端传来的信息 */
				// 由Socket对象得到输入流，并构造相应的BufferedReader对象
				recvMsg(socket);

				//发送报文
				sendMsg(socket, "hello Client, I am Server!".getBytes());
				
				socket.close();
			}
		} catch (Exception e) {
			System.out.println("Exception:" + e);
		} finally {
			// serverSocket.close();
		}
	}

	/**
	 * 发送包文，在报头存在的情况下，先发送报头数据，再发送报文长度数据<br>
	 * 报文长度的格式采用网络字节序，这里的实际长度以short限制为最大值(2字节)
	 * 
	 * @param str
	 *            发送的包文内容,byte数组形式
	 * @return void - 无返回
	 */
	public void sendMsg(Socket sock, byte[] b) throws RuntimeException {
		try {
			OutputStream out = sock.getOutputStream();
			String sLen = String.format(SocketConstant.HEADER_LEN_FORMAT, b.length);
			out.write(sLen.getBytes(SocketConstant.CHARSET));
			out.write(b);
			out.flush();
		} catch (IOException e) {
			// logger.error("TCP_ERROR:发包失败{}",e);
			throw new RuntimeException("TCP_ERROR:发包失败");
		}
	}

	/**
	 * 接收应答包文，如果有报头，先读取报头，再读取长度部分<br>
	 * 报文长度的格式采用网络字节序，这里的实际长度以short限制为最大值(2字节)
	 * 
	 * @return byte[] - 收到的包文内容
	 */
	public void recvMsg(Socket sock) {
		try {
			InputStream in = sock.getInputStream();
         	byte[] bts = new byte[SocketConstant.HEADER_LEN];
     		in.read(bts); // 获取包长
     		String strLen = new String(bts);
     		int len = Integer.parseInt(strLen);		
     		byte[] buf = new byte[len];
     		in.read(buf);
     		String recv = new String(buf, SocketConstant.CHARSET);
     		System.out.println("客户端报文 : " + recv);
		} catch (Exception e) {
			// logger.error("TCP_ERROR:接收数据超时{}",e);
			throw new RuntimeException("TCP_ERROR:接收数据超时");
		}
	}

}

 

package com.huatech.socket;

import com.huatech.socket.client.TcpClient;
import com.huatech.socket.constant.SocketConstant;

public class SocketClientTest {
	
	public static void main(String[] args) {
				
		TcpClient client = new TcpClient();		
		client.doSubmit(SocketConstant.HOST, SocketConstant.PORT, "hello, i am client!");
		
	}

}

 

package com.huatech.socket;

import com.huatech.socket.constant.SocketConstant;
import com.huatech.socket.server.TcpServer;

public class SocketServerTest {
	
	public static void main(String[] args) {
		
		new TcpServer().start(SocketConstant.PORT);
		
	}

}

 

　　附件为demo工程