aizuda学习日记之gradle -1 gradle 基础

gradle 文件介绍

Gradle构建脚本（build.gradle）它指定了一个项目和它的任务， 也可以说是项目最主要的gradle配置文件。有一个项目就会有一个build.gradle Gradle属性文件（gradle.properties）用来配置构建属性。 Gradle设置文件（gradle.settings）对于只有一个项目的构建而言是可选的，如果我们的构建中包含多于一个项目，那么它就是必须的，因为它描述了哪一个项目参与构建。每一个多项目的构建都必须在项目结构的根目录中加入一个设置文件。 对于我们的项目来说它是必须的，因为项目中有 APP base haodf。三个项目。

gradle 编译脚本

  buildscript {
            ext {
                // https://start.spring.io/actuator/info
                springBootVersion = "2.6.2"
            }

            // 仓库配置
            repositories {
                mavenLocal()
                maven { url 'https://maven.aliyun.com/repository/central' }
                maven { url 'https://maven.aliyun.com/repository/spring' }
                maven { url 'https://maven.aliyun.com/repository/google' }
                maven { url 'https://repo.spring.io/release' }
                maven { url 'https://repo.spring.io/milestone' }
            }

            dependencies {
                classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
            }
        }

项目名称表注

allporjects {
            group "aizuda.com"
        }

子模块配置

subprojects {
apply plugin: 'java-library'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'
    apply plugin: "io.spring.dependency-management"
    }

## 依赖管理 dependencyManagement  约束版本号 此处的功能 相当于 springboot的版本依赖 
在此统一管理引入jar的版本 实现全局统一版本号
```javascript
	//这里使用的springframework
	dependencyManagement {
            imports {
                mavenBom "org.springframework.boot:spring-boot-dependencies:${springBootVersion}"
            }
            dependencies {
                // 单点登录
                dependency("com.baomidou:kisso:3.8.0")
                dependency("org.aspectj:aspectjweaver:1.9.8.M1")
                // 工具类
                dependency("com.aizuda:aizuda-toolkit:0.0.1")

            }
        }

依赖管理模式

1. 依赖介绍
   作者：曾是放牛娃

   1. compile
      从repository（默认是jCenter())里下载一个依赖包进行编译并打包。

   2. implementation
      与compile对应，会添加依赖到编译路径，并且会将依赖打包到输出（aar或apk），但是在编译时不会将依赖的实现暴露给其他module，也就是只有在运行时其他module才能访问这个依赖中的实现。使用这个配置，可以显著提升构建时间，因为它可以减少重新编译的module的数量。建议，尽量使用这个依赖配置。

   3. api
      与compile对应，功能完全一样，会添加依赖到编译路径，并且会将依赖打包到输出（aar或apk），与implementation不同，这个依赖可以传递，其他module无论在编译时和运行时都可以访问这个依赖的实现，也就是会泄漏一些不应该不使用的实现。举个例子，A依赖B，B依赖C，如果都是使用api配置的话，A可以直接使用C中的类（编译时和运行时），而如果是使用implementation配置的话，在编译时，A是无法访问C中的类的。

   4. compileOnly
      与provided对应，Gradle把依赖加到编译路径，编译时使用，不会打包到输出（aar或apk）。这可以减少输出的体积，在只在编译时需要，在运行时可选的情况，很有用。 compileOnly
      不会打包到输出（aar 或 apk）。这可以减少输出的体积，只在编译时需要，在运行时可选的情况，很有用。

   5. runtimeOnly
      Gradle添加依赖只打包到 apk，运行时使用，但不会添加到编译路径

   6. annotationProcessor
      与compile对应，用于注解处理器的依赖配置

   7. dependency：代码编译/运行时所需要的东西：项目打包后这些东西基本都在（一般都在）。

   8. 已经废弃的配置有：compile、provided、apk、providedCompile。此外依赖配置还可以加一些配置项，例如AndroidTestImplementation、debugApi等等。

   常用implementation、api、compileOnly三个依赖配置

2. 依赖配置代码

		
          // 依赖配置
        dependencies {
            api("com.aizuda:aizuda-toolkit")
            //弃用的方式compile('org.projectlombok:lombok:1.18.2)
            //官方推荐的方式
			compile('org.projectlombok:lombok:1.18.2)
            compileOnly("org.projectlombok:lombok")
            annotationProcessor("org.projectlombok:lombok")
     	    testAnnotationProcessor("org.projectlombok:lombok")
      	    testCompileOnly("org.projectlombok:lombok")

            // 编译测试
            testImplementation("org.springframework.boot:spring-boot-starter-test")
            testImplementation("javax.servlet:javax.servlet-api")
        }

jdk 环境配置

编译环境 JDK1.8

// 
		sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8

Gradle之task的使用

每一个Gradle构建脚本中都会包含三个基本的构建块，project、task和property。每一个构建都至少包含一个project，一个或者多个task，在多项目的构建中一个project可以依赖于其它的project，task之间也形成一个依赖关系图来确保它们之间的执行顺序

1. 配置task

task sourcesJar(type: Jar, dependsOn: classes) {
        archiveClassifier = 'sources'
        from sourceSets.main.allSource
    }
      task javadocJar(type: Jar) {
        archiveClassifier = 'javadoc'
        from javadoc
    }
    javadoc {
        options {
            encoding "UTF-8"
            charSet 'UTF-8'
            author true
            version true
            failOnError false
            links "http://docs.oracle.com/javase/7/docs/api"
        }
    }
     tasks.whenTaskAdded { task ->
        if (task.name.contains('signMavenJavaPublication')) {
            task.enabled = new File(project.property('signing.secretKeyRingFile') as String).isFile()
        }
    }

Gradle - 打包上传Maven仓库

教程： https://www.jianshu.com/p/069c6ba27255

publishing {
        repositories {
            maven {
                def userName = System.getProperty("un")
                def passWord = System.getProperty("ps")
                def releasesRepoUrl = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
                def snapshotsRepoUrl = "https://s01.oss.sonatype.org/content/repositories/snapshots/"
                url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl

                credentials {
                    username userName
                    password passWord
                }
            }
        }
        publications {

            mavenJava(MavenPublication) {
                from components.java

                artifact sourcesJar
                artifact javadocJar

                pom {
                    name = 'aizuda-components'
                    packaging 'jar'
                    description = 'aizuda components.'
                    url = 'https://github.com/aizuda/aizuda-components'

                    scm {
                        connection = 'scm:[email protected]:Codearte/gradle-nexus-staging-plugin.git'
                        developerConnection = 'scm:[email protected]:Codearte/gradle-nexus-staging-plugin.git'
                        url = 'https://github.com/aizuda/aizuda-components'
                    }

                    licenses {
                        license {
                            name = 'The Apache License, Version 2.0'
                            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }

                    developers {
                        developer {
                            id = 'aizuda'
                            name = '青苗'
                            email = '[email protected]'
                        }
                    }

                    withXml {
                        def root = asNode()
                        root.dependencies.'*'.findAll {
                            def d = it
                            d.scope.text() == 'runtime' && project.configurations.findByName("implementation").allDependencies.find { dep ->
                                dep.name == it.artifactId.text()
                            }.each() {
                                d.scope*.value = 'compile'
                                d.appendNode('optional', true)
                            }
                        }
                    }
                }
            }
        }

        signing {
            sign publishing.publications.mavenJava
        }
    }