Gradle - Краткое руководство

"Gradle is an open source build automation system"

Ant и Maven достигли значительного успеха на рынке JAVA. Ant был первым инструментом сборки, выпущенным в 2000 году, и он разработан на основе идеи процедурного программирования. Позже он улучшен возможностью принимать плагины и управление зависимостями по сети с помощью Apache-IVY. Основным недостатком является XML как формат для написания сценариев сборки, иерархичность не подходит для процедурного программирования, а XML имеет тенденцию становиться неуправляемо большим.

Maven представлен в 2004 году. По сравнению с ANT, он значительно улучшен. Он меняет свою структуру и продолжает использовать XML для написания спецификаций сборки. Maven полагается на соглашения и может загружать зависимости по сети. Основное преимущество maven - это его жизненный цикл. При непрерывном соблюдении одного и того же жизненного цикла для нескольких проектов. За это приходится платить гибкостью. Maven также сталкивается с некоторыми проблемами в управлении зависимостями. Он плохо справляется с конфликтами между версиями одной и той же библиотеки, и сложные настраиваемые сценарии сборки на самом деле сложнее написать в maven, чем в ANT.

Наконец, в 2012 году появился Gradle. Gradle обладает некоторыми эффективными функциями обоих инструментов.

Особенности Gradle

Ниже приводится список функций, которые предоставляет Gradle.

Declarative builds and build-by-convention- Gradle доступен с отдельным предметным языком (DSL) на основе языка Groovy. Gradle предоставляет элементы декларативного языка. Эти элементы также обеспечивают поддержку сборки по соглашению для Java, Groovy, OSGI, Web и Scala.
Language for dependency based programming - Декларативный язык находится на вершине графа задач общего назначения, который вы можете полностью использовать в своей сборке.
Structure your build- Наконец, Gradle позволяет применять общие принципы проектирования к вашей сборке. Это даст вам идеальную структуру для сборки, так что вы сможете разработать хорошо структурированную и легко обслуживаемую, понятную сборку.
Deep API - Используя этот API, он позволяет вам контролировать и настраивать его конфигурацию и поведение выполнения до его ядра.
Gradle scales - Gradle может легко повысить их продуктивность, от простых сборок отдельных проектов до огромных корпоративных сборок с несколькими проектами.
Multi-project builds- Gradle поддерживает многопроектные сборки и частичные сборки. Если вы создаете подпроект, Gradle позаботится о создании всех подпроектов, от которых он зависит.
Different ways to manage your builds - Gradle поддерживает различные стратегии управления вашими зависимостями.
Gradle is the first build integration tool- Gradle полностью поддерживает ваши задачи ANT, инфраструктуру репозитория Maven и lvy для публикации и получения зависимостей. Gradle также предоставляет конвертер для преобразования Maven pom.xml в скрипт Gradle.
Ease of migration- Gradle может легко адаптироваться к любой вашей структуре. Поэтому вы всегда можете разработать свою сборку Gradle в той же ветке, где вы можете создавать живой скрипт.
Gradle Wrapper- Gradle Wrapper позволяет выполнять сборки Gradle на машинах, на которых Gradle не установлен. Это полезно для непрерывной интеграции серверов.
Free open source - Gradle - это проект с открытым исходным кодом, работающий под лицензией Apache Software License (ASL).
Groovy- Скрипт сборки Gradle написан на Groovy. Весь дизайн Gradle ориентирован на использование как язык, а не как жесткую структуру. Groovy позволяет вам написать собственный сценарий с некоторыми абстракциями. Весь API Gradle полностью разработан на языке Groovy.

Почему Groovy?

Полный API Gradle разработан с использованием языка Groovy. Это преимущество внутреннего DSL над XML. Gradle - это универсальный инструмент сборки по своей сути; его основное внимание уделяется проектам Java. В таких проектах члены команды будут хорошо знакомы с Java, и лучше, чтобы сборка была максимально прозрачной для всех членов команды.

Такие языки, как Python, Groovy или Ruby, лучше подходят для построения фреймворка. Почему был выбран Groovy, потому что он предлагает наибольшую прозрачность для людей, использующих Java. Базовый синтаксис Groovy такой же, как у Java. Groovy предоставляет намного больше возможностей.

Gradle - это инструмент сборки, построенный на основе java. Перед установкой рамы Gradle необходимо установить некоторые предварительные условия.

Предпосылки

JDK и Groovy - это предварительные условия для установки Gradle.

Gradle требует, чтобы в вашей системе был установлен JDK версии 6 или новее. Он использует библиотеки JDK, которые установлены и задают переменную среды JAVA_HOME.
Gradle имеет собственную библиотеку Groovy, поэтому нам не нужно явно устанавливать Groovy. Если он установлен, Gradle игнорирует его.

Ниже приведены шаги по установке Gradle в вашей системе.

Шаг 1. Проверьте установку JAVA.

Прежде всего, вам необходимо установить Java Software Development Kit (SDK) в вашей системе. Чтобы убедиться в этом, выполнитеJava –version на любой платформе, над которой вы работаете.

В Windows -

Выполните следующую команду, чтобы проверить установку Java. Я установил в свою систему JDK 1.8.

C:\> java -version

Выход -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

В Linux -

Выполните следующую команду, чтобы проверить установку Java. Я установил в свою систему JDK 1.8.

$ java - version

Выход -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

Мы предполагаем, что у читателей этого руководства в системе установлен Java SDK версии 1.8.0_66.

Шаг 2 - Загрузите файл сборки Gradle

Загрузите последнюю версию Gradle по ссылке Download Gradle . На справочной странице щелкните значокComplete Distributionссылка. Этот шаг характерен для любой платформы. Для этого вы получите полный дистрибутив в папку «Загрузки».

Шаг 3 - Настройка среды для Gradle

Настройка среды означает, что мы должны извлечь файл дистрибутива, скопировать файлы библиотеки в нужное место. НастройкаGRADLE_HOME и PATH переменные среды.

Этот шаг зависит от платформы.

В Windows -

Извлеките загруженный zip-файл с именем gradle-2.11-all.zip и скопируйте файлы раздачи из Downloads\gradle-2.11\ к C:\gradle\ расположение.

После этого добавьте C:\gradle и C:\gradle\bin каталоги в GRADLE_HOME и PATHсистемные переменные. Следуйте данной инструкции, котораяright click on my computers -> click on properties -> advanced system settings -> click on environmental variables. Там вы найдете диалоговое окно для создания и редактирования системных переменных. Нажмите новую кнопку для создания переменной GRADLE_HOME (см. Снимок экрана слева). Нажмите «Изменить», чтобы изменить существующую системную переменную Path (см. Снимок экрана справа). Следуйте приведенным ниже скриншотам.

В Linux -

Извлеките загруженный zip-файл с именем gradle-2.11-all.zip тогда вы найдете извлеченный файл с именем gradle-2.11.

Вы можете использовать следующее, чтобы переместить файлы распространения из Downloads/gradle-2.11/ к /opt/gradle/расположение. Выполните эту операцию из каталога Downloads.

$ sudo mv gradle-2.11 /opt/gradle

Отредактируйте файл ~ / .bashrc, вставьте в него следующее содержимое и сохраните его.

export ORIENT_HOME = /opt/gradle
export PATH = $PATH:

Выполните следующую команду, чтобы выполнить ~/.bashrc файл.

$ source ~/.bashrc

Шаг 4: проверьте установку Gradle

В окнах:

Вы можете выполнить следующую команду в командной строке.

C:\> gradle –v

Вывод: там вы найдете версию Gradle.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978
Groovy: 2.4.4

Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Windows 8.1 6.3 amd64

В Linux:

Вы можете выполнить следующую команду в терминале.

$ gradle –v

Вывод: там вы найдете версию Gradle.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978

Groovy: 2.4.4
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Linux 3.13.0-74-generic amd64

Gradle создает файл сценария для обработки двух вещей; одинprojects и еще один tasks. Каждая сборка Gradle представляет один или несколько проектов. Проект представляет собой библиотечный JAR-файл или веб-приложение, или он может представлять собой ZIP-архив, собранный из JAR-файлов, созданных другими проектами. Проще говоря, проект состоит из разных задач. Задача - это работа, которую выполняет сборка. Задачей может быть компиляция некоторых классов, создание JAR, создание документации Javadoc или публикация некоторых архивов в репозитории.

Gradle использует Groovy language для написания скриптов.

Написание сценария сборки

Gradle предоставляет доменно-ориентированный язык (DSL) для описания сборок. Здесь используется язык Groovy, чтобы упростить описание сборки. Каждый сценарий сборки Gradle кодируется с использованием UTF-8, сохраняется в автономном режиме и называется build.gradle.

build.gradle

Мы описываем задачи и проекты с помощью скрипта Groovy. Вы можете запустить сборку Gradle с помощью команды Gradle. Эта команда ищет файл с именемbuild.gradle. Взгляните на следующий пример, который представляет собой небольшой сценарий, который печатаетtutorialspoint. Скопируйте и сохраните следующий скрипт в файл с именемbuild.gradle. Этот сценарий сборки определяет имя задачи hello, которое используется для печати строки учебной точки.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Выполните следующую команду в командной строке. Он выполняет указанный выше сценарий. Вы должны выполнить это там, где хранится файл build.gradle.

C:\> gradle –q hello

Вывод:

tutorialspoint

Если вы думаете, что задача работает аналогично цели ANT, тогда это верно - задача Gradle эквивалентна цели ANT.

Вы можете упростить эту задачу приветствия, указав ярлык (представляет собой символ <<) к doLastзаявление. Если вы добавите этот ярлык к указанной выше задачеhello это будет выглядеть как следующий сценарий.

task hello << {
   println 'tutorialspoint'
}

Как и выше, вы можете выполнить приведенный выше сценарий, используя gradle –q hello команда.

Сценарий оценки в основном использует два реальных объекта, один из которых является объектом проекта, а другой - объектом сценария.

Project Object- Каждый сценарий описывает один или несколько проектов. Во время выполнения этот скрипт настраивает объект проекта. Вы можете вызвать некоторые методы и использовать свойства в своем сценарии сборки, которые делегированы объекту проекта.

Script Object- Gradle перенес код сценария в классы, который реализует интерфейс сценария, а затем выполняет. Это означает, что все свойства и методы, объявленные интерфейсом скрипта, доступны в вашем скрипте.

Следующая таблица определяет список standard project properties. Все эти свойства доступны в вашем скрипте сборки.

Sr. No.	имя	Тип	Значение по умолчанию
1	проект	Проект	Экземпляр проекта
2	имя	Строка	Имя каталога проекта.
3	путь	Строка	Абсолютный путь проекта.
4	описание	Строка	Описание проекта.
5	projectDir	файл	Каталог, содержащий сценарий сборки.
6	buildDir	файл	projectDir / build
7	группа	Объект	Неопределенные
8	версия	Объект	Неопределенные
9	муравей	AntBuilder	Экземпляр AntBuilder

Основы Groovy

Скрипты сборки Gradle используют полный API Groovy. Как стартап, обратите внимание на следующие примеры.

В следующем примере объясняется преобразование строки в верхний регистр.

Скопируйте и сохраните приведенный ниже код в build.gradle файл.

task upper << {
   String expString = 'TUTORIALS point'
   println "Original: " + expString
   println "Upper case: " + expString.toUpperCase()
}

C:\> gradle –q upper

Вывод:

Original: TUTORIALS point
Upper case: TUTORIALS POINT

В следующем примере объясняется, как 4 раза печатать значение неявного параметра ($ it).

Скопируйте и сохраните следующий код в build.gradle файл.

task count << {
   4.times { 
      print "$it " 
   }
}

$ gradle –q count

Вывод:

0 1 2 3

Язык Groovy предоставляет множество функций, некоторые из которых обсуждаются ниже.

Groovy JDK методы

Groovy добавляет множество полезных методов к стандартным классам Java. Например, Iterable API от JDK реализуетeach() метод, который выполняет итерацию по элементам Iterable Interface.

Скопируйте и сохраните следующий код в build.gradle файл.

task groovyJDK << {
   String myName = "Marc";
   myName.each() { 
      println "${it}" 
   };
}

C:\> gradle –q groovyJDK

Вывод:

M
a
r
c

Аксессоры собственности

Вы можете автоматически обращаться к соответствующим методам получения и установки определенного свойства, указав его ссылку.

В следующем фрагменте определяется синтаксис методов получения и установки свойства. buildDir.

// Using a getter method
println project.buildDir
println getProject().getBuildDir()

// Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')

Необязательные круглые скобки при вызове методов

Groovy содержит специальную функцию при вызове методов, заключающуюся в том, что скобки не являются обязательными для вызова методов. Эта функция также применима к сценариям Gradle.

Взгляните на следующий синтаксис. Это определяет вызов методаsystemProperty из test объект.

test.systemProperty 'some.prop', 'value'
test.systemProperty('some.prop', 'value')

Замыкание как последний параметр метода

Gradle DSL использует замыкания во многих местах. Если последний параметр метода - это закрытие, вы можете поместить закрытие после вызова метода.

Следующий фрагмент определяет синтаксис, который Closures использует в качестве параметров метода repositories ().

repositories {
   println "in a closure"
}
repositories() { 
   println "in a closure" 
}
repositories({ println "in a closure" })

Импорт по умолчанию

Gradle автоматически добавляет набор операторов импорта в скрипты Gradle. В следующем списке показаны пакеты импорта по умолчанию для скрипта Gradle.

Ниже приведены пакеты импорта по умолчанию для скрипта Gradle.

import org.gradle.*
import org.gradle.api.*
import org.gradle.api.artifacts.*
import org.gradle.api.artifacts.cache.*
import org.gradle.api.artifacts.component.*
import org.gradle.api.artifacts.dsl.*
import org.gradle.api.artifacts.ivy.*
import org.gradle.api.artifacts.maven.*
import org.gradle.api.artifacts.query.*
import org.gradle.api.artifacts.repositories.*
import org.gradle.api.artifacts.result.*
import org.gradle.api.component.*
import org.gradle.api.credentials.*
import org.gradle.api.distribution.*
import org.gradle.api.distribution.plugins.*
import org.gradle.api.dsl.*
import org.gradle.api.execution.*
import org.gradle.api.file.*
import org.gradle.api.initialization.*
import org.gradle.api.initialization.dsl.*
import org.gradle.api.invocation.*
import org.gradle.api.java.archives.*
import org.gradle.api.logging.*
import org.gradle.api.plugins.*
import org.gradle.api.plugins.announce.*
import org.gradle.api.plugins.antlr.*
import org.gradle.api.plugins.buildcomparison.gradle.*
import org.gradle.api.plugins.jetty.*
import org.gradle.api.plugins.osgi.*
import org.gradle.api.plugins.quality.*
import org.gradle.api.plugins.scala.*
import org.gradle.api.plugins.sonar.*
import org.gradle.api.plugins.sonar.model.*
import org.gradle.api.publish.*
import org.gradle.api.publish.ivy.*
import org.gradle.api.publish.ivy.plugins.*
import org.gradle.api.publish.ivy.tasks.*
import org.gradle.api.publish.maven.*
import org.gradle.api.publish.maven.plugins.*
import org.gradle.api.publish.maven.tasks.*
import org.gradle.api.publish.plugins.*
import org.gradle.api.reporting.*
import org.gradle.api.reporting.components.*
import org.gradle.api.reporting.dependencies.*
import org.gradle.api.reporting.model.*
import org.gradle.api.reporting.plugins.*
import org.gradle.api.resources.*
import org.gradle.api.specs.*
import org.gradle.api.tasks.*
import org.gradle.api.tasks.ant.*
import org.gradle.api.tasks.application.*
import org.gradle.api.tasks.bundling.*
import org.gradle.api.tasks.compile.*
import org.gradle.api.tasks.diagnostics.*
import org.gradle.api.tasks.incremental.*
import org.gradle.api.tasks.javadoc.*
import org.gradle.api.tasks.scala.*
import org.gradle.api.tasks.testing.*
import org.gradle.api.tasks.testing.junit.*
import org.gradle.api.tasks.testing.testng.*
import org.gradle.api.tasks.util.*
import org.gradle.api.tasks.wrapper.*
import org.gradle.authentication.*
import org.gradle.authentication.http.*
import org.gradle.buildinit.plugins.*
import org.gradle.buildinit.tasks.*
import org.gradle.external.javadoc.*
import org.gradle.ide.cdt.*
import org.gradle.ide.cdt.tasks.*
import org.gradle.ide.visualstudio.*
import org.gradle.ide.visualstudio.plugins.*
import org.gradle.ide.visualstudio.tasks.*
import org.gradle.ivy.*
import org.gradle.jvm.*
import org.gradle.jvm.application.scripts.*
import org.gradle.jvm.application.tasks.*
import org.gradle.jvm.platform.*
import org.gradle.jvm.plugins.*
import org.gradle.jvm.tasks.*
import org.gradle.jvm.tasks.api.*
import org.gradle.jvm.test.*
import org.gradle.jvm.toolchain.*
import org.gradle.language.assembler.*
import org.gradle.language.assembler.plugins.*
import org.gradle.language.assembler.tasks.*
import org.gradle.language.base.*
import org.gradle.language.base.artifact.*
import org.gradle.language.base.plugins.*
import org.gradle.language.base.sources.*
import org.gradle.language.c.*
import org.gradle.language.c.plugins.*
import org.gradle.language.c.tasks.*
import org.gradle.language.coffeescript.*
import org.gradle.language.cpp.*
import org.gradle.language.cpp.plugins.*
import org.gradle.language.cpp.tasks.*
import org.gradle.language.java.*
import org.gradle.language.java.artifact.*
import org.gradle.language.java.plugins.*
import org.gradle.language.java.tasks.*
import org.gradle.language.javascript.*
import org.gradle.language.jvm.*
import org.gradle.language.jvm.plugins.*
import org.gradle.language.jvm.tasks.*
import org.gradle.language.nativeplatform.*
import org.gradle.language.nativeplatform.tasks.*
import org.gradle.language.objectivec.*
import org.gradle.language.objectivec.plugins.*
import org.gradle.language.objectivec.tasks.*
import org.gradle.language.objectivecpp.*
import org.gradle.language.objectivecpp.plugins.*
import org.gradle.language.objectivecpp.tasks.*
import org.gradle.language.rc.*
import org.gradle.language.rc.plugins.*
import org.gradle.language.rc.tasks.*
import org.gradle.language.routes.*
import org.gradle.language.scala.*
import org.gradle.language.scala.plugins.*
import org.gradle.language.scala.tasks.*
import org.gradle.language.scala.toolchain.*
import org.gradle.language.twirl.*
import org.gradle.maven.*
import org.gradle.model.*
import org.gradle.nativeplatform.*
import org.gradle.nativeplatform.platform.*
import org.gradle.nativeplatform.plugins.*
import org.gradle.nativeplatform.tasks.*
import org.gradle.nativeplatform.test.*
import org.gradle.nativeplatform.test.cunit.*
import org.gradle.nativeplatform.test.cunit.plugins.*
import org.gradle.nativeplatform.test.cunit.tasks.*
import org.gradle.nativeplatform.test.googletest.*
import org.gradle.nativeplatform.test.googletest.plugins.*
import org.gradle.nativeplatform.test.plugins.*
import org.gradle.nativeplatform.test.tasks.*
import org.gradle.nativeplatform.toolchain.*
import org.gradle.nativeplatform.toolchain.plugins.*
import org.gradle.platform.base.*
import org.gradle.platform.base.binary
import org.gradle.platform.base.component.*
import org.gradle.platform.base.plugins.*
import org.gradle.platform.base.test.*
import org.gradle.play.*
import org.gradle.play.distribution.*
import org.gradle.play.platform.*
import org.gradle.play.plugins.*
import org.gradle.play.tasks.*
import org.gradle.play.toolchain.*
import org.gradle.plugin.use.*
import org.gradle.plugins.ear.*
import org.gradle.plugins.ear.descriptor.*
import org.gradle.plugins.ide.api.*
import org.gradle.plugins.ide.eclipse.*
import org.gradle.plugins.ide.idea.*
import org.gradle.plugins.javascript.base.*
import org.gradle.plugins.javascript.coffeescript.*
import org.gradle.plugins.javascript.envjs.*
import org.gradle.plugins.javascript.envjs.browser.*
import org.gradle.plugins.javascript.envjs.http.*
import org.gradle.plugins.javascript.envjs.http.simple.*
import org.gradle.plugins.javascript.jshint.*
import org.gradle.plugins.javascript.rhino.*
import org.gradle.plugins.javascript.rhino.worker.*
import org.gradle.plugins.signing.*
import org.gradle.plugins.signing.signatory.*
import org.gradle.plugins.signing.signatory.pgp.*
import org.gradle.plugins.signing.type.*
import org.gradle.plugins.signing.type.pgp.*
import org.gradle.process.*
import org.gradle.sonar.runner.*
import org.gradle.sonar.runner.plugins.*
import org.gradle.sonar.runner.tasks.*
import org.gradle.testing.jacoco.plugins.*
import org.gradle.testing.jacoco.tasks.*
import org.gradle.testkit.runner.*
import org.gradle.util.*

Сценарий сборки Gradle описывает один или несколько проектов. Каждый проект состоит из разных задач. Задача - это часть работы, которую выполняет сборка. Задача может заключаться в компиляции некоторых классов, хранении файлов классов в отдельной целевой папке, создании JAR, создании документации Javadoc или публикации некоторых достижений в репозиториях.

В этой главе объясняется, что такое задача и как ее создать и выполнить.

Определение задач

Задача - это ключевое слово, которое используется для определения задачи в скрипте сборки. Взгляните на следующий пример, который представляет задачу с именемhello это печатает tutorialspoint. Скопируйте и сохраните следующий скрипт в файл с именемbuild.gradle. Этот сценарий сборки определяет имя задачи hello, которое используется для печати строки учебной точки.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

C:\> gradle –q hello

Вывод:

tutorialspoint

task hello << {
   println 'tutorialspoint'
}

Вы можете выполнить приведенный выше сценарий, используя gradle –q hello команда.

Вот несколько вариантов определения задачи, взгляните на это. В следующем примере определяется задачаhello.

Скопируйте и сохраните следующий код в build.gradle файл.

task (hello) << {
   println "tutorialspoint"
}

C:\> gradle –q hello

Вывод:

tutorialspoint

Вы также можете использовать строки для имен задач. Взгляните на тот же приветственный пример. Здесь мы будем использовать String как задачу.

Скопируйте и сохраните следующий код в build.gradle файл.

task('hello') << {
   println "tutorialspoint"
}

C:\> gradle –q hello

Вывод:

tutorialspoint

Вы также можете использовать альтернативный синтаксис для определения задачи. Это использование метода create () для определения задачи. Взгляните на тот же пример приветствия, приведенный ниже.

Скопируйте и сохраните приведенный ниже код в build.gradle файл.

tasks.create(name: 'hello') << {
   println "tutorialspoint"
}

C:\> gradle –q hello

Вывод:

tutorialspoint

Поиск задач

Если вы хотите найти задачи, которые вы определили в файле сборки, вы должны использовать соответствующие стандартные свойства проекта. Это означает, что каждая задача доступна как свойство проекта с использованием имени задачи в качестве имени свойства.

Взгляните на следующий код, который обращается к задачам как к свойствам.

Скопируйте и сохраните приведенный ниже код в build.gradle файл.

task hello

println hello.name
println project.hello.name

C:\> gradle –q hello

Вывод:

hello
hello

Вы также можете использовать все свойства через коллекцию задач.

Скопируйте и сохраните следующий код в build.gradle файл.

task hello

println tasks.hello.name
println tasks['hello'].name

C:\> gradle –q hello

Вывод:

hello
hello

Вы также можете получить доступ к пути к задаче с помощью задач. Для этого вы можете вызвать метод getByPath () с именем задачи, относительным путем или абсолютным путем.

Скопируйте и сохраните приведенный ниже код в build.gradle файл.

project(':projectA') {
   task hello
}
task hello

println tasks.getByPath('hello').path
println tasks.getByPath(':hello').path
println tasks.getByPath('projectA:hello').path
println tasks.getByPath(':projectA:hello').path

C:\> gradle –q hello

Вывод:

:hello
:hello
:projectA:hello
:projectA:hello

Добавление зависимостей в задачи

Вы можете сделать задачу зависимой от другой задачи, что означает, что когда одна задача будет выполнена, запустится только другая задача. Каждая задача отличается названием задачи. Коллекция имен задач называется ее коллекцией задач. Чтобы ссылаться на задачу в другом проекте, вы должны использовать путь к проекту в качестве префикса к соответствующему имени задачи.

В следующем примере добавляется зависимость от taskX к taskY.

Скопируйте и сохраните приведенный ниже код в build.gradleфайл. Взгляните на следующий код.

task taskX << {
   println 'taskX'
}
task taskY(dependsOn: 'taskX') << {
   println "taskY"
}

Выполните следующую команду в командной строке. Он выполняет указанный выше сценарий. Вы должны выполнить это, гдеbuild.gradle файловые хранилища.

C:\> gradle –q taskY

Вывод:

taskX
taskY

В приведенном выше примере добавляется зависимость от задачи с помощью ее имен. Есть еще один способ добиться зависимости задачи, который определяет зависимость с помощью объекта Task.

Давайте возьмем тот же пример, когда taskY зависит от taskX, но мы используем объекты задач вместо имен ссылок на задачи.

Скопируйте и сохраните следующий код в build.gradle файл.

task taskY << {
   println 'taskY'
}
task taskX << {
   println 'taskX'
}
taskY.dependsOn taskX

Выполните следующую команду в командной строке. Вы должны выполнить это там, где хранится файл build.gradle.

C:\> gradle –q taskY

Вывод:

taskX
taskY

Здесь мы берем тот же пример, что taskY зависит от taskX, но мы используем объекты задач вместо имен ссылок на задачи. Взгляните на это.

Скопируйте и сохраните приведенный ниже код в build.gradleфайл. Взгляните на следующий код.

task taskX << {
   println 'taskX'
}
taskX.dependsOn {
   tasks.findAll { 
      task → task.name.startsWith('lib') 
   }
}
task lib1 << {
   println 'lib1'
}
task lib2 << {
   println 'lib2'
}
task notALib << {
   println 'notALib'
}

C:\> gradle –q taskX

Вывод:

lib1
lib2
taskX

Добавление описания к задаче

Вы можете добавить описание к своей задаче. Это описание отображается при выполненииGradle tasks. Это возможно с помощью ключевого слова description.

Скопируйте и сохраните следующий код в build.gradleфайл. Взгляните на следующий код.

task copy(type: Copy) {
   description 'Copies the resource directory to the target directory.'
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
   println("description applied")
}

Выполните следующую команду в командной строке. Вы должны выполнить это там, где хранится файл build.gradle.

C:\> gradle –q copy

Если команда выполнена успешно, вы получите следующий результат.

description applied

Пропуск задач

Пропустить задачи можно, передав закрытие предиката. Это возможно только в том случае, если метод задачи или закрытие бросаетStopExecutionException до того, как будет выполнена фактическая работа над задачей.

Скопируйте и сохраните следующий код в build.gradle файл.

task eclipse << {
   println 'Hello Eclipse'
}

// #1st approach - closure returning true, if the task should be executed, false if not.
eclipse.onlyIf {
   project.hasProperty('usingEclipse')
}

// #2nd approach - alternatively throw an StopExecutionException() like this
eclipse.doFirst {
   if(!usingEclipse) {
      throw new StopExecutionException()
   }
}

Выполните следующую команду в командной строке. Вы должны выполнить это там, где хранится файл build.gradle.

C:\> gradle –q eclipse

Структура задачи

Gradle имеет разные фазы при работе с задачами. Прежде всего, это этап настройки, на котором выполняется код, указанный непосредственно в закрытии задачи. Блок конфигурации выполняется для каждой доступной задачи, а не только для тех задач, которые позже фактически выполняются.

После фазы настройки фаза выполнения запускает код внутри doFirst или же doLast закрытие тех задач, которые фактически выполняются.

Сценарий сборки Gradle определяет процесс сборки проектов; каждый проект содержит некоторые зависимости и некоторые публикации. Зависимости означают то, что поддерживает создание вашего проекта, например, требуемый файл JAR из других проектов и внешние JAR, такие как JDBC JAR или Eh-cache JAR в пути к классам. Публикации означают результаты проекта, такие как файлы тестовых классов и файлы сборки, такие как файлы войны.

Практически все проекты не являются самодостаточными. Им нужны файлы, созданные другими проектами, для компиляции и тестирования исходных файлов. Например, чтобы использовать Hibernate в проекте, вам необходимо включить несколько Hibernate JAR в путь к классам. Gradle использует специальный скрипт для определения зависимостей, которые необходимо загрузить.

Gradle позаботится о создании и публикации результатов где-нибудь. Публикация основана на задаче, которую вы определяете. Он может захотеть скопировать файлы в локальный каталог или загрузить их в удаленный репозиторий Maven или lvy, или вы можете использовать файлы из другого проекта в той же многопроектной сборке. Мы можем назвать процесс публикации задачи публикацией.

Объявление ваших зависимостей

Конфигурация зависимости - это не что иное, как определение набора зависимостей. Вы можете использовать эту функцию для объявления внешних зависимостей, средств, которые вы хотите загрузить из сети. Это определяет различные стандарты, такие как следующие.

apply plugin: 'java'

repositories {
   mavenCentral()
}

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

Конфигурации зависимостей

Конфигурация зависимости - это не что иное, как определение набора зависимостей. Вы можете использовать эту функцию для объявления внешних зависимостей, которые вы хотите загрузить из Интернета. Это определяет следующие различные стандартные конфигурации.

Compile - Зависимости, необходимые для компиляции исходного кода проекта.
Runtime- Зависимости, требуемые производственными классами во время выполнения. По умолчанию также включает зависимости времени компиляции.
Test Compile- Зависимости, необходимые для компиляции тестового источника проекта. По умолчанию он включает скомпилированные производственные классы и зависимости времени компиляции.
Test Runtime- Зависимости, необходимые для запуска тестов. По умолчанию он включает зависимости времени выполнения и тестовой компиляции.

Внешние зависимости

Внешние зависимости - это один из видов зависимостей. Это зависимость от некоторых файлов, созданных вне текущей сборки и хранящихся в каком-либо репозитории, таком как Maven central, или корпоративный репозиторий Maven или lvy, или каталог в локальной файловой системе.

Следующий фрагмент кода предназначен для определения внешней зависимости. Используйте этот код вbuild.gradle файл.

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
}

Внешняя зависимость объявляет внешние зависимости, а форма быстрого доступа выглядит как «группа: имя: версия».

Репозитории

При добавлении внешних зависимостей. Gradle ищет их в репозитории. Репозиторий - это просто набор файлов, упорядоченных по группам, имени и версии. По умолчанию Gradle не определяет никаких репозиториев. Мы должны явно определить по крайней мере один репозиторий. Следующий фрагмент кода определяет, как определить репозиторий maven. Используйте этот код вbuild.gradle файл.

repositories {
   mavenCentral()
}

Следующий код предназначен для определения удаленного maven. Используйте этот код вbuild.gradle файл.

repositories {
   maven {
      url "http://repo.mycompany.com/maven2"
   }
}

Публикация артефактов

Конфигурации зависимостей также используются для публикации файлов. Эти опубликованные файлы называются артефактами. Обычно мы используем плагины для определения артефактов. Однако вам нужно указать Gradle, где публиковать артефакты. Вы можете добиться этого, прикрепив репозитории к задаче загрузки архивов. Взгляните на следующий синтаксис для публикации репозитория Maven. Во время выполнения Gradle сгенерирует и загрузит Pom.xml в соответствии с требованиями проекта. Используйте этот код вbuild.gradle файл.

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://localhost/tmp/myRepo/")
      }
   }
}

Плагин - это не что иное, как набор задач, почти все полезные задачи, такие как компиляция задач, установка объектов домена, настройка исходных файлов и т. Д., Выполняются плагинами. Применение плагина к проекту означает, что он позволяет расширять возможности проекта. Плагины могут делать такие вещи, как -

Расширьте базовую модель Gradle (например, добавьте новые элементы DSL, которые можно настроить).
Настройте проект в соответствии с преобразованиями (например, добавьте новые задачи или настройте разумные значения по умолчанию).
Примените определенную конфигурацию (например, добавьте репозитории организации или обеспечьте соблюдение стандартов).

Типы плагинов

В Gradle есть плагины двух типов: плагины скриптов и бинарные плагины. Плагины скрипта - это дополнительный скрипт сборки, который дает декларативный подход к управлению сборкой. Обычно это используется в сборке. Двоичные плагины - это классы, реализующие интерфейс плагина и применяющие программный подход к управлению сборкой. Двоичные плагины могут находиться в сценарии сборки, в иерархии проекта или извне в JAR плагина.

Применение плагинов

Project.apply()Метод API используется для применения конкретного плагина. Вы можете использовать один и тот же плагин несколько раз. Есть два типа плагинов: один - скриптовый, а второй - бинарный.

Плагины скриптов

Плагины сценария могут применяться из сценария в локальной файловой системе или в удаленном месте. Расположение файловой системы зависит от каталога проекта, а расположение удаленного сценария указывает URL-адрес HTTP. Взгляните на следующий фрагмент кода. Он используется для нанесенияother.gradleплагин к сценарию сборки. Используйте этот код вbuild.gradle файл.

apply from: 'other.gradle'

Бинарные плагины

Каждый плагин идентифицируется по идентификатору плагина в тех некоторых основных плагинах, которые используют короткие имена для его применения, а некоторые плагины сообщества используют полное имя для идентификатора плагина. Некоторое время это позволяет указать класс плагина.

Взгляните на следующий фрагмент кода. Он показывает, как применить плагин Java, используя его тип. Используйте этот код вbuild.gradle файл.

apply plugin: JavaPlugin

Взгляните на следующий код для применения основного плагина с использованием короткого имени. Используйте этот код вbuild.gradle файл.

plugins {
   id 'java'
}

Взгляните на следующий код для применения плагина сообщества с использованием короткого имени. Используйте этот код вbuild.gradle файл.

plugins {
   id "com.jfrog.bintray" version "0.4.1"
}

Написание собственных плагинов

При создании настраиваемого плагина вам необходимо написать его реализацию. Gradle создает экземпляр плагина и вызывает экземпляр плагина с помощью метода Plugin.apply (). В следующем примере содержится плагин приветствия, который добавляет в проект задачу приветствия. Взгляните на следующий код. Используйте этот код вbuild.gradle файл.

apply plugin: GreetingPlugin

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.task('hello') << {
         println "Hello from the GreetingPlugin"
      }
   }
}

Используйте следующий код для выполнения вышеуказанного скрипта.

C:\> gradle -q hello

Вывод:

Hello from the GreetingPlugin

Получение входных данных из сборки

Большинству плагинов требуется поддержка конфигурации из сценария сборки. У проекта Gradle есть связанный объект ExtensionContainer, который помогает отслеживать все параметры и свойства, передаваемые плагинам.

Добавим в проект простой объект расширения. Здесь мы добавляем в проект объект расширения приветствия, который позволяет вам настроить приветствие. Используйте этот код вbuild.gradle файл.

apply plugin: GreetingPlugin

greeting.message = 'Hi from Gradle'

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      // Add the 'greeting' extension object
      project.extensions.create("greeting", GreetingPluginExtension)
		
      // Add a task that uses the configuration
      project.task('hello') << {
         println project.greeting.message
      }
   }
}

class GreetingPluginExtension {
   def String message = 'Hello from GreetingPlugin'
}

Используйте следующий код для выполнения вышеуказанного скрипта.

C:\> gradle -q hello

Вывод:

Hi from Gradle

В этом примере GreetingPlugin - это простой старый объект Groovy с полем с именем message. Объект расширения добавляется в список плагинов с именем приветствия. Затем этот объект становится доступным как свойство проекта с тем же именем, что и объект расширения.

Gradle добавляет закрытие конфигурации для каждого объекта расширения, чтобы вы могли сгруппировать настройки вместе. Взгляните на следующий код. Используйте этот код вbuild.gradle файл.

apply plugin: GreetingPlugin

greeting {
   message = 'Hi'
   greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.extensions.create("greeting", GreetingPluginExtension)
		
      project.task('hello') << {
         println "${project.greeting.message} from ${project.greeting.greeter}"
      }
   }
}

class GreetingPluginExtension {
   String message
   String greeter
}

Используйте следующий код для выполнения вышеуказанного скрипта.

C:\> gradle -q hello

Вывод:

Hello from Gradle

Стандартные плагины Gradle

В дистрибутив Gradle включены различные плагины.

Языковые плагины

Эти плагины добавляют поддержку различных языков, которые могут быть скомпилированы и выполнены в JVM.

Идентификатор плагина	Применяется автоматически	Описание
Ява	java-base	Добавляет в проект возможности компиляции, тестирования и объединения Java. Он служит основой для многих других плагинов Gradle.
заводной	Java, Groovy-base	Добавляет поддержку для создания проектов Groovy.
Scala	java, scala-base	Добавляет поддержку для создания проектов Scala.
Antlr	Ява	Добавляет поддержку генерации парсеров с помощью Antlr.

Инкубационные языковые плагины

Эти плагины добавляют поддержку различных языков.

Идентификатор плагина	Применяется автоматически	Описание
ассемблер	-	Добавляет в проект возможности родного языка ассемблера.
c	-	Добавляет в проект возможности компиляции исходного кода C.
cpp	-	Добавляет в проект возможности компиляции исходного кода C ++.
цель-c	-	Добавляет в проект возможности компиляции исходного кода Objective-C.
цель-cpp	-	Добавляет в проект возможности компиляции исходного кода Objective-C ++.
Windows-ресурсы	-	Добавляет поддержку включения ресурсов Windows в собственные двоичные файлы.

Gradle предоставляет командную строку для выполнения сценария сборки. Он может выполнять более одной задачи одновременно. В этой главе объясняется, как выполнять несколько задач, используя разные параметры.

Выполнение нескольких задач

Вы можете выполнять несколько задач из одного файла сборки. Gradle может обрабатывать этот файл сборки, используяgradle command. Эта команда скомпилирует каждую задачу в том порядке, в котором они перечислены, и выполнит каждую задачу вместе с зависимостями с использованием различных параметров.

Example- Всего четыре задачи - задача1, задача2, задача3 и задача4. Задача 3 и задача 4 зависит от задачи 1 и задачи 2. Взгляните на следующую диаграмму.

В приведенных выше 4 задачах зависят друг от друга, представленных символом стрелки. Взгляните на следующий код. Копировать можно вставить вbuild.gradle файл.

task task1 << {
   println 'compiling source'
}

task task2(dependsOn: task1) << {
   println 'compiling unit tests'
}

task task3(dependsOn: [task1, task2]) << {
   println 'running unit tests'
}

task task4(dependsOn: [task1, task3]) << {
   println 'building the distribution'
}

Вы можете использовать следующий код для компиляции и выполнения вышеуказанной задачи.

C:\> gradle task4 test

Вывод:

:task1
compiling source
:task2
compiling unit tests
:task3
running unit tests
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Исключение задач

При исключении задачи из выполнения вы можете использовать параметр –x вместе с командой gradle и указать имя задачи, которую вы хотите исключить.

Используйте следующую команду, чтобы исключить task4 из приведенного выше сценария.

C:\> gradle task4 -x test

Вывод:

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Продолжение сборки при возникновении сбоя

Gradle прервет выполнение и завершит сборку сразу после сбоя любой задачи. Вы можете продолжить выполнение, даже если произойдет сбой. Для этого вы должны использовать параметр –continue с командой gradle. Он обрабатывает каждую задачу отдельно вместе со своими зависимостями. И главное, он будет ловить каждый обнаруженный сбой и сообщать в конце выполнения сборки. Предположим, что в случае сбоя задачи зависимые последующие задачи также не будут выполнены.

Выбор сборки для выполнения

Когда вы запускаете команду gradle, она ищет файл сборки в текущем каталоге. Вы можете использовать опцию –b, чтобы выбрать конкретный файл сборки вместе с абсолютным путем. В следующем примере выбирается привет из проекта.myproject.gradle файл, который находится в subdir/ взгляните на это.

task hello << {
   println "using build file '$buildFile.name' in '$buildFile.parentFile.name'."
}

Вы можете использовать следующую команду для выполнения вышеуказанного сценария.

C:\> gradle -q -b subdir/myproject.gradle hello

Вывод:

using build file 'myproject.gradle' in 'subdir'.

Получение информации о сборке

Gradle предоставляет несколько встроенных задач для получения подробной информации о задаче и проекте. Это может быть полезно для понимания структуры и зависимостей вашей сборки, а также для устранения проблем. Вы можете использовать плагин отчетов по проекту, чтобы добавлять задачи в свой проект, которые будут создавать эти отчеты.

Листинг проектов

Вы можете перечислить иерархию выбранного проекта и его подпроектов, используя gradle –q projectsкоманда. Вот пример, используйте следующую команду, чтобы вывести список всех проектов в файле сборки.

C:\> gradle -q projects

Вывод:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

В отчете отображается описание каждого проекта, если он указан. Вы можете использовать следующую команду, чтобы указать описание. Вставьте это вbuild.gradle файл.

description = 'The shared API for the application'

Список задач

Вы можете перечислить все задачи, принадлежащие нескольким проектам, с помощью следующей команды.

C:\> gradle -q tasks

Вывод:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
dists - Builds the distribution
libs - Builds the JAR

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
components - Displays the components produced by root project 'projectReports'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
properties - Displays the properties of root project 'projectReports'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).

To see all tasks and more detail, run gradle tasks --all

To see more detail about a task, run gradle help --task <task>

Вы можете использовать следующую команду для отображения информации обо всех задачах.

C:\> gradle -q tasks --all

Вывод:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
api:clean - Deletes the build directory (build)
webapp:clean - Deletes the build directory (build)
dists - Builds the distribution [api:libs, webapp:libs]
   docs - Builds the documentation
api:libs - Builds the JAR
   api:compile - Compiles the source files
webapp:libs - Builds the JAR [api:libs]
   webapp:compile - Compiles the source files

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
api:buildEnvironment - Displays all buildscript dependencies declared in project ':api'.
webapp:buildEnvironment - Displays all buildscript dependencies declared in project ':webapp'.
components - Displays the components produced by root project 'projectReports'. [incubating]
api:components - Displays the components produced by project ':api'. [incubating]
webapp:components - Displays the components produced by project ':webapp'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
api:dependencies - Displays all dependencies declared in project ':api'.
webapp:dependencies - Displays all dependencies declared in project ':webapp'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
api:dependencyInsight - Displays the insight into a specific dependency in project ':api'.
webapp:dependencyInsight - Displays the insight into a specific dependency in project ':webapp'.
help - Displays a help message.
api:help - Displays a help message.
webapp:help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
api:model - Displays the configuration model of project ':api'. [incubating]
webapp:model - Displays the configuration model of project ':webapp'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
api:projects - Displays the sub-projects of project ':api'.
webapp:projects - Displays the sub-projects of project ':webapp'.
properties - Displays the properties of root project 'projectReports'.
api:properties - Displays the properties of project ':api'.
webapp:properties - Displays the properties of project ':webapp'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).
api:tasks - Displays the tasks runnable from project ':api'.
webapp:tasks - Displays the tasks runnable from project ':webapp'.

Вот несколько команд в таблице с описанием различных опций.

Sr. No.	Команда	Описание
1	gradle –q help –task <название задачи>	Предоставляет информацию об использовании (например, путь, тип, описание, группа) о конкретной задаче или нескольких задачах.
2	gradle –q зависимости	Предоставляет список зависимостей выбранного проекта.
3	gradle -q api: dependencies --configuration <имя задачи>	Предоставляет список ограниченных зависимостей, соответствующих конфигурации.
4	gradle –q buildEnvironment	Предоставляет список зависимостей сценария сборки.
5	gradle –q dependencyInsight	Дает представление о конкретной зависимости.
6	Свойства Gradle –q	Предоставляет список свойств выбранного проекта.

В этой главе объясняется, как создать проект Java с использованием файла сборки Gradle.

Прежде всего, мы должны добавить java-плагин в сценарий сборки, потому что он предоставляет задачи для компиляции исходного кода Java, запуска модульных тестов, создания Javadoc и создания файла JAR. Используйте следующую строку вbuild.gradle файл.

apply plugin: 'java'

Макет проекта Java по умолчанию

Когда вы добавляете плагин в свою сборку, он предполагает определенную настройку вашего Java-проекта (аналогично Maven). взгляните на следующую структуру каталогов.

src / main / java содержит исходный код Java
src / test / java содержит тесты Java

Если вы выполните эту настройку, следующего файла сборки будет достаточно для компиляции, тестирования и объединения проекта Java.

Чтобы начать сборку, введите следующую команду в командной строке.

C:\> gradle build

SourceSetsможно использовать для указания другой структуры проекта. Например, источники хранятся вsrc папка, а не в src/main/java. Взгляните на следующую структуру каталогов.

apply plugin: 'java'
sourceSets {
   main {
      java {
         srcDir 'src'
      }
   }
	
   test {
      java {
         srcDir 'test'
      }
   }
}

init Выполнение задачи

Gradle еще не поддерживает несколько шаблонов проектов. Но он предлагаетinitзадача создать структуру нового проекта Gradle. Без дополнительных параметров эта задача создает проект Gradle, который содержит файлы оболочки Gradle,build.gradle и settings.gradle файл.

При добавлении --type параметр с java-library в качестве значения создается структура проекта Java и build.gradleфайл содержит некий шаблон Java с Junit. Взгляните на следующий код дляbuild.gradle файл.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

В разделе репозиториев он определяет, где найти зависимости. Jcenterдля разрешения ваших зависимостей. Раздел Зависимости предназначен для предоставления информации о внешних зависимостях.

Указание версии Java

Обычно у проекта Java есть версия и целевая JRE, на которой он компилируется. Вversion и sourceCompatibility свойство можно установить в build.gradle файл.

version = 0.1.0
sourceCompatibility = 1.8

Если артефакт является исполняемым приложением Java, MANIFEST.MF file должен знать класс с основным методом.

apply plugin: 'java'

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Example:

Создайте структуру каталогов, как показано на скриншоте ниже.

Скопируйте приведенный ниже код java в файл App.java и сохраните в consumerbanking\src\main\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Скопируйте приведенный ниже код java в файл AppTset.java и сохраните в consumerbanking\src\test\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App{
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Скопируйте приведенный ниже код в файл build.gradle и поместите в consumerbanking\ каталог.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Чтобы скомпилировать и выполнить приведенный выше сценарий, используйте приведенные ниже команды.

consumerbanking\> gradle tasks
consumerbanking\> gradle assemble
consumerbanking\> gradle build

Проверьте все файлы классов в соответствующих каталогах и проверьте consumerbanking\build\lib папка для consumerbanking.jar файл.

В этой главе объясняется, как скомпилировать и выполнить проект Groovy с помощью build.gradle файл.

Подключаемый модуль Groovy

Подключаемый модуль Groovy для Gradle расширяет надстройку Java и предоставляет задачи для программ Groovy. Вы можете использовать следующую строку для применения плагина Groovy.

apply plugin: 'groovy'

Полный файл сценария сборки выглядит следующим образом. Скопируйте следующий код вbuild.gradle файл.

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

dependencies {
   compile 'org.codehaus.groovy:groovy-all:2.4.5'
   testCompile 'junit:junit:4.12'
}

Вы можете использовать следующую команду для выполнения сценария сборки.

gradle build

Макет проекта Groovy по умолчанию

Плагин Groovy предполагает определенную настройку вашего проекта Groovy.

src / main / groovy содержит исходный код Groovy
src / test / groovy содержит тесты Groovy
src / main / java содержит исходный код Java
src / test / java содержит тесты Java

Проверьте соответствующий каталог, где build.gradle файловые места для папки сборки.

Тестовая задача автоматически обнаруживает и выполняет все модульные тесты в исходном наборе тестов. Он также создает отчет после завершения выполнения теста. JUnit и TestNG - это поддерживаемые API.

В тестовом задании есть Test.getDebug(), который можно настроить на запуск, чтобы JVM ожидала отладчика. Перед тем, как перейти к выполнению, он устанавливает сообщение отладчика на5005.

Обнаружение теста

В Test Taskопределяет, какие классы являются тестовыми, проверяя скомпилированные тестовые классы. По умолчанию он сканирует все файлы .class. Вы можете настроить собственные включения / исключения, только эти классы будут сканироваться. В зависимости от используемой тестовой среды (JUnit / TestNG) при обнаружении тестового класса используются разные критерии.

При использовании JUnit мы сканируем тестовые классы JUnit 3 и 4. Если какой-либо из следующих критериев соответствует, класс считается тестовым классом JUnit:

Класс или суперкласс расширяет TestCase или GroovyTestCase
Класс или суперкласс помечается @RunWith
Класс или суперкласс содержат метод, помеченный @Test
При использовании TestNG мы ищем методы, помеченные @Test

Note- Абстрактные классы не выполняются. Gradle также просматривает дерево наследования в файлы jar в пути к тестовым классам.

Если вы не хотите использовать обнаружение тестового класса, вы можете отключить его, установив scanForTestClasses к ложному.

Тестовая группировка

JUnit и TestNG позволяют сложные группы методов тестирования. Для группировки тестовые классы и методы JUnit. JUnit 4.8 вводит понятие категорий. Тестовая задача позволяет указать категории JUnit, которые вы хотите включить или исключить.

Вы можете использовать следующий фрагмент кода в файле build.gradle для группировки методов тестирования.

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

Включить и исключить определенные тесты

В Test класс имеет include и excludeметод. Эти методы можно использовать, чтобы указать, какие тесты следует запускать.

Запускайте только включенные тесты -

test {
   include '**my.package.name/*'
}

Пропустить исключенные тесты -

test {
   exclude '**my.package.name/*'
}

Образец build.gradle файл, как показано ниже, показывает различные параметры конфигурации.

apply plugin: 'java' // adds 'test' task

test {
   // enable TestNG support (default is JUnit)
   useTestNG()

   // set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

   // explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

   // show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

   // set heap size for the test JVM(s)
   minHeapSize = "128m"
   maxHeapSize = "512m"

   // set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'
   
   // listen to events in the test execution lifecycle
   beforeTest { 
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

   // listen to standard out and standard error of the test JVM(s)
   onOutput { 
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: " 
         + event.message )
   }
}

Вы можете использовать следующий синтаксис команды для выполнения некоторой тестовой задачи.

gradle <someTestTask> --debug-jvm

Gradle легко справляется с самыми маленькими и крупными проектами. Небольшие проекты имеют один файл сборки и дерево исходных текстов. Очень легко переварить и понять проект, разделенный на более мелкие, взаимозависимые модули. Gradle отлично поддерживает этот сценарий многопроектной сборки.

Структура для многопроектной сборки

Такие сборки бывают самых разных форм и размеров, но у них есть некоторые общие характеристики:

А settings.gradle файл в корневом или главном каталоге проекта.
А build.gradle файл в корневом или главном каталоге.
Дочерние каталоги, у которых есть собственные *.gradle файлы сборки (в некоторых сборках с несколькими проектами могут отсутствовать сценарии сборки дочерних проектов).

Чтобы перечислить все проекты в файле сборки, вы можете использовать следующую команду.

C:\> gradle -q projects

Вывод:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

description = 'The shared API for the application'

Указание общей конфигурации сборки

В build.gradle файла в root_project, общие настройки могут применяться ко всем проектам или только к подпроектам.

allprojects {
   group = 'com.example.gradle'
   version = '0.1.0'
}

subprojects {
   apply plugin: 'java'
   apply plugin: 'eclipse'
}

Это определяет общий com.example.gradle группа и 0.1.0версия ко всем проектам. Вsubprojects закрытие применяет общие конфигурации для всех подпроектов, но не для корневого проекта, например allprojects закрытие.

Конкретные конфигурации и зависимости проекта

Ядро ui и util подпроекты также могут иметь свои build.gradle файл, если у них есть особые потребности, которые еще не учтены в общей конфигурации корневого проекта.

Например, проект пользовательского интерфейса обычно зависит от основного проекта. Итак, проекту пользовательского интерфейса нужен собственныйbuild.gradle файл, чтобы указать эту зависимость.

dependencies {
   compile project(':core')
   compile 'log4j:log4j:1.2.17'
}

Зависимости проекта указываются в методе проекта.

Gradle предлагает несколько способов развертывания репозиториев артефактов сборки. При развертывании подписей для ваших артефактов в репозитории Maven вы также захотите подписать опубликованный файл POM.

Использование плагина Maven-publish

maven-publishплагин, который по умолчанию предоставляется Gradle. Используется для публикации скрипта Gradle. Взгляните на следующий код.

apply plugin: 'java'
apply plugin: 'maven-publish'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
         url "$buildDir/repo"
      }
   }
}

Есть несколько вариантов публикации, когда Java и maven-publishплагин применяется. Взгляните на следующий код, он развернет проект в удаленном репозитории.

apply plugin: 'groovy'
apply plugin: 'maven-publish'

group 'workshop'
version = '1.0.0'

publishing {
   publications {
      mavenJava(MavenPublication) { 
         from components.java 
      }
   }
	
   repositories {
      maven {
          default credentials for a nexus repository manager
         credentials {
            username 'admin'
            password 'admin123'
         }
         // url to the releases maven repository
            url "http://localhost:8081/nexus/content/repositories/releases/"
      }
   }
}

Преобразование проекта из Maven в Gradle

Есть специальная команда для конвертации Apache Maven pom.xml файлы в файлы сборки Gradle, если для этой задачи известны все используемые плагины Maven.

В этом разделе следующие pom.xmlКонфигурация maven будет преобразована в проект Gradle. Взгляните на это.

<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
	
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.app</groupId>
   <artifactId>example-app</artifactId>
   <packaging>jar</packaging>
   
   <version>1.0.0-SNAPSHOT</version>
	
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>

         <version>4.11</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
	
</project>

Вы можете использовать следующую команду в командной строке, что приведет к следующей конфигурации Gradle.

C:\> gradle init --type pom

В init задача зависит от задачи оболочки, поэтому создается оболочка Gradle.

Результирующий build.gradle файл выглядит примерно так -

apply plugin: 'java'
apply plugin: 'maven'

group = 'com.example.app'
version = '1.0.0-SNAPSHOT'

description = """"""

sourceCompatibility = 1.5
targetCompatibility = 1.5

repositories {
   maven { url "http://repo.maven.apache.org/maven2" }
}

dependencies {
   testCompile group: 'junit', name: 'junit', version:'4.11'
}

В этой главе рассказывается об интеграции eclipse и Gradle. Следуйте приведенным ниже инструкциям, чтобы добавить плагин Gradle в eclipse.

Шаг 1 - Откройте Eclipse Marketplace

Прежде всего откройте eclipse, установленный в вашей системе. Перейдите в раздел помощи -> щелкните EclipseMarketplace. Взгляните на следующий снимок экрана.

Шаг 2 - Установите плагин Buildship

После нажатия на Eclipse Marketplace вы найдете следующий снимок экрана. Здесь в строке поиска слева введитеbuildship. Buildship - это плагин интеграции Gradle. Когда вы найдете сборку на своем экране, нажмите «Установить» справа. Взгляните на следующий снимок экрана.

После этого вы найдете следующий снимок экрана, где вам нужно подтвердить установку программного обеспечения, нажав кнопку подтверждения. Взгляните на следующий снимок экрана.

После этого вам нужно нажать на «Принять лицензионное соглашение» на следующем экране и нажать «Готово». Взгляните на следующий снимок экрана.

Установка займет некоторое время. Взгляните на следующий снимок экрана.

После этого он попросит перезапустить Eclipse. Там вы выберетеYes.

Шаг 3 - Проверка плагина Gradle

Во время проверки мы создадим новый проект, следуя данной процедуре. В затмении перейдите в файл -> щелкните новый -> щелкните другие проекты. Там вы увидите следующий экран. Там выберите проект Gradle и нажмите «Далее». Взгляните на следующий снимок экрана.

После нажатия кнопки «Далее» вы увидите следующий экран. Здесь вы укажете путь к домашнему каталогу Gradle локальной файловой системы и нажмите кнопку «Далее». Взгляните на следующий снимок экрана.

Взгляните на следующий снимок экрана, где вы предоставите имя для проекта Gradle. В этом уроке мы используемdemoproject и нажмите кнопку «Готово».

Взгляните на следующий снимок экрана, где нам нужно подтвердить проект. Для этого на следующем экране нажмите кнопку «Готово».

Шаг 4 - Проверка структуры каталогов

После успешной установки плагина Gradle проверьте структуру каталогов демонстрационного проекта на наличие файлов и папок по умолчанию, как показано на следующем снимке экрана.