【Java高级编程】网络编程

ゝ一纸荒年。 2023-10-12 23:27 61阅读 0赞

![在这里插入图片描述][59b0b2cf0e6449b48573896acf6a882b.png_pic_center]  
[【Java核心技术】Java基本语法][Java_Java]  
[【Java核心技术】Java面向对象编程][Java_Java 1]  
[【Java核心技术】Java异常处理][Java_Java 2]  
[【Java高级编程】Java多线程][Java_Java 3]  
[【Java高级编程】Java常用类][Java_Java 4]  
[【Java高级编程】Java枚举类&注解][Java_Java 5]  
[【Java高级编程】Java集合][Java_Java 6]  
[【Java高级编程】Java泛型][Java_Java 7]  
[【Java高级编程】JavaIO流][Java_JavaIO]  
[【Java高级编程】Java网络编程][Java_Java 8]  
[【Java高级编程】Java反射机制][Java_Java 9]  
[【Java高级编程】Java8的新特性][Java_Java8]

#### 网络编程 ####

*   *   *  1、InetAddress类的使用
         *   *  1.1、实现网络通信需要解决的两个问题
             *  1.2、网络通信的两个要素
             *  1.3、通信要素一：IP和端口号
             *  1.4、通信要素二：网络通信协议
             *  1.5、TCP和UDP的区别
             *  1.6、TCP三次握手和四次挥手
         *  2、TCP网络编程
         *  3、UDP网络编程
         *  4、URL编程
         *   *  4.1、URL(Uniform Resource Locator)的理解
             *  4.2、URL的5个基本结构
             *  4.3、如何实例化
             *  4.4、常用方法
             *  4.5、可以读取、下载对应的url资源

#### 1、InetAddress类的使用 ####

##### 1.1、实现网络通信需要解决的两个问题 #####

*  如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
 *  找到主机后如何可靠高效地进行数据传输

##### 1.2、网络通信的两个要素 #####

*  对应问题一：IP和端口号
 *  对应问题二：提供网络通信协议：TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层）

##### 1.3、通信要素一：IP和端口号 #####

*  IP的理解
    
     *  IP：唯一的标识Internet上的计算机（通信实体）
     *  在Java中使用InetAddress类代表IP
     *  IP分类：IPv4和IPv6；万维网和局域网
     *  域名：www.baidu.com、www.mi.com
        
         *  域名解析：域名容易记忆，当在连接网络时输入一个主机的域名后，域名服务器（DNS）负责将域名转化成IP地址，这样才能和主机建立连接。
     *  本地回路地址：127.0.0.1 对应着：localhost
 *  InetAddress类：此类的一个对象就代表着一个具体的IP地址
    
     *  实例化：
        
         *  getByName(String host)
         *  getLocalHost()
     *  常用方法：
        
         *  getHostName()
         *  getHostAddress()
 *  端口号：正在计算机上运行的进程
    
     *  要求：不同的进程不同的端口号
     *  范围：被规定为一个16位的整数 0~65535
 *  端口号与IP地址的组合得出一个网络套接字：Socket

##### 1.4、通信要素二：网络通信协议 #####

<table> 
 <thead> 
  <tr> 
   <th align="center">OSI参考模型</th> 
   <th align="center">TCP/IP参考模型</th> 
   <th align="center">TCP/IP参考模型各层对应协议</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">应用层、表示层、会话层</td> 
   <td align="center">应用层</td> 
   <td align="center">HTTP、FTP、Telnet、DNS…</td> 
  </tr> 
  <tr> 
   <td align="center">传输层</td> 
   <td align="center">传输层</td> 
   <td align="center">TCP、UDP…</td> 
  </tr> 
  <tr> 
   <td align="center">网络层</td> 
   <td align="center">网络层</td> 
   <td align="center">IP、ICMP、ARP…</td> 
  </tr> 
  <tr> 
   <td align="center">数据链路层、物理层</td> 
   <td align="center">物理+数据链路层</td> 
   <td align="center">Link</td> 
  </tr> 
 </tbody> 
</table>

##### 1.5、TCP和UDP的区别 #####

*  TCP协议：
    
     *  使用TCP协议前，须先建立TCP连接，形成传输数据通道
     *  传输前，采用“三次握手”方式，点对点通信，是可靠的
     *  TCP协议进行通信的两个应用进程：客户端、服务端
     *  在连接中可进行大数据量的传输
     *  传输完毕，需要释放已建立的连接，效率低
 *  UDP协议：
    
     *  将数据、源、目的封装成数据包，不需要建立连接
     *  每个数据报的大小限制在64K内
     *  发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
     *  可以广播发送
     *  发送数据结束时无需释放资源，开销小，速度快

##### 1.6、TCP三次握手和四次挥手 #####

*  三次握手

客户端服务端seq=x,SYN=1客户端发送syn报文，并置发送序号为xACK=x+1,seq=y,SYN=1服务端发送syn+ACK报文并置发送序号为y，再确定序号为x+1ACK=y+1,seq=z客户端发送ACK报文，并置发送序号为z再确定序号为Y+1客户端服务端

*  四次挥手

主动方被动方Fin=1,Ack=z,seq=x主动方发送Fin+Ack报文，并置发送序号为XACK=x+1,seq=z被动方发送ACK报文，并置发送序号为Z，再确定序号为X+1Fin=1,ack=x,seq=y被动方发送Fin+Ack报文，并置发送序号为Y，再确定序号为XACK=Y,seq=x主动方发送ack报文，并置发送序号为X，再确认序号为Y主动方被动方

#### 2、TCP网络编程 ####

/**
     * 客户端发送信息给服务端，服务端将数据显示在控制台上
     */
    public class TCPTest1 {
        // 客户端
        @Test
        public void client() {
            Socket socket = null;
            OutputStream os = null;
            try {
                // 1、创建Socket对象，指明服务器端的IP和端口号
                InetAddress inet = InetAddress.getByName("127.0.0.1");
                socket = new Socket(inet, 8899);
                // 2、获取一个输出流，用于输出数据
                os = socket.getOutputStream();
                // 3、写出数据的操作
                os.write("你好，我是客户端mm".getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 4、资源的关闭
                if (os != null) {
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        //服务端
        @Test
        public void server () {
            ServerSocket ss = null;
            Socket socket = null;
            InputStream is = null;
            ByteArrayOutputStream baos = null;
            try {
                // 1、创建服务器端的ServerSocket，指明自己的端口号
                ss = new ServerSocket(8899);
                // 2、调用accept()表示接收来自客户端的socket
                socket = ss.accept();
                // 3、获取输入流
                is = socket.getInputStream();
                // 4、读取输入流中的数据
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[5];
                int len;
                while ((len = is.read(buffer)) != -1) {
                    baos.write(buffer, 0, len);
                }
    
                System.out.println(socket.getInetAddress().getHostAddress() + "：" + baos.toString());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 5、关闭资源
                if (baos != null) {
                    try {
                        baos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (is != null) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (ss != null) {
                    try {
                        ss.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

/**
     * 客户端发送文件给服务端，服务端将文件保存在本地
     */
    public class TCPTest2 {
        // 客户端
        @Test
        public void client () {
            Socket socket = null;
            OutputStream os = null;
            FileInputStream fis = null;
            try {
                socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
                os = socket.getOutputStream();
                fis = new FileInputStream(new File("beauty.jpg"));
                byte[] buffer = new byte[1024];
                int len;
                while ((len = fis.read(buffer)) != -1) {
                    os.write(buffer, 0, len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (os != null) {
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        //服务端
        @Test
        public void server () {
            ServerSocket ss = null;
            Socket socket = null;
            InputStream is = null;
            FileOutputStream fos = null;
            try {
                ss = new ServerSocket(9090);
                socket = ss.accept();
                is = socket.getInputStream();
                fos = new FileOutputStream(new File("beauty1.jpg"));
    
                byte[] buffer = new byte[1024];
                int len;
                while ((len = is.read(buffer)) != -1) {
                    fos.write(buffer, 0, len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (is != null) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (ss != null) {
                    try {
                        ss.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

/**
     * 从客户端发送文件给服务器，服务端保存到本地。并返回“发送成功”给客户端
     * 并关闭相关的连接
     */
    public class TCPTest3 {
        // 客户端
        @Test
        public void client ()
        {
            Socket socket = null;
            OutputStream os = null;
            FileInputStream fis = null;
            InputStream is = null;
            ByteArrayOutputStream baos = null;
            try {
                socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
                os = socket.getOutputStream();
                fis = new FileInputStream(new File("beauty.jpg"));
    
                byte[] buffer = new byte[1024];
                int len;
                while ((len = fis.read(buffer)) != -1) {
                    os.write(buffer, 0, len);
                }
                // 关闭数据的输出
                socket.shutdownOutput();
    
                // 接收来自于服务器端的数据，并显示到控制台上
                is = socket.getInputStream();
                baos = new ByteArrayOutputStream();
                byte[] buffer1 = new byte[20];
                int len1;
                while ((len1 = is.read(buffer1)) != -1) {
                    baos.write(buffer1, 0, len1);
                }
    
                System.out.println(baos.toString());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (baos != null) {
                    try {
                        baos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (is != null) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (os != null) {
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
            }
        }
    
        // 服务端
        @Test
        public void server () {
            ServerSocket ss = null;
            Socket socket = null;
            InputStream is = null;
            FileOutputStream fos = null;
            OutputStream os = null;
            try {
                ss = new ServerSocket(9090);
                socket = ss.accept();
                is = socket.getInputStream();
                fos = new FileOutputStream(new File("beauty2.jpg"));
    
                byte[] buffer = new byte[1024];
                int len;
                while ((len = is.read(buffer)) != -1) {
                    fos.write(buffer, 0, len);
                }
    
                System.out.println("图片传输完成");
    
                // 服务器端给予客户单反馈
                os = socket.getOutputStream();
                os.write("你好，美女，照片我已收到，非常漂亮！".getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (os != null) {
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (is != null) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (ss != null) {
                    try {
                        ss.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

#### 3、UDP网络编程 ####

public class UDPTest {
        // 发送端
        @Test
        public void sender () {
            DatagramSocket socket = null;
            try {
                socket = new DatagramSocket();
    
                String str = "我是UDP方式发送的导弹";
                byte[] data = str.getBytes();
                InetAddress inet = InetAddress.getLocalHost();
                DatagramPacket packet = new DatagramPacket(data, 0, data.length, inet, 9090);
    
                socket.send(packet);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (socket != null) {
                    socket.close();
                }
            }
        }
        // 接收端
        @Test
        public void receiver () {
            DatagramSocket socket = null;
            try {
                socket = new DatagramSocket(9090);
    
                byte[] buffer = new byte[100];
                DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
    
                socket.receive(packet);
    
                System.out.println(new String(packet.getData(), 0, packet.getLength()));
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                socket.close();
            }
        }
    }

#### 4、URL编程 ####

##### 4.1、URL(Uniform Resource Locator)的理解 #####

*  统一资源定位符，对应着互联网的某一资源地址

##### 4.2、URL的5个基本结构 #####

*  协议
 *  主机名
 *  端口号
 *  资源地址
 *  参数列表

##### 4.3、如何实例化 #####

*  `URL url = new URL("http://localhost:8080/examples/beauty.jpg?username=Tom")`

##### 4.4、常用方法 #####

*  public String getProtocol()：获取该URL的协议名
 *  public String getHost()：获取该URL的主机名
 *  public String getPort()：获取该URL的端口号
 *  public String getPath()：获取该URL的文件路径
 *  public String getFile()：获取该URL的文件名
 *  public String getQuery()：获取该URL的查询名

##### 4.5、可以读取、下载对应的url资源 #####

public static void main(String[] args) {
        HttpURLConnection urlConnection = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            URL url = new URL("http://localhost:8080/examples/beauty.jpg");
            urlConnection = (HttpURLConnection) url.openConnection();
            urlConnection.connect();
    
            is = urlConnection.getInputStream();
            fos = new FileOutputStream("day10\\beauty3.jpg");
    
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
    
            System.out.println("下载完成");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
        }
    }

[59b0b2cf0e6449b48573896acf6a882b.png_pic_center]: https://img-blog.csdnimg.cn/59b0b2cf0e6449b48573896acf6a882b.png#pic_center
[Java_Java]: https://jumper.blog.csdn.net/article/details/131418978
[Java_Java 1]: https://jumper.blog.csdn.net/article/details/131425785
[Java_Java 2]: https://jumper.blog.csdn.net/article/details/131428791
[Java_Java 3]: https://jumper.blog.csdn.net/article/details/131436162
[Java_Java 4]: https://jumper.blog.csdn.net/article/details/131443038
[Java_Java 5]: https://jumper.blog.csdn.net/article/details/131443124
[Java_Java 6]: https://jumper.blog.csdn.net/article/details/131443179
[Java_Java 7]: https://jumper.blog.csdn.net/article/details/131443217
[Java_JavaIO]: https://jumper.blog.csdn.net/article/details/131443242
[Java_Java 8]: https://jumper.blog.csdn.net/article/details/131448537
[Java_Java 9]: https://jumper.blog.csdn.net/article/details/131448541
[Java_Java8]: https://jumper.blog.csdn.net/article/details/131448546