【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来分配的

特别注意

对于 ObjectOutputStream，它本身包含了更多的信息，能够更好地表示对象的边界，因此不需要显式地调用 shutdownOutput。

当你使用 BufferedWriter 写入数据时，并没有类似于换行符的标志来表示数据的结束，所以你需要通过 shutdownOutput 来显式关闭输出流。

当你使用 OutputStream 直接写入字节时，也需要调用 shutdownOutput 来表示数据的结束。

因为在Java中，ObjectOutputStream 是用于将对象序列化为字节流的类。这个类会将对象的数据以及对象的类型信息一并写入输出流中。在这个过程中，ObjectOutputStream 会使用一些特殊的标记和格式来标识不同的对象，并在读取时还原这些信息。

底层的工作原理涉及到Java序列化机制，以下是一些关键概念：

序列化： 将对象转换为字节流的过程称为序列化。在Java中，对象要想序列化，必须实现 Serializable 接口。

对象流的特殊处理： ObjectOutputStream 和 ObjectInputStream 会处理对象的序列化和反序列化。它们会使用特殊的标记来表示对象的类型、字段等信息。

对象边界： 在对象流中，每个写入的对象都被看作是一个边界。ObjectOutputStream 会负责处理对象的序列化，包括将对象的类型信息写入流中，以便在反序列化时正确还原对象。

由于 ObjectOutputStream 在写入对象时已经包含了足够的信息来表示对象的边界，所以在正常情况下，不需要显式地调用 shutdownOutput 来关闭输出流。关闭输出流的目的是告知对方数据发送结束，但对于 ObjectOutputStream 来说，对象边界的信息已经足够表示数据的结束。

总体来说，这是Java序列化机制和 ObjectOutputStream 的设计，使得在对象流中不需要显式关闭输出流，而字节流和字符流需要显式关闭以确保对方能够正确判断数据的结束。

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