TCP和UDP通信

socket：用於描述IP地址和端口，是一個通信鏈的句柄。

ServerSocket：用於服務端。

原理：應用程序通過“套接字”向網絡發出請求或者應答網絡請求。

構造方法：Socket(String url,int port)

常用方法：

int getLocalPort()

InetAddress getLocalAddress()

使用InetAddress獲取本地的地址方法。

String getCanonicalHostNmae()

String getHostAddress()獲取IP地址

int getPort()通過Socket獲取服務器端的端口號

InetAddress getInetAddress()獲取服務器端地址

通過Socket獲取網絡輸入流和網絡輸出流：

InputStream getInputStream()

OutputStream getOutputStream()

close()

Server端：

ServerSocket server = new ServerSocket(8888);

Socket socket = server.accept()

public class Client {
    //客戶端Socket
    private Socket socket;
    /**
     * 構造方法，用於初始化
     */
    public Client(){
        try {
            socket = new Socket("localhost",8088);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 客戶端工作方法
     */
    public void start(){
        try {
            OutputStream out = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
            PrintWriter pw = new PrintWriter(osw,true);
            
            //創建Scanner讀取用戶輸入內容
            Scanner scanner = new Scanner(System.in);
            while(true){
                pw.println(scanner.nextLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    public static void main(String[] args) {
        Client client = new Client();
        client.start();
    }
}

/**
 * 服務端應用程序
 */
public class Server {
    //服務端Socket
    private ServerSocket serverSocket;
    /**
     * 構造方法，用於初始化
     */
    public Server(){
        try {
            serverSocket = new ServerSocket(8088);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 服務端開啓方法
     */
    public void start(){
        try {
            System.out.println("等待客戶端連接...");
            //監聽客戶端的連接
            Socket socket = serverSocket.accept();
            System.out.println("客戶端已連接!");
            InputStream in = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(in,"UTF-8");
            BufferedReader br = new BufferedReader(isr);
            
            //循環讀取客戶端發送的信息
            while(true){
                System.out.println("客戶端說:"+br.readLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }
}

多個客戶端連接：

/**
 * 服務端應用程序
*/
public class Server {
    // 服務端Socket
    private ServerSocket serverSocket;
    // 所有客戶端輸出流
    private List<PrintWriter> allOut;
    // 線程池
    private ExecutorService threadPool;
    /**
     * 構造方法，用於初始化
     */
    public Server() {
        try {
            serverSocket = new ServerSocket(8088);
            
            allOut = new ArrayList<PrintWriter>();
            
            threadPool = Executors.newFixedThreadPool(40);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 服務端開啓方法
     */
    public void start() {
        try {
            //循環監聽客戶端的連接
            while(true){
                System.out.println("等待客戶端連接...");
                // 監聽客戶端的連接
                Socket socket = serverSocket.accept();
                System.out.println("客戶端已連接!");
                
                //啓動一個線程來完成針對該客戶端的交互
                ClientHandler handler = new ClientHandler(socket);
                threadPool.execute(handler);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 將輸出流存入共享集合，與下面兩個方法互斥，保證同步安全
     * @param out
     */
    private synchronized void addOut(PrintWriter out){
        allOut.add(out);
    }
    /**
     * 將給定輸出流從共享集合刪除
     * @param out
     */
    private synchronized void removeOut(PrintWriter out){
        allOut.remove(out);
    }
    /**
     * 將消息轉發給所有客戶端
     * @param message
     */
    private synchronized void sendMessage(String message){
        for(PrintWriter o : allOut){
            o.println(message);
        }
    }
    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }
    /**
     * 線程體，用於併發處理不同客戶端的交互
     */
    private class ClientHandler implements Runnable {
        // 該線程用於處理的客戶端
        private Socket socket;
        public ClientHandler(Socket socket) {
            this.socket = socket;
        }
        @Override
        public void run() {
            PrintWriter pw = null;
            try {
                //將客戶端的輸出流存入共享集合，以便廣播消息
                OutputStream out = socket.getOutputStream();
                OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
                pw = new PrintWriter(osw,true);
                /*
                 * 將用戶信息存入共享集合
                 * 需要同步
                 */
                addOut(pw);                
                
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in, "UTF-8");
                BufferedReader br = new BufferedReader(isr);
                
                String message = null;
                // 循環讀取客戶端發送的信息
                while ((message = br.readLine())!=null) {
                    /*
                     * 遍歷所有輸出流，將該客戶端發送的信息轉發給所有客戶端
                     * 需要同步
                     */
                    sendMessage(message);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                /*
                 * 當客戶端斷線，要將輸出流從共享集合中刪除
                 * 需要同步
                 */
                removeOut(pw);
                
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

UDP通信：

接收包：DatagramPacket（byte[] buf, int length）

               DatagramPacket(byte[] buf ,int offset, int length)

發送包：

              Datagrampacket(byte[] buf, int length, InetAddress clientAddress, int clientPort)

              Datagrampacket(byte[] buf,int offset, int length, InetAddress clientAddress, int clientPort)

客戶端：

               DatagramSocket()

               send(DatagramPacket dp)

服務器端：

             DatagramSocket(int port)

              receive(DatagramPacket d)

例子：

public class Client {
    private void start() {
        try {
            DatagramSocket client = new DatagramSocket();
            String sendStr = "Hello! I'm Client";
            byte[] sendBuf;
            sendBuf = sendStr.getBytes();
            InetAddress addr = InetAddress.getByName("127.0.0.1");
            int port = 8088;
            DatagramPacket sendPacket = new DatagramPacket(sendBuf,
                    sendBuf.length, addr, port);
            client.send(sendPacket);
            byte[] recvBuf = new byte[100];
            DatagramPacket recvPacket = new DatagramPacket(recvBuf,    recvBuf.length);
            client.receive(recvPacket);
            String recvStr = new String(recvPacket.getData(), 0,
                    recvPacket.getLength());
            System.out.println("服務端說:" + recvStr);
            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        Client client = new Client();
        client.start();
    }
}


public class Server {
    public void start() {
        try {
            DatagramSocket server = new DatagramSocket(8088);
            byte[] recvBuf = new byte[100];
            DatagramPacket recvPacket = new DatagramPacket(recvBuf,
                    recvBuf.length);
            server.receive(recvPacket);
            String recvStr = new String(recvPacket.getData(), 0,
                    recvPacket.getLength());
            System.out.println("客戶端說:" + recvStr);
            int port = recvPacket.getPort();
            InetAddress addr = recvPacket.getAddress();
            String sendStr = "Hello ! I'm Server";
            byte[] sendBuf;
            sendBuf = sendStr.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(sendBuf,
                    sendBuf.length, addr, port);
            server.send(sendPacket);
            server.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
}
    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }
}