【JAVA学习笔记】 68 - 网络—

项目代码

https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter21/src

网络

一、网络相关概念

1.网络通讯

1.概念:两台设备之间通过网络实现数据传输

2.网络通信:将数据通过网络从一台设备传输到另一台设备

3. java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信

2.网络

概念:两台或多台设备通过一定物理设备连接起来构成了网络

2.根据网络的覆盖范围不同，对网络

进行分类:

局域网:覆盖范围最小，仅仅覆盖一个教室或一个机房

城域网:覆盖范围较大，可以覆盖个城市

广域网:覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

3.IP地址

1.概念:用于唯一标识网络中的每台计算机/主机

2.查看ip地址: ipconfig

3. ip地址的表示形式:点分十进制xx.xxx.xx

4.每一个十进制数的范围: 0~255

5. ip地址的组成=网络地址+主机地址，比如: 192.168.16.69

对于IPV4：4个字节(32位)表示 1个字节的范围是0~255

6. iIPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址。使用16机制表示

7.由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联的障碍

4.域名

1. www.baidu.com

2.好处:为了方便记忆，解决记ip的困难

3.概念:将ip地址映射成域名

5.端口号

1.概念:用于标识计算机上某个特定的网络程序

2.表示形式:以整数形式，范围0~ 65535 （两个字节表示）

3.0~1024已经被占用，比如ssh 22, ftp 21, smtp 25 http 80

在网络开发中，不要使用0 - 1024的端口

4.常见的网络程序端口号:

tomcat :8080

mysql:3306

oracle:1521

sqlserver:1433

6.网络通讯协议

TCP/IP (Transmission Control Protocol/Internet Protocol)的简写，

中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。

TCP协议:传输控制协议

1.使用TCP协议前，须先建立TCP连接，形成传输数据通道

2.传输前，采用"三次握手"方式，是可靠的

3. TCP协议进行通信的两个应用进程:客户端、服务端

4.在连接中可进行大数据量的传输

5.传输完毕，需释放已建立的连接，效率低

UDP协议:

1.将数据、源、目的封装成数据包，不需要建立连接

2.每个数据报的大小限制在64K内，不适合传输大量数据

3.因无需连接，故是不可靠的

4.发送数据结束时无需释放资源(因为不是面向连接的)，速度快

5.举例:厕所通知

二、InetAddress类

1.相关方法

1.获取本机InetAddress对象getL ocalHost

2.根据指定主机名/域名获取ip地址对象getByName

3.获取InetAddress对象的主机名getHostName

4.获取InetAddress对象的地址getHostAddress

public class API_ {
    public static void main(String[] args) throws UnknownHostException {

        //1. 获取本机的InetAddress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);//DESKTOP-9UOSPK2/192.168.0.105

        //2. 根据指定主机名 获取 InetAddress对象
        InetAddress host1 = InetAddress.getByName("DESKTOP-9UOSPK2");
        System.out.println("host1=" + host1);//DESKTOP-9UOSPK2/192.168.0.105

        //3. 根据域名返回 InetAddress对象, 比如 www.baidu.com 对应
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println("host2=" + host2);//www.baidu.com / 14.119.104.254

        //4. 通过 InetAddress 对象，获取对应的地址
        String hostAddress = host2.getHostAddress();//IP 110.242.68.4
        System.out.println("host2 对应的ip = " + hostAddress);//14.119.104.254

        //5. 通过 InetAddress 对象，获取对应的主机名/或者的域名
        String hostName = host2.getHostName();
        System.out.println("host2对应的主机名/域名=" + hostName); // www.baidu.com
    }
}

三、Socket

1.基本介绍

1.套接字(Socket)开发网络应用程序被厂泛采用，以至于成为事实上的标准。

2.通信的两端都要有Socket,是两台机器间通信的端点

3.网络通信其实就是Socket间的通信。

4. Socket允许程序把网络连接当成一个流，数据在两个Socket间通过I0传输。

5. 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

示意图:

2.TCP网络通信编程

基本介绍

1.基于客户端一服务端的网络通信

2.底层使用的是TCP/IP协议

3.应用场景举例:客户端发送数据，服务端接受并显示

4.基于Socket的TCP编程

应用案例1

1.编写一个服务器端，和一个客户端

2.服务器端在9999端口监听

3.客户端连接到服务器端，发送"hello,server”,然后退出

4.服务器端接收到客户端发送的信息，输出，并退出

服务端

public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        //要求 该port端口没有其他服务在监听9999
        //ServerSocket可以对应多个socket //细节:这个ServerSocket 可以通过accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端在9999端口监听，等待连接");
        //如果没有客户端连接9999程序会阻塞，等待连接
        //如果有客户端连接，则会返回socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端socket =" + socket.getClass());
        //io读取
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf) )!= -1){
            System.out.println(new String(buf,0,readLen));
        }
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

客户端

public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //解读: 连接本机的 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 world".getBytes());
        //4. 关闭流对象和socket, 必须关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");

    }
}

应用案例2

1.编写个服务端，和一个客户端

2.服务器端在9999端口监听

3.客户端连接到服务端，发送"hello, server"并接收服务器端回发的"hello,client, 再退出

4.服务器端接收到客户端发送的信息，输出，并发送"hello, client", 再退出

注意，在案例1的基础上更改，需要在服务端Out字节流完之后告诉客户端我发送完毕，否则程序不知道什么时候结束，需要设置一个结束标记socket.shutdownOutput()（案例1是因为客户端关闭了才结束的。）

服务端

public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        //该port端口没有其他服务在监听9999
        //1.创建ServerSocket服务端
        //ServerSocket可以对应多个socket //细节:这个ServerSocket 可以通过accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端在9999端口监听，等待连接");
        //2.获取socket管道
        //如果没有客户端连接9999程序会阻塞，等待连接
        //如果有客户端连接，则会返回socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端socket =" + socket.getClass());
        //3.回去客户端写入管道的数据
        InputStream inputStream = socket.getInputStream();
        //4.io读取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf) )!= -1){
            System.out.println(new String(buf,0,readLen));
        }
        socket.shutdownInput();//设置关闭读取标记
        //5.获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello client by server".getBytes());

        //6.关闭流
        inputStream.close();
        outputStream.close();
        socket.close();
        serverSocket.close();
    }
}

客户端

public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        //解读: 连接本机的 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 by client ".getBytes());
        socket.shutdownOutput();//设置发送完毕标记
        //4.获取和socket关联的输入流，读取数据(字节)，并显示
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1){
            System.out.println(new String(buf,0,readLen));
        }
        //5. 关闭流对象和socket, 必须关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

应用案例3

1.编写一个服务端，和一个客户端

2.服务端在9999端口监听

3.客户端连接到服务端，发送"hello, server"，并接收服务端回发的"hello,client",再退出

4.服务端接收到客户端发送的信息，输出，并发送"hello, client",再退出

服务端

public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        //该port端口没有其他服务在监听9999
        //1.创建ServerSocket服务端
        //ServerSocket可以对应多个socket //细节:这个ServerSocket 可以通过accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端在9999端口监听，等待连接");
        //2.获取socket管道
        //如果没有客户端连接9999程序会阻塞，等待连接
        //如果有客户端连接，则会返回socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端socket =" + socket.getClass());
        //3.转成字符流 获取客户端写入管道的数据
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        //4.io读取
        String line;
        while ((line =  bufferedReader.readLine())!= null){
            System.out.println(line + "\r\n");
        }
        socket.shutdownInput();//设置关闭读取标记

        //5.获取socket相关联的输出流 并转成字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        //6.写入数据
        bufferedWriter.write("hello client by server");
        bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束，注意，要求对方使用readLine()!!!!
        bufferedWriter.flush();
        socket.shutdownOutput();//设置发送完毕标记

        //6.关闭流
        socket.close();
        serverSocket.close();
    }
}

客户端

public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        //解读: 连接本机的 9999端口, 如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回=" + socket.getClass());

        //2. 连接上后，生成Socket, 通过socket.getOutputStream()
        //   得到 和 socket对象关联的输出流对象
        //3.将output转成writer 通过输出流，写入数据到 数据通道
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bufferedWriter.write("hello server by client ");
        bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束，注意，要求对方使用readLine()!!!!
        bufferedWriter.flush();//如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
        //4.关闭输出流
        socket.shutdownOutput();//设置发送完毕标记 即便是字符流而且没有显式的定义OutputStream也需要关闭

        //5.获取和socket关联的输入流，读取数据(字节)，并显示
        //6.转成Reader
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line;
        while ((line = bufferedReader.readLine())!=null){
            System.out.println(line + "\r\n");
        }
        // socket.shutdownInput();
        //5. 关闭流对象和socket, 必须关闭

        bufferedReader.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

应用案例4

1.编写一个服务端，和一个客户端

2.服务器端在8888端口监听

3.客户端连接到服务端，发送一张图片e:\qie.png

4.服务器端接收到客户端发送的图片，保存到src下，发送"收到图片"再退出

5.客户端接收到服务端发送的"收到图片"，再退出

6.该程序要求使用StreamUtils.java

客户端

public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        //解读: 连接本机的 9999端口, 如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回=" + socket.getClass());

        //2. 连接上后，生成Socket, 通过socket.getOutputStream()
        //   得到 和 socket对象关联的输出流对象
        //3.将output转成writer 通过输出流，写入数据到 数据通道
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bufferedWriter.write("hello server by client ");
        bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束，注意，要求对方使用readLine()!!!!
        bufferedWriter.flush();//如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
        //4.关闭输出流
        socket.shutdownOutput();//设置发送完毕标记 即便是字符流而且没有显式的定义OutputStream也需要关闭

        //5.获取和socket关联的输入流，读取数据(字节)，并显示
        //6.转成Reader
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line;
        while ((line = bufferedReader.readLine())!=null){
            System.out.println(line + "\r\n");
        }
        // com.yinhai.socket.shutdownInput();
        //5. 关闭流对象和socket, 必须关闭

        bufferedReader.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

服务端

public class SocketTCP04Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8888);
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        //该方法已经读到了数组
        byte[] bytes = StreamUtils.streamToByteArray(bufferedInputStream);

        //将得到的byte数组写入到指定的路径
        String receptionPath = "src\\com\\yinhai\\socket\\upload\\serverReceptionFile\\mikuByServer.jpg";
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(receptionPath));
        bufferedOutputStream.write(bytes);
        bufferedOutputStream.flush();


        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bufferedWriter.write("Server已收到客户端传来的文件,文件创建在" + receptionPath);
        bufferedWriter.newLine();
        bufferedWriter.flush();
        socket.shutdownOutput();


        //关闭流
        bufferedOutputStream.close();
        socket.close();
        bufferedInputStream.close();
        bufferedWriter.close();

    }
}

netset指令

1. netstat - an可以查看当前主机网络情况，包括端口监听情况和网络连接情况

2. netstat - an | more可以分页显示

3.要求在dos控制台下执行

说明:

(1) Listening表示某个端口在监听

(2)如果有一个外部程序(客户端)(外部地址)连接到该端口，就会显示一条连接信息

使用netstat -anb | more可以查看是哪个程序正在监听（需要以管理员身份启动）

细节

当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP来分配的

3.UDP网络通信编程

1.基本介绍

1.类DatagramSocket和DatagramPacket[数据包/数据报]实现了基于UDP协议网络程序。

2. UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。

3. DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。

4. UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

2.UDP说明

1.没有明确的服务端和客户端，演变成数据的发送端和接收端

2.接收数据和发送数据是通过DatagramSocket对象完成

3.将数据封装到DatagramPacket对象/装包

4.当接收到DatagramPacket对象,需要进行拆包，取出数据

5. DatagramSocket可以指定在哪个端接收数据

3.基本流程

1.核心的两个类/对象DatagramSocket与DatagramPacket

2.建立发送端，接收端(没有服务端和客户端概念)

3.发送数据前，建立数据包/报DatagramPacket对象

4.调用DatagramSocket的发送、接收方法

5.关闭DatagramSocket

4.案例1

1.编写一个接收端A，和一个发送端B

2.接收端A在9999端口等待接收数据(receive)

3.发送端A向接收端B发送数据"hello ，明天吃火锅~

4.接收端B接收到发送端A发送的数据，回复"好的，明天见"再退出

5.发送端接收回复的数据，再退出

接收端

public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //创建一个DatagramSocket对象 准备在9999端口接收
        DatagramSocket datagramSocket = new DatagramSocket(9999);
        //2.构建数据包，准备接收数据,一个数据包最大为64k
        byte[] buf = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(buf, buf.length);
        //3.调用接收方法，通过网络传输的packet对象填充到packet对象内
        datagramSocket.receive(datagramPacket);//如果没有数据包发送过来，就会阻塞等待
        //4.把packet拆包并显示
        int length = datagramPacket.getLength();//实际接收到的长度
        byte[] data = datagramPacket.getData();//接受数据
        String s = new String(data, 0, length);
        System.out.println(s);
        //接受到后发送ok回去
        byte[] bytes = "OK,I get it and hello UDPSender".getBytes();

        DatagramPacket datagramPacket1 =
                new DatagramPacket(bytes, bytes.length, InetAddress.getByName("192.168.0.105"),9998);
        datagramSocket.send(datagramPacket1);
        //5.关闭资源
        datagramSocket.close();
    }
}

发送端

public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket对象，准备发送和数据，该对象 可以接受和发送
        DatagramSocket datagramSocket = new DatagramSocket(9998);//准备在9998等别人的发送数据
        //2.将需要发送的数据封装到packet对象中
        byte[] bytes = "hello UDPReceiver".getBytes();
        //说明:封装的DatagramPacket对象(内容字节数组，data.Length ,主机(IP) ,端口)
        DatagramPacket datagramPacket =
                new DatagramPacket(bytes, bytes.length, InetAddress.getByName("192.168.0.105"), 9999);
        datagramSocket.send(datagramPacket);
        byte[] buf = new byte[1024];
        DatagramPacket datagramPacket1 = new DatagramPacket(buf, buf.length);
        //3.调用接收方法，通过网络传输的packet对象填充到packet对象内
        datagramSocket.receive(datagramPacket1);//如果没有数据包发送过来，就会阻塞等待
        //4.把packet拆包并显示
        int length = datagramPacket1.getLength();//实际接收到的长度
        byte[] data = datagramPacket1.getData();//接受数据
        String s = new String(data, 0, length);
        System.out.println(s);
        datagramSocket.close();
    }
}

四、本章作业

1.

服务端

public class Homework01Server {
    public static void main(String[] args) throws IOException {
        //该port端口没有其他服务在监听9999
        //1.创建ServerSocket服务端
        //ServerSocket可以对应多个socket //细节:这个ServerSocket 可以通过accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端在9999端口监听，等待连接");
        //2.获取socket管道
        //如果没有客户端连接9999程序会阻塞，等待连接
        //如果有客户端连接，则会返回socket对象，程序继续


        //3.转成字符流 获取客户端写入管道的数据

        //4.io读取
        while (true) {
            Socket socket = serverSocket.accept();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String line;
            String answer = null;
            while ((line = bufferedReader.readLine()) != null) {
                if (line.equals("name")) {
                    answer = "My name is yinhai";
                } else if ("hobby".equals(line)) {
                    answer = "My favor to compile program";
                }else if ("exit".equals(line)){
                    answer = "exit";
                }
                else {
                    answer = "Sorry , about that cant understand with me";
                }
            }
            socket.shutdownInput();

            //5.获取socket相关联的输出流 并转成字符流
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            //6.写入数据
            bufferedWriter.write(answer);
            bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束，注意，要求对方使用readLine()!!!!
            bufferedWriter.flush();
            socket.shutdownOutput();//设置发送完毕标记
            if (answer.equals("exit")){
                socket.close();
                break;
            }
        }

        //6.关闭流

        serverSocket.close();
    }
}

客户端

public class Homework01Client {
    public static void main(String[] args) throws IOException {
        while (true) {
            Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入你的问题");
            String next = scanner.next();

            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            bufferedWriter.write(next);
            bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束，注意，要求对方使用readLine()!!!!
            bufferedWriter.flush();//如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
            //4.关闭输出流
            socket.shutdownOutput();//设置发送完毕标记 即便是字符流而且没有显式的定义OutputStream也需要关闭

            //5.获取和socket关联的输入流，读取数据(字节)，并显示
            //6.转成Reader
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line + "\r\n");
            }
            if(next.equals("exit")){
                socket.close();
                break;
            }
            // com.yinhai.socket.shutdownInput();
            //5. 关闭流对象和socket, 必须关闭
            bufferedReader.close();
        }
        System.out.println("客户端退出...");
    }

}

2.

发送端

public class Homework02SenderB {
    public static void main(String[] args) throws IOException {

        //1.创建 DatagramSocket 对象，准备在9998端口 接收数据
        DatagramSocket socket = new DatagramSocket(9998);

        //2. 将需要发送的数据，封装到 DatagramPacket对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的问题: ");
        String question = scanner.next();
        byte[] data = question.getBytes(); //

        //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
        DatagramPacket packet =
                new DatagramPacket(data, data.length, InetAddress.getByName("192.168.12.1"), 8888);

        socket.send(packet);

        //3.=== 接收从A端回复的信息
        //(1)   构建一个 DatagramPacket 对象，准备接收数据
        //   在前面讲解UDP 协议时，老师说过一个数据包最大 64k
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2)    调用 接收方法, 将通过网络传输的 DatagramPacket 对象
        //   填充到 packet对象
        //老师提示: 当有数据包发送到 本机的9998端口时，就会接收到数据
        //   如果没有数据包发送到 本机的9998端口, 就会阻塞等待.
        socket.receive(packet);

        //(3)  可以把packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//实际接收到的数据字节长度
        data = packet.getData();//接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);

        //关闭资源
        socket.close();
        System.out.println("B端退出");
    }
}

接受端

public class Homework02ReceiverA {
    public static void main(String[] args) throws IOException {
        //1. 创建一个 DatagramSocket 对象，准备在8888接收数据
        DatagramSocket socket = new DatagramSocket(8888);
        //2. 构建一个 DatagramPacket 对象，准备接收数据
        //   在前面讲解UDP 协议时，老师说过一个数据包最大 64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //3. 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
        //   填充到 packet对象
        System.out.println("接收端 等待接收问题 ");
        socket.receive(packet);

        //4. 可以把packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//实际接收到的数据字节长度
        byte[] data = packet.getData();//接收到数据
        String s = new String(data, 0, length);
        //判断接收到的信息是什么
        String answer = "";
        if("四大名著是哪些".equals(s)) {
            answer = "四大名著 <<红楼梦>> <<三国演示>> <<西游记>> <<水浒传>>";
        } else {
            answer = "what?";
        }


        //===回复信息给B端
        //将需要发送的数据，封装到 DatagramPacket对象
        data = answer.getBytes();
        //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
        packet =
                new DatagramPacket(data, data.length, InetAddress.getByName("192.168.12.1"), 9998);

        socket.send(packet);//发送

        //5. 关闭资源
        socket.close();
        System.out.println("A端退出...");

    }
}

3.

服务端

public class Homework03Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        byte[] b = new byte[1024];
        int len = 0;
        String downloadFileName = "";
        while ((len = inputStream.read(b))!= -1){
            downloadFileName += new String(b,0,len);
        }
        System.out.println(downloadFileName);
        //服务器上有两个文件 无名.mp3 高山流水.mp3
        //如果下载的是高山流水返回该文件，否则一律返回无名
        String resFileName = "";
        if("高山流水".equals(downloadFileName)){
            resFileName = "src\\高山流水.mp3";
        }else{
            resFileName = "src\\无名.mp3";
        }
        //创建输入流读取文件
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(resFileName));
        //使用工具类
        byte[] bytes = StreamUtils.streamToByteArray(bufferedInputStream);
        //得到socket相关的输出流
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(socket.getOutputStream());
        bufferedOutputStream.write(bytes);
        bufferedOutputStream.flush();
        socket.shutdownOutput();

        //关闭相关的资源
        inputStream.close();
        bufferedInputStream.close();
        bufferedOutputStream.close();
        socket.close();
        serverSocket.close();
        System.out.println("关闭服务端");
    }
}

客户端

public class Homework03Client {
    public static void main(String[] args) throws Exception {
        //接受用户输入 准备从服务端下载
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要下载的名字");
        String downloadFileName = scanner.next();
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);
        OutputStream outputStream = socket.getOutputStream();
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
        bufferedOutputStream.write(downloadFileName.getBytes());
        bufferedOutputStream.flush();
        socket.shutdownOutput();

        InputStream inputStream = socket.getInputStream();
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        byte[] bytes1 = StreamUtils.streamToByteArray(bufferedInputStream);

        String fileName = "";
        if(downloadFileName.equals("高山流水")){
            fileName = "高山流水";
        }else {
            fileName ="无名";
        }
        String filePath = "src\\com\\yinhai\\homework\\downloadFile\\" + fileName + ".mp3" ;
        BufferedOutputStream bufferedOutputStream1 = new BufferedOutputStream(new FileOutputStream(filePath));
        bufferedOutputStream1.write(bytes1);
        bufferedOutputStream1.flush();

        bufferedInputStream.close();
        bufferedOutputStream.close();
        bufferedOutputStream1.close();
        socket.close();
    }
}