1. 网络编程的目的?
      1. 直接或间接的通过网络协议与其他计算机实现数据交换、进行通讯
    2. 网络编程的两个主要问题
      1. 如何准确的定位网络上的一台或多台主机 :定位主机上特定的应用
        1. ip确定网络上唯一的主机 对应Java类 InetAddress
        2. 端口号确定特定的应用
      2. 找到主机后 如何进行高效的可靠的数据传输
        1. 解: 通过网络通信协议
    3. 网络通信协议
      1. 通信协议同层可以传递
      2. 上层可以调下层进行传递
      3. 不可以跃层传递

    image.png

    1. TCP协议
      1. 采用TCP协议前 先创建TCP链接 形成数据传输通道
      2. 传输前 采用’三次握手’方式 建立点对点通信 是可靠的
      3. TCP协议的两个应用进程: 客户端、服务端
      4. 在链接中可进行大量的数据传输
      5. 传输完毕 释放已建立的链接 效率低

    2. UDP协议

      1. 将数据、源、目的封装成数据包 不需要建立链接
      2. 每个数据报大小限制在64k内
      3. 发送不管对方是否准备好接收 接收方收到也不确认 不可靠的
      4. 可以广播发送
      5. 发送结束时无需释放资源 开销小 速度快

    3. TCP网络编程示例

      1. Socket类 = ip+端口号 理解为客户端应用 通过他链接到服务器 实现数据传输、通信
      2. TCP示例 如客户端访问服务端
      3. 浏览器访问tomcat ```java **

      • @author:LYY 创建时间:2022/5/11 */ public class TCPTest {

        /**

        • TCP编程案例二
        • 客户端发送文件到服务端 服务端接收保存并返回收到信息给客户端 客户端打印收到信息到控制台

        • 自定义服务端 */ @Test void test04() throws IOException {

          OutputStream outputStream = null; FileOutputStream fileOutputStream = null; InputStream inputStream = null; Socket socket = null; ServerSocket serverSocket = null; try {

          1.  // 创建服务端Socket
          2.  serverSocket = new ServerSocket(8999);
          3.  // 获取服务端链接
          4.  socket = serverSocket.accept();
          5.  // 获取输入流 获取客户端发送的文件
          6.  inputStream = socket.getInputStream();
          7.  // 获取输出流 保存客户端发送的文件到服务器(硬盘)
          8.  fileOutputStream = new FileOutputStream("美图.jpg");
          9.  byte[] bytes = new byte[1024];
          10.  // 记录每次读取的字节数量
          11.  int len;
          12.  while ((len = inputStream.read(bytes)) != -1) {
          13.      // 将文件流写到硬盘
          14.      fileOutputStream.write(bytes, 0, len);
          15.  }
          16.  // 返回客户端消息
          17.  outputStream = socket.getOutputStream();
          18.  outputStream.write("文件接收完成!".getBytes());

          } catch (IOException e) {

          1.  e.printStackTrace();

          } finally {

          1.  // 释放资源
          2.  if (outputStream != null) {
          3.      try {
          4.          outputStream.close();
          5.      } catch (IOException e) {
          6.          e.printStackTrace();
          7.      }
          8.  }
          9.  if (fileOutputStream != null) {
          10.      try {
          11.          fileOutputStream.close();
          12.      } catch (IOException e) {
          13.          e.printStackTrace();
          14.      }
          15.  }
          16.  if (inputStream != null) {
          17.      try {
          18.          inputStream.close();
          19.      } catch (IOException e) {
          20.          e.printStackTrace();
          21.      }
          22.  }
          23.  if (socket != null) {
          24.      try {
          25.          socket.close();
          26.      } catch (IOException e) {
          27.          e.printStackTrace();
          28.      }
          29.  }
          30.  if (serverSocket != null) {
          31.      serverSocket.close();
          32.  }

          } }

        /**

        • TCP编程案例二
        • 客户端发送文件到服务端 服务端接收保存并返回收到信息给客户端 客户端打印收到信息到控制台

        • 自定义客户端 */ @Test void test03() { Socket socket = null; OutputStream outputStream = null; FileInputStream fileInputStream = null; try {

          1.  // 创建Socket对象
          2.  socket = new Socket(InetAddress.getByName("192.168.1.52"), 8999);
          3.  // 获取输入流 将要发送的文件转换为字节流
          4.  fileInputStream = new FileInputStream("preview.jpg");
          5.  // 获取输出流 发送文件
          6.  outputStream = socket.getOutputStream();
          7.  byte[] bytes = new byte[1024];
          8.  int read;
          9.  // 读文件的字节流
          10.  while ((read = fileInputStream.read(bytes)) != -1) {
          11.      // 发送文件
          12.      outputStream.write(bytes, 0, read);
          13.  }
          14.  // 告诉服务端 发送数据结束
          15.  socket.shutdownOutput();
          17.  // 获取输入流 准备获取服务端发送的消息
          18.  InputStream inputStream = socket.getInputStream();
          19.  bytes = new byte[1024];
          20.  // 记录每次读取的字节
          21.  int len;
          22.  ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
          23.  while ((len = inputStream.read(bytes))!=-1) {
          24.      byteArrayOutputStream.write(bytes,0,len);
          25.  }
          26.  System.out.println(byteArrayOutputStream.toString());

          } catch (IOException e) {

          1.  e.printStackTrace();

          } finally {

          1.  if (socket != null) {
          2.      try {
          3.          socket.close();
          4.      } catch (IOException e) {
          5.          e.printStackTrace();
          6.      }
          7.  }
          8.  if (outputStream != null) {
          9.      try {
          10.          outputStream.close();
          11.      } catch (IOException e) {
          12.          e.printStackTrace();
          13.      }
          14.  }
          15.  if (fileInputStream != null) {
          16.      try {
          17.          fileInputStream.close();
          18.      } catch (IOException e) {
          19.          e.printStackTrace();
          20.      }
          21.  }

          } }

    1. /**
    2.  * TCP编程案例一
    3.  *  客户端发送数据到服务端 服务端将接收到的数据显示在控制台
    4.  * 自定义客户端
    5.  */
    6. @Test
    7. void test01() {
    8.     OutputStream outputStream = null;
    9.     Socket socket = null;
    10.     try {
    11.         // 客户端TCP指向服务器端
    12.         socket = new Socket(InetAddress.getByName("192.168.1.52"), 8999);
    14.         // 获取输出流
    15.         outputStream = socket.getOutputStream();
    17.         // 将消息写出到服务器端
    18.         outputStream.write("我是客户端发送的消息!".getBytes());
    20.     } catch (IOException e) {
    21.         e.printStackTrace();
    22.     } finally {
    24.         // 关闭输出流
    25.         if (outputStream != null) {
    26.             try {
    27.                 outputStream.close();
    28.             } catch (IOException e) {
    29.                 e.printStackTrace();
    30.             }
    31.         }
    33.         // 关闭Socket(网通通信)
    34.         if (socket != null) {
    35.             try {
    36.                 socket.close();
    37.             } catch (IOException e) {
    38.                 e.printStackTrace();
    39.             }
    40.         }
    41.     }
    42. }
    45. /**
    46.  * TCP通信编程案例一
    47.  * 自定义服务器端
    48.  * 接收客户端消息 并写出到控制台
    49.  */
    50. @Test
    51. void test02() throws IOException {
    53.     ByteArrayOutputStream byteArrayOutputStream = null;
    54.     InputStream inputStream = null;
    55.     Socket accept = null;
    56.     ServerSocket serverSocket = null;
    57.     try {
    58.         // 创建服务器客户端
    59.         serverSocket = new ServerSocket(8999);
    61.         // 获取到客户端链接
    62.         accept = serverSocket.accept();
    64.         // 从客户获取到输入流 获取到客户端发送的内容
    65.         inputStream = accept.getInputStream();
    66.         // ByteArrayOutputStream 处理接收字节流输出字符串时容易出现乱码的问题
    67.         byteArrayOutputStream = new ByteArrayOutputStream();
    68.         byte[] bytes = new byte[1024];
    69.         // 记录每次读取到的字节数
    70.         int len;
    71.         // 读客户端发送的数据(字节流)
    72.         while ((len = inputStream.read(bytes)) != -1) {
    73.             byteArrayOutputStream.write(bytes, 0, len);
    74.         };
    75.         // toString方法调用ByteArrayOutputStream中的数组 并将数组中保存的所有字节(byte)创建成String返回
    76.         System.out.println(byteArrayOutputStream.toString());
    77.     } catch (IOException e) {
    78.         e.printStackTrace();
    79.     } finally {
    80.         // 释放资源
    81.         if (byteArrayOutputStream != null) {
    82.             try {
    83.                 byteArrayOutputStream.close();
    84.             } catch (IOException e) {
    85.                 e.printStackTrace();
    86.             }
    87.         }
    89.         if (inputStream != null) {
    90.             try {
    91.                 inputStream.close();
    92.             } catch (IOException e) {
    93.                 e.printStackTrace();
    94.             }
    95.         }
    97.         if (accept != null) {
    98.             try {
    99.                 accept.close();
    100.             } catch (IOException e) {
    101.                 e.printStackTrace();
    102.             }
    103.         }
    105.         if (serverSocket != null) {
    106.             serverSocket.close();
    107.         }
    108.     }
    109. }

    }

    2. 7. UDP编程示例
    3. ```java
    5. /**
    6.  * @author:LYY 创建时间:2022/5/11
    7.  *  UDP编程示例
    8.  */
    9. public class UDPTest {
    11.     /**
    12.      * 发送端
    13.      */
    14.     @Test
    15.     void seedTest() {
    16.         DatagramSocket datagramSocket = null;
    17.         try {
    18.             // UDP编程对象
    19.             datagramSocket = new DatagramSocket();
    20.             byte[] bytes = "测试信息!".getBytes();
    21.             // 数据打包对象
    22.             DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length,InetAddress.getByName("127.0.0.1"),8999);
    23.             // 发送数据
    24.             datagramSocket.send(datagramPacket);
    25.         } catch (SocketException e) {
    26.             e.printStackTrace();
    27.         } catch (IOException e) {
    28.             e.printStackTrace();
    29.         } finally {
    30.             // 释放资源
    31.             if (datagramSocket != null) {
    32.                 datagramSocket.close();
    33.             }
    34.         }
    35.     }
    37.     /**
    38.      * 接收端
    39.      */
    40.     @Test
    41.     void receiver() {
    43.         DatagramSocket datagramSocket = null;
    44.         try {
    45.             // UDP对象
    46.             datagramSocket = new DatagramSocket(8999);
    48.             // 定义接收字节数据的数组
    49.             byte[] bytes = new byte[64];
    50.             DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);
    52.             // 接收数据 数据保存到datagramPacket中
    53.             datagramSocket.receive(datagramPacket);
    54.             // 取出数据
    55.             byte[] data = datagramPacket.getData();
    56.             // 将字节转换成String
    57.             String s = new String(data, 0, datagramPacket.getLength());
    58.             System.out.println(s);
    59.         } catch (SocketException e) {
    60.             e.printStackTrace();
    61.         } catch (UnknownHostException e) {
    62.             e.printStackTrace();
    63.         } catch (IOException e) {
    64.             e.printStackTrace();
    65.         } finally {
    66.             if (datagramSocket != null) {
    67.                 datagramSocket.close();
    68.             }
    69.         }
    70.     }
    71. }