一、新建一个microboot的gradle项目，并在项目根目录新建gradle.properties文件

project_group=com.it
project.version=1.0.0
project_jdk=11

二、在项目根目录新建dependencies.gradle文件，负责管理依赖的版本。

// 定义所有要使用到的版本号
ext.versions = [
        springboot                                 :'2.5.5',
        log4jtoslf4j                               :'2.14.1',
        log4japi                                   :'2.0',
        junit                                      :'4.12',
        lombok                                     :'1.18.22'
]

// 定义所有的依赖库
ext.libraries = [
        'spring-boot-gradle-plugin' : "org.springframework.boot:spring-boot-gradle-plugin:${versions.springboot}",
        'log4j-to-slf4j' : "org.apache.logging.log4j:log4j-to-slf4j:${versions.log4jtoslf4j}",
        'log4j-api' : "org.apache.logging.log4j:log4j-api:${versions.log4japi}",
        'junit' : "junit:junit:${versions.junit}",
        'lombok' : "org.projectlombok:lombok:${versions.lombok}"
]

三、修改build.gradle文件，定义脚本资源、配置项目信息、定义子模块公用配置。

buildscript { // 定义脚本资源
    apply from: file('dependencies.gradle') // 引入所需要的依赖文件
    repositories { // 脚本资源仓库
        maven { url 'https://maven.aliyun.com/repository/google' }
        maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
        maven { url 'https://maven.aliyun.com/repository/public' }
        maven { url 'https://maven.aliyun.com/repository/jcenter' }
    }
    dependencies { // gradle依赖库
        classpath libraries.'spring-boot-gradle-plugin'
    }
}

group project_group // 通过gradle.properties文件导入
version version     // 通过gradle.properties文件导入
apply from: file('dependencies.gradle') // 引入所需要的依赖文件
def env = System.getProperty('env') ?: 'dev' // 获取env环境属性

subprojects { // 子模块
    apply plugin: 'java'
    apply plugin: 'io.spring.dependency-management' // 由此插件负责版本号的统一维护
    apply plugin: 'org.springframework.boot' // 将版本编号配置在插件内部
    sourceCompatibility = project_jdk // 本次项目都是基于JDK-11版本编写的
    targetCompatibility = project_jdk // 本次项目都是基于JDK-11版本编写的
    repositories {  // 配置gradle仓库
        def ALIYUN_REPOSITORY_URL = 'http://maven.aliyun.com/nexus/content/groups/public'
        def ALIYUN_JCENTER_URL = 'http://maven.aliyun.com/nexus/content/repositories/jcenter'
        all {
            ArtifactRepository repo ->
                if (repo instanceof MavenArtifactRepository) {
                    def url = repo.url.toString()
                    if (url.startsWith('https://repo1.maven.org/maven2')) {
                        project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_REPOSITORY_URL."
                        remove repo
                    }
                    if (url.startsWith('https://jcenter.bintray.com/')) {
                        project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_JCENTER_URL."
                        remove repo
                    }
                }
        }
        maven { url ALIYUN_REPOSITORY_URL } // 设置阿里云仓库
        maven { url ALIYUN_JCENTER_URL } // 设置阿里云仓库
    }
    dependencies {  // 公共依赖库管理
    	compile libraries.'log4j-to-slf4j'
        compile libraries.'log4j-api'
        testCompile 'org.springframework.boot:spring-boot-starter-test'
        testCompile libraries.'junit'
        runtime 'org.springframework.boot:spring-boot-devtools'
        compileOnly libraries.'lombok'
        annotationProcessor libraries.'lombok'
    }
    sourceSets {    // 源代码目录配置
        main { // main及相关子目录配置
            java { srcDirs = ['src/main/java'] }
            resources { srcDirs = ['src/main/resources', "src/main/profiles/$env"] }
        }
        test { // test及相关子目录配置
            java { srcDirs = ['src/test/java'] }
            resources { srcDirs = ['src/test/resources'] }
        }
    }
    test {  // 配置测试任务
        useJUnitPlatform() // 使用JUnit测试平台
    }
    // 最终生成的jar文件名称：baseName-version-classifier.extension
    task sourceJar(type: Jar, dependsOn: classes) { // 源代码的打包任务
        archiveClassifier = 'sources' // 设置文件的后缀
        from sourceSets.main.allSource // 所有源代码的读取路径
    }
    task javadocTask(type: Javadoc) { // JavaDoc文档打包任务
        options.encoding = 'UTF-8' // 设置文件编码
        source = sourceSets.main.allJava // 定义所有的Java源代码
    }
    task javadocJar(type: Jar, dependsOn: javadocTask) { // 先生成JavaDoc再打包
        archiveClassifier = 'javadoc' // 文件标记类型
        from javadocTask.destinationDir // 通过JavadocTask任务中找到目标路径
    }
    tasks.withType(Javadoc) {   // 文档编码配置
        options.encoding = 'UTF-8' // 定义编码
    }
    tasks.withType(JavaCompile) {   // 编译编码配置
        options.encoding = 'UTF-8' // 定义编码
    }
    artifacts { // 最终的打包的操作任务
        archives sourceJar // 源代码打包
        archives javadocJar // javadoc打包
    }
    gradle.taskGraph.whenReady {    // 在所有的操作准备好后触发
        tasks.each { task ->    // 找出所有的任务
            if (task.name.contains('test')) {   // 如果现在发现有test任务
                // 如果将enabled设置为true表示要执行测试任务，如果设置为false表示不执行测试任务
                task.enabled = true
            }
        }
    }
    [compileJava, compileTestJava, javadoc]*.options*.encoding = 'UTF-8' // 编码配置
}

四、新建microboot-common项目和microboot-web项目，microboot-common负责定义公共接口，microboot-web对外提供服务。
项目结构如下：

五、修改microboot-common项目的build.gradle文件，引入依赖：

jar {enabled true} //允许当前模块打包为*.jar文件

// 不启用javaDoc任务
javadoc {enabled false}
javadocTask{enabled false}
// 不生成javadoc的*.jar文件
javadocJar{enabled false}
// 不执行springboot的打包任务
bootJar{enabled false}

dependencies {
    compile 'org.springframework.boot:spring-boot-starter-web'
}

由于在父project中配置了子project使用spring-boot-gradle-plugin，所以gradle task会与spring boot task进行绑定。但是microboot-common项目并不是一个spring boot项目，因此会造成构建失败，所以需要手动进行部分任务的禁用。
六、修改microboot-web项目的build.gradle文件，引入依赖：

dependencies { // 配置子模块依赖
    compile project('microboot-common') // 引入其他子模块
}

bootJar { // SpringBoot提供的任务名称
    archiveBaseName = 'spring-boot-project' // 设置打包文件名称
    archiveVersion = '1.0.0' // 设置版本号
    mainClassName = 'com.it.StartSpringBoot' // 程序启动类
}

由于项目中引入了microboot-common，且microboot-common引入了compile范围的spring-boot-starter-web，所以可以直接在microboot-web项目使用spring-boot-starter-web。