Java学习配套代码资源包 - 初学者至进阶者的完整指南

本文还有配套的精品资源，点击获取

简介：本资源包《IT学习资料3》为Java学习者提供了丰富的编程示例和学习材料，从基础到高级覆盖广泛知识点，并涉及常用框架和技术。包括算法实现、开发工具使用、ORM技术、Spring框架应用、学习笔记和课程代码等，旨在帮助学习者系统掌握Java编程语言，并提升实际开发技能。

1. Java基础知识精讲

Java语言自1995年诞生以来，一直以其跨平台、对象导向的特性成为IT领域的主流编程语言之一。本章将回顾Java的基础知识，从语法结构到基本概念，为读者构建坚实的编程基础。

1.1 Java语言特性回顾

Java是一种强类型的、面向对象的编程语言，它通过虚拟机跨平台运行，保证了“一次编写，到处运行”的特性。Java代码首先被编译成字节码，然后由Java虚拟机（JVM）执行。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

上述代码展示了Java程序的基本结构，其中 public class 定义了一个公共类， main 方法是程序的入口。

1.2 数据类型与变量

Java定义了基本数据类型如整型、浮点型、字符型和布尔型，以及复杂的引用数据类型如数组和对象。每种数据类型的存储方式和范围都有严格规定。

int integerVar = 10;
double doubleVar = 3.14;
boolean booleanVar = true;

变量的定义需要指定数据类型，并可在定义时直接赋值。

1.3 控制流语句

控制流语句是编程中用于决定程序执行路径的语句，包括条件判断和循环结构。 if 、 switch 语句用于条件判断，而 for 、 while 和 do-while 循环用于重复执行代码块。

if (integerVar == 10) {
    // 条件满足时执行
} else {
    // 条件不满足时执行
}

for (int i = 0; i < 5; i++) {
    System.out.println("Loop iteration: " + i);
}

这些语句是编写动态逻辑的基础，对理解程序流程至关重要。

Java基础知识是任何Java开发者必须掌握的，它是构建复杂应用程序的前提。通过本章内容，读者将能更深入地理解Java的运行机制及基本编程方法。

2. 编程示例与学习材料深入剖析

深入理解和掌握编程技能是任何一名IT专业人员的必经之路。在本章中，我们将深入探讨Java编程的基础知识，并通过实际的编程示例和学习材料进行剖析，以帮助读者巩固理论知识并提升实战能力。

2.1 基本语法和结构深入

2.1.1 变量、数据类型与运算符

在Java中，变量是用来存储数据的容器，数据类型则指明了变量所存储的数据种类。Java是一种强类型语言，要求在使用变量之前必须声明其类型。数据类型分为基本数据类型和引用数据类型两大类。基本数据类型包括整型、浮点型、字符型和布尔型，而引用数据类型包括类、接口和数组。

运算符用于在程序中执行数学和逻辑运算。Java提供了多种运算符，如算术运算符、关系运算符、逻辑运算符、位运算符等。在实际编码中，合理地使用运算符可以简化代码，但同时也应注意运算符优先级和短路逻辑对程序行为的影响。

// 示例代码：基本数据类型变量的声明与赋值
int num = 10; // 整型变量
double height = 175.5; // 浮点型变量
char grade = 'A'; // 字符型变量
boolean isAvailable = true; // 布尔型变量

// 示例代码：运算符的使用
int sum = num + 10;
if (num > 5 && isAvailable) { // 使用逻辑与运算符
    System.out.println("num is greater than 5 and is available");
}

2.1.2 控制流语句与代码块

控制流语句是编程中用于控制程序执行顺序的语句。在Java中，控制流语句包括条件语句和循环语句。常见的条件语句有if-else、switch-case，而循环语句包括for、while和do-while。通过这些控制流语句，我们可以构建出复杂的程序逻辑结构。

代码块是一组用大括号 {} 包围起来的语句集合，在Java中定义了一个新的作用域。代码块可以出现在任何允许出现单条语句的地方，如方法体、循环体和条件语句体中。

// 示例代码：控制流语句
for (int i = 0; i < 5; i++) { // for循环
    System.out.println("The value of i is: " + i);
    if (i == 3) {
        break; // 跳出循环
    }
}

2.2 面向对象编程案例分析

2.2.1 类与对象的创建和使用

面向对象编程（OOP）是Java的核心概念之一。类是创建对象的蓝图，而对象则是类的实例。类包含了数据和操作数据的方法，方法定义了对象的行为。创建对象的过程包括声明变量、分配内存和初始化对象。

// 示例代码：类与对象的创建和使用
class Car {
    String make;
    String model;
    public Car(String make, String model) {
        this.make = make;
        this.model = model;
    }
    public void displayInfo() {
        System.out.println("This is a " + make + " " + model);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Camry");
        myCar.displayInfo(); // 输出: This is a Toyota Camry
    }
}

2.2.2 继承、封装和多态性的实际应用

继承是面向对象编程中的一种机制，它允许我们创建一个新类，该类拥有另一个类的属性和方法。封装是将数据（属性）和代码（方法）绑定在一起的过程，隐藏了对象的内部细节。多态性意味着不同的对象可以执行相同的操作，但实现细节可能不同。

// 示例代码：继承与多态性的应用
class Vehicle {
    private String color;
    public void start() {
        System.out.println("The vehicle starts");
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
}

class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("The car starts with a specific sound");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle myVehicle = new Vehicle();
        myVehicle.start(); // 输出: The vehicle starts
        Car myCar = new Car();
        myCar.start(); // 输出: The car starts with a specific sound
    }
}

2.3 异常处理和文件I/O操作

2.3.1 异常处理机制的理解与实践

Java的异常处理机制提供了处理程序运行时错误的能力。异常是在程序执行过程中发生的不正常事件，可能导致程序非正常终止。Java通过try-catch-finally语句来捕获和处理异常。

// 示例代码：异常处理机制的应用
try {
    // 可能抛出异常的代码块
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // 捕获异常，并进行处理
    System.out.println("Cannot divide by zero!");
} finally {
    // 无论是否发生异常都会执行的代码块
    System.out.println("This is the finally block.");
}

2.3.2 文件的读写操作与NIO的新特性

Java提供了丰富的API进行文件操作，其中I/O流类库用于读写数据。Java 7引入了NIO.2（New IO），它提供了一种更有效的方式来处理文件系统。

import java.io.*;
import java.nio.file.*;

public class FileReadWriteExample {
    public static void main(String[] args) {
        // 文件写入示例
        Path path = Paths.get("example.txt");
        String data = "Hello, Java NIO.2!";
        try (BufferedWriter writer = Files.newBufferedWriter(path, StandardCharsets.UTF_8)) {
            writer.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 文件读取示例
        try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上章节内容深入浅出地剖析了Java编程的基本语法、面向对象编程、异常处理以及文件I/O操作的基础知识与实践应用，为读者提供了一个系统性的学习路径，帮助他们巩固基础知识并提升实战技能。下一章节将继续深入探讨Java的高级主题。

3. 经典排序与搜索算法在Java中的实现

排序和搜索算法是计算机科学的基础，对于任何需要数据组织和检索的场景都是必不可少的。在Java中，实现这些算法不仅可以加深对算法本身的理解，还能提升使用Java解决问题的综合能力。本章节将通过经典排序算法的代码实现及其优化，以及搜索算法的实践与应用，深入探讨如何在Java环境中高效地操作数据集。

3.1 排序算法的代码实现与优化

排序算法在计算机科学中占据着举足轻重的地位，它是数据结构和算法课程的基础内容，同时也是日常编程工作中经常遇到的问题。在Java中实现排序算法不仅能帮助我们理解算法逻辑，还能通过分析算法性能来加深对时间复杂度和空间复杂度概念的理解。

3.1.1 冒泡排序、选择排序和插入排序

冒泡排序、选择排序和插入排序是三种基本的排序算法，它们简单直观，适合初学者学习和理解排序的基本概念。

冒泡排序

冒泡排序的核心思想是通过重复遍历待排序的数组，比较相邻元素的大小，并在必要时交换它们的位置，直到整个数组排序完成。

public void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换 arr[j+1] 和 arr[j]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

选择排序

选择排序通过不断选择剩余元素中的最小者，然后放到未排序序列的开头，以此来对数组进行排序。

public void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++)
            if (arr[j] < arr[min_idx])
                min_idx = j;
        // 交换找到的最小值元素与第i位置上的元素
        int temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
}

插入排序

插入排序的工作方式类似于我们整理扑克牌。通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

public void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; ++i) {
        int key = arr[i];
        int j = i - 1;
        // 将arr[i]插入到已排序的arr[0...i-1]序列中
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

3.1.2 快速排序、归并排序的递归实现

快速排序和归并排序是两种更为高效的排序算法，它们采用了分而治之的策略，通常适用于大规模数据集的排序。

快速排序

快速排序的核心操作是分区，选择一个元素作为基准（pivot），重新排列数组，所有比基准小的元素摆放在基准前面，所有比基准大的元素摆放在基准后面。通过递归的方式，将小于基准值元素的子数组和大于基准值元素的子数组排序。

public void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);  // 分别排序基准左右两边的子数组
        quickSort(arr, pi + 1, high);
    }
}

private int partition(int[] arr, int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, high);
    return (i + 1);
}

private void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

归并排序

归并排序的主过程是先递归地将当前序列平均分割成两半，对每部分递归地应用归并排序，然后将排序好的两半合并成一个有序序列。

public void mergeSort(int[] arr, int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

private void merge(int[] arr, int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;
    int[] L = new int[n1];
    int[] R = new int[n2];

    for (int i = 0; i < n1; ++i)
        L[i] = arr[l + i];
    for (int j = 0; j < n2; ++j)
        R[j] = arr[m + 1 + j];

    int i = 0, j = 0;
    int k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

快速排序和归并排序的性能通常优于冒泡排序、选择排序和插入排序。快速排序在最好的情况下时间复杂度为O(n log n)，归并排序在所有情况下都能保证O(n log n)的时间复杂度。然而，这两种排序算法的实现相对复杂，需要更多的内存空间来存储临时数据，尤其是在递归实现归并排序时。

通过本章节内容的介绍，我们已经了解了多种排序算法在Java中的实现方式，包括它们的特点、适用场景和性能分析。在下一节中，我们将继续探讨搜索算法的原理及代码实现，进一步完善我们的数据处理能力。

4. ```

第四章：开发工具和库的代码示例

4.1 集成开发环境（IDE）的高级功能

4.1.1 Eclipse与IntelliJ IDEA的配置与使用

随着Java开发的普及，选择一款高效的集成开发环境（IDE）是提高工作效率的关键。在本节中，我们将深入探讨Eclipse和IntelliJ IDEA，两种广受欢迎的Java IDE。

Eclipse是最传统的Java开发环境之一，以其强大的插件生态和灵活的配置受到许多开发者的喜爱。在Eclipse中，可以使用“Help”->“Eclipse Marketplace”安装所需的插件。安装完成后，通过“Window”->“Preferences”可以对Eclipse进行一系列的配置。例如，针对编码风格的配置，可以进入到“Java”->“Code Style”，进而配置编码格式、导入排序规则等。

IntelliJ IDEA是近年来广受好评的IDE，其对Java语言的深度优化、智能代码辅助及重构工具等特性，使其成为许多开发者的首选。在IntelliJ IDEA中，你可以通过“File”->“Settings”或使用快捷键 Ctrl+Alt+S 进行IDE的个性化设置。它支持一键代码重构、智能代码补全以及对Spring和Hibernate等框架的特殊支持。

以下是安装插件、配置IDEEclipse和IntelliJ IDEA的代码块示例及其解释：

// Eclipse 插件安装代码示例
public void installPlugin(String pluginUrl) {
    EclipsePlugin installPlugin = new EclipsePlugin();
    installPlugin.setUrl(pluginUrl);
    installPlugin.setName(name);
    pluginRegistry.add(installPlugin);
    eclipseRestart();
}

// IntelliJ IDEA 插件安装代码示例
public void installPluginInIntelliJ(String pluginId) {
    final PluginManager pluginManager = PluginManager.getInstance(project);
    final IdeaPluginDescriptor plugin = pluginManager.getPlugin(pluginId);
    if (plugin == null) {
        throw new PluginException("Plugin with id " + pluginId + " was not found.");
    }
    pluginManager/installPlugin(plugin);
}

在Eclipse中安装插件通常需要提供插件的URL地址，并调用相关API完成安装。而IntelliJ IDEA中则可以使用 PluginManager 提供的方法来安装插件。上述代码块虽然并未展示实际的API调用，但展示了安装插件的概念性逻辑。

4.1.2 Maven和Gradle的构建工具应用

构建工具在Java项目中扮演着至关重要的角色，它们负责项目的构建过程，包括编译、测试、打包等一系列操作。Maven和Gradle是目前较为流行的构建工具，它们各有特点，为开发者提供不同的构建体验。

Maven是基于项目对象模型（POM）的概念，通过定义一套项目对象模型来管理项目的构建、报告和文档。通常，Maven项目的 pom.xml 文件中定义了项目的基本信息、依赖关系、构建配置等。一个基本的 pom.xml 配置片段如下所示：

<project xmlns="***"
         xmlns:xsi="***"
         xsi:schemaLocation="***
                             ***">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.example</groupId>
    <artifactId>example-java-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.6.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

在Maven中，所有依赖管理、构建指令等都可以通过定义在 pom.xml 中的配置来完成，而无需编写复杂的脚本。这大大简化了项目构建过程。

Gradle则提供了一种更为灵活的构建方式，使用Groovy或Kotlin DSL来描述项目构建脚本。以下是使用Gradle构建一个简单的Java项目的 build.gradle 文件示例：

plugins {
    id 'java'
}

group 'org.example'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.0'
}

test {
    useJUnitPlatform()
}

Gradle的构建文件同样定义了项目的各种参数、仓库地址以及依赖信息。通过定义任务（task），Gradle可以实现更复杂的构建逻辑，如自动下载依赖、打包应用程序等。

4.2 核心库的深入学习与代码实践

4.2.1 Java集合框架的使用与扩展

Java集合框架是Java API中非常重要的一个部分，提供了大量接口和实现类，用于存储和操作对象群集。本节将深入探讨集合框架的使用与一些高级特性。

集合框架主要包括List、Set、Map三大类接口，以及它们的众多实现类。例如，ArrayList实现了List接口，HashMap实现了Map接口。开发者可以根据需要选择合适的集合类型。以下是一个使用ArrayList和HashMap的简单代码示例：

import java.util.*;

public class CollectionExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        Map<String, Integer> ages = new HashMap<>();
        ages.put("Alice", 30);
        ages.put("Bob", 35);
        ages.put("Charlie", 40);

        for (String name : names) {
            System.out.println(name);
            if (ages.containsKey(name)) {
                System.out.println("Age: " + ages.get(name));
            }
        }
    }
}

在代码中创建了一个 ArrayList 和一个 HashMap ，然后向这些集合中添加了数据。通过遍历 ArrayList ，可以访问到存储的名字，并且通过 HashMap 查询到对应人的年龄。

Java集合框架的高级特性还包括并发集合（如 ConcurrentHashMap ），它为多线程环境下的集合操作提供了线程安全的实现。另外还有 NavigableMap 等接口，它们提供了诸如 floorEntry() 或 higherEntry() 等在有序映射中查找特定键的方法。

4.2.2 Java I/O流的高级用法

Java I/O流是进行输入输出操作的核心工具，它提供了一种统一的方式来处理数据的读写。Java I/O流被分为字节流和字符流，包括输入流和输出流两大类。字节流主要用于处理原始二进制数据，而字符流则用于处理文本数据。

Java I/O流的高级用法包括使用装饰者模式增强流的功能，例如可以将一个 FileInputStream 装饰成带有缓冲功能的 BufferedInputStream ，以提高数据读取的效率。下面的示例代码展示了如何使用装饰者模式增强I/O流：

import java.io.*;

public class IOTest {
    public static void main(String[] args) {
        try (
            FileInputStream fis = new FileInputStream("example.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);
            DataInputStream dis = new DataInputStream(bis);
        ) {
            String name = dis.readUTF();
            System.out.println("Name: " + name);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在代码中，我们首先创建了一个 FileInputStream ，然后通过 BufferedInputStream 和 DataInputStream 对其进行装饰。这样的组合可以让我们高效地读取文本数据，并且可以读取特定类型的数据，如本例中的UTF格式字符串。

装饰者模式不仅限于字节流，对于字符流也一样适用。这允许开发者根据需要灵活地构建读取和写入数据的管道，以适应各种不同的I/O需求。

在Java 7中引入的 try-with-resources 语句可以自动关闭实现了 AutoCloseable 接口的资源。这在处理多个I/O资源时非常有用，可以简化资源管理的代码，避免资源泄漏。

try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
    // 使用reader进行文件读取操作
}
// 文件读取操作完毕后，reader会自动关闭

使用 try-with-resources 语句，我们不再需要在 finally 块中手动关闭资源，这提高了代码的可读性和健壮性。以上代码展示了如何安全且高效地读取文件内容。

通过以上内容，我们不仅学习了如何配置和使用Java中的集成开发环境（IDE）和构建工具，还深入探讨了Java集合框架和I/O流的高级用法。接下来，将继续探索框架技术与Java企业级应用的内容。

# 5. 框架技术与Java企业级应用

## 5.1 ORM技术应用实战

### 5.1.1 Hibernate框架的配置与映射

在企业级Java应用开发中，Hibernate框架凭借其强大的ORM（对象关系映射）能力，成为处理数据库交互的重要工具。正确配置Hibernate，以及合理映射对象到数据库表是开发高效、稳定应用的关键。

配置Hibernate通常涉及以下几个步骤：
1. **添加依赖库**：在项目中加入Hibernate核心库以及JDBC驱动。
2. **配置文件**：创建`hibernate.cfg.xml`，在该文件中配置数据库连接信息，如URL、用户名、密码，以及映射文件的位置。
3. **创建实体类**：定义Java对象，映射到数据库中的表。
4. **创建映射文件**：XML或注解方式指定实体类与数据库表的对应关系。

一个简单的`hibernate.cfg.xml`配置示例如下：

```xml
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "***">
<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/your_database</property>
        <property name="connection.username">your_username</property>
        <property name="connection.password">your_password</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>
        <!-- Mapping files -->
        <mapping class="com.example.EntityClass" />
    </session-factory>
</hibernate-configuration>

使用注解映射实体类通常更加简洁，示例如下：

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name", nullable = false)
    private String name;

    // ... other fields, getters, and setters ...
}

5.1.2 MyBatis的动态SQL与缓存策略

MyBatis是一个灵活的SQL Mapping框架，其动态SQL能力允许开发者编写灵活的SQL语句，以适应不同的查询需求。此外，MyBatis还支持多种缓存策略，能够显著提高数据访问的效率。

在MyBatis中，动态SQL的构建通常依赖于XML映射文件，示例如下：

<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectUsersWithCondition" resultType="User">
        SELECT * FROM users
        <where>
            <if test="name != null">
                AND name LIKE CONCAT('%', #{name}, '%')
            </if>
            <if test="age != null">
                AND age = #{age}
            </if>
        </where>
    </select>
</mapper>

MyBatis支持一级和二级缓存策略： - 一级缓存 ：也称为会话级缓存，它是基于SqlSession的，同一个SqlSession对象查询的数据会被缓存，且只在当前SqlSession会话中有效。 - 二级缓存 ：也称为全局缓存，是基于mapper namespace的，跨多个SqlSession共享。当使用二级缓存时，通常需要配置缓存的实现类，比如ehcache。

<cache eviction="LRU" flushInterval="60000" size="512" readOnly="true" />

通过适当的缓存策略，可以有效减少数据库的访问次数，提高应用性能。

本文还有配套的精品资源，点击获取

简介：本资源包《IT学习资料3》为Java学习者提供了丰富的编程示例和学习材料，从基础到高级覆盖广泛知识点，并涉及常用框架和技术。包括算法实现、开发工具使用、ORM技术、Spring框架应用、学习笔记和课程代码等，旨在帮助学习者系统掌握Java编程语言，并提升实际开发技能。

本文还有配套的精品资源，点击获取