自己写了个连接socket服务的功能，连接成功后向服务发送数据并接收数据

1、ConnectToServerByTcp 这个方法是连接socket服务的

// 直接上代码

public static Socket ConnectToServerByTcp(String serverIp, int serverPort, int timeOutSecond,
   int connectCS) {
  // 建立通讯连接
  Socket otherSocket = null;
  boolean connectOk = false;
  try {
   // 创建一个流套接字并将其连接到指定主机上的指定端口号
   otherSocket = new Socket();
   System.out.println("serverIp " + serverIp + ", serverPort" + serverPort);
   SocketAddress socketAddress = new InetSocketAddress(serverIp, serverPort);
   // 接收超时限制在5到180秒，连接超时限制在5秒
   timeOutSecond = (timeOutSecond < 1 || timeOutSecond > 180) ? 1 : timeOutSecond;
   for (int i = 0; i < connectCS; i++) {
    try {
     otherSocket.connect(socketAddress, 5000); // 连接超时限制在5秒
     otherSocket.setSoTimeout(1000 * timeOutSecond);//设置读操作超时时间5到180秒
     connectOk = true;
     break;
    } catch (Exception e1) {
     log.error(e1);
    }
   }
   if (!connectOk) {
    if (otherSocket != null)
     otherSocket.close();
    otherSocket = null;
   }
   return otherSocket;
  } catch (Exception e) {
   log.error(e);
   e.printStackTrace();
  }
  return otherSocket;

 }

2、上一步的连接成功后，返回的Socket传给下边这个方法，并且加上你与服务器的交互数据。socketS 是连接的对象，bufS是要发送给服务器的数据，bufR 是服务器返回给的数据

public static void SockSend(Socket socketS, Buf bufS,Buf bufR) throws PosException {
     // 发送网络数据
  boolean oK = false;
  String sErr = "";
  DataOutputStream out = null;
  try {
   if (bufS.get_dataLen() < 1)
    sErr = "数据长度[" + bufS.get_dataLen() + "]无效";
   // 向服务器端发送数据
   out = new DataOutputStream(socketS.getOutputStream());
   out.write(bufS.get_dataBuf(), 0, bufS.get_dataLen());
   //Thread.sleep(200);
   out.flush();
   oK = true;
   //关闭客户端的输出流。相当于给流中加入一个结束标记-1.这个样子服务器的输入流的reaLine方法就会读到一个-1，然后结束readLIne方法
   socketS.shutdownOutput();
  } catch (Exception e) {
   log.error(e);
   oK = false;
   sErr = e.toString();
   e.printStackTrace();
  }
  if (!oK)
   throw new PosException("", "发送银行数据异常", sErr);
  
  // 接收报文
  int getLen = 0;
  InputStream inputStream = null;
  DataInputStream bs = null;
  try {
   inputStream = socketS.getInputStream();
   bs = new DataInputStream(inputStream);
   bufR.set_dataLen(0);
   byte[] data = new byte[4096];
   getLen = bs.read(data);
   bufR.set_bufLen(getLen);
   log.info("TcpReadLen======" + getLen);
   if (getLen > 1) {
    System.arraycopy(data, 0, bufR.get_dataBuf(), 0, getLen);


    bufR.set_dataLen(getLen);
    log.info("TcpReceiveMsg======" + ByteUtils.getString(bufR.get_dataBuf()));
   } else {
    sErr = "接收数据失败:实收长度[" + getLen + "]无效";
    getLen = 0;
    bufR.set_dataLen(0);
   }
   bs.close();
   inputStream.close();
   socketS.close();
   log.info("-------主动断开socket通讯 ");
  } catch (IOException e2) {
   log.error(e2);
   e2.printStackTrace();
  }
  if (getLen < 2) {
   throw new PosException("", "接收数据失败", sErr);
  }
 }

3，Buf实体类

/**
 * 封装处理过的数据缓冲类
 *
 */
public class Buf{
 /**
  * 缓冲区长度  4*1024 固定長度
  */
 protected int _bufLen = 0;
 /**
  * 数据长度   
  */
 protected int _dataLen = 0;
    /**
     * Byte类型缓冲数组
     */
 protected byte[] _dataBuf = null;
 
    public int get_bufLen() {
  return _bufLen;
 }

 public void set_bufLen(int _bufLen) {
  //数据缓冲区长度无效时，不作任何操作
  if (_bufLen > this._bufLen && _bufLen > 0){
   //数据缓冲区长度不能小于64个字节
   if (_bufLen > 64) {
    this._bufLen = _bufLen;
   } else {
    this._bufLen = 64;
   }
   //当数据缓冲区内有数据时，复制元数据到新的据缓数冲
   if (_dataLen > 0){
    byte[] bufOld = new byte[_dataLen + 1];
    System.arraycopy(_dataBuf, 0, bufOld, 0, _dataLen);
    _dataBuf = new byte[this._bufLen + 1];
    System.arraycopy(bufOld, 0, _dataBuf, 0, _dataLen);
    _dataBuf[_dataLen] = 0x0;
   } else {
    _dataBuf = new byte[this._bufLen + 1];
   }
  }
 }
 
 /**
  * 数据长度   
  */
    public int get_dataLen() {
  return _dataLen;
 }

 public void set_dataLen(int _dataLen) {
  if (_dataLen >= 0) {
   this._dataLen = _dataLen;
  } else {
   this._dataLen = 0;
  }
  if (this._dataLen > _bufLen)
   {
   this._dataLen = _bufLen;
  }
 }
 /// <summary>
    /// 缓冲区
    /// </summary>
 public byte[] get_dataBuf() {
  return _dataBuf;
 }

 public void set_dataBuf(byte[] _dataBuf) {
  this._dataBuf = _dataBuf;
 }
    /// <summary>
    /// 构造方法    
    /// 设置缓冲区长度为64，数据长度为0
    /// </summary>
 public Buf(){
  _bufLen = 64;
  _dataLen = 0;
 }

    /// <summary>
    /// 构造方法    
    /// 设置缓冲区长度为指定长度，数据长度为0
    /// </summary>
    /// <param name="bufLen">缓冲区长度</param>
 public Buf(int bufLen){
  _bufLen = bufLen;
  _dataLen = 0;
 }

}

3、模拟测试接收数据正常，OK