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();
    }
}