第一章 企业级 gradle 依赖管理层次结构设计

最新推荐文章于 2024-04-30 06:20:31 发布
最新推荐文章于 2024-04-30 06:20:31 发布
阅读量650 收藏 1
点赞数 2
分类专栏： jingwei-cloud 文章标签： java spring boot gradle spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muyimeng/article/details/109683802
版权

第一章 企业级 gradle 依赖管理层次结构设计

Gradle概述

Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建工具。它使用一种基于Groovy的特定领域语言来声明项目设置，而不是传统的XML。Gradle就是工程的管理，帮我们做了依赖、打包、部署、发布、各种渠道的差异管理等工作。

Gradle优势

  1. 一款最新的，功能最强大的构建工具，用它逼格更高
  2. 使用程序代替传统的XML配置，项目构建更灵活
  3. 丰富的第三方插件，让你随心所欲使用
  4. Maven、Ant能做的，Gradle都能做，但是Gradle能做的，Maven、Ant不一定能做。

Maven中依赖概述

  • 一方库：本工程中各个模块之间的依赖
  • 二方库(xxx-dependencies)：企业内部的依赖库，一般指企业内部的其他项目发布的依赖（jar 包）
  • 三方库(xxx-parent)：企业之外的第三方依赖库， 如 Spring、Apache、Google 等发布的依赖（jar 包）


一般来说，企业的开发框架搭建完成后，三方库依赖除了漏洞和 Bug 升级外，很少频繁升级大改，而企业内部的二方库由于迭代和更新，版本升级频率较三方库要高，所以层次结构中二方库依赖三方库，三方库在更底层。先控制三方库依赖版本，在此基础上再控制二方库的版本。这里只对项目结构设计进行讲解，至于Nexus 私服搭建大家百度一下就好了。

项目搭建

本文项目地址 jingwei-cloud

新建项目初始化工程

**sparrow **模块为 **jingwei-cloud **的两方库模块，**jingwei-cloud **所有子模块均会引入该模块，这个模块相当于企业中的共享模块，后期也可以单独拆分成一个独立工程维护。

  • sparrow目录结构
    ![1-sparrow目录结构.jpeg](https://img-blog.csdnimg.cn/img_convert/161baf6e214ffe56eff25a0698ce3273.png#align=left&display=inline&height=736&margin=[object Object]&name=1-sparrow目录结构.jpeg&originHeight=736&originWidth=1366&size=123191&status=done&style=none&width=1366

jingwei-cloud配置

  • jingwei-cloud > build.gradle
buildscript {
    ext {
        set("springBootVersion", "2.3.4.RELEASE")
        set("dependencyManagementVersion", "1.0.10.RELEASE")
    }
}
description = "根目录用于管理所有项目"
configurations.all {
    resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
}
allprojects {
    repositories {
        maven { url 'https://maven.aliyun.com/repository/public/' }
        mavenCentral()
    }
    tasks.withType(JavaCompile) {
        options.encoding = "UTF-8"
    }
}

sparrow根模块

  • jingwei-cloud > sparrow > build.gradle
import org.springframework.boot.gradle.plugin.SpringBootPlugin

buildscript {
    ext {
        set("ignoreProjects",
            [
                project(":sparrow:sparrow-parent"),
                project(":sparrow:sparrow-dependencies"),
            ]
        )
        set("moduleProjects", subprojects - ignoreProjects)
        // 两方包 不能包含引用jar
        set("excludeProjects", project(":sparrow:sparrow-client"))
    }
}

plugins {
    id 'org.springframework.boot' version "$springBootVersion" apply false
    id 'io.spring.dependency-management' version "$dependencyManagementVersion" apply false
    id 'java'
}
description = "sparrow(麻雀), 基础工程，通用工程骨架"
allprojects {
    group = 'com.vastmoon.sparrow'
    version = '2.0.0-SNAPSHOT'
}

configure(moduleProjects) {
    apply plugin: "java"
    apply from: "${rootDir}/gradle/framework-module.gradle"
    sourceCompatibility = '1.8'
    configurations {
        compileOnly {
            extendsFrom annotationProcessor
        }
    }
    test {
        useJUnitPlatform()
    }
}

configure(moduleProjects - excludeProjects) {
    apply plugin: "io.spring.dependency-management"
    dependencyManagement {
        imports {
            mavenBom SpringBootPlugin.BOM_COORDINATES
        }
        generatedPomCustomization {
            enabled = false
        }
    }

    dependencies {
        implementation(enforcedPlatform(project(":sparrow:sparrow-parent")))
        annotationProcessor 'org.projectlombok:lombok'
        compileOnly 'org.projectlombok:lombok'
        annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
        testImplementation('org.springframework.boot:spring-boot-starter-test') {
            exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
        }
        implementation("org.springframework.boot:spring-boot-starter-validation")
        implementation("org.apache.commons:commons-collections4")
        implementation("cn.hutool:hutool-all")
        implementation("org.apache.commons:commons-lang3")
        implementation("com.google.guava:guava")
    }
}

set("excludeProjects", project(":sparrow:sparrow-client")) client不能包含任何依赖，这个包可能会发给Dubbo等RPC框架实现远程调用，因此不能依赖第三方jar包

apply plugin: "io.spring.dependency-management"
    dependencyManagement {
        imports {
            mavenBom SpringBootPlugin.BOM_COORDINATES
        }
        generatedPomCustomization {
            enabled = false
        }
    }

这里有一个坑，如果不这样配置，会找不到spingboot的依赖，目前没有找到什么原因造成的。具体错误原因如下图：![1-gradle报错.jpeg](https://img-blog.csdnimg.cn/img_convert/75b4fb8898e1ce6a07858aec66c3b785.png#align=left&display=inline&height=736&margin=[object Object]&name=1-gradle报错.jpeg&originHeight=736&originWidth=1366&size=228996&status=done&style=none&width=1366)

sparrow-parent 配置

  • jingwei-cloud > sparrow > sparrow-parent > build.gradle
import org.springframework.boot.gradle.plugin.SpringBootPlugin

apply plugin: 'java-platform'
apply from: "$rootDir/gradle/publications.gradle"
ext {
    set('springCloudAlibabaVersion', "2.2.2.RELEASE")
    set('springCloudVersion', "Hoxton.SR8")
    set("collections4Version", "4.4")
    set("hutoolVersion", "5.4.7")
    set("ulisesbocchioVersion", "3.0.3")
    set("springSecurityJwtVersion", "1.1.1.RELEASE")
}
javaPlatform {
    allowDependencies()
}

dependencies {
    api enforcedPlatform(SpringBootPlugin.BOM_COORDINATES)
    api enforcedPlatform("org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}")
    api enforcedPlatform("com.alibaba.cloud:spring-cloud-alibaba-dependencies:${springCloudAlibabaVersion}")
    constraints {
        api("org.apache.commons:commons-collections4:$collections4Version")
        api("cn.hutool:hutool-all:$hutoolVersion")
        api("com.github.ulisesbocchio:jasypt-spring-boot:$ulisesbocchioVersion")
        api('org.springframework.security:spring-security-jwt:$springSecurityJwtVersion')
    }

}

publishing {
    publications {
        //noinspection GroovyAssignabilityCheck
        mavenJava(MavenPublication) {
            //noinspection GroovyAssignabilityCheck
            from components.javaPlatform
        }
    }
}

sparrow-parent 模块为三方库管理模块，主要用于维护三方库， 这里用到的插件 java-platform 具体的配置信息大家可以去官网查看，官网地址 ：https://docs.gradle.org/current/userguide/java_platform_plugin.html

sparrow-dependencies配置

  • jingwei-cloud > sparrow > sparrow-dependencies > build.gradle
apply plugin: 'java-platform'
apply from: "$rootDir/gradle/publications.gradle"
javaPlatform {
    allowDependencies()
}
dependencies {
    api enforcedPlatform(project(":sparrow:sparrow-parent"))
    constraints {
        parent.moduleProjects.sort { it.name }.each {
            api it
        }
    }
}

publishing {
    publications {
        //noinspection GroovyAssignabilityCheck
        mavenJava(MavenPublication) {
            //noinspection GroovyAssignabilityCheck
            from components.javaPlatform
        }
    }
}

sparrow-dependencies 模块为两方库模块，下面的配置为把两方模块加入到pom文件中

constraints {
        parent.moduleProjects.sort { it.name }.each {
            api it
        }
    }

项目编译

![1-sparrow-pom运行.jpeg](https://img-blog.csdnimg.cn/img_convert/73d274900918eedc04481ba17e3c04b0.png#align=left&display=inline&height=736&margin=[object Object]&name=1-sparrow-pom运行.jpeg&originHeight=736&originWidth=1366&size=140748&status=done&style=none&width=1366]

sparrow-parent pom文件

  • sparrow > sparrow-parent > build > publications > mavenJava > pom-default.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <!-- This module was also published with a richer model, Gradle metadata,  -->
  <!-- which should be used instead. Do not delete the following line which  -->
  <!-- is to indicate to Gradle or any Gradle module metadata file consumer  -->
  <!-- that they should prefer consuming it instead. -->
  <!-- do_not_remove: published-with-gradle-metadata -->
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.vastmoon.sparrow</groupId>
  <artifactId>sparrow-parent</artifactId>
  <version>2.0.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-collections4</artifactId>
        <version>4.4</version>
      </dependency>
      <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.4.7</version>
      </dependency>
      <dependency>
        <groupId>com.github.ulisesbocchio</groupId>
        <artifactId>jasypt-spring-boot</artifactId>
        <version>3.0.3</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-jwt</artifactId>
        <version>$springSecurityJwtVersion</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.3.4.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>Hoxton.SR8</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>2.2.2.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>

sparrow-dependencies pom文件

  • sparrow > sparrow-dependencies > build > publications > mavenJava > pom-default.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <!-- This module was also published with a richer model, Gradle metadata,  -->
  <!-- which should be used instead. Do not delete the following line which  -->
  <!-- is to indicate to Gradle or any Gradle module metadata file consumer  -->
  <!-- that they should prefer consuming it instead. -->
  <!-- do_not_remove: published-with-gradle-metadata -->
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.vastmoon.sparrow</groupId>
  <artifactId>sparrow-dependencies</artifactId>
  <version>2.0.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>com.vastmoon.sparrow</groupId>
        <artifactId>sparrow-client</artifactId>
        <version>2.0.0-SNAPSHOT</version>
      </dependency>
      <dependency>
        <groupId>com.vastmoon.sparrow</groupId>
        <artifactId>sparrow-core</artifactId>
        <version>2.0.0-SNAPSHOT</version>
      </dependency>
      <dependency>
        <groupId>com.vastmoon.sparrow</groupId>
        <artifactId>sparrow-parent</artifactId>
        <version>2.0.0-SNAPSHOT</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>

上传私服公共配置

这里参照了spring-framework的公共配置

  • gradle > framework-module.gradle
apply from: "$rootDir/gradle/publications.gradle"
jar {
	manifest.attributes["Implementation-Title"] = project.name
	manifest.attributes["Implementation-Version"] = project.version
	manifest.attributes["Automatic-Module-Name"] = project.name.replace('-', '.')  // for Jigsaw
	manifest.attributes["Created-By"] =
			"${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"

//	from("${rootDir}/src/docs/dist") {
//		include "license.txt"
//		include "notice.txt"
//		into "META-INF"
//		expand(copyright: new Date().format("yyyy"), version: project.version)
//	}
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			from components.java
//			artifact sourcesJar
//			artifact javadocJar
		}
	}
}
  • gradle > publications.gradle
apply plugin: "maven-publish"
publishing {
	publications {
		mavenJava(MavenPublication) {
			pom {
				afterEvaluate {
					name = project.description
					description = project.description
				}
			}
			versionMapping {
				usage('java-api') {
					fromResolutionResult()
				}
				usage('java-runtime') {
					fromResolutionResult()
				}
			}
		}
	}

	repositories {
		maven {
			// change to point to your repo, e.g. http://my.org/repo
			def releasesRepoUrl = "http://localhost:8081/repository/maven-releases/"
			def snapshotsRepoUrl = "http://localhost:8081/repository/maven-snapshots/"
			url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
			credentials {
				username = 'admin'
				password = 'admin123'
			}
		}
	}
}

可选模块

这里还创建了一个sparrow-gradle-plugin模块用于公司内部统一使用springboot版本

sparrow-gradle-plugin build.gradle

  • sparrow > sparrow-gradle-plugin > build.gradle
plugins {
    id "java-gradle-plugin"
}
apply from: "$rootDir/gradle/publications.gradle"
dependencies {
    implementation "org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion"
    implementation "io.spring.gradle:dependency-management-plugin:$dependencyManagementVersion"
}
gradlePlugin {
    plugins {
        sparrowGradlePlugin {
            //noinspection GroovyAssignabilityCheck
            id = 'com.vastmoon.sparrow'
            //noinspection GroovyAssignabilityCheck
            implementationClass = 'com.vastmoon.sparrow.gradle.SparrowGradlePlugin'
        }
    }
}

sparrow-gradle-plugin 插件类

public class SparrowGradlePlugin implements Plugin<Project> {
    public static final String BOM_COORDINATES = "com.vastmoon.sparrow:sparrow-dependencies:";
    @Override
    public void apply(Project project) {
        project.getPlugins().apply(SpringBootPlugin.class);
    }
}

引用sparrow到其他工程中

新建一个新项目 sparrow-example

  • sparrow-example > settings.gradle
pluginManagement {
    repositories {
        gradlePluginPortal()
        maven { url 'https://maven.aliyun.com/repository/public/' }
        mavenCentral()
        mavenLocal()
        maven { url 'http://localhost:8081/repository/maven-public/' }
    }
}
rootProject.name = 'sparrow-example'
  • sparrow-example > build.gradle
buildscript {
    ext {
        set("sparrowVersion", "2.0.0-SNAPSHOT")
    }
}
plugins {
    id 'com.vastmoon.sparrow' version "$sparrowVersion" apply false
    id 'java'
}

description = "sparrow测试项目"
group = 'com.vastmoon.example'
version = '0.0.1-SNAPSHOT'
repositories {
    mavenLocal()
    maven { url 'https://maven.aliyun.com/repository/public/' }
    mavenCentral()
    maven { url 'http://localhost:8081/repository/maven-public/' }
}
configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}
test {
    useJUnitPlatform()
}
apply plugin: "io.spring.dependency-management"
dependencyManagement {
    imports {
        mavenBom "com.vastmoon.sparrow:sparrow-dependencies:$sparrowVersion"
    }
}
apply plugin: "org.springframework.boot"
dependencies {
    implementation("com.vastmoon.sparrow:sparrow-core")
    annotationProcessor 'org.projectlombok:lombok'
    compileOnly 'org.projectlombok:lombok'
    implementation("org.springframework.boot:spring-boot-starter-web")
    annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }

}

总结

这样的结构我参照着springboot源码和spring-framework源码的工程目录总结出来的，现在看来和maven的项目管理没什么区别了，希望gradle构建多模块项目越来越方便。

无为000
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Gradle 2.0 用户指南翻译——第六十五章. Maven 发布（新）
一个码农的博客
04-01 627
本章内容描述了一个新的 孵化中的 功能，是由“maven-publish”插件提供的 maven 发布支持。最终这个新的发布支持将取代通过Upload任务发布的方式。 如果你正在查找有关使用 Upload 任务的原始的 Maven 发布支持的文档，请查阅《第五十一章，发布工件》。
Gradle实现Maven中的dependencyManagement
Harryfin的专栏
07-04 3799
在Maven中，我们可以通过dependencyManagement把Jar包版本进行统一管理，以后各项目引用组件时，就不用标注组件的版本号了。这为解决多项目版本冲突问题带来了很大的便利。那么在Gradle中，是否也可以实现Maven的这个特性呢？答案是肯定的。看了网上的一些资料，发现有些方法比较绕，感觉思路不是很对。其实在官网上就有介绍这个问题，在这里也和大家再做一个分享。1）创建一个项目，里面只需一个build.gradle文件即可。待会我们把要管理的依赖及其版本都封装到这个gradle脚本中，最后把它
【gradle8升级系列】 constrains 替换force
wang2leee的博客
08-03 553
在Gradle 8中，引入了一种名为"constraints"的新功能，用于管理和解决依赖项之间的冲突。通过使用"constraints"，您可以更精确地指定依赖项的版本范围，并确保它们与其他依赖项兼容。
【Android Gradle 插件】Android Studio 工程 Gradle 构建流程 ② ( settings
最新发布
2301_78399616的博客
04-30 1043
参考之前的博客中的配置 ,
ConstraintLayuot学习
seekting的专栏
08-03 426
ConstraintLayuot学习 ConstraintLayuot学习 一. Constraints(条件约束) 1.1 布局代码 1.2 结果 二. Chains链 2.1 布局代码 2.2 结果 2.3 Chains链的三种形式 2.3.1 spread形式 截图 代码 注意 2.3.2 spread_in形式 截图 代码 2.3.3 packed形式 截图 代码 注意 ...
gradle 上传jar包_Gradle学习记录014 关于依赖的声明
weixin_39576133的博客
12-06 139
详细学习Gradle构建的依赖声明。该学习记录基于Gradle官方网站资料。本篇参考链接如下：https://docs.gradle.org/current/userguide/declaring_dependencies.html声明一个模块作为依赖通常声明一个模块作为依赖，需要指定这个模块的版本。Gradle提供了一套机制，允许指定动态的版本。指定固定版本dependencies { // 固...
Android Gradle依赖管理、去除重复依赖、忽略的方式
08-19
一、Android Gradle依赖管理 Android Gradle依赖管理是使用Gradle构建工具来管理Android应用程序的依赖关系。Gradle是基于Groovy语言的构建自动化工具，可以自动管理项目的依赖关系、编译、打包和发布。Android ...
详解Android使用Gradle统一配置依赖管理
08-28
本篇文章主要介绍了详解Android 使用 Gradle 统一配置依赖管理，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
GradleDependencyManagement：Gradle依赖的统一管理
02-04
Gradle常用命令 windows往掉前面的./ ./gradlew //下载更新gradle ./gradlew -v //版本号 ./gradlew assemble //构建项目输出 ./gradlew check //运行检测和测试任务 ./gradlew clean //清除build文件夹 ./gradlew ...
详解Gradle依赖冲突解决方式
08-27
我们可以创建一个config.gradle文件，在project目录下，将需要统一管理的依赖项添加到里面。例如： ext { //Dependencies supportLibraryVersion = '25.3.1' okHttpVersion = '3.8.0' domainTestDependencies =...
使用Gradle生成BOM管理依赖版本
拾级而上
02-07 3522
写在前边 自Gradle 5开始添加了Maven中 BOM 的支持，然而Gradle 6 以前，想使用BOM 需要使用 Maven 定义 pom.xml 并作为 pom 发布，才行。 参考了 《Gradle 实战》一书，查遍此书并没有通过Gradle生成BOM的方式；查阅 StackOverFlow 发现了一些复杂的实现方式。 好在 Gradle 6 开始，官方提供了一个插件 java-platform 支持生成 BOM，并可以发布，本文就带大家作一个demo 以学习此插件的使用。 什么是 BOM？ BOM
【Gradle-6】一文搞懂Gradle的依赖管理和版本决议
yechaoa
04-30 3367
当有多个相同依赖时，不管是哪里引入的，gradle总会优先选择最高版本；当多个相同依赖没有版本约束条件时，优先选择主模块(app)中的版本，且默认有strictly约束版本；force优先级高于strictly，如果二者同时显式声明，则会报错，推荐使用strictly；同时使用force强制依赖版本时，版本决议的结果跟依赖顺序有关，最早force的版本优先；本文主要介绍了Gradle的依赖管理和版本决议。依赖管理里面需要关注的是依赖方式，不同的依赖方式决定了是否会依赖传递；
Gradle 1.12用户指南翻译——第六十四章. 发布到Ivy（新）
weixin_34313182的博客
07-14 201
其他章节的翻译请参见：http://blog.csdn.net/column/details/gradle-translation.html翻译项目请关注Github上的地址：https://github.com/msdx/gradledoc本文翻译所在分支：https://github.com/msdx/gradledoc/tree/1.12。直接浏览...
一文搞懂Gradle的依赖管理和版本决议
chuyouyinghe的专栏
04-21 3103
当有多个相同依赖时，不管是哪里引入的，gradle总会优先选择最高版本；当多个相同依赖没有版本约束条件时，优先选择主模块(app)中的版本，且默认有strictly约束版本；force优先级高于strictly，如果二者同时显式声明，则会报错，推荐使用strictly；同时使用force强制依赖版本时，版本决议的结果跟依赖顺序有关，最早force的版本优先；本文主要介绍了Gradle的依赖管理和版本决议。依赖管理里面需要关注的是依赖方式，不同的依赖方式决定了是否会依赖传递；
Gradle-04：BOM管理依赖版本
孤山之王
08-21 872
Grale构建BOM
Gradle插件编写(三)
Mr_Tony的专栏
01-19 2395
使用maven-pubilsh发布gradle插件到本地
gradle使用学习（一）————环境与配置
czhcc的专栏
03-23 4509
现在越来睵多的开源项目使用gradle管理工程。由于公司一直使用Maven管理工程代码，在使用gradle时希望能与现在的Maven环境结合起来，于是学习了一下gradle的内容，现在总结一下备忘。
使用Gradle发布工件到Maven仓库
热门推荐
yingaizhu的博客
12-21 1万+
使用Gradle发布工件到Maven仓库（Publishing Artifacts） 此文章基于Gradle 4.6编写。 1. Maven Plugin（旧版发布插件） 使用Maven Plugin发布Artifcat是旧的插件，新版Gradle有新的插件Maven Publish Plugin发布Artifact 官方文档 Maven Plugin是添加支持发布artifact到Mav...
Gradle之发布(8)
ashencode的博客
08-29 639
Gradle之自动化测试 项目通常是多人协作的，那么就需要我们将自己的代码打包成jar，发布到私服上。 一、发布 通常发布的地方：1）本地仓库；2）公司私服；3）公共仓库 二、如何发布 在项目build.gradle配置 // 所有项目配置 allprojects { apply plugin:'java' sourceCompatibility = 1.8...
android gradle依赖管理、去除重复依赖、忽略的方式
09-07
在 Android Gradle 中，可以通过在 build.gradle 文件中声明依赖来管理项目中所需的第三方库。 首先，要避免重复依赖，可以通过以下几种方式来解决： 1. 使用 implementation 替代 compile： 在构建文件中，使用 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值