Gradle Effective Implementations Guide 2nd Edition by Hubert Klein Ikkink ISBN 1784394971 9781784394974

Gradle Effective Implementations Guide 2nd Edition by Hubert Klein Ikkink – Ebook PDF Instant Download/Delivery: 1784394971 ,9781784394974
Full download Gradle Effective Implementations Guide 2nd Edition after payment

Product details:

ISBN 10: 1784394971
ISBN 13: 9781784394974
Author: Hubert Klein Ikkink

Gradle is a project automation tool that has a wide range of applications. The basic aim of Gradle is to automate a wide variety of tasks performed by software developers, including compiling computer source code to binary code, packaging binary codes, running tests, deploying applications to production systems, and creating documentation. The book will start with the fundamentals of Gradle and introduce you to the tools that will be used in further chapters. You will learn to create and work with Gradle scripts and then see how to use Gradle to build your Java Projects. While building Java application, you will find out about other important topics such as dependency management, publishing artifacts, and integrating the application with other JVM languages such as Scala and Groovy. By the end of this book, you will be able to use Gradle in your daily development. Writing tasks, applying plugins, and creating build logic will be your second nature.

Gradle Effective Implementations Guide 2nd Edition Table of contents:

1. Starting with 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

Installing with SKDMAN!

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

Offline usage

Understanding the Gradle graphical 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

Getting more information about a task

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

Archiving files

Project properties

Defining custom properties in script

Defining properties using an external file

Passing properties via the command line

Defining properties via system properties

Adding properties via environment variables

Using logging

Controlling output

Using the Gradle Wrapper

Creating wrapper scripts

Customizing the Gradle Wrapper

Summary

4. Using Gradle for Java Projects

Why plugins?

Getting started with the Java plugin

Using the Java plugin

Working with source sets

Creating a new source set

Custom configuration

Working with properties

Creating Javadoc 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 our projects

Using TestNG for testing

Configuring the test process

Determining tests

Logging test output

Changing the test report directory

Running Java applications

Running an application from a project

Running an application as a task

Running an application with the application plugin

Creating a distributable application archive

Publishing artifacts

Uploading our artifacts to a Maven repository

Working with multiple artifacts

Signing artifacts

Packaging Java Enterprise Edition applications

Creating a WAR file

Creating an EAR file

Summary

7. Multi-project Builds

Working with multi-project builds

Executing tasks by project path

Using a flat layout

Ways of 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

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. Gradle in the Enterprise

Creating a sample project

Using Jenkins

Adding the Gradle plugin

Configuring a 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 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 an XML manipulation

Merging configuration

Configuring WTP

Using the IntelliJ IDEA plugin

Customizing file generation

Running Gradle in Eclipse

Installing the buildship plugin

Importing a Gradle project

Running tasks

Running Gradle in IntelliJ IDEA

Installing the plugin

Importing a project

Running tasks

Summary

People also search for Gradle Effective Implementations Guide 2nd Edition:

gradle best practices
    
gradle implementation examples
    
gradle implementation keyword
    
gradle implementation vs api
    
gradle effective pom

Tags: Hubert Klein Ikkink, Gradle Effective Implementations