如何使用Java完成Socket通信

import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
    服务器端
 */
public class SocketTCP_Server {
    public static void main(String[] args) throws Exception {
        //思路
        //1. 在本机 的9999端口监听, 等待连接
        //   细节: 要求在本机没有其它服务在监听9999
        //   细节：这个 ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务器段，监听9999端口，等待连接");
        //2. 当没有客户端连接9999端口时，程序会 阻塞, 等待连接
        //   如果有客户端连接，则会返回Socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务器端 socket = " + socket.getClass());
        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
        //4. IO读取
        byte[] buf = new byte[1024];
        int readLine = 0;
        while ((readLine = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, readLine));
        }
        //5.关闭IO流和socket
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
 * 客户端
 */
public class SocketTCP_Client {
    public static void main(String[] args) throws Exception {
        //1. 连接服务端 (ip , 端口）
        //解读:连接本机的 9999端口, 如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket = " + socket.getClass());
        //2. 连接上后，生成Socket, 通过socket.getOutputStream()
        //得到和 socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3. 通过输出流，写入数据到 数据通道
        outputStream.write("Hello,server".getBytes());
        //4. 关闭流对象和socket, 必须关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

    /**
     * 建立服务端
     *
     * @param sp 建立服务端的通信端口
     */
    private static void StartServer(int sp) {
        try {
            serverSocket = new ServerSocket(sp);   //服务端使用ServerSocket建立
            System.out.println("Server started at:" + InetAddress.getLocalHost());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        new Thread(){
            @Override
            public void run() {
                while (SERVER_ENABLE) { //循环监听
                    try {
                        s = serverSocket.accept(); //在有客户端连入之前，while循环将一直卡在这里
                        new MasterServerThread(s).start(); //客户端连接成功后，开启一个自定义的服务器线程
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

    /**
     * 服务器主线程
     */
    private static class MasterServerThread extends Thread {
        Socket masterSocket = null; //传入的客户端Socket
        String socketKind = null;
        //构造方法，在实例化本Class时要求传入客户端的socket
        public MasterServerThread(Socket s) {
            this.masterSocket = s;
        }
        @Override
        public void run() {
            BufferedReader bre = null;
            try {
                bre = new BufferedReader(new InputStreamReader(masterSocket.getInputStream(), "utf-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                while ((socketKind = bre.readLine()) != null) { //接收读取传输过来的数据 
                    //根据发过来的数据是什么，决定进行指定操作        
                     if (socketKind.contains(LOGIN_REQUEST)) {//TODO 处理登陆请求操作
                           //......
                     } else if (socketKind.contains(OPERATION_OF_BINDING_DEVICE)) {//TODO 处理设备绑定
                           //......
                     }                 
                }
            } catch (Exception e) {
                //e.printStackTrace();
            }
        }
    }

/**
*    SERVER_IP : String型
*  SERVER_PORT ：int型
*/
Socket socket = new Socket(SERVER_IP, SERVER_PORT); //服务端用的ServerSocket，客户端对应的是使用Socket
ClientThread ct = new ClientThread(socket);  //同样开启客户端线程，与服务器通信用
ct.start();
 

    /**
     * Class : ClientThread
     * 与服务端线程class十分相像
     */
    private class ClientThread extends Thread {
        Socket cSocket;
        BufferedReader br;
        public ClientThread(Socket s) {
            this.cSocket = s;
        }
        @Override
        public void run() {
            try {
                br = new BufferedReader(new InputStreamReader(cSocket.getInputStream(), "UTF-8"));
                while ((temp = br.readLine()) != null) {
                    //Do Something...
                   }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }

 /**
     * 发送登陆信息
     * @param id 用户ID
     * @param pwd 账号密码
     */
    private void sendLoginMsg(final String id, final String pwd) {
        new Thread() {
            @Override
            public void run() {
                try {
                    PrintWriter printWriter = new PrintWriter(socket.getOutputStream());
                    printWriter.println(LOGIN_REQUEST + "CONNECTION_FROM_APP" + "_" + id + "$" + pwd + "&");
                    printWriter.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }