Gradle Effective Implementation Guide电子书

Gradle Effective Implementation Guide

Table of Contents

Gradle Effective Implementation Guide

Credits

About the Author

Acknowledgement

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers and more

Why Subscribe?

Free Access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Starting with Gradle

Introducing Gradle

Declarative builds and convention over configuration

Support for Ant tasks and Maven repositories

Incremental builds

Multi-project builds

Gradle wrapper

Free and open source

Getting started

Installing Gradle

Writing our first build script

Default Gradle tasks

Task name abbreviation

Executing multiple tasks

Command-line options

Logging options

Changing the build file and directory

Running tasks without execution

Gradle daemon

Profiling

Understanding the Gradle user interface

Task Tree

Favorites

Command Line

Setup

Summary

2. Creating Gradle Build Scripts

Writing a build script

Defining tasks

Defining actions with the Action interface

Build scripts are Groovy code

Defining dependencies between tasks

Defining dependencies via tasks

Defining dependencies via closures

Setting default tasks

Organizing tasks

Adding a description to tasks

Grouping tasks together

Adding tasks in other ways

Using task rules

Accessing tasks as project properties

Adding additional properties to tasks

Avoiding common pitfalls

Skipping tasks

Using onlyIf predicates

Skipping tasks by throwing StopExecutionException

Enabling and disabling tasks

Skipping from the command line

Skipping tasks that are up-to-date

Summary

3. Working with Gradle Build Scripts

Working with files

Locating files

Using file collections

Working with file trees

Copying files

Renaming files

Filtering files

Archiving files

Project properties

Defining custom properties in script

Passing properties via the command line

Defining properties via system properties

Adding properties via environment variables

Defining properties using an external file

Using logging

Controlling output

Using the Gradle wrapper

Creating wrapper scripts

Customizing the Gradle wrapper

Summary

4. Using Gradle for Java Projects

Using plugins

Getting started

Using the Java plugin

Working with source sets

Creating a new source set

Custom configuration

Working with properties

Creating documentation

Assembling archives

Summary

5. Dependency Management

Dependency configuration

Repositories

Adding Maven repositories

Adding Ivy repositories

Adding a local directory repository

Defining dependencies

Using external module dependencies

Using project dependencies

Using file dependencies

Using client module dependencies

Using Gradle and Groovy dependencies

Accessing configuration dependencies

Setting dynamic versions

Resolving version conflicts

Adding optional ANT tasks

Using dependency configurations as files

Summary

6. Testing, Building, and Publishing Artifacts

Testing

Using TestNG for testing

Configuring the test process

Determining tests

Logging test output

Generating test reports

Running Java applications

Running an application from a project

Running an application as task

Running an application with the application plugin

Creating a distributable application archive

Publishing artifacts

Uploading to a Maven repository

Multiple artifacts

Signing artifacts

Publishing signature files

Configuring conditional signing

Packaging Java Enterprise Edition applications

Creating a WAR file

Using the War plugin

Creating an EAR file

Using the Ear plugin

Summary

7. Multi-project Builds

Working with multi-project builds

Executing tasks by project path

Using a flat layout

Defining projects

Filtering projects

Defining task dependencies between projects

Defining configuration dependencies

Working with Java multi-project builds

Using partial builds

Using the Jetty plugin

Summary

8. Mixed Languages

Using the Groovy plugin

Creating documentation with the Groovy plugin

Using the Scala plugin

Creating documentation with the Scala plugin

Summary

9. Maintaining Code Quality

Using the Checkstyle plugin

Using the PMD plugin

Using the FindBugs plugin

Using the JDepend plugin

Using the CodeNarc plugin

Using the Sonar plugin

Summary

10. Writing Custom Tasks and Plugins

Creating a custom task

Creating a custom task in the build file

Using incremental build support

Creating a task in the project source directory

Writing tests

Creating a task in a standalone project

Creating a custom plugin

Creating a plugin in the build file

Creating a plugin in the project source directory

Testing a plugin

Creating a plugin in a standalone project

Summary

11. Using Gradle with Continuous Integration

Creating a sample project

Using Jenkins

Adding the Gradle plugin

Configuring Jenkins job

Running the job

Configuring artifacts and test results

Adding Gradle versions

Using JetBrains TeamCity

Creating a project

Running the project

Using Atlassian Bamboo

Defining a build plan

Running the build plan

Summary

12. IDE Support

Using the Eclipse plugin

Customizing generated files

Customizing using DSL

Customizing with merge hooks

Customizing with XML manipulation

Merging configuration

Configuring WTP

Customizing file generation

Using the IntelliJ IDEA plugin

Customizing file generation

Customizing using DSL

Customizing with merged hooks

Customizing with XML manipulation

Running Gradle in Eclipse

Installing Gradle plugin

Importing Gradle project

Running tasks

Editing build files

Running Gradle in IntelliJ IDEA

Installing the plugin

Importing a project

Running tasks

Summary

Index