Android 客户端Socket 实现及简单封装。

Socket,客户端实现。先下载SocketTools工具，以便测试。
第一次用，没有写到的，请指出。首先 建个类，然后写方法。。。。。。调皮了。。直接来

TCP UDP 连接

public class SocketClient {
    private static final Socket SOCKET=null;
    private static final DataInputStream dis=null;//输入
    private static final DataOutputStream dos=null;//输出
    private Timer heartBeatTimer;
    private TimerTask heartBeatTask;
    private SocketClient(){}
    private static SocketClient socketClient;
    private static DatagramSocket socketUdp=null;
    private static Socket socketTcp=null;
    //获取单例
    public static SocketClient getSingle(){
          if(socketClient==null){
              synchronized (SocketClient.class) {//加锁 多个进程使用
                  if(socketClient==null){//优化
                      socketClient=new SocketClient();
                  }
              }
          }
          return socketClient;
      }
         /**
          * 获取TCP连接
          * @param serverIp ：服务Ip地址
          * @param prot ：端口号
          * @param data ：data 要发送的数据
          * @param call ：CallBackSocket  接口
          */
       public void getTCPConnect(String serverIp,int prot,String data,CallBackSocketTCP call){
            //创建Socket"192.168.1.115",60000
            try {
                  socketTcp= new Socket(serverIp,prot);
                SocketUtil util=new SocketUtil(socketTcp);
                util.sendData(data);
                //获取输入流，并读取服务端的响应信息
                boolean b=true;
                while(b){
                    boolean ba=util.isConnect();
                    //把值给接口，这里的接口作用，就是传值的作用
                    call.isConnect(ba);
                    System.out.println("当前Soket是否连接："+ba);
                    String info =util.receiveData();
                    //同理
                    call.Receive(info);
                    System.out.println(" 服务器说："+info);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }   
        }
    /**
     * UDP连接，
     * @param port 端口号
     * @param data 通过UDP发送的数据
     */
       public void getUDPConnect(int port,String datas,CallBackSocketUDP call){
           try {
               /*
                 * 向服务器端发送数据
                 */
                // 1.定义服务器的地址、端口号、数据localhost
            InetAddress address = InetAddress.getByName("localhost");
//                port = 8800;
                  byte []  data = datas.getBytes();
                // 2.创建数据报，包含发送的数据信息
                DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
                // 3.创建DatagramSocket对象
                  socketUdp = new DatagramSocket();
                // 4.向服务器端发送数据报
                  socketUdp.send(packet);
                  boolean b=true;
                    while(b){
                         /*
                         * 接收服务器端响应的数据
                         */
                        // 1.创建数据报，用于接收服务器端响应的数据
                        byte[] data2 = new byte[1024];
                        DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
                        // 2.接收服务器响应的数据
                        socketUdp.receive(packet2);
                        // 3.读取数据
                        String reply = new String(data2, 0, packet2.getLength());

                        call.Receive(reply);//把发送的数据交给接口

                        System.out.println("我是客户端，服务器说：" + reply);
                        // 4.关闭资源
                    }
//              socketUdp.close();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
       }

 /**
  * 关闭 这里请教一个问题。 就是我关闭不了。为了实现长连接。怎么弄。
  */
    public  void closeSocket(){
        if(socketUdp!=null){
            socketUdp.close();
            System.out.println("关闭了UDP连接");
        }else if(socketTcp!=null){
            try {
                socketTcp.close();
                System.out.println("关闭了TCP连接");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            System.out.println("没有打开无须关闭！！");
        }
    }

在这里面。使用了两个接口。不要忘记添加了

//TCP
public interface CallBackSocketTCP {
    //这个回调用于获取服务端返回的数据
      void Receive(String info);
    //判断是否处在连接在状态
      void isConnect(boolean state);
}
//UDP
public interface CallBackSocketUDP {
    void isConnect(boolean state);//判断状态
    void Receive(String data); //接收服务端返回的数据
}
//对了，还有一个工具类
/**
 * 
 * @author jay chen
 *  Socket 工具类
 */
public class SocketUtil {
    Socket socket = null;

    public SocketUtil(Socket socket) {
        super();
        this.socket = socket;
    }

    //断开连接
    public void closeConnect(){
        try {
            socket.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //检测是否连接 如果断开就重连
    public boolean isConnect(){
        if(socket.isClosed()){//检测是否关闭状态
            //TODO 这个地方检测数 是断开，在这写重连的方法。

            return false;
        } 
        return true;
    }
    //发送数据
    public void sendData(String data) throws IOException {
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(data.getBytes());
    }

    //接收数据
    public String receiveData() throws IOException {
        InputStream inputStream = socket.getInputStream();
//        DataInputStream data=new DataInputStream(inputStream);
        byte[] buf = new byte[1024];
        int len = inputStream.read(buf);
        String text = new String(buf, 0, len);
        return text;
    }
}

最后就是调用了。

    public static void main(String[] args) {
//IP 请填写你们的本机地址         SocketClient.getSingle().getTCPConnect("192.168.00.00", 60000,"客户端 要发送的data", new CallBackSocketTCP() {
//              @Override
//              public void Receive(String info) {
//                  // TODO Auto-generated method stub
//                  System.out.println("服务端返回的数据:"+info);
//              
//              }
//              
//              @Override
//              public void isConnect(boolean state) {
//                  // TODO Auto-generated method stub
//                   if(state){
//                       System.out.println(state);
//                   }else{
//                       System.out.println("正在尝试重新连接socket"); 
//                   }
//              }
//              
//               
//          });

            SocketClient.getSingle().getUDPConnect(55555,"这是我要发送的数据",new CallBackSocketUDP() {

                @Override
                public void isConnect(boolean state) {//连接状态
                    // TODO Auto-generated method stub
                    System.out.println(state);
                }

                @Override
                public void Receive(String data) {//返回的数据
                    // TODO Auto-generated method stub
                    System.out.println(data);
                }
            });
            //关闭 socket
            SocketClient.getSingle().closeSocket();
        } 

打开SocketTool 开始测试吧。。