一个Socket通讯工具类

我在开发过程中自己写的程序代码，放这里供初学者大家参考，希望大家提出宝贵的意见：
package com.cc.pub;

import java.net.*;
import java.io.*;

/**
* Agent 、Client 的连接请求
*/
public class TcpConnector{

    private static final int DEF_TIME_OUT=30000;//缺省的超时时间
    private static final int DEF_WAT=32; //每次 sleep 时间(ms)

    private int    iMaxTime=0; //超时时间(ms);

    private Socket socket; //连接

    private java.io.DataInputStream in=null;   //从 Socket 中取得的数据输入流
    private java.io.DataOutputStream out=null; //从 Socket 中取得的数据输出流
    private String ip="";     //IP 地址
    private int iLocalPort=0;
    private int iRemotePort=0;

    public TcpConnector(Socket s){
        setTimeOut(DEF_TIME_OUT); //30 s
        socket=s;
        init();
    }

    public Socket getSocket(){
        return socket;
    }

    public String toString(){
        if(socket==null){
            return "Closed-Connect!";
        }
        return socket.toString();
    }

    public void setTimeOut(int i){
        iMaxTime=i;
    }

    public int getTimeOut(){
        return iMaxTime;
    }

    public int getLocalPort(){
        return iLocalPort;
    }

    public int getRemotePort(){
        return iRemotePort;
    }

    public boolean init(){
        if(in!=null) return true;
        boolean b=false;
        try{
            in  = new DataInputStream(socket.getInputStream());
            out = new DataOutputStream(socket.getOutputStream());
            InetAddress ia=socket.getInetAddress();
            ip = ia.getHostAddress();
            iLocalPort=socket.getLocalPort();
            iRemotePort=socket.getPort();
            b=true;
        }catch(Exception e){
            e.printStackTrace();
        }

        return b;
    }

    public String getIP(){
        return ip;
    }

    /**
     * 取得可以从输入流读取的字节数
     * 如果 -1 表示连接流出现问题
     */
    synchronized public int available(){
        if(socket==null){
            return -1;
        }
        int iLen=-1;
        try{
            iLen=in.available();
        }catch(Exception e){
            //e.printStackTrace();
        }
        return iLen;
    }

    /**
     * 从输入流读取指定字节长度的数据
     * @param iLen  数据长度
     * @return  读取的字节, 如为 null 表示读取过程可能发生异常
     */
    public byte[] read(int iLen){

        if(iLen<1) return null;
        byte []b=new byte[iLen];
        int iRead=read(b,0,iLen);

        if(iRead<1) return null;

        if(iRead<iLen){
            byte []br=new byte[iRead];
            System.arraycopy(b,0,br,0,iRead);
            return br;
        }
        return b;
    }

    /**
     * 从输入流读取指定字节长度的数据
     * @param b 数据 buffer
     * @param iFrom 存放数据起点
     * @param iLen  读取数据长度
     * @return  >=0 取得的数据字节数, -1 错误
     */
    synchronized public int read(byte []b,int iFrom,int iLen)
    {
        if(socket==null){
            return -1;
        }

        if(b==null || iLen<1 || iFrom<0 || b.length<iFrom+iLen){
            return 0;
        }

        int iGot=0;
        int iRead=0;
        int iTry=0;

        try{
            while( iRead<iLen && iGot>=0 && ( getTimeOut()>0 && iTry<getTimeOut() ) ){
                if(available()<0){
                    break;
                }
                iGot=0;
                if(available()>0){
                    iGot=in.read(b,iFrom+iRead,iLen-iRead);
                    if(iGot>0){
                       iRead+=iGot;
                    }
                }
                if(iGot==0){
                    try{
                        Thread.sleep(DEF_WAT);
                        iTry+=DEF_WAT;
                    }catch(Exception ee){}
                }else{
                    iTry+=1;
                }
            }
            return iRead;
        }catch(Exception e){
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 写数据到输出流
     * @param b 数据
     * @param iFrom 起始位置
     * @param iLen  数据长度
     * @return 0 写成功, -1 失败, 1 参数错误
     */
    synchronized public int write(byte[] b,int iFrom,int iLen){

        if(socket==null){
            System.out.print("---------null scoket--------");
            return -1;
        }
        try{
            if(b!=null && iFrom>=0 && iFrom+iLen<=b.length){
                out.write(b,iFrom,iLen);
                out.flush();
                return 0;
            }else{
                return 1;
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 写数据到输出流
     */
    public int write(byte[] b){
        return write(b,0,b.length);
    }

    public void close(){
        try{
            in.close();
        }catch(Exception e){
            //e.printStackTrace();
        }
        try{
            out.close();
        }catch(Exception e){
            //e.printStackTrace();
        }
        try{
            socket.close();
        }catch(Exception e){
            //e.printStackTrace();
        }
        socket=null;
    }　
}


有了上面的类，那么通讯会变得简单些，如：

Socket s=new Scoket(ip,port);
TcpConnector t=new TcpConnector();
byte []b="hello".getBytes();
t.write(b,0,b.length);
int len=t.read(b,0,1);//读取1个字节
//在读的方法中如果读不到数据，程序会 sleep 后再读，尽量的读到延时的数据,如果有更好的办法，请留言，谢谢！