1. 网络相关概念
2. InetAddress 类
- 相关方法
3. Socket
- 基本介绍
4. TCP 网络通信编程
5. netstat 指令
6. TCP 网络通讯不为人知的秘密
7. UDP 网络通信编程(了解)
- 基本流程
  - 构造器
- 应用案例
  - 发送端A:
  - 接收端B:
8. 网络编程作业
- 客户端(先写)

1. 网络相关概念

网络通信

第19章网络编程 - 图1

网络

第19章网络编程 - 图2

ip地址

第19章网络编程 - 图3

ipv4 地址分类

第19章网络编程 - 图4

第19章网络编程 - 图5

域名

第19章网络编程 - 图6

网络通信协议

第19章网络编程 - 图7

第19章网络编程 - 图8

网络通信协议

第19章网络编程 - 图9

TCP 和 UDP

第19章网络编程 - 图10

2. InetAddress 类

3. Socket

基本介绍

套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准。
通信的两端都要有Socket，是两台机器间通信的端点
网络通信其实就Socket间的通信。
Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输.
一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

示意图:

第19章网络编程 - 图11

4. TCP 网络通信编程

基于客户端—服务端的网络通信
底层使用的是TCP/IP协议
应用场景举例：客户端发送费服务端接受并显示控制台
基于Socket的TCP编程

第19章网络编程 - 图12

应用案例 1(使用字节流)

第19章网络编程 - 图13

第19章网络编程 - 图14

客户端

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

服务端

public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的9999端口监听, 等待连接
        //   细节: 要求在本机没有其它服务在监听9999
        //   细节：这个 ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接..");
        //2. 当没有客户端连接9999端口时，程序会 阻塞, 等待连接
        //   如果有客户端连接，则会返回Socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket =" + socket.getClass());
        //
        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        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));//根据读取到的实际长度，显示内容.
        }
        //5.关闭流和socket
        inputStream.close();
        socket.close();
        serverSocket.close();//关闭
    }
}

应用案例 2(使用字节流)

第19章网络编程 - 图15

第19章网络编程 - 图16

客户端

public class SocketTCP02Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连接服务端 (ip , 端口）
        //解读: 连接本机的 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".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, 必须关闭
        inputStream.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

服务端

public class SocketTCP02Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的9999端口监听, 等待连接
        //   细节: 要求在本机没有其它服务在监听9999
        //   细节：这个 ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接..");
        //2. 当没有客户端连接9999端口时，程序会 阻塞, 等待连接
        //   如果有客户端连接，则会返回Socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket =" + socket.getClass());
        //
        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        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));//根据读取到的实际长度，显示内容.
        }
        //5. 获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello, client".getBytes());
        //   设置结束标记
        socket.shutdownOutput();
        //6.关闭流和socket
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();//关闭
    }
}

应用案例 3(使用字符流)

第19章网络编程 - 图17

客户端:

public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 连接服务端 (ip , 端口）
        //解读: 连接本机的 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. 通过输出流，写入数据到 数据通道, 使用字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello, server 字符流");
        bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束, 注意，要求对方使用readLine()!!!!
        bufferedWriter.flush();// 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
        //4. 获取和socket关联的输入流. 读取数据(字符)，并显示
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
        //5. 关闭流对象和socket, 必须关闭
        bufferedReader.close();//关闭外层流
        bufferedWriter.close();
        socket.close();
        System.out.println("客户端退出.....");
    }
}

服务端:

public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的9999端口监听, 等待连接
        //   细节: 要求在本机没有其它服务在监听9999
        //   细节：这个 ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接..");
        //2. 当没有客户端连接9999端口时，程序会 阻塞, 等待连接
        //   如果有客户端连接，则会返回Socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket =" + socket.getClass());
        //
        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
        //4. IO读取, 使用字符流, 老师使用 InputStreamReader 将 inputStream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);//输出
        //5. 获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
       //    使用字符输出流的方式回复信息
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello client 字符流");
        bufferedWriter.newLine();// 插入一个换行符，表示回复内容的结束
        bufferedWriter.flush();//注意需要手动的flush
        //6.关闭流和socket
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();//关闭
    }
}

bufferedWriter.newLine() 插入一个换行符，表示写入的内容结束, 注意，要求对方使用readLine()!!!!

bufferedWriter.flush() 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道

应用案例 4 : 网络上传文件

思路 : 从磁盘上读取文件到客户端存到一个文件数据对应的字节数组中 - 用Socket把文件传到数据通道 - 在服务端用Socket把文件读到文件数据对应的字节数组中 - 再把文件刷新到磁盘上 - 刷新后服务端通过Socket得到一个输出流 - 通过数据通道 - 客户端通过Socket把数据通道中的消息读出来 - 在输出到显示器中显示出来.

客户端

public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {
        //客户端连接服务端 8888，得到Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //创建读取磁盘文件的输入流
        //String filePath = "e:\\qie.png";
        String filePath = "e:\\abc.mp4";
        BufferedInputStream bis  = new BufferedInputStream(new FileInputStream(filePath));
        //bytes 就是filePath对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //通过socket获取到输出流, 将bytes数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
        bis.close();
        socket.shutdownOutput();//设置写入数据的结束标记
        //=====接收从服务端回复的消息=====
        InputStream inputStream = socket.getInputStream();
        //使用StreamUtils 的方法，直接将 inputStream 读取到的内容 转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);
        //关闭相关的流
        inputStream.close();
        bos.close();
        socket.close();
    }

服务端

public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {
        //1. 服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端在8888端口监听....");
        //2. 等待连接
        Socket socket = serverSocket.accept();
        //3. 读取客户端发送的数据
        //   通过Socket得到输入流
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //4. 将得到 bytes 数组，写入到指定的路径，就得到一个文件了
        String destFilePath = "D:/hh.jpg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();
        // 向客户端回复 "收到图片"
        // 通过socket 获取到输出流(字符)
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到图片");
        writer.flush();//把内容刷新到数据通道
        socket.shutdownOutput();//设置写入结束标记
        //关闭其他资源
        writer.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}

StreamUtils.java

public class StreamUtils {
   /**
    * 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
    * @param is
    * @return
    * @throws Exception
    */
   public static byte[] streamToByteArray(InputStream is) throws Exception{
      ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
      byte[] b = new byte[1024];//字节数组
      int len;
      while((len=is.read(b))!=-1){//循环读取
         bos.write(b, 0, len);//把读取到的数据，写入bos   
      }
      byte[] array = bos.toByteArray();//然后将bos 转成字节数组
      bos.close();
      return array;
   }
   /**
    * 功能：将InputStream转换成String
    * @param is
    * @return
    * @throws Exception
    */
   public static String streamToString(InputStream is) throws Exception{
      BufferedReader reader = new BufferedReader(new InputStreamReader(is));
      StringBuilder builder= new StringBuilder();
      String line;
      while((line=reader.readLine())!=null){ //当读取到null时,就表示结束
         builder.append(line+"\r\n");
      }
      return builder.toString();
   }
}

5. netstat 指令

netstat -an 可以查看当前主机网络情况,包括端口监听情况和网络连接情况
netstat -an | more 可以分页显示
要求在dos控制台下执行
说明:
1. Listening 表示某个端口在监听
2. 如果有一个外部程序(客户端)连接到该端口，就会显示一条连接信息.
3. 可以输入ctrl＋c 退出指令

第19章网络编程 - 图18

6. TCP 网络通讯不为人知的秘密

第19章网络编程 - 图19

当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的,这个端口是TCP/IP 协议来分
配的，是不确定的，是随机的。
示意图
程序验证+netstat

7. UDP 网络通信编程(了解)

类 DatagramSocket 和 DatagramPacket[数据包/数据报]实现了基于UDP协议网络程序。
UDP数据报通过数据报套接字DatagramSocket发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

基本流程

核心的两个类/对象 DatagramSocket与DatagramPacket
建立发送端，接收端(没有服务端和客户端概念)
发送数据前，建立数据包/报 DatagramPacket对象
调用DatagramSocket的发送、接收方法
关闭DatagramSocket

第19章网络编程 - 图20

构造器

第19章网络编程 - 图21

应用案例

第19章网络编程 - 图22

发送端A:

public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //1. 创建一个 DatagramSocket 对象，准备在9999接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2. 构建一个 DatagramPacket 对象，准备接收数据
        //   在前面讲解UDP 协议时，老师说过一个数据包最大 64k
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        //3. 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
        //   填充到 packet对象
        //老师提示: 当有数据包发送到 本机的9999端口时，就会接收到数据
        //   如果没有数据包发送到 本机的9999端口, 就会阻塞等待.
        System.out.println("接收端A 等待接收数据..");
        socket.receive(packet);
        //4. 可以把packet 进行拆包，取出数据，并显示.
        int length = packet.getLength();//实际接收到的数据字节长度
        byte[] data = packet.getData();//接收到数据
        String s = new String(data, 0, length);
        System.out.println(s);
        //===回复信息给B端
        //将需要发送的数据，封装到 DatagramPacket对象
        data = "好的, 明天见".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端退出...");
    }
}

接收端B:

public class  UDPSenderB {
    public static void main(String[] args) throws IOException {
        //1.创建 DatagramSocket 对象，准备在9998端口 接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        //2. 将需要发送的数据，封装到 DatagramPacket对象
        byte[] data = "hello 明天吃火锅~".getBytes(); //
        //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
        DatagramPacket packet =
                new DatagramPacket(data, data.length, InetAddress.getByName("192.168.12.1"), 9999);
        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端退出");
    }
}

8. 网络编程作业

第19章网络编程 - 图23

客户端(先写)

public class Homework01Client {
    public static void main(String[] args)  {
        try (
                //先连接
                Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
                //连接上后 创建写入流
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                //创建读取流
                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()))
        ) {
            //从键盘读取用户的问题
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入你的问题");
            String question = scanner.next();
            //将问题写入连接
            bw.write(question);
            bw.newLine();//插入一个换行符，表示写入的内容结束, 注意，要求对方使用readLine()!!!!
            bw.flush();// 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
            //读取流中的数据
            String s = br.readLine();
            System.out.println(s);
        }  catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端

public class Homework01Server {
    public static void main(String[] args) throws IOException {
        //思路
        //1. 在本机 的9999端口监听, 等待连接
        //   细节: 要求在本机没有其它服务在监听9999
        //   细节：这个 ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接..");
        //2. 当没有客户端连接9999端口时，程序会 阻塞, 等待连接
        //   如果有客户端连接，则会返回Socket对象，程序继续
        Socket socket = serverSocket.accept();
        //
        //3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
        InputStream inputStream = socket.getInputStream();
        //4. IO读取, 使用字符流, 老师使用 InputStreamReader 将 inputStream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        String answer = "";
        if ("name".equals(s)) {
            answer = "我是韩顺平";
        } else if("hobby".equals(s)) {
            answer = "编写java程序";
        } else {
            answer = "你说的啥子";
        }
        //5. 获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        //    使用字符输出流的方式回复信息
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write(answer);
        bufferedWriter.newLine();// 插入一个换行符，表示回复内容的结束
        bufferedWriter.flush();//注意需要手动的flush
        //6.关闭流和socket
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();//关闭
    }
}

第19章网络编程 - 图24

发送端(先写)

public class Homework02SenderB {
    public static void main(String[] args) {
        try (
                //创建DatagramSocket对象,在9998接受数据
                DatagramSocket socket = new DatagramSocket(9998);
        ) {
            //将要发送的数据包装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.231.1"),8888);
            //发送
            socket.send(packet);
            //=== 接收从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);
        }  catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("B端退出");
    }
}

接收端

public class Homework02ReceiverA {
    public static void main(String[] args) {
        try (
                //创建一个 DatagramSocket 对象，准备在8888接收数据
                DatagramSocket socket = new DatagramSocket(8888);
        ) {
            //构建一个 DatagramPacket 对象，准备接收数据
            //在前面讲解UDP 协议时，老师说过一个数据包最大 64k
            //创建一个数据包
            byte[] buf = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buf,buf.length);
            //调用 接收方法, 将通过网络传输的 DatagramPacket 对象
            //填充到 packet对象
            System.out.println("接收端 等待接收问题 ");
            socket.receive(packet);
            //可以把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.231.1"), 9998);
            socket.send(packet);//发送
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("A端退出...");
    }
}

第19章网络编程 - 图25

第19章网络编程 - 图26

客户端

public class Homework03Client {
    public static void main(String[] args) {
        //接收用户输入,指定文件下载名
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入下载的文件名");
        String downloadFileName = scanner.next();
        try (
                //客户端连接服务器
                Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
                //获取和Socket关联的输出流
                OutputStream outputStream = socket.getOutputStream();
        ) {
            //获取和Socket关联的输出流
            outputStream.write(downloadFileName.getBytes());
            //设置写入结束的标志
            socket.shutdownOutput();
            //读取服务端返回的文件(字节数据)
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            byte[] bytes = StreamUtils.streamToByteArray(bis);
            //得到一个输出流，准备将 bytes 写入到磁盘文件
            //比如你下载的是 高山流水 => 下载的就是 高山流水.mp3
            //    你下载的是 韩顺平 => 下载的就是 无名.mp3  文件名 韩顺平.mp3
            String filePath = "D:\\mydat\\" + downloadFileName + ".mp3";
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
            bos.write(bytes);
            System.out.println("客户端下载完毕，正确退出..");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端

public class Homework03Server {
    public static void main(String[] args) {
        try (
                //1 监听 9999端口
                ServerSocket serverSocket = new ServerSocket(9999)
        ) {
            //2.等待客户端连接
            System.out.println("服务端，在9999端口监听，等待下载文件");
            Socket socket = serverSocket.accept();
            //3.读取 客户端发送要下载的文件名
            //  这里老师使用了while读取文件名，时考虑将来客户端发送的数据较大的情况
            InputStream inputStream = socket.getInputStream();
            byte[] data = new byte[1024];
            int len = 0;
            String downLoadFileName = "";
            while ((len = inputStream.read(data)) != -1) {
                downLoadFileName += new String(data, 0 , len);
            }
            System.out.println("客户端希望下载文件名=" + downLoadFileName);
            //老师在服务器上有两个文件, 无名.mp3 高山流水.mp3
            //如果客户下载的是 高山流水 我们就返回该文件，否则一律返回 无名.mp3
            String resFileName = "";
            if("高山流水".equals(downLoadFileName)) {
                resFileName = "chapter21\\src\\高山流水.mp3";
            } else {
                resFileName = "chapter21\\src\\无名.mp3";
            }
            //4. 创建一个输入流，读取文件
            BufferedInputStream bis =
                    new BufferedInputStream(new FileInputStream(resFileName));
            //5. 使用工具类StreamUtils ，读取文件到一个字节数组
            byte[] bytes = StreamUtils.streamToByteArray(bis);
            //6. 得到Socket关联的输出流
            BufferedOutputStream bos =
                    new BufferedOutputStream(socket.getOutputStream());
            //7. 写入到数据通道，返回给客户端
            bos.write(bytes);
            socket.shutdownOutput();//很关键.
            System.out.println("服务端退出...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

tips：服务端下载的是什么我们不知道，我们只能在客户端设置下载文件的名称，但是文件的内容是由服务端决定的

第19章 网络编程

1. 网络相关概念

网络通信

网络

ip地址

ipv4 地址分类

域名

网络通信协议

网络通信协议

TCP 和 UDP

2. InetAddress 类

相关方法

3. Socket

基本介绍

4. TCP 网络通信编程

应用案例 1(使用字节流)

客户端

服务端

应用案例 2(使用字节流)

客户端

服务端

应用案例 3(使用字符流)

客户端:

服务端:

应用案例 4 : 网络上传文件

客户端

服务端

StreamUtils.java

5. netstat 指令

6. TCP 网络通讯不为人知的秘密

7. UDP 网络通信编程(了解)

基本流程

构造器

应用案例

发送端A:

接收端B:

8. 网络编程作业

客户端(先写)

服务端

发送端(先写)

接收端

客户端

服务端

第19章网络编程