Gradle

Gradle 与 Maven 的区别可以看这篇文章：https://gradle.org/maven-vs-gradle/。

日常使用哪个都是没有问题的。网络上很多人说 Gradle 过于灵活，较难上手，其实完全可以把它使用成 Maven 的样子，只作为依赖管理工具，高级功能不用就行（后面熟悉了再用） 😄。

这两个工具中 Gradle 的更新版本较快，高版本的部分语法是不兼容低版本的，所以力求稳定的话直接使用 Maven 即可，Gradle 升级不是那么的平缓。强大的灵活性失去的就是易用性。有句话说的好：高端玩家选择自定义设置，普通玩家选择默认配置。

本文使用 build.gradle.kts 的写法，毕竟 Kotlin 很好用！kts 的语法大部分都是以键值对的方式存在的，如果自己感觉很陌生，但是自己有基础的话，可以看一下 B 站霍老师的的视频：

迁移至gradle.ktshttps://www.bilibili.com/video/BV1Kf4y1p7zq/?share_source=copy_web&vd_source=0b7b4ba48d2cb78ec7e6042083167a54

墙裂推荐在 ~/.gradle 目录中创建 init.gradle.kts 文件，添加以下内容。这段内容的意思是：如果 Gradle 下载的依赖源是在 https://repo.maven.apache.org/maven2、https://dl.google.com/dl/android/maven2、https://plugins.gradle.org/m2 三个源中的依赖，下载依赖时实际使用的地址将被替换为 to 后面定义的镜像地址，此配置是全局生效的，不需要对新建的项目进行修改。

镜像地址使用的腾讯云的，是否使用根据自己的需要修改即可。这段代码也是来自于霍老师的，浪子自己手打的，累啊，霍老师竟然给了个 gist……

~/.gradle/init.gradle
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
fun RepositoryHandler.enableMirror() {
    all {
        if (this is MavenArtifactRepository) {
            val originUrl = this.url.toString().removeSuffix("/")
            urlMappings[originUrl]?.let {
                logger.lifecycle("Repository[$url] is mirrored to $it")
                this.setUrl(it)
            }
        }
    }
}

val urlMappings = mapOf(
    "https://repo.maven.apache.org/maven2" to "https://mirrors.cloud.tencent.com/nexus/repository/maven-public/",
    "https://dl.google.com/dl/android/maven2" to "https://mirrors.cloud.tencent.com/nexus/repository/maven-public/",
    "https://plugins.gradle.org/m2" to "https://mirrors.cloud.tencent.com/nexus/repository/maven-public/"
)

gradle.allprojects {
    buildscript {
        repositories.enableMirror()
    }
    repositories.enableMirror()
}

gradle.beforeSettings {
    pluginManagement.repositories.enableMirror()
    dependencyResolutionManagement.repositories.enableMirror()
}

以上脚本仅在 Gradle > 6.8 时可用。

提示

  • Gradle 提供了两个环境变量很有用，GRADLE_HOME 自己本机安装的 Gradle；
  • GRADLE_USER_HOME：可以自定义下载依赖的存放的路径，包括使用 IDEA 旧版本时创建或者 Clone Gradle 项目时下载的不同版本的 Gradle；
  • 如果不想 Gradle 的依赖存放于默认的位置(通常是 ~/.gradle/)，如果 C 盘空间不够，强烈推荐设置 GRADLE_USER_HOME。
1
2
3
4
5
6
7
8
9
10
11
12
# Gradle 查找下载配置的顺序 * 代表可以为任意名称
~/.gradle/init.gradle
~/.gradle/init.d/*.gradle
GRADLE_HOME/init.d/*.gradle
GRADLE_USER_HOME/init.gradle
GRADLE_USER_HOME/init.d/*.gradle

# Gradle 查找依赖的顺序
# M2_HOME 是 Maven 的安装路径环境变量
~/.m2/settings.xml
M2_HOME/conf/settings.xml
~/.m2/repository

如果 Gradle 版本 >= 7，并且喜欢 Kotlin，推荐使用 kts，体验更佳！

两个文件

多模块目录示例：

1
2
3
4
5
6
7
8
|-- Project
    |-- sub-project-1
        |-- src
        |-- build.gradle.kts
    |-- sub-project-2
        |-- src
        |-- build.gradle.kts
    |-- settings.gradle.kts

1. settings.gradle.kts

settings.gradle.kts
1
2
3
4
5
6
7
8
// 项目的根文件名称
rootProject.name = "根项目文件夹名称"
// 包含的子模块，下面两种写法方式都可以
// 方式一：冒号表示相对路径；也支持省略冒号的方式，这将使模块名称被解释为相对于 settings.gradle.kts 文件所在目录的路径
include(":module1", ":module2", ":module3", ":module4")
// 方式二：
include(":module1")
include(":module2")

2. build.gradle.kts

build.gradle.kts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 项目使用插件
plugins {

}

group = "com.code"
version = "1.0-SNAPSHOT"

allprojects {
    
    // 依赖下载源
    repositories {
        // 本地仓库
        mavenLocal()
        // 腾讯云仓库
        maven("https://mirrors.cloud.tencent.com/nexus/repository/maven-public/")
        // 如果项目中需要从 http 下载依赖，打开下面的设置
        // maven {
        //     url = uri("http://mirrors.cloud.tencent.com/nexus/repository/maven-public/")
        //     isAllowInsecureProtocol = true
        // }
    }

    // 所有项目引入依赖
    dependencies {
        testImplementation "org.springframework.boot:spring-boot-starter-test"
    }
}

dependencies {
    implementation("org.jetbrains.kotlin:kotlin-reflect")
}
// 设置编译器的字符集，以便能够正确地处理文件中的 Unicode 字符。
tasks.withType<JavaCompile> {
    options.encoding = "UTF-8"
}

推荐使用 Gradle 8.x 版本的 Version catalog 方式管理依赖。

Maven

Maven 是一个 Java 生态用的较多的依赖管理工具。

Maven 中有 6 种 scope：

  1. compile（默认）

    这是默认作用域，如果未指定，则使用该 scope。编译依赖项在项目的所有类路径中都可用。此外，这些依赖项将传播到依赖项目，在编译与打包时都会加入。

  2. provided

    这很像 compile ，但表示您希望 JDK 或容器在运行时提供依赖项。例如，在为 Java Enterprise Edition 构建 Web 应用程序时，您需要将对 Servlet API 和相关 Java EE API 的依赖设置为范围 provided ，因为 Web 容器提供了这些类。具有此作用域的依赖项将添加到用于编译和测试的类路径中，但不添加到运行时类路径中（打包时不加入）。它不是可传递的。

  3. runtime

    此范围指示编译不需要依赖项，但执行程序需要依赖。Maven 在运行时和测试类路径中包含此作用域的依赖项，但不包括编译类路径。

  4. test

    此范围指示依赖项不是正常使用应用程序所必需的，并且仅适用于测试编译和执行阶段。此范围不是可传递的。通常，此范围用于测试库，如 JUnit 和 Mockito。它也用于非测试库，如 Apache Commons IO，这些库用于单元测试（src/test/java）但不用于代码（src/main/java）。

  5. system

    此作用域类似于 provided，但是需要结合 systemPath 提供显式包含它的 JAR，即而从本地文件系统获取依赖项，不会在存储库中查找。

    1
    2
    3
    4
    5
    6
    7
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.30</version>
        <scope>system</scope>
        <systemPath>${basedir}/lib/mysql-connector-java.jar</systemPath>
    </dependency>

  6. import

    此作用域仅支持 POM 文件中的 dependencyManagement 部分。它表示依赖关系将被指定 POM 的 dependencyManagement 部分中的有效依赖关系列表替换。

自己的 jar 包安装到 maven 仓库

相信很多新手在没用 maven 之前，项目目录中都会单独使用一个文件夹存放项目使用的目录。但是使用 maven 之后就不需要了，使用 maven 管理要方便许多，那么问题来了，如果有的 jar 包在下载失败或者配置的下载源中没有怎么办？

这个时候就可以自己去官网或者 jar 包作者提供的下载方式自己下载，然后使用 maven 提供的安装命令，安装到本地的 maven 仓库，然后项目中引入即可。

比如 Oracle 的 ojdbc8.jar，这个 jar 包当时浪子使用的阿里的下载源就没下载成功。后来去 Oracle 官网下载的 jar 包，在本地安装并引用。

食用方法，把对应的 jar 包放在使用它的项目中（其实这个不是必须的啦，maven 官方文档描述中说明：在目标 jar 包的同级目录中必须要有 pom.xml 文件），然后执行以下命令：

1
2
# 安装 jar 包到本地 maven 仓库
mvn install:install-file -Dfile=ojdbc8-23.2.0.0.jar -DgroupId=com.oracle -DartifactId=ojdbc8 -Dversion=23.2.0.0 -Dpackaging=jar

-Dfile：jar 包名称，这里 jar 包是在项目根路径，所以直接写
-DgroupId、-DartifactId：坐标位置
-Dversion：版本号

上面的命令执行成功以后就可以去本地 maven 仓库中根据自己写的坐标位置找到刚才安装的 jar 包啦，这时候就可以使用 maven 引入项目使用了，刚在项目中的 jar 包也可以删除了（如果没用的话）。

Maven打包

打包之前推荐先清理（clean）再打包（package）。jar 包比较简单，SpringBoot 默认打的就是 jar 包。这里说一下 war 包的打包方式方式。

  1. 修改打包方式，去除内嵌的 tomcat 依赖

    pom.xml
    1
    2
    3
    4
    5
    6
    <packaging>war</packaging>

    ...

    <!-- 去除内嵌的 tomcat 依赖 -->
    <scope>provided</scope>

  2. 如果整合的是 jsp，那么使用打包的插件时，打包插件必须是 1.4.2 的版本，另外，在pom文件中加入以下内容，指定 jsp 文件的打包位置：

    pom.xml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    <resources>
        <!-- 打包时将 jsp 文件拷贝到 META-INF 目录下 -->
        <resource>
            <!-- 指定 resources 插件处理那个目录下的资源文件 -->
            <directory>src/main/webapp</directory>
            <!-- 指定必须要放在此目录下才能被访问到 -->
            <targetPath>META-INF/resources</targetPath>
            <includes>
                <include>**/**</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/**</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
        <directory>src/main/java</directory>
            <excludes>
                <exclude>**/*.java</exclude>
            </excludes>
        </resource>
    </resources>

  3. 在插件中指定入口类：

    1
    2
    3
    4
    5
    <configuration>
        <fork>true</fork>
        <jvmArgument>-Dfile.encoding=UTF-8</jvmArgument>
        <mainClass>com.XXX.Application.class</mainClass>
    </configuration>

  4. 在启动类中，继承 SpringBootServletInitiallizer 类，重写 configure() 方法进行配置:

    1
    2
    3
    4
    5
    6
    public class xxxApplication extends SpringBootServletInitializer {
        @Override
        protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
            return builder.sources(xxxApplication.class);
        }
    }

注意： 打成的 war 包使用外部 Tomcat 部署时，项目配置文件中配置的端口和项目名称会失效。
后台方式启动 jar 包：nohup java -jar jar包名称 &

留下来过的印记~

本站由 江湖浪子 使用 Stellar 1.28.1 主题创建。
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议，转载请注明出处。