学习笔记 on 秋萤blog

Maven的入门和使用

Fri, 22 Nov 2024 16:44:00 +0000

一、什么是Maven？

Maven 是一个流行的项目管理工具和构建工具，可以对 Java 项目进行构建、依赖管理。简单来说，它就像一个“助手”，使得项目的开发和管理变得更加简单和高效。

其它知识点补充：

项目管理工具：指的是一种软件，帮助开发者组织、管理和跟踪项目的进展。使用 Maven，可以轻松创建、配置和维护 Java 项目。

构建：是指将源代码转换为可以运行的程序的过程。Maven 可以自动化这个过程，它会根据指定的配置文件（通常是 pom.xml）来编译代码、打包程序、运行测试等。

依赖管理：是指处理项目中使用的库或其他组件（称为依赖）的过程。很多 Java 项目会依赖于其他库来实现某些功能。Maven 可以自动下载这些依赖，并确保它们的版本兼容，这样开发者就不需要手动管理这些库的版本和下载。

二、Maven有什么用？我们为什么要学Maven？

Maven 有什么用

项目的自动构建，包括代码的编译、测试、打包、安装、部署等操作。
依赖管理，项目使用到哪些依赖，可以快速完成导入，不需要手动导入jar包。

我们为什么要学 Maven？

简单一句话，你不学maven就别想学别的东西(例如springcloud)！

三、Maven项目结构

而下面的pom.xml则是Maven的核心配置，也是整个项目的所有依赖、插件、以及各种配置的集合，它也是使用XML格式编写的，一个标准的pom配置长这样：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;BookManage&lt;/artifactId&gt;
&lt;version&gt;1.0&lt;/version&gt;

&lt;properties&gt;
    &lt;maven.compiler.source&gt;17&lt;/maven.compiler.source&gt;
    &lt;maven.compiler.target&gt;17&lt;/maven.compiler.target&gt;
    &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
&lt;/properties&gt;

</project>

pom配置解释：

project:：根节点。

modelVersion:：定义了当前模型的版本，不用管它。

groupId、artifactId、version:：这三个元素合在一起，用于唯一区别每个项目，别人如果需要将我们编写的代码作为依赖，那么就必须通过这三个元素来定位我们的项目，我们称为一个项目的基本坐标，所有的项目一般都有自己的Maven坐标，因此我们通过Maven导入其他的依赖只需要填写这三个基本元素就可以了，无需再下载Jar文件，而是Maven自动帮助我们下载依赖并导入。

groupId 一般用于指定组名称，命名规则一般和包名一致，比如我们这里使用的是org.example，一个组下面可以有很多个项目。
artifactId 一般用于指定项目在当前组中的唯一名称，也就是说在组中用于区分于其他项目的标记。
version 代表项目版本，随着我们项目的开发和改进，版本号也会不断更新，我们可以手动指定当前项目的版本号，其他人使用我们的项目作为依赖时，也可以根据版本号进行选择（这里的SNAPSHOT代表快照，一般表示这是一个处于开发中的项目，正式发布项目一般只带版本号）

properties：这里一般都是一些变量和选项的配置，我们这里指定了JDK的源代码和编译版本为17，同时下面的源代码编码格式为UTF-8，无需进行修改。

四、Maven依赖导入

<dependencies>
//里面填写的就是所有的依赖
</dependencies>

举例说明（以插入Lombok依赖为例）：

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
</dependency>

五、Maven依赖作用域

除了三个基本的属性用于定位坐标外，依赖还可以添加以下属性：

type：依赖的类型，对于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值为jar
scope：依赖的范围
optional：标记依赖是否可选
exclusions：用来排除传递性依赖（一个项目有可能依赖于其他项目，就像我们的项目，如果别人要用我们的项目作为依赖，那么就需要一起下载我们项目的依赖，如Lombok）

`1. type`

作用：定义依赖的类型，对应项目的打包类型（packaging）。
默认值：jar。
使用场景：当依赖的类型不是 jar 时，例如 war（Web 应用）、pom（父项目定义）、zip 等，需要显式声明。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>example-artifact</artifactId>
<version>1.0.0</version>
<type>war</type>
</dependency>

`2. scope（重点）`

作用：定义依赖的作用范围。主要范围包括：
- compile（默认值）：编译、测试和运行时都需要。
- provided：编译和测试时需要，但运行时由容器（如 Tomcat）提供。
- runtime：运行和测试时需要，编译时不需要。
- test：仅测试时需要，编译和运行时不需要。
- system：类似于 provided，但需要本地提供依赖路径（几乎不用）。
- import：用于引入 BOM（Bill of Materials）依赖管理。

示例：

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

3. `optional`

作用：标记依赖是否为可选依赖，避免被传递到依赖的消费者（下游项目）。
默认值：false。
使用场景：当依赖是可选功能模块，不想影响下游项目时。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>optional-lib</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

4. `exclusions`

作用：用于排除传递性依赖，防止不必要的依赖被引入。
使用场景：当依赖的项目中包含的某些传递性依赖与你的项目冲突时。

示例：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.5.0</version>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>

六、Maven安装、可选和排除

1、Maven 安装

问题导入：如何在其他项目中引入我们自己编写的Maven项目作为依赖使用呢？

先创建一个用于测试的简单项目：

<?xml version=“1.0” encoding=“UTF-8”?>
<project xmlns=“http://maven.apache.org/POM/4.0.0"
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;TestMaven&lt;/artifactId&gt;
&lt;version&gt;1.0-SNAPSHOT&lt;/version&gt;

...

</project>

public class TestUtils {
public static void test() {
System.out.println(“家人们谁懂啊，蒸虾头，怎么会有人想吃我家鸽鸽下的蛋”);
}
}

接着我们点击右上角的Maven选项，然后执行install或直接在命令行中输入mvn install来安装我们自己的项目到本地Maven仓库中。

接着我们就可以在需要使用此项目作为依赖的其他项目中使用它了，只需要填写和这边一样的坐标：

<dependency>
<groupId>com.test</groupId>
<artifactId>TestMaven</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

接着我们就可以在项目中直接使用了：

public static void main(String[] args) {
TestUtils.test();
}

2、Maven 中的可选依赖（Optional）

作用

Maven 的可选依赖属性 optional 用于标记某个依赖是否是可选的。
默认行为：Maven 会传递所有依赖的依赖（传递性依赖），即如果项目 A 依赖项目 B，而项目 B 又依赖项目 C，则项目 A 会默认获取 B 和 C。
使用 optional 可以避免这种传递性。

场景

当某个依赖是额外的功能模块，而下游项目可能不需要它时。
避免引入无用的依赖，减少构建时间和冲突风险。

示例

项目 A 依赖项目 B，项目 B 依赖项目 C：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
</dependency>

项目 B 中声明 C 为可选依赖：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

结果：项目 A 不会自动获取 C，除非手动添加。

3、Maven 中的依赖排除（Exclusions）

作用

排除传递性依赖中不需要的模块。
为什么需要？
- 防止依赖冲突（例如不同版本的库）。
- 删除多余的依赖以优化项目构建。

示例

项目 A 依赖项目 B，而项目 B 又依赖项目 C，但项目 A 不需要 C。

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
<exclusions>
<exclusion>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
</exclusion>
</exclusions>
</dependency>

传递性依赖的层级示例

项目 A -> 项目 B -> 项目 C。
如果不需要项目 C，可通过 exclusions 将其排除，最终 A 只包含 B。

常见问题解决

依赖冲突：当传递性依赖中某个库的多个版本引入冲突时，排除旧版本并手动引入所需版本。
避免不必要的依赖：减少构建体积，避免不需要的模块。

Maven的继承

Maven 的继承机制允许项目的 POM 文件继承另一个 POM 文件中的配置，从而避免重复定义相同的配置。

1. 继承的特点

层级结构：Maven 的继承是树状结构，一个子项目只能继承一个父项目。
统一管理：父 POM 通常定义通用的依赖、插件、构建配置等，子 POM 自动继承。
减少重复：多个子项目可以共享父 POM 中的配置，提高复用性。

2. 父 POM 定义

父 POM 中定义通用配置，例如：

3. 子项目继承

子项目通过 <parent> 标签指定父 POM：

子项目继承父 POM 的依赖管理和插件配置。
可在子项目中覆盖或补充父 POM 的配置。

多模块机制用于将一个大项目拆分为多个模块，每个模块都是一个独立的 Maven 项目，但可以共享配置和依赖。

Maven的多模块

1. 多模块结构

多模块项目通常有一个父 POM 和多个子模块，目录结构如下：

project-root/
├── pom.xml          # 父 POM
├── module-a/        # 子模块 A
│   └── pom.xml
├── module-b/        # 子模块 B
│   └── pom.xml

2. 父 POM（根 POM）

父 POM 除了继承机制的配置外，还需要声明模块：

<project>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>multi-module-project</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging> <!– 必须是 pom 类型 –>
&lt;modules&gt;
    &lt;module&gt;module-a&lt;/module&gt;
    &lt;module&gt;module-b&lt;/module&gt;
&lt;/modules&gt;

</project>

3. 子模块的 POM

子模块 POM 需要指定父项目：

<project>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.example</groupId>
<artifactId>multi-module-project</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>module-a</artifactId>
</project>

4. 构建和依赖管理

构建：在根目录运行 mvn install，会依次构建所有模块。

依赖管理：模块之间可以互相依赖：

<dependency>
<groupId>com.example</groupId>
<artifactId>module-a</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

5. 优势

模块化：每个模块负责单一功能，便于开发和维护。
共享配置：通过父 POM 统一管理版本和插件。
并行构建：Maven 可以并行构建多个模块，加快构建速度。

Maven测试和打包

在 IDEA 中，Maven 项目有多个生命周期，每个生命周期对应一个插件执行任务。常见的命令如下：

clean：清理 target 文件夹，解决缓存问题。
validate：验证项目的可用性。
compile：编译项目为 .class 文件。
install：将项目安装到本地仓库，供其他项目作为依赖使用。
verify：依次执行 validate、compile、package 等生命周期阶段。

每个命令执行完后，IDE 会显示 BUILD SUCCESS，如果出现错误则会显示详细信息。

1. 测试命令

通过 test 命令，Maven 会自动运行 test 目录下的所有测试案例。测试类的名称需要以 Test 结尾（例如 MainTest），测试方法必须标注 @Test 注解。示例如下：

public class MainTest {
@Test
public void test() {
    System.out.println("我测你码");
}

}

2. 打包命令

使用 package 命令可以将项目打包成 JAR 文件，生成的 JAR 文件可以作为其他项目的依赖或可执行文件。执行 package 时，会先自动执行测试命令，确保项目没有问题。如果希望跳过测试，可以使用以下命令：

mvn package -Dmaven.test.skip=true

3. 打包带依赖的 JAR 文件

通常，打包后的 JAR 文件仅包含项目自己的类，而缺少所需的外部依赖。如果要将项目及其依赖一起打包，可以使用 maven-assembly-plugin 插件。插件配置如下：

<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.1.0</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<mainClass>com.test.Main</mainClass>
</manifest>
</archive>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>

配置好后，重新执行 package 命令，最终会生成两个 JAR 文件：一个是普通的 JAR 文件，另一个是包含所有依赖的 JAR 文件。我们只需要执行以下命令即可运行：

java -jar your-project-jar-with-dependencies.jar

&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;BookManage&lt;/artifactId&gt;
&lt;version&gt;1.0&lt;/version&gt;

&lt;properties&gt;
    &lt;maven.compiler.source&gt;17&lt;/maven.compiler.source&gt;
    &lt;maven.compiler.target&gt;17&lt;/maven.compiler.target&gt;
    &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
&lt;/properties&gt;

</project>

pom配置解释：

project:：根节点。

modelVersion:：定义了当前模型的版本，不用管它。

groupId 一般用于指定组名称，命名规则一般和包名一致，比如我们这里使用的是org.example，一个组下面可以有很多个项目。
artifactId 一般用于指定项目在当前组中的唯一名称，也就是说在组中用于区分于其他项目的标记。
version 代表项目版本，随着我们项目的开发和改进，版本号也会不断更新，我们可以手动指定当前项目的版本号，其他人使用我们的项目作为依赖时，也可以根据版本号进行选择（这里的SNAPSHOT代表快照，一般表示这是一个处于开发中的项目，正式发布项目一般只带版本号）

properties：这里一般都是一些变量和选项的配置，我们这里指定了JDK的源代码和编译版本为17，同时下面的源代码编码格式为UTF-8，无需进行修改。

四、Maven依赖导入

<dependencies>
//里面填写的就是所有的依赖
</dependencies>

举例说明（以插入Lombok依赖为例）：

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
</dependency>

五、Maven依赖作用域

除了三个基本的属性用于定位坐标外，依赖还可以添加以下属性：

type：依赖的类型，对于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值为jar
scope：依赖的范围
optional：标记依赖是否可选
exclusions：用来排除传递性依赖（一个项目有可能依赖于其他项目，就像我们的项目，如果别人要用我们的项目作为依赖，那么就需要一起下载我们项目的依赖，如Lombok）

`1. type`

作用：定义依赖的类型，对应项目的打包类型（packaging）。
默认值：jar。
使用场景：当依赖的类型不是 jar 时，例如 war（Web 应用）、pom（父项目定义）、zip 等，需要显式声明。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>example-artifact</artifactId>
<version>1.0.0</version>
<type>war</type>
</dependency>

`2. scope（重点）`

作用：定义依赖的作用范围。主要范围包括：
- compile（默认值）：编译、测试和运行时都需要。
- provided：编译和测试时需要，但运行时由容器（如 Tomcat）提供。
- runtime：运行和测试时需要，编译时不需要。
- test：仅测试时需要，编译和运行时不需要。
- system：类似于 provided，但需要本地提供依赖路径（几乎不用）。
- import：用于引入 BOM（Bill of Materials）依赖管理。

示例：

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

3. `optional`

作用：标记依赖是否为可选依赖，避免被传递到依赖的消费者（下游项目）。
默认值：false。
使用场景：当依赖是可选功能模块，不想影响下游项目时。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>optional-lib</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

4. `exclusions`

作用：用于排除传递性依赖，防止不必要的依赖被引入。
使用场景：当依赖的项目中包含的某些传递性依赖与你的项目冲突时。

示例：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.5.0</version>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>

六、Maven安装、可选和排除

1、Maven 安装

问题导入：如何在其他项目中引入我们自己编写的Maven项目作为依赖使用呢？

先创建一个用于测试的简单项目：

<?xml version=“1.0” encoding=“UTF-8”?>
<project xmlns=“http://maven.apache.org/POM/4.0.0"
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;TestMaven&lt;/artifactId&gt;
&lt;version&gt;1.0-SNAPSHOT&lt;/version&gt;

...

</project>

public class TestUtils {
public static void test() {
System.out.println(“家人们谁懂啊，蒸虾头，怎么会有人想吃我家鸽鸽下的蛋”);
}
}

接着我们点击右上角的Maven选项，然后执行install或直接在命令行中输入mvn install来安装我们自己的项目到本地Maven仓库中。

接着我们就可以在需要使用此项目作为依赖的其他项目中使用它了，只需要填写和这边一样的坐标：

<dependency>
<groupId>com.test</groupId>
<artifactId>TestMaven</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

接着我们就可以在项目中直接使用了：

public static void main(String[] args) {
TestUtils.test();
}

2、Maven 中的可选依赖（Optional）

作用

Maven 的可选依赖属性 optional 用于标记某个依赖是否是可选的。
默认行为：Maven 会传递所有依赖的依赖（传递性依赖），即如果项目 A 依赖项目 B，而项目 B 又依赖项目 C，则项目 A 会默认获取 B 和 C。
使用 optional 可以避免这种传递性。

场景

当某个依赖是额外的功能模块，而下游项目可能不需要它时。
避免引入无用的依赖，减少构建时间和冲突风险。

示例

项目 A 依赖项目 B，项目 B 依赖项目 C：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
</dependency>

项目 B 中声明 C 为可选依赖：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

结果：项目 A 不会自动获取 C，除非手动添加。

3、Maven 中的依赖排除（Exclusions）

作用

排除传递性依赖中不需要的模块。
为什么需要？
- 防止依赖冲突（例如不同版本的库）。
- 删除多余的依赖以优化项目构建。

示例

项目 A 依赖项目 B，而项目 B 又依赖项目 C，但项目 A 不需要 C。

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
<exclusions>
<exclusion>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
</exclusion>
</exclusions>
</dependency>

传递性依赖的层级示例

项目 A -> 项目 B -> 项目 C。
如果不需要项目 C，可通过 exclusions 将其排除，最终 A 只包含 B。

常见问题解决

依赖冲突：当传递性依赖中某个库的多个版本引入冲突时，排除旧版本并手动引入所需版本。
避免不必要的依赖：减少构建体积，避免不需要的模块。

Maven的继承

Maven 的继承机制允许项目的 POM 文件继承另一个 POM 文件中的配置，从而避免重复定义相同的配置。

1. 继承的特点

层级结构：Maven 的继承是树状结构，一个子项目只能继承一个父项目。
统一管理：父 POM 通常定义通用的依赖、插件、构建配置等，子 POM 自动继承。
减少重复：多个子项目可以共享父 POM 中的配置，提高复用性。

2. 父 POM 定义

父 POM 中定义通用配置，例如：

3. 子项目继承

子项目通过 <parent> 标签指定父 POM：

子项目继承父 POM 的依赖管理和插件配置。
可在子项目中覆盖或补充父 POM 的配置。

多模块机制用于将一个大项目拆分为多个模块，每个模块都是一个独立的 Maven 项目，但可以共享配置和依赖。

Maven的多模块

1. 多模块结构

多模块项目通常有一个父 POM 和多个子模块，目录结构如下：

project-root/
├── pom.xml          # 父 POM
├── module-a/        # 子模块 A
│   └── pom.xml
├── module-b/        # 子模块 B
│   └── pom.xml

2. 父 POM（根 POM）

父 POM 除了继承机制的配置外，还需要声明模块：

<project>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>multi-module-project</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging> <!– 必须是 pom 类型 –>
&lt;modules&gt;
    &lt;module&gt;module-a&lt;/module&gt;
    &lt;module&gt;module-b&lt;/module&gt;
&lt;/modules&gt;

</project>

3. 子模块的 POM

子模块 POM 需要指定父项目：

<project>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.example</groupId>
<artifactId>multi-module-project</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>module-a</artifactId>
</project>

4. 构建和依赖管理

构建：在根目录运行 mvn install，会依次构建所有模块。

依赖管理：模块之间可以互相依赖：

<dependency>
<groupId>com.example</groupId>
<artifactId>module-a</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

5. 优势

模块化：每个模块负责单一功能，便于开发和维护。
共享配置：通过父 POM 统一管理版本和插件。
并行构建：Maven 可以并行构建多个模块，加快构建速度。

Maven测试和打包

在 IDEA 中，Maven 项目有多个生命周期，每个生命周期对应一个插件执行任务。常见的命令如下：

clean：清理 target 文件夹，解决缓存问题。
validate：验证项目的可用性。
compile：编译项目为 .class 文件。
install：将项目安装到本地仓库，供其他项目作为依赖使用。
verify：依次执行 validate、compile、package 等生命周期阶段。

每个命令执行完后，IDE 会显示 BUILD SUCCESS，如果出现错误则会显示详细信息。

1. 测试命令

public class MainTest {
@Test
public void test() {
    System.out.println("我测你码");
}

}

2. 打包命令

mvn package -Dmaven.test.skip=true

3. 打包带依赖的 JAR 文件

&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;BookManage&lt;/artifactId&gt;
&lt;version&gt;1.0&lt;/version&gt;

&lt;properties&gt;
    &lt;maven.compiler.source&gt;17&lt;/maven.compiler.source&gt;
    &lt;maven.compiler.target&gt;17&lt;/maven.compiler.target&gt;
    &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
&lt;/properties&gt;

</project>

pom配置解释：

project:：根节点。

modelVersion:：定义了当前模型的版本，不用管它。

groupId 一般用于指定组名称，命名规则一般和包名一致，比如我们这里使用的是org.example，一个组下面可以有很多个项目。
artifactId 一般用于指定项目在当前组中的唯一名称，也就是说在组中用于区分于其他项目的标记。
version 代表项目版本，随着我们项目的开发和改进，版本号也会不断更新，我们可以手动指定当前项目的版本号，其他人使用我们的项目作为依赖时，也可以根据版本号进行选择（这里的SNAPSHOT代表快照，一般表示这是一个处于开发中的项目，正式发布项目一般只带版本号）

properties：这里一般都是一些变量和选项的配置，我们这里指定了JDK的源代码和编译版本为17，同时下面的源代码编码格式为UTF-8，无需进行修改。

四、Maven依赖导入

<dependencies>
//里面填写的就是所有的依赖
</dependencies>

举例说明（以插入Lombok依赖为例）：

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
</dependency>

五、Maven依赖作用域

除了三个基本的属性用于定位坐标外，依赖还可以添加以下属性：

type：依赖的类型，对于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值为jar
scope：依赖的范围
optional：标记依赖是否可选
exclusions：用来排除传递性依赖（一个项目有可能依赖于其他项目，就像我们的项目，如果别人要用我们的项目作为依赖，那么就需要一起下载我们项目的依赖，如Lombok）

`1. type`

作用：定义依赖的类型，对应项目的打包类型（packaging）。
默认值：jar。
使用场景：当依赖的类型不是 jar 时，例如 war（Web 应用）、pom（父项目定义）、zip 等，需要显式声明。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>example-artifact</artifactId>
<version>1.0.0</version>
<type>war</type>
</dependency>

`2. scope（重点）`

作用：定义依赖的作用范围。主要范围包括：
- compile（默认值）：编译、测试和运行时都需要。
- provided：编译和测试时需要，但运行时由容器（如 Tomcat）提供。
- runtime：运行和测试时需要，编译时不需要。
- test：仅测试时需要，编译和运行时不需要。
- system：类似于 provided，但需要本地提供依赖路径（几乎不用）。
- import：用于引入 BOM（Bill of Materials）依赖管理。

示例：

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

3. `optional`

作用：标记依赖是否为可选依赖，避免被传递到依赖的消费者（下游项目）。
默认值：false。
使用场景：当依赖是可选功能模块，不想影响下游项目时。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>optional-lib</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

4. `exclusions`

作用：用于排除传递性依赖，防止不必要的依赖被引入。
使用场景：当依赖的项目中包含的某些传递性依赖与你的项目冲突时。

示例：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.5.0</version>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>

六、Maven安装、可选和排除

Maven 安装

问题导入：如何在其他项目中引入我们自己编写的Maven项目作为依赖使用呢？

先创建一个用于测试的简单项目：

<?xml version=“1.0” encoding=“UTF-8”?>
<project xmlns=“http://maven.apache.org/POM/4.0.0"
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;TestMaven&lt;/artifactId&gt;
&lt;version&gt;1.0-SNAPSHOT&lt;/version&gt;

...

</project>

public class TestUtils {
public static void test() {
System.out.println(“家人们谁懂啊，蒸虾头，怎么会有人想吃我家鸽鸽下的蛋”);
}
}

接着我们点击右上角的Maven选项，然后执行install或直接在命令行中输入mvn install来安装我们自己的项目到本地Maven仓库中。

接着我们就可以在需要使用此项目作为依赖的其他项目中使用它了，只需要填写和这边一样的坐标：

<dependency>
<groupId>com.test</groupId>
<artifactId>TestMaven</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

接着我们就可以在项目中直接使用了：

public static void main(String[] args) {
TestUtils.test();
}

Maven 中的可选依赖（Optional）

作用

Maven 的可选依赖属性 optional 用于标记某个依赖是否是可选的。
默认行为：Maven 会传递所有依赖的依赖（传递性依赖），即如果项目 A 依赖项目 B，而项目 B 又依赖项目 C，则项目 A 会默认获取 B 和 C。
使用 optional 可以避免这种传递性。

场景

当某个依赖是额外的功能模块，而下游项目可能不需要它时。
避免引入无用的依赖，减少构建时间和冲突风险。

示例

项目 A 依赖项目 B，项目 B 依赖项目 C：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
</dependency>

项目 B 中声明 C 为可选依赖：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

结果：项目 A 不会自动获取 C，除非手动添加。

Maven 中的依赖排除（Exclusions）

作用

排除传递性依赖中不需要的模块。
为什么需要？
- 防止依赖冲突（例如不同版本的库）。
- 删除多余的依赖以优化项目构建。

示例

项目 A 依赖项目 B，而项目 B 又依赖项目 C，但项目 A 不需要 C。

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
<exclusions>
<exclusion>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
</exclusion>
</exclusions>
</dependency>

传递性依赖的层级示例

项目 A -> 项目 B -> 项目 C。
如果不需要项目 C，可通过 exclusions 将其排除，最终 A 只包含 B。

常见问题解决

依赖冲突：当传递性依赖中某个库的多个版本引入冲突时，排除旧版本并手动引入所需版本。
避免不必要的依赖：减少构建体积，避免不需要的模块。

Maven继承和多模块

&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;BookManage&lt;/artifactId&gt;
&lt;version&gt;1.0&lt;/version&gt;

&lt;properties&gt;
    &lt;maven.compiler.source&gt;17&lt;/maven.compiler.source&gt;
    &lt;maven.compiler.target&gt;17&lt;/maven.compiler.target&gt;
    &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
&lt;/properties&gt;

</project>

pom配置解释：

project:：根节点。

modelVersion:：定义了当前模型的版本，不用管它。

groupId 一般用于指定组名称，命名规则一般和包名一致，比如我们这里使用的是org.example，一个组下面可以有很多个项目。
artifactId 一般用于指定项目在当前组中的唯一名称，也就是说在组中用于区分于其他项目的标记。
version 代表项目版本，随着我们项目的开发和改进，版本号也会不断更新，我们可以手动指定当前项目的版本号，其他人使用我们的项目作为依赖时，也可以根据版本号进行选择（这里的SNAPSHOT代表快照，一般表示这是一个处于开发中的项目，正式发布项目一般只带版本号）

properties：这里一般都是一些变量和选项的配置，我们这里指定了JDK的源代码和编译版本为17，同时下面的源代码编码格式为UTF-8，无需进行修改。

四、Maven依赖导入

<dependencies>
//里面填写的就是所有的依赖
</dependencies>

举例说明（以插入Lombok依赖为例）：

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
</dependency>

五、Maven依赖作用域

除了三个基本的属性用于定位坐标外，依赖还可以添加以下属性：

type：依赖的类型，对于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值为jar
scope：依赖的范围
optional：标记依赖是否可选
exclusions：用来排除传递性依赖（一个项目有可能依赖于其他项目，就像我们的项目，如果别人要用我们的项目作为依赖，那么就需要一起下载我们项目的依赖，如Lombok）

`1. type`

作用：定义依赖的类型，对应项目的打包类型（packaging）。
默认值：jar。
使用场景：当依赖的类型不是 jar 时，例如 war（Web 应用）、pom（父项目定义）、zip 等，需要显式声明。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>example-artifact</artifactId>
<version>1.0.0</version>
<type>war</type>
</dependency>

`2. scope（重点）`

作用：定义依赖的作用范围。主要范围包括：
- compile（默认值）：编译、测试和运行时都需要。
- provided：编译和测试时需要，但运行时由容器（如 Tomcat）提供。
- runtime：运行和测试时需要，编译时不需要。
- test：仅测试时需要，编译和运行时不需要。
- system：类似于 provided，但需要本地提供依赖路径（几乎不用）。
- import：用于引入 BOM（Bill of Materials）依赖管理。

示例：

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

3. `optional`

作用：标记依赖是否为可选依赖，避免被传递到依赖的消费者（下游项目）。
默认值：false。
使用场景：当依赖是可选功能模块，不想影响下游项目时。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>optional-lib</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

4. `exclusions`

作用：用于排除传递性依赖，防止不必要的依赖被引入。
使用场景：当依赖的项目中包含的某些传递性依赖与你的项目冲突时。

示例：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.5.0</version>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>

六、Maven安装、可选和排除

Maven 安装

问题导入：如何在其他项目中引入我们自己编写的Maven项目作为依赖使用呢？

先创建一个用于测试的简单项目：

<?xml version=“1.0” encoding=“UTF-8”?>
<project xmlns=“http://maven.apache.org/POM/4.0.0"
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;TestMaven&lt;/artifactId&gt;
&lt;version&gt;1.0-SNAPSHOT&lt;/version&gt;

...

</project>

public class TestUtils {
public static void test() {
System.out.println(“家人们谁懂啊，蒸虾头，怎么会有人想吃我家鸽鸽下的蛋”);
}
}

接着我们点击右上角的Maven选项，然后执行install或直接在命令行中输入mvn install来安装我们自己的项目到本地Maven仓库中。

接着我们就可以在需要使用此项目作为依赖的其他项目中使用它了，只需要填写和这边一样的坐标：

<dependency>
<groupId>com.test</groupId>
<artifactId>TestMaven</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

接着我们就可以在项目中直接使用了：

public static void main(String[] args) {
TestUtils.test();
}

Maven 中的可选依赖（Optional）

作用

Maven 的可选依赖属性 optional 用于标记某个依赖是否是可选的。
默认行为：Maven 会传递所有依赖的依赖（传递性依赖），即如果项目 A 依赖项目 B，而项目 B 又依赖项目 C，则项目 A 会默认获取 B 和 C。
使用 optional 可以避免这种传递性。

场景

当某个依赖是额外的功能模块，而下游项目可能不需要它时。
避免引入无用的依赖，减少构建时间和冲突风险。

示例

项目 A 依赖项目 B，项目 B 依赖项目 C：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
</dependency>

项目 B 中声明 C 为可选依赖：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

结果：项目 A 不会自动获取 C，除非手动添加。

Maven 中的依赖排除（Exclusions）

作用

排除传递性依赖中不需要的模块。
为什么需要？
- 防止依赖冲突（例如不同版本的库）。
- 删除多余的依赖以优化项目构建。

示例

项目 A 依赖项目 B，而项目 B 又依赖项目 C，但项目 A 不需要 C。

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
<exclusions>
<exclusion>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
</exclusion>
</exclusions>
</dependency>

传递性依赖的层级示例

项目 A -> 项目 B -> 项目 C。
如果不需要项目 C，可通过 exclusions 将其排除，最终 A 只包含 B。

常见问题解决

依赖冲突：当传递性依赖中某个库的多个版本引入冲突时，排除旧版本并手动引入所需版本。
避免不必要的依赖：减少构建体积，避免不需要的模块。

&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;BookManage&lt;/artifactId&gt;
&lt;version&gt;1.0&lt;/version&gt;

&lt;properties&gt;
    &lt;maven.compiler.source&gt;17&lt;/maven.compiler.source&gt;
    &lt;maven.compiler.target&gt;17&lt;/maven.compiler.target&gt;
    &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
&lt;/properties&gt;

</project>

pom配置解释：

project:：根节点。

modelVersion:：定义了当前模型的版本，不用管它。

groupId 一般用于指定组名称，命名规则一般和包名一致，比如我们这里使用的是org.example，一个组下面可以有很多个项目。
artifactId 一般用于指定项目在当前组中的唯一名称，也就是说在组中用于区分于其他项目的标记。
version 代表项目版本，随着我们项目的开发和改进，版本号也会不断更新，我们可以手动指定当前项目的版本号，其他人使用我们的项目作为依赖时，也可以根据版本号进行选择（这里的SNAPSHOT代表快照，一般表示这是一个处于开发中的项目，正式发布项目一般只带版本号）

properties：这里一般都是一些变量和选项的配置，我们这里指定了JDK的源代码和编译版本为17，同时下面的源代码编码格式为UTF-8，无需进行修改。

四、Maven依赖导入

<dependencies>
//里面填写的就是所有的依赖
</dependencies>

举例说明（以插入Lombok依赖为例）：

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
</dependency>

五、Maven依赖作用域

除了三个基本的属性用于定位坐标外，依赖还可以添加以下属性：

type：依赖的类型，对于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值为jar
scope：依赖的范围
optional：标记依赖是否可选
exclusions：用来排除传递性依赖（一个项目有可能依赖于其他项目，就像我们的项目，如果别人要用我们的项目作为依赖，那么就需要一起下载我们项目的依赖，如Lombok）

`1. type`

作用：定义依赖的类型，对应项目的打包类型（packaging）。
默认值：jar。
使用场景：当依赖的类型不是 jar 时，例如 war（Web 应用）、pom（父项目定义）、zip 等，需要显式声明。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>example-artifact</artifactId>
<version>1.0.0</version>
<type>war</type>
</dependency>

`2. scope（重点）`

作用：定义依赖的作用范围。主要范围包括：
- compile（默认值）：编译、测试和运行时都需要。
- provided：编译和测试时需要，但运行时由容器（如 Tomcat）提供。
- runtime：运行和测试时需要，编译时不需要。
- test：仅测试时需要，编译和运行时不需要。
- system：类似于 provided，但需要本地提供依赖路径（几乎不用）。
- import：用于引入 BOM（Bill of Materials）依赖管理。

示例：

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

3. `optional`

作用：标记依赖是否为可选依赖，避免被传递到依赖的消费者（下游项目）。
默认值：false。
使用场景：当依赖是可选功能模块，不想影响下游项目时。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>optional-lib</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

4. `exclusions`

作用：用于排除传递性依赖，防止不必要的依赖被引入。
使用场景：当依赖的项目中包含的某些传递性依赖与你的项目冲突时。

示例：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.5.0</version>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>

六、Maven安装、可选和排除

Maven 安装

问题导入：如何在其他项目中引入我们自己编写的Maven项目作为依赖使用呢？

先创建一个用于测试的简单项目：

<?xml version=“1.0” encoding=“UTF-8”?>
<project xmlns=“http://maven.apache.org/POM/4.0.0"
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
&lt;groupId&gt;com.test&lt;/groupId&gt;
&lt;artifactId&gt;TestMaven&lt;/artifactId&gt;
&lt;version&gt;1.0-SNAPSHOT&lt;/version&gt;

...

</project>

public class TestUtils {
public static void test() {
System.out.println(“家人们谁懂啊，蒸虾头，怎么会有人想吃我家鸽鸽下的蛋”);
}
}

接着我们点击右上角的Maven选项，然后执行install或直接在命令行中输入mvn install来安装我们自己的项目到本地Maven仓库中。

接着我们就可以在需要使用此项目作为依赖的其他项目中使用它了，只需要填写和这边一样的坐标：

<dependency>
<groupId>com.test</groupId>
<artifactId>TestMaven</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

接着我们就可以在项目中直接使用了：

public static void main(String[] args) {
TestUtils.test();
}

Maven 中的可选依赖（Optional）

作用

Maven 的可选依赖属性 optional 用于标记某个依赖是否是可选的。
默认行为：Maven 会传递所有依赖的依赖（传递性依赖），即如果项目 A 依赖项目 B，而项目 B 又依赖项目 C，则项目 A 会默认获取 B 和 C。
使用 optional 可以避免这种传递性。

场景

当某个依赖是额外的功能模块，而下游项目可能不需要它时。
避免引入无用的依赖，减少构建时间和冲突风险。

示例

项目 A 依赖项目 B，项目 B 依赖项目 C：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
</dependency>

项目 B 中声明 C 为可选依赖：

<dependency>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

结果：项目 A 不会自动获取 C，除非手动添加。

Maven 中的依赖排除（Exclusions）

作用

排除传递性依赖中不需要的模块。
为什么需要？
- 防止依赖冲突（例如不同版本的库）。
- 删除多余的依赖以优化项目构建。

示例

项目 A 依赖项目 B，而项目 B 又依赖项目 C，但项目 A 不需要 C。

<dependency>
<groupId>org.example</groupId>
<artifactId>project-b</artifactId>
<version>1.0.0</version>
<exclusions>
<exclusion>
<groupId>org.example</groupId>
<artifactId>project-c</artifactId>
</exclusion>
</exclusions>
</dependency>

传递性依赖的层级示例

项目 A -> 项目 B -> 项目 C。
如果不需要项目 C，可通过 exclusions 将其排除，最终 A 只包含 B。

常见问题解决

依赖冲突：当传递性依赖中某个库的多个版本引入冲突时，排除旧版本并手动引入所需版本。
避免不必要的依赖：减少构建体积，避免不需要的模块。

&lt;groupId&gt;qiuying&lt;/groupId&gt;
&lt;artifactId&gt;BookManage&lt;/artifactId&gt;
&lt;version&gt;1.0&lt;/version&gt;

&lt;properties&gt;
    &lt;maven.compiler.source&gt;17&lt;/maven.compiler.source&gt;
    &lt;maven.compiler.target&gt;17&lt;/maven.compiler.target&gt;
    &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
&lt;/properties&gt;

</project>

pom配置解释：

project:：根节点。

modelVersion:：定义了当前模型的版本，不用管它。

groupId 一般用于指定组名称，命名规则一般和包名一致，比如我们这里使用的是org.example，一个组下面可以有很多个项目。
artifactId 一般用于指定项目在当前组中的唯一名称，也就是说在组中用于区分于其他项目的标记。
version 代表项目版本，随着我们项目的开发和改进，版本号也会不断更新，我们可以手动指定当前项目的版本号，其他人使用我们的项目作为依赖时，也可以根据版本号进行选择（这里的SNAPSHOT代表快照，一般表示这是一个处于开发中的项目，正式发布项目一般只带版本号）

properties：这里一般都是一些变量和选项的配置，我们这里指定了JDK的源代码和编译版本为17，同时下面的源代码编码格式为UTF-8，无需进行修改。

四、Maven依赖导入

<dependencies>
//里面填写的就是所有的依赖
</dependencies>

举例说明（以插入Lombok依赖为例）：

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
</dependency>

五、Maven依赖作用域

除了三个基本的属性用于定位坐标外，依赖还可以添加以下属性：

type：依赖的类型，对于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值为jar
scope：依赖的范围
optional：标记依赖是否可选
exclusions：用来排除传递性依赖（一个项目有可能依赖于其他项目，就像我们的项目，如果别人要用我们的项目作为依赖，那么就需要一起下载我们项目的依赖，如Lombok）

`1. type`

作用：定义依赖的类型，对应项目的打包类型（packaging）。
默认值：jar。
使用场景：当依赖的类型不是 jar 时，例如 war（Web 应用）、pom（父项目定义）、zip 等，需要显式声明。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>example-artifact</artifactId>
<version>1.0.0</version>
<type>war</type>
</dependency>

`2. scope`

作用：定义依赖的作用范围。主要范围包括：
- compile（默认值）：编译、测试和运行时都需要。
- provided：编译和测试时需要，但运行时由容器（如 Tomcat）提供。
- runtime：运行和测试时需要，编译时不需要。
- test：仅测试时需要，编译和运行时不需要。
- system：类似于 provided，但需要本地提供依赖路径（几乎不用）。
- import：用于引入 BOM（Bill of Materials）依赖管理。

示例：

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

3. `optional`

作用：标记依赖是否为可选依赖，避免被传递到依赖的消费者（下游项目）。
默认值：false。
使用场景：当依赖是可选功能模块，不想影响下游项目时。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>optional-lib</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

4. `exclusions`

作用：用于排除传递性依赖，防止不必要的依赖被引入。
使用场景：当依赖的项目中包含的某些传递性依赖与你的项目冲突时。

示例：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.5.0</version>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>

&lt;groupId&gt;qiuying&lt;/groupId&gt;
&lt;artifactId&gt;BookManage&lt;/artifactId&gt;
&lt;version&gt;1.0&lt;/version&gt;

&lt;properties&gt;
    &lt;maven.compiler.source&gt;17&lt;/maven.compiler.source&gt;
    &lt;maven.compiler.target&gt;17&lt;/maven.compiler.target&gt;
    &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
&lt;/properties&gt;

</project>

pom配置解释：

project:：根节点。

modelVersion:：定义了当前模型的版本，不用管它。

groupId 一般用于指定组名称，命名规则一般和包名一致，比如我们这里使用的是org.example，一个组下面可以有很多个项目。
artifactId 一般用于指定项目在当前组中的唯一名称，也就是说在组中用于区分于其他项目的标记。
version 代表项目版本，随着我们项目的开发和改进，版本号也会不断更新，我们可以手动指定当前项目的版本号，其他人使用我们的项目作为依赖时，也可以根据版本号进行选择（这里的SNAPSHOT代表快照，一般表示这是一个处于开发中的项目，正式发布项目一般只带版本号）

properties：这里一般都是一些变量和选项的配置，我们这里指定了JDK的源代码和编译版本为17，同时下面的源代码编码格式为UTF-8，无需进行修改。

Maven依赖导入

<dependencies>
//里面填写的就是所有的依赖
</dependencies>

举例说明（以插入Lombok依赖为例）：

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.36</version>
</dependency>

Maven依赖作用域

除了三个基本的属性用于定位坐标外，依赖还可以添加以下属性：

type：依赖的类型，对于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值为jar
scope：依赖的范围
optional：标记依赖是否可选
exclusions：用来排除传递性依赖（一个项目有可能依赖于其他项目，就像我们的项目，如果别人要用我们的项目作为依赖，那么就需要一起下载我们项目的依赖，如Lombok）

`1. type`

作用：定义依赖的类型，对应项目的打包类型（packaging）。
默认值：jar。
使用场景：当依赖的类型不是 jar 时，例如 war（Web 应用）、pom（父项目定义）、zip 等，需要显式声明。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>example-artifact</artifactId>
<version>1.0.0</version>
<type>war</type>
</dependency>

`2. scope`

作用：定义依赖的作用范围。主要范围包括：
- compile（默认值）：编译、测试和运行时都需要。
- provided：编译和测试时需要，但运行时由容器（如 Tomcat）提供。
- runtime：运行和测试时需要，编译时不需要。
- test：仅测试时需要，编译和运行时不需要。
- system：类似于 provided，但需要本地提供依赖路径（几乎不用）。
- import：用于引入 BOM（Bill of Materials）依赖管理。

示例：

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

3. `optional`

作用：标记依赖是否为可选依赖，避免被传递到依赖的消费者（下游项目）。
默认值：false。
使用场景：当依赖是可选功能模块，不想影响下游项目时。

示例：

<dependency>
<groupId>org.example</groupId>
<artifactId>optional-lib</artifactId>
<version>1.0.0</version>
<optional>true</optional>
</dependency>

4. `exclusions`

作用：用于排除传递性依赖，防止不必要的依赖被引入。
使用场景：当依赖的项目中包含的某些传递性依赖与你的项目冲突时。

示例：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.5.0</version>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>

Lambda表达式

Fri, 22 Nov 2024 15:59:00 +0000

什么是Lambda表达式？

Lambda 表达式是 Java 中的一种简洁语法，用于表示匿名函数。

它是 Java 8 中引入的功能，旨在提高代码的简洁性和可读性。

尤其是在处理函数式编程或需要传递行为的场景下，例如集合操作、并行流处理等。

我们为什么要学习或使用Lambda表达式？

代码更简洁：减少了匿名类的样板代码。
更具可读性：将行为直接传递给函数。
结合 Stream API 提高数据处理的效率和易读性。

什么时候可以用Lambda表达式？

如果一个接口中有且只有一个待实现的抽象方法，那么我们可以将匿名内部类简写为Lambda表达式

public static void main(String[] args) {
    Study study = () -> System.out.println("我是逆蝶！");
  	study.study();
}

注意事项

Lambda 表达式只能用于函数式接口（接口中有且只有一个抽象方法）。
如果需要使用外部变量，它必须是隐式 final（不能在 Lambda 表达式内外修改其值）。

Lambda 表达式的语法

基本语法结构为：

(参数列表) -> {方法体}

构成部分

参数列表：可以有零个、一个或多个参数，参数类型可以省略（由编译器推断）。
箭头符号 (->)：分隔参数列表和方法体。
方法体：包含 Lambda 表达式的逻辑，可用一条或多条语句。

或者可以这么表示：

([参数类型 参数名称,]...) ‐> { 代码语句，包括返回值 }

和匿名内部类不同，Lambda仅支持接口，不支持抽象类
接口内部必须有且仅有一个抽象方法（可以有多个方法，但是必须保证其他方法有默认实现，必须留一个抽象方法出来）

示例

1. 无参数的 Lambda 表达式

() -> System.out.println("Hello Lambda!");

2. 有一个参数的 Lambda 表达式

x -> System.out.println(x);

3. 有多个参数的 Lambda 表达式

(a, b) -> a + b

4. 有多条语句的方法体

(x, y) -> { int sum = x + y; return sum; }

没看懂？那让我们举一个不那么抽象的例子：

@FunctionalInterface   //添加了此注解的接口，都支持lambda表达式，符合函数式接口定义
public interface Runnable {
    public abstract void run();   //有且仅有一个抽象方法，此方法返回值为void，且没有参数
}

因此，Runable的的匿名内部类实现，就可以简写为：

Runnable runnable = () -> {    };

我们也可以写一个玩玩：

@FunctionalInterface
public interface Test {   //接口类型
    String test(Integer i);    //只有这一个抽象方法，且接受一个int类型参数，返回一个String类型结果
}

它的Lambda表达式的实现就可以写为：

Test test = (Integer i) -> { return i+""; };  //这里我们就简单将i转换为字符串形式

一些回忆——搭建该博客的流程

Wed, 13 Nov 2024 06:41:06 +0000

注册域名

什么是域名？

域名可以通俗地理解为互联网上的“门牌号码”或“地址”。每个网站在互联网上都有一个唯一的地址，这个地址就是域名。比如，人们常常访问的“baidu.com”，“taobao.com”等都是域名。它们由一串字符组成，通常包括字母、数字和连接符“-”，并由“.”分隔成几部分。域名的作用是让人们能够更容易地访问和记住网站，而不需要记住复杂的IP地址。同时，域名也具有一定的商业价值，可以作为企业或个人在互联网上的标识和品牌形象。

域名注册

博主域名是在阿里云购买的

官网：阿里云

阿里云-计算，为了无法计算的价值

首先注册账户，然后输入你想购买的域名

域名备案

然后到域名控制台进行实名认证和解析域名就行。

如果你用的内地服务器那还需要进行域名备案。

备案的流程就不细说，自己去了解一下就行。

购买云服务器

准备

首先需要一台云服务器，要有公网IP的，推荐雨云的：

雨云优惠注册地址：

https://www.rainyun.com/114514aa_

优惠码：114514aa

使用优惠码注册后绑定微信可获得5折优惠券

注册完账号后进到雨云控制台，云服务器入口可以在后台的总览和云产品部分找到：

点击购买云服务器，接着选择服务器区域，国内用户建议选择内地机房，因为延迟低网络稳定，比如宿迁和十堰，其中推荐十堰，因为IP便宜，如果预算充足选择宿迁更好（防御高，BGP线路）。但如果你没有备案域名那建议选择香港或美国的服务器。

这里我买了HK的服务器（因为懒得备案）

配置选择2核2G一般够用了，如果你网站用户多就选高点的配置，也可以后期升级配置。

系统选Debian11就行，预安装APP一个都别选（因为可能会有些不太好的事情发生，别问，问就说是发生了些不友好的经历...）

都选好后就可以点击立即购买了，也可以选择1元试用1天。

购买后即可在我的云服务器这里看到你买的云服务器，点击管理。

安装1Panel面板

首先需要通过SSH客户端连接服务器

下载安装并打开ssh客户端软件，ssh客户端软件推荐putty或mobaxterm，还有用win自带的终端或CMD也行

安装1Panel

curl -sSL https://resource.fit2cloud.com/1panel/package/quick_start.sh -o quick_start.sh && bash quick_start.sh

安装成功后，控制台会打印面板访问信息，可通过浏览器访问 1Panel：

http://目标服务器 IP 地址:目标端口/安全入口

如果使用的是云服务器，请至安全组开放目标端口。

ssh 登录 1Panel 服务器后，执行 1pctl user-info 命令可获取安全入口（entrance）

安装成功后，可使用 1pctl 命令行工具来维护 1Panel

记得记住账号密码噢

然后浏览器输入地址登录进去就行惹

接着安装应用

使用 1Panel 部署 | Halo 文档

1Panel 简介

1Panel 是一个现代化、开源的 Linux 服务器运维管理面板。

功能

快速建站：深度集成 WordPress 和 Halo，域名绑定、SSL 证书配置等一键搞定。
高效管理：通过 Web 端轻松管理 Linux 服务器，包括应用管理、主机监控、文件管理、数据库管理、容器管理等。
安全可靠：最小漏洞暴露面，提供防火墙和安全审计等功能。
一键备份：支持一键备份和恢复，备份数据云端存储，永不丢失。

安装基础软件

在安装 Halo 之前，我们需要先在 1Panel 上安装好所需的软件，包括 OpenResty 和数据库（MySQL、PostgreSQL、MariaDB 都可以）。在接下来的文档中，我们会默认你已经安装好了这两个软件，并不再赘述。

安装 Halo 应用

进入应用商店应用列表，选择其中的 Halo 应用进行安装。

在应用详情页选择最新的 Halo 版本进行安装。

参数说明：

名称：要创建的 Halo 应用的名称。
版本：选择最新的版本即可。
数据库服务：Halo 应用使用的数据库应用，支持下拉选择已安装的数据库应用，1Panel 会自动配置 Halo 使用该数据库。
数据库名：Halo 应用使用的数据库名称，1Panel 会在选中的数据库中自动创建这个数据库。
数据库用户：Halo 应用使用的数据库用户名，1Panel 会在选中的数据库中自动创建这个用户，并添加对应的数据库授权。
数据库用户密码：Halo 应用使用的数据库用户密码，1Panel 会在选中的数据库中自动为上一步创建的用户配置该密码。
外部访问地址：Halo 应用的最终访问地址，如果有为 Halo 规划域名，需要配置为域名格式，例如 http://halo.example.com。否则配置为 http://服务器IP:PORT，例如 http://192.168.1.1:8090。
端口：Halo 应用的服务端口。

开始安装后页面自动跳转到已安装应用列表，等待刚刚安装的 Halo 应用变为已启动状态。

创建网站

完成 Halo 应用的安装后，此时并不会自动创建一个网站，我们需要手动创建一个网站，然后将 Halo 应用绑定到这个网站上才能使用域名访问。

点击 1Panel 菜单的网站，进入网站列表页，点击 创建网站 按钮。

在已装应用中选择我们刚刚新建的 Halo 应用。
正确填写主域名，需要注意的是需要提前解析好域名到服务器 IP。

最后，点击确认按钮，等待网站创建完成即可访问网站进行初始化。

这样我们就部署完成了

关于如何在CentOS8上部署若依项目的思考

Wed, 13 Nov 2024 00:54:13 +0000

前提条件

Java环境：确保安装了jdk(博主用的jdk11.0.23)
数据库：MySQL(博主用的MySQL8.0.26)
Redis：在若依项目中通常用作缓存和消息队列，提升数据访问速度和处理能力(博主用的redis0.5.3)
Nginx：作为反向代理服务器，可以处理请求负载均衡、静态资源服务和 HTTPS 加密，确保高效的流量管理和更好的性能。两者结合使用，可以极大提升应用的响应速度和可靠性(博主用的nginx1.14.1)

具体操作

Java

安装jdk

第一种方法：个人建议去官网上下载jdk的jar包

访问官方网站：前往 Oracle JDK 下载页面或 OpenJDK 下载页面。

选择版本：选择你需要的JDK版本（记得选Linux x64哦）。

下载包：找到对应的JAR包或安装包（通常是.tar.gz或.zip格式），点击下载。

解压缩（如需要）：下载完成后，如果是压缩包，可以使用以下命令解压：

tar -zxvf jdk-<version>.tar.gz

把下载好的jar包直接拖进你的home文件夹里

第二种方法：直接通过命令行下载

通过包管理器安装

sudo dnf install java-11-openjdk-devel

确认安装：

java -version

MySQL

安装MySQL

sudo dnf install @mysql

启动MySQL服务

sudo systemctl start mysqld

设置MySQL服务

sudo systemctl enable mysqld

运行安全配置

sudo mysql_secure_installation

登录MySQL并创建若依项目需要的数据库和用户

mysql -u root -p

修改 root 的密码为 123456

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '123456';

FLUSH PRIVILEGES;

修改 root 可以远程登录

update user set host = '%' where user = 'root';

FLUSH PRIVILEGES;

在MySQL提示符下执行

CREATE DATABASE ruoyi;

CREATE USER 'ruoyiuser'@'localhost' IDENTIFIED BY 'your_password';

GRANT ALL PRIVILEGES ON ruoyi.* TO 'ruoyiuser'@'localhost';

FLUSH PRIVILEGES;

EXIT;

修改 mysql 的配置文件

sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf

修改如下配置

bind-address=0.0.0.0

重启 mysql 服务

service mysql restart

使用如下命令查看 MySQL 服务状态

service mysql status

Redis

安装 Redis

sudo dnf install epel-release -y

sudo dnf install redis -y

启动 Redis

sudo systemctl start redis

设置 Redis

sudo systemctl enable redis

验证 Redis 是否正常运行：

redis-cli ping

返回 PONG 就是正常运行啦！

Nginx

安装 Nginx

sudo dnf install nginx -y

启动 Nginx

sudo systemctl start nginx

设置 Nginx

sudo systemctl enable nginx

部署若依项目

ps：博主自己从阿里的源下载失败了，所以这里就推荐用jar包

具体步骤：

进入若依的官网，然后复制箭头所指的地址

打开你的IDEA，"File"→"Close Project"，关闭现有的项目

然后新建"Project"→"Get from VCS"→在"URL那行粘贴下载地址

创建项目后，更改主库数据源

准备数据库表

先创建一个数据库，这里我们创建一个名为 ruoyi 的数据库。

将项目所需的表创建。

依次将两个 sql 文件中的内容拷贝到 navicat 中，在 sql 中添加使用当前数据库的语句：

然后执行整个 sql。

两个 sql 文件全部执行之后，会生成这些表：

配置数据库

编辑 application-dev.yml 或 application.yml，配置数据库连接：

spring:
      datasource:
        url: jdbc:mysql://localhost:3306/ruoyi?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
        username: ruoyiuser
        password: your_password

先运行一遍确保没有报错，然后打开右侧的"maven"→"ruoyi"→"Lifecycle"→"package"，然后等待打包完成，就可以在左侧的"ruoyi-admin"→"target" 看到"ruoyi-admin.jar"了。

然后右键"ruoyi-admin.jar"→"Open in"→"Explorer",你就看到若依的jar包啦

新建部署目录

mkdir -p /opt/deploy/ruoyi/{api,web}

把你的若依jar包放进api里

启动若依项目

在 target 目录下运行：

java -jar ruoyi-admin.jar

此时后端已经准备完毕，我们接下来准备前端

将ruoyi-vue里的ruoyi-ui打开，然后

1、安装依赖包，运行 RUOYI-VUE/bin/package.bat

2、打包构建，运行 RUOYI-VUE/bin/build.bat

（前提：已安装nodejs和yarn）

然后把这web文件放这里边

/opt/deploy/ruoyi/web

配置Nginx

创建新的配置文件：

sudo vi /etc/nginx/conf.d/ruoyi.conf

添加以下内容：

server {
        listen 80;
        server_name your_domain_or_ip;
    location / {
        proxy_pass http://localhost:8080;  # 若依默认端口
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}</code></pre><p style="">然后Esc → ： → wq</p><h3 style="" id="%E9%87%8D%E5%90%AF-nginx">重启 Nginx</h3><pre><code class="language-Shell">sudo systemctl restart nginx</code></pre><h3 style="" id="%E6%9C%80%E7%BB%88%E6%95%88%E6%9E%9C">最终效果</h3><p style="">最后，打开浏览器，访问 http://your_domain_or_ip，就可以看到若依的登录界面了。</p><p style=""><img src="/upload/%E5%89%8D%E7%AB%AF%E6%88%90%E5%8A%9F.webp" alt="前端成功.png" width="100%" height="100%" style="display: inline-block"></p><p style=""><img src="/upload/%E5%90%8E%E7%AB%AF%E6%88%90%E5%8A%9F.webp" alt="后端成功.png" width="100%" height="100%" style="display: inline-block"></p>
  datasource:
    url: jdbc:mysql://localhost:3306/ruoyi?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC
    username: ruoyiuser
    password: your_password</code></pre><p style="">先运行一遍确保没有报错，然后打开右侧的"maven"→"ruoyi"→"Lifecycle"→"package"，然后等待打包完成，就可以在左侧的"ruoyi-admin"→"target" 看到"ruoyi-admin.jar"了。</p><p style=""><img src="/upload/%E6%89%93%E5%8C%85%E8%8B%A5%E4%BE%9D.webp" alt="打包若依.png" width="100%" height="100%" style="display: inline-block"></p><p style="">然后右键"ruoyi-admin.jar"→"Open in"→"Explorer",你就看到若依的jar包啦</p><h3 style="" id="%E6%96%B0%E5%BB%BA%E9%83%A8%E7%BD%B2%E7%9B%AE%E5%BD%95">新建部署目录</h3><pre><code class="language-Shell">mkdir -p /opt/deploy/ruoyi/{api,web}</code></pre><p style="">把你的若依jar包放进api里</p><h3 style="" id="%E5%90%AF%E5%8A%A8%E8%8B%A5%E4%BE%9D%E9%A1%B9%E7%9B%AE">启动若依项目</h3><p style="">在 target 目录下运行：</p><pre><code class="language-Shell">java -jar ruoyi-admin.jar</code></pre><p style="">此时后端已经准备完毕，我们接下来准备前端</p><p style="">将ruoyi-vue里的ruoyi-ui打开，然后</p><p style="">1、安装依赖包，运行 RUOYI-VUE/bin/package.bat</p><p style="">2、打包构建，运行 RUOYI-VUE/bin/build.bat</p><p style="">（前提：已安装nodejs和yarn）</p><p style=""><img src="/upload/%E9%83%A8%E7%BD%B2%E5%89%8D%E7%AB%AF01.webp" alt="部署前端01.png" width="100%" height="100%" style="display: inline-block"></p><p style="">然后把这web文件放这里边</p><pre><code>/opt/deploy/ruoyi/web</code></pre><p style=""><img src="/upload/%E9%83%A8%E7%BD%B2%E5%89%8D%E7%AB%AF02.webp" alt="部署前端02.png" width="100%" height="100%" style="display: inline-block"></p><h3 style="" id="%E9%85%8D%E7%BD%AEnginx">配置Nginx</h3><p style="">创建新的配置文件：</p><pre><code class="language-Shell">sudo vi /etc/nginx/conf.d/ruoyi.conf</code></pre><p style="">添加以下内容：</p><pre><code class="language-Shell">server {
    listen 80;
    server_name your_domain_or_ip;

    location / {
        proxy_pass http://localhost:8080;  # 若依默认端口
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}</code></pre><p style="">然后Esc → ： → wq</p><h3 style="" id="%E9%87%8D%E5%90%AF-nginx">重启 Nginx</h3><pre><code class="language-Shell">sudo systemctl restart nginx</code></pre><h3 style="" id="%E6%9C%80%E7%BB%88%E6%95%88%E6%9E%9C">最终效果</h3><p style="">最后，打开浏览器，访问 http://your_domain_or_ip，就可以看到若依的登录界面了。</p><p style=""><img src="/upload/%E5%89%8D%E7%AB%AF%E6%88%90%E5%8A%9F.webp" alt="前端成功.png" width="100%" height="100%" style="display: inline-block"></p><p style=""><img src="/upload/%E5%90%8E%E7%AB%AF%E6%88%90%E5%8A%9F.webp" alt="后端成功.png" width="100%" height="100%" style="display: inline-block"></p>
  datasource:
    url: jdbc:mysql://localhost:3306/ruoyi?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC
    username: ruoyiuser
    password: your_password</code></pre><p style="">先运行一遍确保没有报错，然后打开右侧的"maven"→"ruoyi"→"Lifecycle"→"package"，然后等待打包完成，就可以在左侧的"ruoyi-admin"→"target" 看到"ruoyi-admin.jar"了。</p><p style=""><img src="/upload/%E6%89%93%E5%8C%85%E8%8B%A5%E4%BE%9D.webp" alt="打包若依.png" width="100%" height="100%" style="display: inline-block"></p><p style="">然后右键"ruoyi-admin.jar"→"Open in"→"Explorer",你就看到若依的jar包啦</p><h3 style="" id="%E6%96%B0%E5%BB%BA%E9%83%A8%E7%BD%B2%E7%9B%AE%E5%BD%95">新建部署目录</h3><pre><code class="language-Shell">mkdir -p /opt/deploy/ruoyi/{api,web}</code></pre><p style="">把你的若依jar包放进api里</p><h3 style="" id="%E5%90%AF%E5%8A%A8%E8%8B%A5%E4%BE%9D%E9%A1%B9%E7%9B%AE">启动若依项目</h3><p style="">在 target 目录下运行：</p><pre><code class="language-Shell">java -jar ruoyi-admin.jar</code></pre><p style=""><span fontsize="" color="">此时后端已经准备完毕，我们接下来准备前端</span></p><p style="">将ruoyi-vue里的ruoyi-ui打开，然后</p><p style="">1、安装依赖包，运行 RUOYI-VUE/bin/package.bat</p><p style="">2、打包构建，运行 RUOYI-VUE/bin/build.bat</p><p style=""><span fontsize="" color="">（前提：已安装nodejs和yarn）</span></p><p style=""><img src="/upload/%E9%83%A8%E7%BD%B2%E5%89%8D%E7%AB%AF01.webp" alt="部署前端01.png" width="100%" height="100%" style="display: inline-block"></p><p style="">然后把这web文件放这里边</p><pre><code>/opt/deploy/ruoyi/web</code></pre><p style=""><img src="/upload/%E9%83%A8%E7%BD%B2%E5%89%8D%E7%AB%AF02.webp" alt="部署前端02.png" width="100%" height="100%" style="display: inline-block"></p><h3 style="" id="%E9%85%8D%E7%BD%AEnginx"><span fontsize="" color="">配置Nginx</span></h3><p style=""><span fontsize="" color="">创建新的配置文件：</span></p><pre><code class="language-Shell">sudo vi /etc/nginx/conf.d/ruoyi.conf</code></pre><p style=""><span fontsize="" color="">添加以下内容：</span></p><pre><code class="language-Shell">server {
    listen 80;
    server_name your_domain_or_ip;

    location / {
        proxy_pass http://localhost:8080;  # 若依默认端口
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}</code></pre><p style=""><span fontsize="" color="">然后Esc → ： → wq</span></p><h3 style="" id="%E9%87%8D%E5%90%AF-nginx"><span fontsize="" color="">重启 Nginx</span></h3><pre><code class="language-Shell">sudo systemctl restart nginx</code></pre><h3 style="" id="%E6%9C%80%E7%BB%88%E6%95%88%E6%9E%9C">最终效果</h3><p style="">最后，打开浏览器，访问 http://your_domain_or_ip，就可以看到若依的登录界面了。</p><p style=""><img src="/upload/%E5%89%8D%E7%AB%AF%E6%88%90%E5%8A%9F.webp" alt="前端成功.png" width="100%" height="100%" style="display: inline-block"></p><p style=""><img src="/upload/%E5%90%8E%E7%AB%AF%E6%88%90%E5%8A%9F.webp" alt="后端成功.png" width="100%" height="100%" style="display: inline-block"></p>
  datasource:
    url: jdbc:mysql://localhost:3306/ruoyi?useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC
    username: ruoyiuser
    password: your_password</code></pre><p style="">先运行一遍确保没有报错，然后打开右侧的"maven"→"ruoyi"→"Lifecycle"→"package"，然后等待打包完成，就可以在左侧的"ruoyi-admin"→"target" 看到"ruoyi-admin.jar"了。</p><p style=""><img src="/upload/%E6%89%93%E5%8C%85%E8%8B%A5%E4%BE%9D.webp" alt="打包若依.png" width="100%" height="100%" style="display: inline-block"></p><p style="">然后右键"ruoyi-admin.jar"→"Open in"→"Explorer",你就看到若依的jar包啦</p><p style="">新建部署目录</p><pre><code>mkdir -p /opt/deploy/ruoyi/{api,web}</code></pre><p style="">把你的若依jar包放进api里</p><p style="">启动若依项目：</p><p style="">在 target 目录下运行：</p><pre><code>java -jar ruoyi-admin.jar</code></pre><p style=""><span style="font-size: 11ptpx">此时后端已经准备完毕，我们接下来准备前端</span></p><p style="">将ruoyi-vue里的ruoyi-ui打开，然后</p><p style="">1、安装依赖包，运行 RUOYI-VUE/bin/package.bat</p><p style="">2、打包构建，运行 RUOYI-VUE/bin/build.bat</p><p style=""><span style="font-size: 11ptpx">（前提：已安装nodejs和yarn）</span></p><p style=""><img src="/upload/%E9%83%A8%E7%BD%B2%E5%89%8D%E7%AB%AF01.webp" alt="部署前端01.png" width="100%" height="100%" style="display: inline-block"></p><p style="">然后把这web文件放这里边</p><pre><code>/opt/deploy/ruoyi/web</code></pre><p style=""><img src="/upload/%E9%83%A8%E7%BD%B2%E5%89%8D%E7%AB%AF02.webp" alt="部署前端02.png" width="100%" height="100%" style="display: inline-block"></p><p style=""><span style="font-size: 11ptpx">配置Nginx</span></p><p style=""><span style="font-size: 11ptpx">创建新的配置文件：</span></p><pre><code>sudo vi /etc/nginx/conf.d/ruoyi.conf</code></pre><p style=""><span style="font-size: 11ptpx">添加以下内容：</span></p><pre><code>server {
    listen 80;
    server_name your_domain_or_ip;

    location / {
        proxy_pass http://localhost:8080;  # 若依默认端口
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}</code></pre><p style=""><span style="font-size: 11ptpx">然后Esc → ： → wq</span></p><p style=""><span style="font-size: 11ptpx">重启 Nginx：</span></p><pre><code>sudo systemctl restart nginx</code></pre><p style="">最后，打开浏览器，访问 http://your_domain_or_ip，就可以看到若依的登录界面了。</p><p style=""><img src="/upload/%E5%89%8D%E7%AB%AF%E6%88%90%E5%8A%9F.webp" alt="前端成功.png" width="100%" height="100%" style="display: inline-block"></p><p style=""><img src="/upload/%E5%90%8E%E7%AB%AF%E6%88%90%E5%8A%9F.webp" alt="后端成功.png" width="100%" height="100%" style="display: inline-block"></p>

学习笔记 on 秋萤blog

Maven的入门和使用

一、什么是Maven？

二、Maven有什么用？我们为什么要学Maven？

Maven 有什么用

我们为什么要学 Maven？

三、Maven项目结构

pom配置解释：

四、Maven依赖导入

五、Maven依赖作用域

1. type

2. scope（重点）

3. optional

4. exclusions

六、Maven安装、可选和排除

1、Maven 安装

2、Maven 中的可选依赖（Optional）

3、Maven 中的依赖排除（Exclusions）

Maven的继承

1. 继承的特点

2. 父 POM 定义

3. 子项目继承

Maven的多模块

1. 多模块结构

2. 父 POM（根 POM）

3. 子模块的 POM

4. 构建和依赖管理

5. 优势

Maven测试和打包

1. 测试命令

2. 打包命令

3. 打包带依赖的 JAR 文件

pom配置解释：

四、Maven依赖导入

五、Maven依赖作用域

1. type

2. scope（重点）

3. optional

4. exclusions

六、Maven安装、可选和排除

1、Maven 安装

2、Maven 中的可选依赖（Optional）

3、Maven 中的依赖排除（Exclusions）

Maven的继承

1. 继承的特点

2. 父 POM 定义

3. 子项目继承

Maven的多模块

1. 多模块结构

2. 父 POM（根 POM）

3. 子模块的 POM

4. 构建和依赖管理

5. 优势

Maven测试和打包

1. 测试命令

2. 打包命令

3. 打包带依赖的 JAR 文件

pom配置解释：

四、Maven依赖导入

五、Maven依赖作用域

1. type

2. scope（重点）

3. optional

4. exclusions

六、Maven安装、可选和排除

Maven 安装

Maven 中的可选依赖（Optional）

Maven 中的依赖排除（Exclusions）

Maven继承和多模块

pom配置解释：

四、Maven依赖导入

五、Maven依赖作用域

1. type

2. scope（重点）

3. optional

4. exclusions

六、Maven安装、可选和排除

Maven 安装

Maven 中的可选依赖（Optional）

Maven 中的依赖排除（Exclusions）

`1. type`

`2. scope（重点）`

3. `optional`

4. `exclusions`

`1. type`

`2. scope（重点）`

3. `optional`

4. `exclusions`

`1. type`

`2. scope（重点）`

3. `optional`

4. `exclusions`

`1. type`

`2. scope（重点）`

3. `optional`

4. `exclusions`

`1. type`

`2. scope（重点）`

3. `optional`

4. `exclusions`

`1. type`

`2. scope`

3. `optional`

4. `exclusions`

`1. type`

`2. scope`

3. `optional`

4. `exclusions`

安装 Halo 应用

创建网站