尚硅谷-JavaSE-拓展【网络编程】 - 《Java 尚学课堂笔记》

15.6 TCP网络编程
15.7 UDP网络编程

15.6 TCP网络编程

15.6.1 通信模型

Java语言的基于套接字TCP编程分为服务端编程和客户端编程，其通信模型如图所示：

尚硅谷-JavaSE-拓展【网络编程】 - 图1

15.6.2 开发步骤

1、服务器端

服务器程序的工作过程包含以下四个基本的步骤：

调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
调用 accept() ：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
调用该Socket 类对象的 getOutputStream() 和 getInputStream () ：获取输出流和输入流，开始网络数据的发送和接收。
关闭Socket 对象：客户端访问结束，关闭通信套接字。

2、客户端

客户端Socket 的工作过程包含以下四个基本的步骤：

创建 Socket ：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
打开连接到 Socket 的输入/ 出流：使用 getInputStream()方法获得输入流，使用getOutputStream()方法获得输出流，进行数据传输
按照一定的协议对 Socket 进行读/ 写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线路。
关闭 Socket ：断开客户端到服务器的连接，释放线路

15.6.3 相关API

ServerSocket类的构造方法：

ServerSocket(int port) ：创建绑定到特定端口的服务器套接字。

ServerSocket类的常用方法：

Socket accept()：侦听并接受到此套接字的连接。

Socket类的常用构造方法：

public Socket(InetAddress address,int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
public Socket(String host,int port)：创建一个流套接字并将其连接到指定主机上的指定端口号。

Socket类的常用方法：

public InputStream getInputStream()：返回此套接字的输入流，可以用于接收消息
public OutputStream getOutputStream()：返回此套接字的输出流，可以用于发送消息
public InetAddress getInetAddress()：此套接字连接到的远程 IP 地址；如果套接字是未连接的，则返回 null。
public InetAddress getLocalAddress()：获取套接字绑定的本地地址。
public int getPort()：此套接字连接到的远程端口号；如果尚未连接套接字，则返回 0。
public int getLocalPort()：返回此套接字绑定到的本地端口。如果尚未绑定套接字，则返回 -1。
public void close()：关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接或重新绑定）。需要创建新的套接字对象。关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。
public void shutdownInput()：如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将返回 EOF（文件结束符）。即不能在从此套接字的输入流中接收任何数据。
public void shutdownOutput()：禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException。即不能通过此套接字的输出流发送任何数据。

注意：先后调用Socket的shutdownInput()和shutdownOutput()方法，仅仅关闭了输入流和输出流，并不等于调用Socket的close()方法。在通信结束后，仍然要调用Scoket的close()方法，因为只有该方法才会释放Socket占用的资源，比如占用的本地端口号等。

15.6.4 示例一：单个客户端与服务器单次通信

需求：客户端连接服务器，连接成功后给服务发送“lalala”，服务器收到消息后，给客户端返回“欢迎登录”，客户端接收消息后，断开连接

客户端示例代码

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class Client {
    public static void main(String[] args) throws Exception {
        // 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1", 8888);
        // 2、获取输出流，用来发送数据给服务器
        OutputStream out = socket.getOutputStream();
        // 发送数据
        out.write("lalala".getBytes());
        //会在流末尾写入一个“流的末尾”标记，对方才能读到-1，否则对方的读取方法会一致阻塞
        socket.shutdownOutput();
        //3、获取输入流，用来接收服务器发送给该客户端的数据
        InputStream input = socket.getInputStream();
        // 接收数据
        byte[] data = new byte[1024];
        StringBuilder s = new StringBuilder();
        int len;
        while ((len = input.read(data)) != -1) {
            s.append(new String(data, 0, len));
        }
        System.out.println("服务器返回的消息是：" + s);
        //4、关闭socket，不再与服务器通信，即断开与服务器的连接
        //socket关闭，意味着InputStream和OutputStream也关闭了
        socket.close();
    }
}

服务器端示例代码

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
    public static void main(String[] args)throws Exception {
        //1、准备一个ServerSocket对象，并绑定8888端口
        ServerSocket server =  new ServerSocket(8888);
        System.out.println("等待连接....");
    //2、在8888端口监听客户端的连接，该方法是个阻塞的方法，如果没有客户端连接，将一直等待
        Socket socket = server.accept();
        System.out.println("一个客户端连接成功！！");
        //3、获取输入流，用来接收该客户端发送给服务器的数据
        InputStream input = socket.getInputStream();
        //接收数据
        byte[] data = new byte[1024];
        StringBuilder s = new StringBuilder();
        int len;
        while ((len = input.read(data)) != -1) {
            s.append(new String(data, 0, len));
        }
        System.out.println("客户端发送的消息是：" + s);
        //4、获取输出流，用来发送数据给该客户端
        OutputStream out = socket.getOutputStream();
        //发送数据
        out.write("欢迎登录".getBytes());
        out.flush();
        //5、关闭socket，不再与该客户端通信
        //socket关闭，意味着InputStream和OutputStream也关闭了
        socket.close();
        //6、如果不再接收任何客户端通信，可以关闭ServerSocket
        server.close();
    }
}

15.6.5 示例二：多个客户端与服务器之间的多次通信

通常情况下，服务器不应该只接受一个客户端请求，而应该不断地接受来自客户端的所有请求，所以Java程序通常会通过循环，不断地调用ServerSocket的accept()方法。

如果服务器端要“同时”处理多个客户端的请求，因此服务器端需要为每一个客户端单独分配一个线程来处理，否则无法实现“同时”。

咱们之前学习IO流的时候，提到过装饰者设计模式，该设计使得不管底层IO流是怎样的节点流：文件流也好，网络Socket产生的流也好，程序都可以将其包装成处理流，甚至可以多层包装，从而提供更多方便的处理。

案例需求：多个客户端连接服务器，并进行多次通信

每一个客户端连接成功后，从键盘输入英文单词或中国成语，并发送给服务器
服务器收到客户端的消息后，把词语“反转”后返回给客户端
客户端接收服务器返回的“词语”，打印显示
当客户端输入“stop”时断开与服务器的连接
多个客户端可以同时给服务器发送“词语”，服务器可以“同时”处理多个客户端的请求

尚硅谷-JavaSE-拓展【网络编程】 - 图2

客户端示例代码

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;
public class Client2 {
    public static void main(String[] args) throws Exception {
        // 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1", 8888);
        // 2、获取输出流，用来发送数据给服务器
        OutputStream out = socket.getOutputStream();
        PrintStream ps = new PrintStream(out);
        // 3、获取输入流，用来接收服务器发送给该客户端的数据
        InputStream input = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(input));
        Scanner scanner = new Scanner(System.in);
        while(true){
            System.out.println("输入发送给服务器的单词或成语：");
            String message = scanner.nextLine();
            if(message.equals("stop")){
                socket.shutdownOutput();
                break;
            }
            // 4、 发送数据
            ps.println(message);
            // 接收数据
            String feedback  = br.readLine();
            System.out.println("从服务器收到的反馈是：" + feedback);
        }
        //5、关闭socket，断开与服务器的连接
        scanner.close();
        socket.close();
    }
}

服务器端示例代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server2 {
    public static void main(String[] args) throws IOException {
        // 1、准备一个ServerSocket
        ServerSocket server = new ServerSocket(8888);
        System.out.println("等待连接...");
        int count = 0;
        while(true){
            // 2、监听一个客户端的连接
            Socket socket = server.accept();
            System.out.println("第" + ++count + "个客户端"+socket.getInetAddress().getHostAddress()+"连接成功！！");
            ClientHandlerThread ct = new ClientHandlerThread(socket);
            ct.start();
        }
        //这里没有关闭server，永远监听
    }
    static class ClientHandlerThread extends Thread{
        private Socket socket;
        public ClientHandlerThread(Socket socket) {
            super();
            this.socket = socket;
        }
        public void run(){
            try{
                //（1）获取输入流，用来接收该客户端发送给服务器的数据
                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                //（2）获取输出流，用来发送数据给该客户端
                PrintStream ps = new PrintStream(socket.getOutputStream());
                String str;
                // （3）接收数据
                while ((str = br.readLine()) != null) {
                    //（4）反转
                    StringBuilder word = new StringBuilder(str);
                    word.reverse();
                    //（5）返回给客户端
                    ps.println(word);
                }
                System.out.println(socket.getInetAddress().getHostAddress()+"正常退出");
            }catch(Exception  e){
                System.out.println(socket.getInetAddress().getHostAddress()+"意外退出");
            }finally{
                try {
                    //（6）断开连接
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

15.6.6 示例三：多个客户端上传文件

需求：每一个客户端启动后都可以给服务器上传一个文件；服务器接收到文件后保存到一个upload目录中，可以同时接收多个客户端的文件上传。

思考分析：

（1）服务器端要“同时”处理多个客户端的请求，那么必须使用多线程，每一个客户端的通信需要单独的线程来处理。

（2）服务器保存上传文件的目录只有一个upload，而每个客户端给服务器发送的文件可能重名，所以需要保证文件名的唯一。我们可以使用“时间戳”作为文件名，而后缀名不变

（3）客户端需要给服务器上传文件名（含后缀名）以及文件内容。而文件名是字符串，文件内容不一定是纯文本的，因此选择DataOutputStream和DataInputStream。

客户端示例代码

package com.atguigu.net;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
public class Client3 {
    public static void main(String[] args) throws Exception {
        // (1)连接服务器
        Socket socket = new Socket("127.0.0.1", 8888);
        Scanner input = new Scanner(System.in);
        // (2)从键盘输入文件的路径和名称
        System.out.print("请选择要上传的文件：");
        String path = input.nextLine();
        File file = new File(path);
        OutputStream out = socket.getOutputStream();
        // 用它的目的是为了既可以单独传一个字符串，又可以写字节内容
        DataOutputStream dos = new DataOutputStream(out);
        // 先发送文件名（含后缀名）
        dos.writeUTF(file.getName());// 单独发一个字符串
        // 还需要一个IO流，从文件读取内容，给服务器发过去
        FileInputStream fis = new FileInputStream(file);
        // （3）把文件内容给服务器传过去，类似与复制文件
        byte[] data = new byte[1024];
        while (true) {
            int len = fis.read(data);
            if (len == -1) {
                break;
            }
            dos.write(data, 0, len);
        }
        socket.shutdownOutput();//数据发送完毕，不再发送，但是还要接收，所以是半关闭
        // (4)接收服务器返回的结果
        InputStream is = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(is);// 把字节流转成字符流
        BufferedReader br = new BufferedReader(isr);
        String result = br.readLine();
        System.out.println(result);
        // (5)关闭
        fis.close();
        input.close();
        socket.close();
    }
}

服务器示例代码

package com.atguigu.net;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Server3 {
    public static void main(String[] args) throws Exception{
        //服务器在8888端口号监听数据
        @SuppressWarnings("resource")
        ServerSocket server = new ServerSocket(8888);
        while(true){
            //(2)等待连接 
            //这句代码执行一次，意味着一个客户端连接
            Socket accept = server.accept();
            FileUploadThread ft = new FileUploadThread(accept);
            ft.start();
        }
    }
    static class FileUploadThread extends Thread{
        private Socket socket;
        private String dir = "upload/";//可以把它放到配置文件中
        public FileUploadThread(Socket socket) {
            super();
            this.socket = socket;
        }
        public void run(){
            FileOutputStream fos = null;
            try {
                InputStream is = socket.getInputStream();
                DataInputStream dis = new DataInputStream(is);    
                //读取文件名（含后缀名）
                String filename = dis.readUTF();
                int lastIndexOfDot = filename.lastIndexOf(".");
                //截取后缀名
                String ext = filename.substring(lastIndexOfDot);
                //生成时间戳
                SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
                //拼接新文件名 = 旧文件名 + 时间戳 + 后缀名
                String newFilename = filename.substring(0,lastIndexOfDot) + sf.format(new Date()) + ext;
                //拼接文件路径
                String pathname = dir + File.separator + newFilename;
                //用新文件路径构建文件输出流
                fos = new FileOutputStream(pathname);
                //接收文件内容
                byte[] data = new byte[1024];
                while(true){
                    int len = is.read(data);
                    if(len==-1){
                        break;
                    }
                    fos.write(data, 0, len);
                }
                //返回结果
                OutputStream out = socket.getOutputStream();
                PrintStream ps = new PrintStream(out);
                ps.println(filename + "：已上传完毕");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    fos.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

15.6.7 示例四：群聊

需求：客户端与服务器连接成功后，就可以看到到其他客户端的发送的聊天信息，当前客户端也可以发送自己的聊天信息。

思考分析：

（1）服务器

要同时接收多个客户端的连接，因此需要多线程

服务器这边充当转发角色，即在服务器这边的某个客户端的Socket接收到自己客户端发送的消息后，要通过服务器端这边其他客户端的Socket将信息转发出去

（2）客户端

同时能够接收和发送消息，因此也要两个线程，一个接收，一个发送

客户端示例代码：

package com.atguigu.net;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
/*
 * 群聊
 */
public class Client4 {
    public static void main(String[] args) throws UnknownHostException, IOException {
        // 1、连接服务器
        Socket socket = new Socket("127.0.0.1", 9999);
        // 2、开启两个线程，一个收消息，一个发消息
        SendThread st = new SendThread(socket);
        ReceiveThread rt = new ReceiveThread(socket);
        st.start();
        rt.start();
        // 等发送线程停下来再往下走
        try {
            st.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 等接收线程停下来，再往下走，断开连接
        try {
            rt.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        socket.close();
    }
    static class SendThread extends Thread {
        private Socket socket;
        public SendThread(Socket socket) {
            super();
            this.socket = socket;
        }
        public void run() {
            try {
                // 键盘输入
                Scanner input = new Scanner(System.in);
                OutputStream out = socket.getOutputStream();
                PrintStream ps = new PrintStream(out);
                while (true) {
                    // 从键盘输入
                    System.out.print("请输入要发送的消息：");
                    String content = input.nextLine();
                    // 给服务器发送
                    ps.println(content);
                    // 如果bye，就结束发送
                    if ("bye".equals(content)) {
                        break;
                    }
                }
                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    static class ReceiveThread extends Thread {
        private Socket socket;
        public ReceiveThread(Socket socket) {
            super();
            this.socket = socket;
        }
        public void run() {
            try {
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in);
                BufferedReader br = new BufferedReader(isr);
                while (true) {
                    String line = br.readLine();
                    if("bye".equals(line)){
                        break;
                    }
                    System.out.println(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

服务器端示例代码：

package com.atguigu.net;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Iterator;
public class Server4 {
    private static ArrayList<Socket> online = new ArrayList<Socket>();
    public static void main(String[] args) throws IOException {
        //1、开启服务器
        ServerSocket server = new ServerSocket(9999);
        while(true){
            //2、接收客户端的连接
            Socket socket = server.accept();
            //把这个客户端加入到online中
            online.add(socket);
            //每一个客户端独立的线程
            MessageHandler mh = new MessageHandler(socket);
            mh.start();
        }
    }
    private static class MessageHandler extends Thread{
        private Socket socket;
        private String ip;
        public MessageHandler(Socket socket) {
            super();
            this.socket = socket;
            this.ip = socket.getInetAddress().getHostAddress();
        }
        public void run(){
            //这个客户端的一连接成功，线程一启动，就可以告诉其他人我上线了
            sendToOthers(ip+"上线了");
            //（1）接收当前的客户端发送的消息
            try {
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in);
                BufferedReader br = new BufferedReader(isr);
                String content;
                while((content = br.readLine()) !=null){
                    //收到一句，转发一句
                    sendToOthers(ip+"说:" + content);
                    if("bye".equals(content)){
                        //给自己发一句bye
                        OutputStream out = socket.getOutputStream();
                        PrintStream ps = new PrintStream(out);
                        ps.println("bye");
                        break;
                    }
                }
                sendToOthers(ip+"下线了");
            } catch (IOException e) {
                sendToOthers(ip+"掉线了");
            }
        }
        //因为转发的代码也很长，独立为一个方法
        public void sendToOthers(String str){
            //遍历所有online的客户端
            Iterator<Socket> iterator = online.iterator();
            while(iterator.hasNext()){
                Socket on = iterator.next();
                if(!on.equals(socket)){//只给其他客户端转发
                    try {
                        OutputStream out = on.getOutputStream();
                        PrintStream ps = new PrintStream(out);
                        ps.println(str);
                    } catch (IOException e) {
                        //说明on这个客户端要么下线了，要么掉线了
                        iterator.remove();
                    }
                }
            }
        }
    }
}

15.7 UDP网络编程

UDP(User Datagram Protocol，用户数据报协议)：是一个无连接的传输层协议、提供面向事务的简单不可靠的信息传送服务，类似于短信。

UDP协议是一种面向非连接的协议，面向非连接指的是在正式通信前不必与对方先建立连接，不管对方状态就直接发送，至于对方是否可以接收到这些数据内容，UDP协议无法控制，因此说，UDP协议是一种不可靠的协议。无连接的好处就是快，省内存空间和流量，因为维护连接需要创建大量的数据结构。UDP会尽最大努力交付数据，但不保证可靠交付，没有TCP的确认机制、重传机制，如果因为网络原因没有传送到对端，UDP也不会给应用层返回错误信息。

UDP协议是面向数据报文的信息传送服务。UDP在发送端没有缓冲区，对于应用层交付下来的报文在添加了首部之后就直接交付于ip层，不会进行合并，也不会进行拆分，而是一次交付一个完整的报文。比如我们要发送100个字节的报文，我们调用一次send()方法就会发送100字节，接收方也需要用receive()方法一次性接收100字节，不能使用循环每次获取10个字节，获取十次这样的做法。

UDP协议没有拥塞控制，所以当网络出现的拥塞不会导致主机发送数据的速率降低。虽然UDP的接收端有缓冲区，但是这个缓冲区只负责接收，并不会保证UDP报文的到达顺序是否和发送的顺序一致。因为网络传输的时候，由于网络拥塞的存在是很大的可能导致先发的报文比后发的报文晚到达。如果此时缓冲区满了，后面到达的报文将直接被丢弃。这个对实时应用来说很重要，比如：视频通话、直播等应用。

因此UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境，数据报大小限制在64K以下。

15.7.1 相关API

基于UDP协议的网络编程仍然需要在通信实例的两端各建立一个Socket，但这两个Socket之间并没有虚拟链路，这两个Socket只是发送、接收数据报的对象，Java提供了DatagramSocket对象作为基于UDP协议的Socket，使用DatagramPacket代表DatagramSocket发送、接收的数据报。

DatagramSocket 类的常用方法：

public DatagramSocket(int port)创建数据报套接字并将其绑定到本地主机上的指定端口。套接字将被绑定到通配符地址，IP 地址由内核来选择。
public DatagramSocket(int port,InetAddress laddr)创建数据报套接字，将其绑定到指定的本地地址。本地端口必须在 0 到 65535 之间（包括两者）。如果 IP 地址为 0.0.0.0，套接字将被绑定到通配符地址，IP 地址由内核选择。
public void close()关闭此数据报套接字。
public void send(DatagramPacket p)从此套接字发送数据报包。DatagramPacket 包含的信息指示：将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号。
public void receive(DatagramPacket p)从此套接字接收数据报包。当此方法返回时，DatagramPacket 的缓冲区填充了接收的数据。数据报包也包含发送方的 IP 地址和发送方机器上的端口号。此方法在接收到数据报前一直阻塞。数据报包对象的 length 字段包含所接收信息的长度。如果信息比包的长度长，该信息将被截短。

DatagramPacket类的常用方法：

public DatagramPacket(byte[] buf,int length)构造 DatagramPacket，用来接收长度为 length 的数据包。 length 参数必须小于等于 buf.length。
public DatagramPacket(byte[] buf,int length,InetAddress address,int port)构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。length 参数必须小于等于 buf.length。
public int getLength()返回将要发送或接收到的数据的长度。

15.7.2 示例代码

发送端：

package com.atguigu.udp;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.ArrayList;
public class Send {
    public static void main(String[] args)throws Exception {
//        1、建立发送端的DatagramSocket
        DatagramSocket ds = new DatagramSocket();
        //要发送的数据
        ArrayList<String> all = new ArrayList<String>();
        all.add("尚硅谷让天下没有难学的技术！");
        all.add("学高端前沿的IT技术来尚硅谷！");
        all.add("尚硅谷让你的梦想变得更具体！");
        all.add("尚硅谷让你的努力更有价值！");
        //接收方的IP地址
        InetAddress ip = InetAddress.getByName("127.0.0.1");
        //接收方的监听端口号
        int port = 9999;
         //发送多个数据报
        for (int i = 0; i < all.size(); i++) {
//            2、建立数据包DatagramPacket
            byte[] data = all.get(i).getBytes();
            DatagramPacket dp = new DatagramPacket(data, data.length, ip, port);
//            3、调用Socket的发送方法
            ds.send(dp);
        }
//        4、关闭Socket
        ds.close();
    }
}

接收端：

package com.atguigu.udp;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Receive {
    public static void main(String[] args) throws Exception {
//        1、建立接收端的DatagramSocket，需要指定本端的监听端口号
        DatagramSocket ds = new DatagramSocket(9999);
        //一直监听数据
        while(true){
    //        2、建立数据包DatagramPacket
            byte[] buffer = new byte[1024*64];
            DatagramPacket dp = new DatagramPacket(buffer , buffer.length);
    //        3、调用Socket的接收方法
            ds.receive(dp);
            //4、拆封数据
            String str = new String(buffer,0,dp.getLength());
            System.out.println(str);
        }
    }
}

15.7.3 多点广播

Datagram只允许数据报发送给指定的目标地址，而MulticastSocket可以将数据报以广播方式发送到数量不等的多个客户端。

IP协议为多点广播提供了这批特殊的IP地址，这些IP地址的范围是224.0.0.0至239.255.255.255。

MulticastSocket常用的方法：

MulticastSocket(int port) ：创建多播套接字并将其绑定到特定端口。创建一个MulticastSocket对象后，还需要将该MulticastSocket加入到指定的多点广播地址，如果结束也需要脱离多点广播地址。
void joinGroup(InetAddress mcastaddr) ：加入多播组。
void leaveGroup(InetAddress mcastaddr) ：离开多播组。
void setLoopbackMode(boolean disable) ：启用/禁用多播数据报的本地回送。true 表示禁用LoopbackMode。

案例：群聊

package com.atguigu.net;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.util.Scanner;
public class GuangBo {
    private volatile static boolean exit = false;
    private static Scanner input = new Scanner(System.in);
    public static void main(String[] args) throws IOException {
        MulticastSocket socket = new MulticastSocket(9999);
        InetAddress ip = InetAddress.getByName("230.0.0.1");
        socket.joinGroup(ip);
        socket.setLoopbackMode(false);
        SendThread s = new SendThread(socket, ip);
        ReceiveThread r = new ReceiveThread(socket);
        s.start();
        r.start();
        try {
            s.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        socket.close();
        input.close();
    }
    static class SendThread extends Thread {
        private MulticastSocket socket;
        private InetAddress ip;
        public SendThread(MulticastSocket socket, InetAddress ip) {
            super();
            this.socket = socket;
            this.ip = ip;
        }
        public void run() {
            try {
                while (!exit) {
                    System.out.print("输入广播消息：");
                    String message = input.nextLine();
                    if ("bye".equals(message)) {
                        exit = true;
                        break;
                    }
                    byte[] data = (socket.getInetAddress().getHostAddress() + ":" + message).getBytes();
                    DatagramPacket dp = new DatagramPacket(data, data.length, ip, 9999);
                    socket.send(dp);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    static class ReceiveThread extends Thread {
        private MulticastSocket socket;
        public ReceiveThread(MulticastSocket socket) {
            super();
            this.socket = socket;
        }
        public void run() {
            try {
                while (!exit) {
                    byte[] data = new byte[1024];
                    DatagramPacket dp = new DatagramPacket(data, data.length);
                    socket.receive(dp);
                    String str = new String(data, 0, dp.getLength());
                    System.out.println(str);
                }
            } catch (IOException e) {
                exit = false;
            }
        }
    }
}