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은 또한 종속성 관리에서 몇 가지 문제에 직면합니다. 동일한 라이브러리 버전 간의 충돌을 잘 처리하지 못하며 복잡한 사용자 정의 빌드 스크립트는 실제로 ANT보다 maven에서 작성하기가 더 어렵습니다.

마침내 Gradle은 2012 년에 등장했습니다. Gradle은 두 도구의 효율적인 기능을 제공합니다.

Gradle의 기능

다음은 Gradle이 제공하는 기능 목록입니다.

  • Declarative builds and build-by-convention− Gradle은 Groovy 언어를 기반으로 별도의 DSL (Domain Specific Language)로 사용할 수 있습니다. 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 소프트웨어 라이선스 (ASL)에 따라 라이선스가 부여됩니다.

  • Groovy− Gradle의 빌드 스크립트는 Groovy로 작성되었습니다. Gradle의 전체 디자인은 엄격한 프레임 워크가 아닌 언어로 사용되도록 지향됩니다. 그리고 Groovy를 사용하면 몇 가지 추상화를 사용하여 자신 만의 스크립트를 작성할 수 있습니다. 전체 Gradle API는 Groovy 언어로 완전히 설계되었습니다.

왜 Groovy인가?

완전한 Gradle API는 Groovy 언어를 사용하여 설계되었습니다. 이것은 XML보다 내부 DSL의 장점입니다. Gradle은 핵심적인 범용 빌드 도구입니다. 주요 초점은 Java 프로젝트입니다. 이러한 프로젝트에서 팀 구성원은 Java에 매우 익숙 할 것이며 모든 팀 구성원에게 가능한 한 투명하게 빌드하는 것이 좋습니다.

Python, Groovy 또는 Ruby와 같은 언어는 빌드 프레임 워크에 더 적합합니다. Groovy가 선택된 이유는 Java를 사용하는 사람들에게 지금까지 최고의 투명성을 제공하기 때문입니다. Groovy의 기본 구문은 Java와 동일합니다. Groovy는 그 위에 훨씬 더 많은 것을 제공합니다.

Gradle은 Java를 기반으로 빌드 된 빌드 도구입니다. Gradle 프레임 작업을 설치하기 전에 설치해야 할 몇 가지 전제 조건이 있습니다.

전제 조건

JDK 및 Groovy는 Gradle 설치의 전제 조건입니다.

  • Gradle을 사용하려면 시스템에 JDK 버전 6 이상이 설치되어 있어야합니다. JAVA_HOME 환경 변수에 설치되고 설정되는 JDK 라이브러리를 사용합니다.

  • Gradle에는 자체 Groovy 라이브러리가 있으므로 명시 적으로 Groovy를 설치할 필요가 없습니다. 설치된 경우 Gradle에서 무시됩니다.

다음은 시스템에 Gradle을 설치하는 단계입니다.

1 단계-JAVA 설치 확인

먼저 시스템에 Java SDK (Software Development Kit)가 설치되어 있어야합니다. 이를 확인하려면 다음을 실행하십시오.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 다운로드 링크 에서 최신 버전의 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 변수를 생성하려면 새 버튼을 클릭하십시오 (왼쪽 스크린 샷을 따르십시오). 기존 경로 시스템 변수를 편집하려면 편집을 클릭하십시오 (오른쪽 스크린 샷 참조). 아래 주어진 스크린 샷을 따르십시오.

Linux에서-

다운로드 한 zip 파일의 압축을 풉니 다. gradle-2.11-all.zip 그러면 이름이 추출 된 파일을 찾을 수 있습니다. gradle-2.11.

다음을 사용하여 배포 파일을 이동할 수 있습니다. Downloads/gradle-2.11/ ...에 /opt/gradle/위치. 다운로드 디렉토리에서이 작업을 실행합니다.

$ 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 또는 웹 애플리케이션을 나타내거나 다른 프로젝트에서 생성 된 JAR에서 어셈블 된 ZIP을 나타낼 수 있습니다. 간단히 말해 프로젝트는 서로 다른 작업으로 구성됩니다. 작업은 빌드가 수행하는 작업을 의미합니다. 태스크는 일부 클래스를 컴파일하거나, JAR을 작성하거나, Javadoc을 생성하거나, 일부 아카이브를 저장소에 게시하는 것일 수 있습니다.

Gradle 사용 Groovy language 스크립트 작성을 위해.

빌드 스크립트 작성

Gradle은 빌드를 설명하기 위해 DSL (Domain Specific Language)을 제공합니다. 빌드를 더 쉽게 설명하기 위해 Groovy 언어를 사용합니다. Gradle의 각 빌드 스크립트는 UTF-8을 사용하여 인코딩되고 오프라인으로 저장되며 build.gradle로 이름이 지정됩니다.

build.gradle

Groovy 스크립트를 사용하여 작업 및 프로젝트에 대해 설명합니다. Gradle 명령어를 사용하여 Gradle 빌드를 실행할 수 있습니다. 이 명령은 다음과 같은 파일을 찾습니다.build.gradle. 인쇄하는 작은 스크립트를 나타내는 다음 예제를 살펴보십시오.tutorialspoint. 다음 스크립트를 복사하여 다음 파일에 저장하십시오.build.gradle. 이 빌드 스크립트는 tutorialspoint 문자열을 인쇄하는 데 사용되는 작업 이름 hello를 정의합니다.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 스크립트를 실행합니다. build.gradle 파일이 저장된 곳에서 이것을 실행해야합니다.

C:\> gradle –q hello

산출:

tutorialspoint

작업이 ANT의 대상과 유사하게 작동한다고 생각하면 맞습니다. Gradle 작업은 ANT 대상과 동일합니다.

바로 가기 (기호를 나타냄)를 지정하여이 hello 작업을 단순화 할 수 있습니다. <<) 로 doLast성명서. 위의 작업에이 바로 가기를 추가하면hello 다음 스크립트와 같습니다.

task hello << {
   println 'tutorialspoint'
}

위와 같이 위의 스크립트를 다음을 사용하여 실행할 수 있습니다. gradle –q hello 명령.

등급 스크립트는 주로 두 개의 실제 개체를 사용했습니다. 하나는 프로젝트 개체이고 다른 하나는 스크립트 개체입니다.

Project Object− 각 스크립트는 하나 또는 여러 프로젝트에 대해 설명합니다. 실행 중에이 스크립트는 프로젝트 개체를 구성합니다. 일부 메서드를 호출하고 프로젝트 개체에 위임 된 빌드 스크립트에서 속성을 사용할 수 있습니다.

Script Object− Gradle은 스크립트 인터페이스를 구현하는 클래스로 스크립트 코드를 가져 와서 실행합니다. 즉, 스크립트 인터페이스에 의해 선언 된 모든 속성과 메서드를 스크립트에서 사용할 수 있습니다.

다음 표는 목록을 정의합니다. standard project properties. 이러한 모든 속성은 빌드 스크립트에서 사용할 수 있습니다.

Sr. No. 이름 유형 기본값
1 계획 계획 프로젝트 인스턴스
2 이름 끈 프로젝트 디렉토리의 이름입니다.
삼 통로 끈 프로젝트의 절대 경로입니다.
4 기술 끈 프로젝트에 대한 설명입니다.
5 projectDir 파일 빌드 스크립트가 포함 된 디렉토리입니다.
6 buildDir 파일 projectDir / 빌드
7 그룹 목적 지정되지 않음
8 버전 목적 지정되지 않음
9 개미 AntBuilder AntBuilder 인스턴스

Groovy 기초

Gradle 빌드 스크립트는 전체 길이 Groovy API를 사용합니다. 스타트 업으로서 다음 예제를 살펴보십시오.

다음 예에서는 문자열을 대문자로 변환하는 방법을 설명합니다.

아래 주어진 코드를 복사하여 저장하십시오. build.gradle 파일.

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

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. build.gradle 파일이 저장된 곳에서 이것을 실행해야합니다.

C:\> gradle –q upper

산출:

Original: TUTORIALS point
Upper case: TUTORIALS POINT

다음 예에서는 암시 적 매개 변수 ($ it)의 값을 4 번 인쇄하는 방법을 설명합니다.

다음 코드를 복사하여 저장하십시오. build.gradle 파일.

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

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. build.gradle 파일이 저장된 곳에서 이것을 실행해야합니다.

$ gradle –q count

산출:

0 1 2 3

Groovy 언어는 아래에서 설명하는 몇 가지 중요한 기능에서 많은 기능을 제공합니다.

Groovy JDK 방법

Groovy는 표준 Java 클래스에 유용한 메소드를 많이 추가합니다. 예를 들어 JDK의 Iterable API는each() Iterable 인터페이스의 요소를 반복하는 메서드입니다.

다음 코드를 복사하여 저장하십시오. build.gradle 파일.

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

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. build.gradle 파일이 저장되는 곳에 이것을 실행해야합니다.

C:\> gradle –q groovyJDK

산출:

M
a
r
c

속성 접근 자

참조를 지정하여 특정 속성의 적절한 getter 및 setter 메서드에 자동으로 액세스 할 수 있습니다.

다음 스 니펫은 속성의 getter 및 setter 메서드 구문을 정의합니다. 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은 여러 곳에서 클로저를 사용합니다. 메서드의 마지막 매개 변수가 클로저 인 경우 메서드 호출 후에 클로저를 배치 할 수 있습니다.

다음 스 니펫은 Closure가 repositories () 메서드 매개 변수로 사용하는 구문을 정의합니다.

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

기본 가져 오기

Gradle은 Gradle 스크립트에 import 문 세트를 자동으로 추가합니다. 다음 목록은 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. 이 빌드 스크립트는 tutorialspoint 문자열을 인쇄하는 데 사용되는 작업 이름 hello를 정의합니다.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 스크립트를 실행합니다. build.gradle 파일이 저장된 곳에서 이것을 실행해야합니다.

C:\> gradle –q hello

산출:

tutorialspoint

바로 가기 (기호를 나타냄)를 지정하여이 hello 작업을 단순화 할 수 있습니다. <<) 로 doLast성명서. 위의 작업에이 바로 가기를 추가하면hello 다음 스크립트와 같습니다.

task hello << {
   println 'tutorialspoint'
}

위의 스크립트를 다음을 사용하여 실행할 수 있습니다. gradle –q hello 명령.

다음은 작업을 정의하는 몇 가지 변형입니다. 살펴보세요. 다음 예제는 작업을 정의합니다.hello.

다음 코드를 복사하여 저장하십시오. build.gradle 파일.

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

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. build.gradle 파일이 저장되는 곳에 이것을 실행해야합니다.

C:\> gradle –q hello

산출:

tutorialspoint

작업 이름에 문자열을 사용할 수도 있습니다. 동일한 hello 예제를 살펴보십시오. 여기서는 문자열을 작업으로 사용합니다.

다음 코드를 복사하여 저장하십시오. build.gradle 파일.

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

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. build.gradle 파일이 저장되는 곳에 이것을 실행해야합니다.

C:\> gradle –q hello

산출:

tutorialspoint

작업을 정의하기 위해 대체 구문을 사용할 수도 있습니다. 작업을 정의하기 위해 create () 메서드를 사용하는 것입니다. 아래에 제공된 동일한 hello 예제를 살펴보십시오.

아래 주어진 코드를 복사하여 저장하십시오. build.gradle 파일.

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

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. build.gradle 파일이 저장되는 곳에 이것을 실행해야합니다.

C:\> gradle –q hello

산출:

tutorialspoint

작업 찾기

빌드 파일에서 정의한 작업을 찾으려면 각각의 표준 프로젝트 속성을 사용해야합니다. 즉, 작업 이름을 속성 이름으로 사용하여 각 작업을 프로젝트의 속성으로 사용할 수 있습니다.

작업을 속성으로 액세스하는 다음 코드를 살펴보십시오.

아래 주어진 코드를 복사하여 저장하십시오. build.gradle 파일.

task hello

println hello.name
println project.hello.name

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. build.gradle 파일이 저장되는 곳에 이것을 실행해야합니다.

C:\> gradle –q hello

산출:

hello
hello

작업 컬렉션을 통해 모든 속성을 사용할 수도 있습니다.

다음 코드를 복사하여 저장하십시오. build.gradle 파일.

task hello

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

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. build.gradle 파일이 저장되는 곳에 이것을 실행해야합니다.

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

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. build.gradle 파일이 저장되는 곳에 이것을 실행해야합니다.

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

위의 예는 이름을 사용하여 작업에 대한 종속성을 추가하는 것입니다. Task 개체를 사용하여 종속성을 정의하는 작업 종속성을 달성하는 또 다른 방법이 있습니다.

여기서 우리는 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'
}

명령 프롬프트에서 다음 명령을 실행하십시오. 위의 주어진 스크립트를 실행합니다. 이것을 실행해야합니다.build.gradle 파일 저장소.

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 파일과 클래스 경로의 JDBC JAR 또는 Eh-cache JAR과 같은 외부 JAR과 같이 프로젝트 빌드를 지원하는 것을 의미합니다. 간행물은 테스트 클래스 파일과 같은 프로젝트의 결과물과 war 파일과 같은 빌드 파일을 의미합니다.

대부분의 모든 프로젝트는 독립적이지 않습니다. 소스 파일을 컴파일하고 테스트하려면 다른 프로젝트에서 빌드 한 파일이 필요합니다. 예를 들어 프로젝트에서 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 중앙, 회사 Maven 또는 lvy 저장소 또는 디렉토리 I 로컬 파일 시스템과 같은 일종의 저장소에 저장되는 일부 파일에 대한 종속성입니다.

다음 코드 조각은 외부 종속성을 정의하는 것입니다. 이 코드 사용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 메서드는 특정 플러그인을 적용하는 데 사용됩니다. 동일한 플러그인을 여러 번 사용할 수 있습니다. 플러그인에는 스크립트 플러그인과 바이너리 플러그인이 있습니다.

스크립트 플러그인

스크립트 플러그인은 로컬 파일 시스템의 스크립트 또는 원격 위치에서 적용 할 수 있습니다. 파일 시스템 위치는 프로젝트 디렉토리에 상대적인 반면 원격 스크립트 위치는 HTTP URL을 지정합니다. 다음 코드 스 니펫을 살펴보십시오. 적용하는 데 사용됩니다other.gradle빌드 스크립트에 플러그인. 이 코드 사용build.gradle 파일.

apply from: 'other.gradle'

바이너리 플러그인

각 플러그인은 일부 핵심 플러그인이 짧은 이름을 사용하여 적용하고 일부 커뮤니티 플러그인은 플러그인 ID에 대해 정규화 된 이름을 사용하는 플러그인 ID로 식별됩니다. 언젠가 플러그인 클래스를 지정할 수 있습니다.

다음 코드 스 니펫을 살펴보십시오. 타입을 사용하여 자바 플러그인을 적용하는 방법을 보여줍니다. 이 코드 사용build.gradle 파일.

apply plugin: JavaPlugin

짧은 이름을 사용하여 핵심 플러그인을 적용하려면 다음 코드를 살펴보십시오. 이 코드 사용build.gradle 파일.

plugins {
   id 'java'
}

짧은 이름을 사용하여 커뮤니티 플러그인을 적용하려면 다음 코드를 살펴보십시오. 이 코드 사용build.gradle 파일.

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

사용자 정의 플러그인 작성

커스텀 플러그인을 생성하는 동안 플러그인 구현을 작성해야합니다. Gradle은 플러그인을 인스턴스화하고 Plugin.apply () 메서드를 사용하여 플러그인 인스턴스를 호출합니다. 다음 샘플에는 프로젝트에 hello 작업을 추가하는 인사말 플러그인이 포함되어 있습니다. 다음 코드를 살펴보십시오. 이 코드 사용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은 message라는 필드가있는 일반 오래된 Groovy 객체입니다. 확장 개체는 greeting이라는 이름으로 플러그인 목록에 추가됩니다. 그러면이 개체는 확장 개체와 이름이 같은 프로젝트 속성으로 사용할 수있게됩니다.

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에서 컴파일 및 실행할 수있는 다양한 언어에 대한 지원을 추가합니다.

플러그인 ID 자동 적용 기술
자바 자바 기반 프로젝트에 Java 컴파일, 테스트 및 번들링 기능을 추가합니다. 다른 많은 Gradle 플러그인의 기초 역할을합니다.
그루비 자바, 그루비 기반 Groovy 프로젝트 빌드 지원을 추가합니다.
스칼라 자바, 스칼라 기반 Scala 프로젝트 빌드 지원을 추가합니다.
개미 자바 Antlr을 사용하여 구문 분석기를 생성하기위한 지원을 추가합니다.

인큐베이팅 언어 플러그인

이 플러그인은 다양한 언어에 대한 지원을 추가합니다.

플러그인 ID 자동 적용 기술
어셈블러 - 프로젝트에 네이티브 어셈블리 언어 기능을 추가합니다.
씨 - 프로젝트에 C 소스 컴파일 기능을 추가합니다.
cpp - 프로젝트에 C ++ 소스 컴파일 기능을 추가합니다.
목적 -c - Objective-C 소스 컴파일 기능을 프로젝트에 추가합니다.
목적 -cpp - 프로젝트에 Objective-C ++ 소스 컴파일 기능을 추가합니다.
창 리소스 - 네이티브 바이너리에 Windows 리소스를 포함하기위한 지원을 추가합니다.

Gradle은 빌드 스크립트를 실행하기위한 명령 줄을 제공합니다. 한 번에 둘 이상의 작업을 실행할 수 있습니다. 이 장에서는 다양한 옵션을 사용하여 여러 작업을 실행하는 방법에 대해 설명합니다.

여러 작업 실행

단일 빌드 파일에서 여러 작업을 실행할 수 있습니다. Gradle은 다음을 사용하여 해당 빌드 파일을 처리 할 수 ​​있습니다.gradle command. 이 명령은 나열된 순서대로 각 작업을 컴파일하고 다른 옵션을 사용하여 종속성과 함께 각 작업을 실행합니다.

Example− task1, task2, task3, task4의 네 가지 작업이 있습니다. Task3 및 task4는 task 1 및 task2에 따라 다릅니다. 다음 다이어그램을 살펴보십시오.

위의 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

작업 제외

실행에서 작업을 제외하는 동안 gradle 명령과 함께 –x 옵션을 사용하고 제외하려는 작업의 이름을 언급 할 수 있습니다.

위의 스크립트에서 task4를 제외하려면 다음 명령을 사용하십시오.

C:\> gradle task4 -x test

산출:

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

오류 발생시 빌드 계속

Gradle은 작업이 실패하는 즉시 실행을 중단하고 빌드를 실패합니다. 장애가 발생하더라도 실행을 계속할 수 있습니다. 이를 위해 gradle 명령과 함께 –continue 옵션을 사용해야합니다. 종속성과 함께 각 작업을 개별적으로 처리합니다. 그리고 가장 중요한 점은 빌드 실행이 끝날 때 발생한 각 오류를 포착하고보고한다는 것입니다. 작업이 실패하면 종속 된 후속 작업도 실행되지 않는다고 가정합니다.

실행할 빌드 선택

gradle 명령을 실행하면 현재 디렉터리에서 빌드 파일을 찾습니다. –b 옵션을 사용하여 절대 경로와 함께 특정 빌드 파일을 선택할 수 있습니다. 다음 예제에서 프로젝트 hello를 선택합니다.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 종속성 선택한 프로젝트의 종속성 목록을 제공합니다.
삼 gradle -q api : dependencies --configuration <작업 이름> 구성에 대한 제한된 종속성 목록을 제공합니다.
4 gradle –q buildEnvironment 빌드 스크립트 종속성 목록을 제공합니다.
5 gradle –q dependencyInsight 특정 종속성에 대한 통찰력을 제공합니다.
6 Gradle –q 속성 선택한 프로젝트의 속성 목록을 제공합니다.

이 장에서는 Gradle 빌드 파일을 사용하여 Java 프로젝트를 빌드하는 방법에 대해 설명합니다.

먼저 자바 소스 코드를 컴파일하고, 유닛 테스트를 실행하고, Javadoc을 생성하고, JAR 파일을 생성하는 작업을 제공하기 때문에 빌드 스크립트에 자바 플러그인을 추가해야합니다. 다음 줄을 사용하십시오.build.gradle 파일.

apply plugin: 'java'

자바 기본 프로젝트 레이아웃

빌드에 플러그인을 추가 할 때마다 Java 프로젝트의 특정 설정 (Maven과 유사)을 가정합니다. 다음 디렉토리 structre를 살펴보십시오.

  • 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'
      }
   }
}

태스크 실행 초기화

Gradle은 아직 여러 프로젝트 템플릿을 지원하지 않습니다. 그러나 그것은 제공합니다init새로운 Gradle 프로젝트의 구조를 만드는 작업입니다. 추가 매개 변수없이이 작업은 gradle 래퍼 파일이 포함 된 Gradle 프로젝트를 만듭니다.build.gradle 과 settings.gradle 파일.

추가 할 때 --type 매개 변수 java-library 가치로 자바 프로젝트 구조가 생성되고 build.gradle파일에는 Junit이있는 특정 Java 템플릿이 포함되어 있습니다. 다음 코드를 살펴보십시오.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 파일은 main 메소드가있는 클래스를 인식해야합니다.

apply plugin: 'java'

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

Example:

아래 스크린 샷과 같이 디렉터리 구조를 만듭니다.

아래 주어진 자바 코드를 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!" );
   }
}

아래 주어진 자바 코드를 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 플러그인

Gradle 용 Groovy 플러그인은 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

보고서는 지정된 경우 각 프로젝트에 대한 설명을 표시합니다. 다음 명령을 사용하여 설명을 지정할 수 있습니다. 붙여 넣기build.gradle 파일.

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 특정 요구 사항이있는 경우 파일 (루트 프로젝트의 일반 구성에 아직 적용되지 않은 경우).

예를 들어 ui 프로젝트에는 일반적으로 핵심 프로젝트에 대한 종속성이 있습니다. 따라서 ui 프로젝트에는 자체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 사용 된 모든 Maven 플러그인이이 작업에 알려진 경우 Gradle 빌드 파일에 파일을 추가합니다.

이 섹션에서 다음 pom.xmlmaven 구성은 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의 통합에 대해 설명합니다. Eclipse에 Gradle 플러그인을 추가하려면 아래 주어진 단계를 따르십시오.

1 단계-Eclipse Marketplace 열기

우선 시스템에 설치된 이클립스를 엽니 다. 도움말로 이동-> EclipseMarketplace를 클릭하십시오. 다음 스크린 샷을 살펴보십시오.

2 단계-Buildship 플러그인 설치

Eclipse Marketplace를 클릭하면 다음 스크린 샷을 찾을 수 있습니다. 여기 왼쪽 검색 창 유형buildship. Buildship은 Gradle 통합 플러그인입니다. 화면에서 빌드 쉽을 찾으면 오른쪽에있는 설치를 클릭하십시오. 다음 스크린 샷을 살펴보십시오.

그런 다음 확인 버튼을 클릭하여 소프트웨어 설치를 확인해야합니다. 다음 스크린 샷을 살펴보십시오.

그 후 다음 화면에서 라이센스 계약 동의를 클릭하고 완료를 클릭해야합니다. 다음 스크린 샷을 살펴보십시오.

설치하는 데 다소 시간이 걸립니다. 다음 스크린 샷을보십시오.

그 후 Eclipse를 다시 시작하라는 메시지가 표시됩니다. 거기에서 선택할 것입니다Yes.

3 단계-Gradle 플러그인 확인

확인하는 동안 주어진 절차에 따라 새 프로젝트를 생성합니다. 이클립스에서 파일로 이동-> 새로 만들기 클릭-> 다른 프로젝트를 클릭하십시오. 거기에 다음 화면이 있습니다. Gradle 프로젝트를 선택하고 다음을 클릭하십시오. 다음 스크린 샷을 살펴보십시오.

다음 버튼을 클릭하면 다음 화면이 나타납니다. 거기에서 로컬 파일 시스템의 Gradle 홈 디렉토리 경로를 제공하고 다음 버튼을 클릭합니다. 다음 스크린 샷을 살펴보십시오.

다음 스크린 샷을 살펴보면 Gradle 프로젝트의 이름이 제공됩니다. 이 튜토리얼에서 우리는demoproject 완료 버튼을 클릭합니다.

프로젝트를 확인하려면 다음 스크린 샷을 살펴보십시오. 이를 위해 다음 화면에서 완료 버튼을 클릭합니다.

4 단계-디렉토리 구조 확인

Gradle 플러그인을 성공적으로 설치 한 후 다음 스크린 샷과 같이 기본 파일 및 폴더의 데모 프로젝트 디렉터리 구조를 확인하십시오.

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved