文章目录

一 java网络编程初识
- 1.1 概述
- 1.2 C/S 架构&B/S架构认识
- - 1.2.1 C/S架构
  - 1.2.2 B/S架构
- 1.3 网络通信两个要素
- 1.4 IP(Inet Adderss)
- 1.5 InetAddress演示
- 1.6 端口号
- 1.7 InetSocketAddress使用
- 1.8 网络通信协议
二 TCP网络编程
- 2.1 信息通信案例
- - 2.1.1 TcpClientDemo
  - 2.1.2 TcpServetDemo
- 2.2 文件传输演示
- - 2.2.1 TcpClientTest
  - 2.2.2 TcpServeTest
- 2.3 初识Tomcat服务器
三 UDP网络编程
- 3.1 简介
- 3.2 UDP通信
- - 3.2.1 UdpClientTest
  - 3.2.2 UdpServeTest
- 3.3 单向沟通案例
- - 3.3.1 ChatSenderTest
  - 3.3.2 ChatReceiveTest
- 3.4 双向沟通【多线程练习】
- - 3.4.1 发送端多线程(TalkSender)
  - 3.4.2 接收端多线程(TalkReceive)
  - 3.4.3 学生端(TalkStudent)
  - 3.4.4 老师端(TalkTeacher)
四 URL编程
- 4.1 URL类简介
- 4.2 URL类使用演示
- 4.3 下载网络资源案例

学自狂神说，感谢您的奉献！

一 java网络编程初识

1.1 概述

Java是Internet上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序。
Java提供的网络类库，可以实现无痛的网络连接，联网的底层细节被隐藏在 Java 的本机安装系统里，由JVM进行控制。并且Java实现了一个跨平台的网络库，程序员面对的是一个统一的网络编程环境。
计算机网络
- 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大，功能强的网络系统，从而使众多的计算机可以方便地互相传递信息，共享硬件，软件，数据信息等资源。
网络编程的目的：
- 直接或间接地通过网络协议与其他计算机实现数据交换，进行通讯。
网络编程中有两个主要的问题：
1. 如何准确的定位网络上的一台或多台主机，和主机上特定的应用
2. 找到主机后如何可靠高效地进行数据传输
网络编程！=网页编程

1.2 C/S 架构&B/S架构认识

1.2.1 C/S架构

C/S架构软件（即客户机/服务器模式）分为客户机和服务器两层
1. 第一层（用户表示层）是在客户机系统上结合了表示与业务逻辑
2. 第二层（数据库层）是通过网络结合了数据库服务器。
客户端和服务器直接相连，这两个组成部分都承担着重要的角色。
1. 第一层的客户机有输入输出，运算、处理计算，数据存储等方面的业务逻辑事务。
2. 第二层的服务器主要承担事务逻辑的处理，由于客户机可以分担一些逻辑事务，所以服务器的负担得以减轻，但使得网络流量增多。
C/S架构的优点
1. 客户端和服务器直接相连的优势
  - 减少了通信流量，节约成本
  - 点对点的模式使得更安全
2. 客户端可以处理一些逻辑事务的优势
  - 客户端有一套完整应用程序，在出错提示、在线帮助等方面都有强大的功能，并且可以在子程序间自由切换
  - 充分利用两者的硬件设施，避免资源的浪费
C/S架构的缺点
- 客户端方面
  - 客户端界面缺乏通用性，且当业务更改时就需要更改界面，重新编写
  - 由于需要安装客户端，安装部署困难，所以不易扩展
- 服务器方面
  - 用户数增多会出现通信拥堵，服务器压力增大，响应速度变慢等
  - 用户是通过ODBC连接到数据库的，且每个连接到数据库的用户都会保持一个ODBC连接，会一直占用中央服务器的资源，对服务器的要求高
C/S架构的应用
- 办公的OFFICE，WPS，如播放器，QQ，微信……

1.2.2 B/S架构

B/S型模式，即浏览器/服务器结构。
它是C/S架构的一种改进，属于三层C/S架构。主要是利用了不断成熟的浏览器技术，用通用浏览器就实现了原来需要复杂专用软件才能实现的强大功能，并节约了开发成本，是一种全新的软件系统构造技术。【记得有人曾说过，未来浏览器是电脑的主体】
第一层是浏览器，只有简单的输入输出功能，处理极少部分的事务逻辑。由于客户不需要安装客户端，只要有浏览器就能上网浏览，所以界面设计得比较简单，通用。
第二层是WEB服务器，扮演着信息传送的角色。当用户想要访问数据库时，会首先向WEB服务器发送请求，WEB服务器统一请求后会向数据库服务器发送访问数据库的请求。
第三层是数据库服务器。当数据库服务器收到了WEB服务器的请求后，会对请求进行处理，并将返回的结果发送给WEB服务器，然后WEB服务器将收到的数据结果转换为HTML文本形式发送给浏览器，也就是我们在浏览器中看到的界面。
B/S架构的优点
- 浏览器负担小
  - 浏览器只处理一些简单的逻辑事务，负担小。
- 拓展成本低
  - 业务扩展方便，只需要增加几个业务扩展的页面即可，不需要大量的编程。
  - 不需要安装特殊的软件，客户端几乎零维护。
B/S架构的缺点
- 页面需要不断地动态刷新，尤其是用户增多，网速慢的情况下，影响使用体验
- 服务器承担着重要的责任，数据负荷较重。一旦发生服务器“崩溃”，后果不堪设想。
B/S架构的应用
- CSDN、B站、雨课堂、U校园……

1.3 网络通信两个要素

如何实现网络中的主机互相通信？
- 通信双方的地址：IP+端口号
网络通信协议
- TCP/IP协议

1.4 IP(Inet Adderss)

ip地址：Inet Adderss
- 唯一的标识 internet 上的计算机 ( 通信实体 )
- 本地回环地址（hostAddress）：127.0.0.1 主机名 ( hostName )：localhost
- IP地址分类1 ：
  - IPV4：4个字节组成，4个0~255。大概42亿个
  - IPV6：：128位（16个字节），写成8个无符号整数，每个整数用四个十六进制位表示，数之间用冒号隔开2001:0db8:3c4d:0015:0000:0000:1c2f:1b2a
- IP地址分类2：
  - 公网地址（万维网使用）
  - 私有地址（局域网使用）:192.168.开头,192.168.0.0 ~ 192.168.255.255
IP的四类地址
域名：IP的别名，方便人类的记忆和使用

1.5 InetAddress演示

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @author 缘友一世
 * date 2022/12/31-23:27
 */
//测试IP
public class TestInetAddress {
    public static void main(String[] args) throws UnknownHostException {
        //查询本机地址
        InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
        System.out.println(inetAddress1);
        InetAddress inetAddress2 = InetAddress.getByName("localhost");
        System.out.println(inetAddress2);
        InetAddress inetAddress3 = InetAddress.getLocalHost();
        System.out.println(inetAddress3);
        //查询网站ip地址
        InetAddress inetAddress4 = InetAddress.getByName("www.baidu.com");
        System.out.println(inetAddress4);
        //常用方法
        //规范的名字
        System.out.println(inetAddress4.getCanonicalHostName());
        //ip
        System.out.println(inetAddress4.getHostAddress());
        //域名，或者自己电脑的名字
        System.out.println(inetAddress4.getHostName());
    }
}

在这里插入图片描述

1.6 端口号

端口号标识正在计算机上运行的进程（程序）
- 不同的进程有不同的端口号，用来区分软件
- 被规定为一个16位的整数 0~65535
- TCP 和 UDP 各有 65535个端口，单个协议下端口不能冲突
- 端口分类：
  - 公认端口： 0~1023。被预先定义的服务通信占用端口。
    - HTTP 默认端口： 80
    - HTTPS 默认端口：443
    - FTP 默认端口： 21
    - Telnet 默认端口：23
  - 注册端口：1024~49151、分配给用户进程或应用程序。
    - tomcat 默认端口：8080
    - Mysql 默认端口：3306
    - Oracle 默认端口：1521
  - 动态、私有端口：49152~65535

netstat -ano #查看所有端口
netstat -ano|findstr "????" #查看指定端口
tasklist|findstr "????" #查看指定进程
Ctrl+Shift+Esc # 使用任务管理器查看PID

端口号与IP地址的组合，得出一个网络套接字：Socket，所以说一些网络编程也被称为Socket编程

1.7 InetSocketAddress使用

import java.net.InetSocketAddress;

/**
 * @author 缘友一世
 * date 2022/12/31-23:50
 */
public class TestSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8081);
        InetSocketAddress socketAddress1 = new InetSocketAddress("localhost", 8081);
        System.out.println(socketAddress);
        System.out.println(socketAddress1);
        System.out.println(socketAddress.getAddress());
        //地址
        System.out.println(socketAddress.getHostName());
        //端口
        System.out.println(socketAddress.getPort());
    }
}

在这里插入图片描述

1.8 网络通信协议

网络通信协议：
- 计算机网络中实现通信必须有一些约定，即通信协议，对速率，传输代码，代码结构，传输控制步骤，出错控制等制定标准。
通信协议分层的思想
- 在制定协议时，把复杂成份分解成一些简单的成份，再将他们复合起来。最常用的复合方式是层次方式，即同层间可以通信，上一层调用下一层，而与再下一层不发生关系。各层互不影响，利于系统的开发和扩展。
TCP
- TCP 协议是一TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。
- 其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。
- 它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送。
UDP
- UDP则不为IP提供可靠性、流控或差错恢复功能。
一般来说，TCP对应的是可靠性要求高的应用，而UDP对应的则是可靠性要求低、传输经济的应用。
TCP和UDP对比
- TCP协议
  - 使用TCP协议前，必须建立TCP连接，形成传输数据通道；
  - TCP协议进行通信的两个应用进程：客户端，服务端。
  - 在连接中可进行大数据量的传输
  - 传输完毕，需要释放已建立的连接，效率低
  - 传输前，采用 三次握手 方式，点对点通信，是可靠的。结束时四次挥手

三次握手——至少需要3次，把稳定连接
A:你愁啥？
B:瞅你咋滴？
A:干一架！
四次挥手——至少需要四次，确保成功断开
A:我决定分手了！
B:你真的决定要分手吗？
B:你真的真的决定要分手吗？
A: 我真的决定分手了！

在这里插入图片描述

UDP协议
- 将数据，源，目的封装成数据包，不需要建立连接
- 每个数据报的大小限制在64K内
- 发送方不管对方是否准备好，接收方收到也不确认，故事不可靠的
- 发送数据结束时，无需释放资源，开销小，速度快。
- 举例：发短信

二 TCP网络编程

2.1 信息通信案例

客户端发送信息给服务端，服务端将数据显示在控制台上。

2.1.1 TcpClientDemo

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author 缘友一世
 * date 2023/1/1-0:15
 */
public class TcpClientDemo {
    public static void main(String[] args) throws IOException {
        Socket socket =null;
        OutputStream os =null;
        try {
            //1 要知道服务器的地址，端口号
            InetAddress servetIp = InetAddress.getByName("127.0.0.1");
            int port=9999;
            //2 创建一个socket连接【规则连接】
            socket = new Socket(servetIp, port);
            //3 发送消息 IO流
            os = socket.getOutputStream();
            os.write("你好，服务器！".getBytes());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            if(os!=null) {
                os.close();
            }
            if(socket!=null) {
                socket.close();
            }
        }
    }
}

2.1.2 TcpServetDemo

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author 缘友一世
 * date 2023/1/1-0:16
 */
public class TcpServetDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket =null;
        Socket socket =null;
        InputStream inputStream =null;
        ByteArrayOutputStream baos =null;
        try {
            //1 要有一个地址
            serverSocket = new ServerSocket(9999);
            while (true) {
                //2 等待客户端链接过来
                socket = serverSocket.accept();
                //3 读取客户端的消息
                inputStream = socket.getInputStream();

                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int length;
                while ((length=inputStream.read(buffer))!=-1) {
                    baos.write(buffer,0,length);
                }
                System.out.println(baos);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            if(baos!=null) {
                baos.close();
            }
            if(inputStream!=null) {
                inputStream.close();
            }
            if(socket!=null) {
                socket.close();
            }
            if(serverSocket!=null) {
                serverSocket.close();
            }
        }
    }
}

在这里插入图片描述

2.2 文件传输演示

客户端发送文件给服务器，服务端将文件保存在本地。

2.2.1 TcpClientTest

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author 缘友一世
 * date 2023/1/1-10:08
 */
public class TcpClientTest {
    public static void main(String[] args) throws IOException {
        // 1 创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        // 2 创建一个输出流
        OutputStream os = socket.getOutputStream();
        // 3 读取文件
        FileInputStream fis = new FileInputStream("src/lesson03/picture01.jpg");
        // 4 写出文件
        byte[] buffer = new byte[1024];
        int length;
        while((length=fis.read(buffer))!=-1) {
            os.write(buffer,0,length);
        }
		 System.out.println("客户端上传完毕！");
        //通知服务端，客户端已经传输完成
        socket.shutdownOutput();

        //确定服务端接收完毕，才可以断开连接
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int length2;
        while((length2=inputStream.read(buffer2))!=-1) {
            outputStream.write(buffer2,0,length2);
        }
        System.out.println(outputStream);

        // 5 关闭资源
        fis.close();
        os.close();
        socket.close();
    }
}

2.2.2 TcpServeTest

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author 缘友一世
 * date 2023/1/1-10:03
 */
public class TcpServeTest {
    public static void main(String[] args) throws IOException {
        //1 创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2 监听客户端的链接
        //阻塞式监听，会一直等待客户端连接
        Socket socket = serverSocket.accept();
        //3 获取输入流
        InputStream is = socket.getInputStream();
        //4 文件输出
        FileOutputStream fos = new FileOutputStream("src/lesson03/picture02.jpg");
        byte[] buffer = new byte[1024];
        int length;
        while((length=is.read(buffer))!=-1) {
            fos.write(buffer,0,length);
        }

        //通知客户端，接收完毕，可以断开了
        FileOutputStream outputStream = (FileOutputStream) socket.getOutputStream();
        outputStream.write("服务端接收完毕！".getBytes());
        //5关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

在这里插入图片描述

2.3 初识Tomcat服务器

参看《javaweb【初识】3 Tomcat》
参看《Tomcat【黑马】》

三 UDP网络编程

3.1 简介

$D a t a g r am S oc k e t$ 和 $D a t a g r am P a c k e t$ 两个类实现了基于UDP协议的网络程序。
UDP 数据报通过数据报套接字 $D a t a g r am S oc k e t$ 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不确定什么时候可以抵达。
$D a t a g r am P a c k e t$ 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
UDP协议中每个数据报都给出了完整的地址信息，因此无需建立发送方和接收方的连接。【如同发快递包裹】

3.2 UDP通信

3.2.1 UdpClientTest

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**Udp的客户端和服务端是相对的
 * @author HP
 */
public class UdpClientTest {
    public static void main(String[] args) throws IOException {
        // 1 建立一个Socket
        //Datagram 数据电报
        //DatagramSocket  数据报套接字
        DatagramSocket socket = new DatagramSocket();
        //2 建立包
        String message="hello，服务器！";
        // 数据的目的地、长度
        InetAddress localhost = InetAddress.getByName("localhost");
        int port=9090;
        DatagramPacket packet = new DatagramPacket(message.getBytes(), 0, message.getBytes().length, localhost, port);

        //3 发送包
        socket.send(packet);
        //4 关闭流
        socket.close();
    }
}

3.2.2 UdpServeTest

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * @author 缘友一世
 * date 2023/1/1-11:04
 */
public class UdpServeTest {
    public static void main(String[] args) throws IOException {
        //1 开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //2 接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
        socket.receive(packet);
        System.out.println(packet.getAddress().getHostName());
        System.out.println(new String(packet.getData(),0,packet.getLength()));
        // 关闭连接
        socket.close();
    }
}

在这里插入图片描述

3.3 单向沟通案例

3.3.1 ChatSenderTest

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

/**
 * @author 缘友一世
 * date 2023/1/1-11:41
 */
public class ChatSenderTest {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(8888);
        //控制台读取数据
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while(true) {
            String data=reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));
            socket.send(packet);
            if("over".equals(data)) {
                break;
            }
        }
        socket.close();
    }
}

3.3.2 ChatReceiveTest

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * @author 缘友一世
 * date 2023/1/1-11:41
 * 两个人聊天
 */
public class ChatReceiveTest {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(6666);
        while(true) {
            //准备接收包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            //阻断式接收包裹
            socket.receive(packet);

            byte[] datas = packet.getData();
            String receiveData = new String(datas, 0,packet.getLength());
            System.out.println(receiveData);
            if(receiveData.equals("over")) {
                break;
            }
        }
        socket.close();
    }
}

在这里插入图片描述

3.4 双向沟通【多线程练习】

多线程内容回顾，参看Java多线程探究【一线程简介、实现】2.7 方式二：实现Runnable接口【推荐】

3.4.1 发送端多线程(TalkSender)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

/**
 * @author 缘友一世
 * date 2023/1/1-11:54
 */
public class TalkSender implements Runnable{
    DatagramSocket socket;
    BufferedReader reader;
    private int resourceAddress;
    private String destinationIp;
    private int destinationPort;

    public TalkSender( int resourceAddress, String destinationIp, int destinationPort) {
        this.resourceAddress = resourceAddress;
        this.destinationIp = destinationIp;
        this.destinationPort = destinationPort;
        try {
            socket = new DatagramSocket(resourceAddress);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void run() {
        while(true) {
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(destinationIp, destinationPort));
                socket.send(packet);
                if("over".equals(data)) {
                    break;
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        socket.close();
    }
}

3.4.2 接收端多线程(TalkReceive)

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

/**
 * @author 缘友一世
 * date 2023/1/1-12:19
 */
public class TalkReceive implements Runnable {
    DatagramSocket socket;
    private String msgFrom;

    public TalkReceive(int port,String msgFrom) {
        this.msgFrom=msgFrom;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            throw new RuntimeException(e);
        }

    }

    @Override
    public void run() {
        try {
            while(true) {
                //准备接收包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                //阻断式接收包裹
                socket.receive(packet);

                byte[] data = packet.getData();
                String receiveData = new String(data, 0, packet.getLength());
                System.out.println(msgFrom+":"+receiveData);
                if(receiveData.equals("over")) {
                    break;
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        socket.close();
    }
}

3.4.3 学生端(TalkStudent)

/**
 * @author 缘友一世
 * date 2023/1/1-12:44
 */
public class TalkStudent {
    public static void main(String[] args) {
        new Thread(new TalkSender(6666,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

3.4.4 老师端(TalkTeacher)

/**
 * @author 缘友一世
 * date 2023/1/1-12:48
 */
public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkReceive(9999,"学生")).start();
        new Thread(new TalkSender(5555,"localhost",8888)).start();
    }
}

在这里插入图片描述

四 URL编程

4.1 URL类简介

URL （Uniform Resource Locator）：统一资源定位符，它表示 internet 上某一资源的地址。
URL类是一种具体的URI，即URL可以用来标识一个资源，而且还指明如何定位这个资源
通过URL 我们可以访问Internet上的各种网络资源。浏览器通过解析给定的URL可以在网络上查找相应的文件或其他资源。
URL 的5个基本组成部分

传输协议://主机名:端口号/文件名#片段名？参数列表
//参数列表格式 ： 参数名=参数值 & 参数名=参数值
//片段名，即锚链接，比如小说网站，可以直接定位到某个章节位置
http://localhost:8080/love/index.jsp#a?username=wjk&password=521

4.2 URL类使用演示

import java.net.MalformedURLException;
import java.net.URL;

/**
 * @author 缘友一世
 * date 2023/1/1-13:14
 */
public class UrlDemo01 {
    public static void main(String[] args) throws MalformedURLException {
            URL url = new URL("http://localhost:8080/helloworld/index.jsp? username=cat&password=123");
            //获取URL的协议名
            System.out.println(url.getProtocol());
            //获取URL的主机名
            System.out.println(url.getHost());
            //获取URL的端口号
            System.out.println(url.getPort());
            //获取URL的文件路径
            System.out.println(url.getPath());
            //获取URL的文件名
            System.out.println(url.getFile());
            //获取URL的查询名
            System.out.println(url.getQuery());
    }
}

在这里插入图片描述

4.3 下载网络资源案例

import javax.net.ssl.HttpsURLConnection;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

/**
 * @author 缘友一世
 * date 2023/1/1-13:20
 */
public class UrlDown {
    public static void main(String[] args) throws IOException {
        //1 下载地址
        URL url = new URL("https://i0.hdslb.com/bfs/banner/32426df655433ef49017cd4c1828dc859c3381bb.jpg@976w_550h_1c_!web-home-carousel-cover.webp");
        //2 连接到这个资源
        HttpsURLConnection urlConnection= (HttpsURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fileOutputStream = new FileOutputStream("src/lesson06/picture.webp");
        byte[] buffer = new byte[1024];
        int length;
        //向指定文件中写出数据
        while((length=inputStream.read(buffer))!=-1) {
            fileOutputStream.write(buffer,0,length);
        }
        fileOutputStream.close();
        inputStream.close();
        //断开连接
        urlConnection.disconnect();
    }
}