Gradle构建多模块项目

KinglyJn 2017-06-27

首先我们先来看一个简单的单模块项目构建示例

zdemo-gradle-simple

settings.gradle

rootProject.name = 'zdemo-gradle-simple'

build.gradle

/*
 * 预定义一些类
 * 类可以直接定义在构建脚本中
 * 更好的方式是构建脚本与构建类分开，gradle默认将构建类放在 build/src/main/groovy 
 * 目录下，然后将编写的  *.groovy导入构建脚本即可
 * 另一种比较常用的方式是建立一个独立的项目来定义task，其他所有的项目均可引用这些task
 */
import version.ProjectVersion
import version.ReleaseVersionTask
import version.ReleaseVersionListener


/*
 * 预定义一些属性
 */
ext {
	//内部版本文件
	versionFile = file('version.properties')
	
	//依赖包版本
	junitVersion = "4.12"
	springframeworkVersion = "4.3.7.RELEASE"
	slf4jVersion = "1.7.24"
	log4jVersion = "1.2.17"
}

/*
 * 预定义一些方法
 */
ProjectVersion readVersion() {   //以下为从配置文件version.properties中读取版本信息的脚本			
	logger.quiet "reading the version file..." //注意无论什么时候执行gradle构建，gradle都会顺序运行 [初始化->配置->执行] 这三个生命周期阶段 
	if (!versionFile.exists()) {
		throw new GradleException("Required version file does not exists, $versionFile.path")
	}
	Properties props = new Properties();
	versionFile.withInputStream { is ->
		props.load(is)
	}
	new ProjectVersion(major:props.major.toInteger(), minor:props.minor.toInteger(), release:props.release.toBoolean())
}



/*
 * 配置插件
 */
apply plugin: 'java-library'
apply plugin: 'groovy'
//apply from: '../build-config/gradle-quality.gradle' //引入外部gradle文件


/*
 * 配置项目和插件的属性
 */
description = 'Gradle项目模板 之 单项目示例'
group = 'com.keyllo.demo'
archivesBaseName = 'zdemo-gradle-simple'
version = readVersion()
sourceCompatibility = 1.8
targetCompatibility = 1.8



/*
 * 配置一些默认类型的任务（默认类型为DefaultTask）
 */
task printVersion {
	group = 'other' 	//配置阶段执行的代码
	description = '打印项目版本'
	//dependsOn = ['task01', 'task02'] //将会在当前任务之前执行
	//finalizedBy = ['task03'] //将会在当前任务执行之后执行（不管当前任务是否抛出异常都会执行finalizedBy任务）
	
	doLast { 			//执行阶段执行的代码
		logger.quiet "version: $version"
	}
}

task makeReleaseVersion {
	group = 'other'
	description = '修改项目版本为发布版本(运行这个任务将改变版本属性，并将新的版本值保存到属性文件中, inputs和outputs保证该任务只会被执行第一次)'
	inputs.property('release', version.release)
	outputs.file(versionFile)
	
	doLast { //这段代码需要在doLast中，否则若直接在task下（配置阶段会执行这些代码），每次执行其他任务版本就会变成发布版本
		version.release = true
		ant.propertyfile(file:versionFile) {
			entry(key:'release', type:'string', operation: '=', value:'true')
		}
		println "make project version release done!"
	}
}

task makeReleaseVersion2(type:ReleaseVersionTask) { //自定义task，与makeReleaseVersion具有相同的功能
	release = version.release
	destFile = versionFile
}

task createDistribution(type:Zip) {
	group = 'other'
	description = '创建发布版本'
	dependsOn = ['makeReleaseVersion']
	
	from jar.outputs.files			//隐式调用 jar task 的输出（对于web项目使用war.outputs.files）
	from(sourceSets*.allSource) {	//把源文件放到zip文件的src目录下
		into 'src'
	}
	from(rootDir) {					//为zip文件夹添加版本文件
		include versionFile.name
	}
}

task backupReleaseDistribution(type:Copy) {
	group = 'other'
	description = '备份发布版本到 backup 文件夹'
	
	from createDistribution.outputs.files	//隐式调用createDistribution的输出(该任务会依赖推断出需要先执行createDistribution任务)
	into "$buildDir/backup"
}

task release {
	group = 'other'
	description = '发布版本'
	dependsOn = ['backupReleaseDistribution']
	
	doLast {
		logger.quiet "released project: $project.name"
	}
}

/*
gradle.taskGraph.whenReady { TaskExecutionGraph taskGraph -> //通过生命周期钩子[hook]实现版本发布的功能[project.getGradle-->gradle.getTaskGraph-->taskExecutionGraph.whenReady]
	if (taskGraph.hasTask(release)) { //查看执行图中是否包含 task release
		version.release = true
		ant.propertyfile(file:versionFile) {
			entry(key:'release', type:'string', operation:'=', value:'true')
		}
	}
}
*/

/*
def releaseVersionListener = new ReleaseVersionListener()   	//通过生命周期监听器实现版本发布的功能
gradle.taskGraph.addTaskExecutionGraphListener(releaseVersionListener) //注册监听器到task执行图
*/

tasks.addRule("Pattern: increment<Vtype>Version - Increments the project major or minor version.") { String taskName ->
	if (taskName.startsWith('increment') && taskName.endsWith('Version')) {
		task(taskName) { //规则命名任务（规则命名任务即使通过插件声明分组了，它也将永远显示在Rules分组下）
			doLast {	 //shell示例：gradle tasks --all  |  gradle task incrementMajorVersion
				String vtype = (taskName-'increment'-'Version').toLowerCase()
				String currentVersion = version.toString()
				switch(vtype) { 
					case 'major':
						++version.major
						break
					case 'minor':
						++version.minor
						break
					default:
						throw new GradleException("Invalid version type $vtype, allowed types:['Major','Minor']")
				}
				String newVersion = version.toString()
				logger.info "Incrementing $vtype project version: $currentVersion -> $newVersion"
				ant.propertyfile(file:versionFile) {
					entry(key:vtype, type:'int', operation:'+', value:1)
				}
			}
		}
	}
}

2.times {counter -> 
	task "dycTask$counter" { //完全动态任务（可以设置分组等信息）
		group = 'other'
		description = '动态任务示例'
		
		doLast {
			println "-----dycTask$counter-----"
		}
	}
}



/*
 * 配置依赖仓库
 */
repositories {
	mavenLocal()
    mavenCentral()
	jcenter()
}



/*
 * 配置依赖项
 * 
 */
configurations { //配置依赖分组信息
	//compile.exclude module: 'commons'
    //all*.exclude group: 'org.gradle.test.excludes', module: 'reports'
	
	//all.resolutionStrategy {  //发生冲突时,使用开发者指定的版本 //与 force:true 配合使用
		//failOnVersionConflict() 
	//}	
}

dependencies { 	//配置具体的依赖项
	//test
	testCompile "junit:junit:${junitVersion}"
	testCompile "org.springframework:spring-test:${springframeworkVersion}"

	//groovy
	//compile gradleApi() //gradleApi导入的gradle-api包中已经包含了slf4j-log4j12相关类，使用了这个包以后自定义的log4j.properties文件就不会起作用了
	//compile localGroovy()
	
	//spring
	compile "org.springframework:spring-context:${springframeworkVersion}"
	compile "org.springframework:spring-context-support:${springframeworkVersion}"
	
	//log4j
	compile "org.slf4j:slf4j-api:${slf4jVersion}"
	compile group:'org.slf4j', name:'slf4j-log4j12', version:'${slf4jVersion}'
	compile "log4j:log4j:${log4jVersion}"
	
	
	/*
	 * 一些依赖配置示例
	 */
	//compile project(':library') //依赖内部其他项目
	
	//compile files('spring-core.jar', 'spring-aap.jar') //依赖文件系统的jar文件
	//compile fileTree(dir: 'deps', include: '*.jar')
	//compile fileTree(dir: 'libs', include: ['*.jar'])
	
	//compile('log4j:log4j:1.2.17') { //排除所有的传递性依赖
		//transitive = false //transitive 属性默认为 true
	//}
	
	//compile ('commons-httpclient:commons-httpclient:3.1'){ //排除部分依赖
		//exclude group:'commons-codec' //排除该group的依赖  //group是必选项,module可选
		//exclude group:'commons-codec',module:'commons-codec'
	//}
	
	//compile group:'b',name:'b',version:'1.1',force:true  //强制使用某个版本
}

buildSrc/src/main/groovy/version/ProjectVersion.groovy

package version

class ProjectVersion {
	def major
	def minor
	def release
	def String toString() {
		"$major.$minor${release ? '-RELEASE' : '-SNAPSHOT'}"
	}
}

buildSrc/src/main/groovy/version/ReleaseVersionTask.groovy

package version

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.*

/**
 * 自定义任务：发布版本
 * @author zhangqingli
 *
 */
class ReleaseVersionTask extends DefaultTask {
	@Input 	  //通过注解声明 task的输入/输出
	@Optional //允许输入值为null
	Boolean release
	@OutputFile
	File destFile
	
	ReleaseVersionTask() { //在构造器中设置task的属性
		group = 'other'
		description = 'this is ReleaseVersionTask, extends from DefaultTask'
	}
	
	@TaskAction
	void start() {
		project.version.release = true
		ant.propertyfile(file:destFile) {
			entry(key:'release', type:'string', operation: '=', value:'true')
		}
	}
}

buildSrc/src/main/groovy/version/ReleaseVersionListener.groovy

package version

import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.api.execution.TaskExecutionGraph
import org.gradle.api.execution.TaskExecutionGraphListener

/**
 * 通过生命周期监听器实现版本发布功能
 * @author zhangqingli
 *
 */
class ReleaseVersionListener implements TaskExecutionGraphListener {
	static final String releaseTaskPath = ":release"
	
	
	@Override
	public void graphPopulated(TaskExecutionGraph taskExecutionGraph) {
		if (taskExecutionGraph.hasTask(releaseTaskPath)) { //确定 release task 任务包含在执行图中
			println "> releaseVersionListener"
			List<Task> allTasks = taskExecutionGraph.allTasks;
			
			Task releaseTask = allTasks.find {
				it.path == releaseTaskPath
			}
			Project project = releaseTask.project //每个task都知道自己所属的project
			
			project.version.release = true
			project.ant.propertyfile(file:project.versionFile) {
				entry(key:'release', type:'string', operation:'=', value:'true')
			}	
		}
	}
}

src/main/java/spring01/hello/User.java

package spring01.hello;

public class User {
	
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "HelloWorld [name=" + name + ", age=" + age + "]";
	}
}

src/main/resources/spring01.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">

	<!-- 引入外部配置文件 -->
	<context:property-placeholder location="db.properties"/>
	
	<!-- 装配beans -->
	<bean id="user01" class="spring01.hello.User">
		<property name="name" value="${user01.name}"/>
		<property name="age" value="${user01.age}"/>
	</bean>
</beans>

src/main/resources/db.properties

user01.name=zhangsan
user01.age=23

src/main/resources/log4j.properties

project.name=zdemo-gradle-simple
fileout.path=/tmp/mytmp/logs
#
log4j.rootLogger=info, STDOUT, FILEOUT
log4j.logger.org.springframework.data.mongodb.core=MONGODB 

log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4j.appender.STDOUT.encoding=UTF-8
log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout
log4j.appender.STDOUT.layout.ConversionPattern=[${project.name}] [%-5p] [%d] [%-3r] %l [%t,%x] %n  - %m%n

log4j.appender.FILEOUT=org.apache.log4j.DailyRollingFileAppender   
log4j.appender.FILEOUT.File=${fileout.path}/${project.name}.log
log4j.appender.FILEOUT.encoding=UTF-8
log4j.appender.FILEOUT.layout=org.apache.log4j.PatternLayout
log4j.appender.FILEOUT.layout.ConversionPattern=[${project.name}] [%-5p] [%d] [%-3r] %l [%t,%x] %n %m%n

src/test/java/spring01/UserTest.java

package spring01;

import java.time.LocalDate;
import java.time.LocalTime;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import spring01.hello.User;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={
		"classpath:/spring01.xml"
})
public class UserTest {
	private static final Logger LOGGER = LoggerFactory.getLogger(UserTest.class);
	
	@Autowired
	@Qualifier("user01")
	private User user01;
	
	
	@Test
	public void test01() {
		LOGGER.info("test01>>");
		System.out.println(user01.getName() + "--" + user01.getAge());
	}
	
	@Test
	public void test02() {
		System.out.println(LocalDate.now() + "--" + LocalTime.now());
		System.out.println(Integer.toBinaryString(0B0101 + 0B0010));
		System.out.println(0B001 & 0B1011);
	}
}

然后我们开始来构建多模块项目，首先初始化多模块项目

> mkdir zdemo-gradle-parent && cd zdemo-gradle-parent
> gradle init

> tree
.
├── build.gradle
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── settings.gradle

初始化子项目

编写 ${rootProject.projectDir}/settings.gradle

rootProject.name = 'zdemo-gradle-parent'

include 'zdemo-gradle-model'
include 'zdemo-gradle-dao'
include 'zdemo-gradle-biz'
include 'zdemo-gradle-app'

编写${rootProject.projectDir}/build.gradle 公共配置：

allprojects：allprojects是父Project的一个属性，该属性会返回该Project对象以及其所有子项目。在父项目的build.gradle脚本里，可以通过给allprojects传一个包含配置信息的闭包，来配置所有项目（包括父项目）的共同设置。通常可以在这里配置IDE的插件，group和version等信息
subprojects：subprojects和allprojects一样，也是父Project的一个属性，该属性会返回所有子项目。在父项目的build.gradle脚本里，给 subprojects传一个包含配置信息的闭包，可以配置所有子项目共有的设置，比如共同的插件、repositories、依赖版本以及依赖配置
configure：在项目中，并不是所有的子项目都会具有相同的配置，但是会有部分子项目具有相同的配置，比如在我所在的项目里除了cis-war和admin-war是web项目之外，其他子项目都不是。所以需要给这两个子项目添加war插件。Gradle的configure可以传入子项目数组，并为这些子项目设置相关配置。

/*
* 全部项目公共配置
*/
allprojects {
	//公共属性
  	group 'com.keyllo.demo'
  	version '0.0.1-SNAPSHOT'
  
  	//公共任务
  	//..
}

/*
* 子项目公共配置
*/
subprojects {
  	//公共插件
	apply plugin: 'eclipse'
	apply plugin: 'java-library'
	apply plugin: 'groovy'
	apply plugin: 'maven'
  
  	//公共参数
 	sourceCompatibility = 1.8
	targetCompatibility = 1.8
	ext {
		junitVersion = "4.12"
	}
  	
  	//公共依赖库和依赖包
  	repositories {
      	mavenLocal()
		mavenCentral()
		jcenter()
  	}
  
  	dependencies {
		testCompile "junit:junit:${junitVersion}"
	}
}

编写${rootProject.projectDir}/build.gradle 独享配置：

在项目中，除了设置共同配置之外，每个子项目还会有其独有的配置。比如每个子项目具有不同的依赖以及每个子项目特殊的task等。Gradle提供了两种方式来分别为每个子项目设置独有的配置。

在父项目的build.gradle文件中通过project(‘:sub-project-name’)来设置对应的子项目的配置。比如在子项目core需要Hibernate的依赖等。
我们还可以在每个子项目的目录里建立自己的构建脚本。在上例中，可以在子项目core目录下为其建立一个build.gradle文件，并在该构建脚本中配置core子项目所需的所有配置。

/*
* 子项目独享配置
*/
Project[] projects = subprojects.findAll {it.name.contains('app')}
configure(projects) {
	apply plugin: 'war'
}

project(':zdemo-gradle-model') {
 	//...
}

project(':zdemo-gradle-dao') {
	//...
}

project(':zdemo-gradle-biz') {
	//...
}

project(':zdemo-gradle-app') {
	//...
}

根据我对Gradle的使用经验，对于子项目少，配置简单的小型项目，推荐使用第一种方式配置，这样就可以把所有的配置信息放在同一个build.gradle文件里。例如我同事郑晔的开源项目moco。它只有两个子项目，因而就使用了第一种方式配置，在项目根目录下的build.gradle文件中设置项目相关的配置信息。但是，若是对于子项目多，并且配置复杂的大型项目，使用第二种方式对项目进行配置会更好。因为，第二种配置方式将各个项目的配置分别放到单独的build.gradle文件中去，可以方便设置和管理每个子项目的配置信息。

运行 gradle build 编译并测试整个项目，这是后会生成整个项目的目录：

> gradle build
> tree
.
├── build
│   ├── libs
│   │   └── zdemo-gradle-parent-0.0.1-SNAPSHOT.war
│   └── tmp
│       └── war
│           └── MANIFEST.MF
├── build.gradle
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
├── zdemo-gradle-app
│   └── build
│       ├── libs
│       │   └── zdemo-gradle-app-0.0.1-SNAPSHOT.jar
│       └── tmp
│           └── jar
│               └── MANIFEST.MF
├── zdemo-gradle-biz
│   └── build
│       ├── libs
│       │   └── zdemo-gradle-biz-0.0.1-SNAPSHOT.jar
│       └── tmp
│           └── jar
│               └── MANIFEST.MF
├── zdemo-gradle-dao
│   └── build
│       ├── libs
│       │   └── zdemo-gradle-dao-0.0.1-SNAPSHOT.jar
│       └── tmp
│           └── jar
│               └── MANIFEST.MF
└── zdemo-gradle-model
    └── build
        ├── libs
        │   └── zdemo-gradle-model-0.0.1-SNAPSHOT.jar
        └── tmp
            └── jar
                └── MANIFEST.MF

使用eclipse或其他集成开发工具打开新创建的gradle项目

import exsisting gradle project 导入刚刚创建的项目，项目导入后如下：