Gradle - Hızlı Kılavuz

"Gradle is an open source build automation system"

Ant ve Maven, JAVA pazarında önemli bir başarıyı paylaştı. Ant, 2000 yılında piyasaya sürülen ilk yapım aracıdır ve prosedürel programlama fikrine dayalı olarak geliştirilmiştir. Daha sonra, Apache-IVY üzerindeki yardımla ağ üzerinden eklentileri ve bağımlılık yönetimini kabul etme yeteneği ile geliştirildi. Ana dezavantaj, derleme komut dosyaları yazmak için bir format olarak XML'dir, hiyerarşik olmak yordamsal programlama için iyi değildir ve XML yönetilemez şekilde büyük olma eğilimindedir.

Maven, 2004 yılında tanıtıldı. ANT'den sonra pek çok gelişme ile geliyor. Yapısını değiştirir ve yapı belirtimlerini yazmak için XML kullanmaya devam eder. Maven, kurallara güvenir ve bağımlılıkları ağ üzerinden indirebilir. Maven'in temel faydaları yaşam döngüsüdür. Birden fazla proje için aynı yaşam döngüsünü sürekli takip ederken. Bunun bir esneklik maliyeti vardır. Maven ayrıca bağımlılık yönetiminde bazı sorunlarla karşı karşıyadır. Aynı kitaplığın sürümleri arasındaki çatışmaları iyi idare etmez ve karmaşık özelleştirilmiş derleme komut dosyalarının aslında ANT'ye göre maven'de yazılması daha zordur.

Sonunda Gradle 2012'de ortaya çıktı. Gradle, her iki araçtan da bazı verimli özellikler taşıyor.

Gradle'ın Özellikleri

Aşağıda, Gradle'ın sağladığı özelliklerin listesi yer almaktadır.

• Declarative builds and build-by-convention- Gradle, Groovy diline dayalı ayrı Etki Alanına Özgü Dil (DSL) ile kullanılabilir. Gradle, bildirimsel bir dil unsurları sağlar. Bu öğeler aynı zamanda Java, Groovy, OSGI, Web ve Scala için standart yapı desteği sağlar.

• Language for dependency based programming - Bildirim dili, yapınızda tam olarak yararlanabileceğiniz genel amaçlı bir görev grafiğinin üzerinde bulunur.

• Structure your build- Gradle nihayet yapınıza ortak tasarım ilkelerini uygulamanıza izin verir. İyi yapılandırılmış ve bakımı kolay, anlaşılır bir yapı tasarlayabilmeniz için size inşa etmek için mükemmel bir yapı verecektir.

• Deep API - Bu API'yi kullanarak, yapılandırmasını ve yürütme davranışını özüne kadar izlemenize ve özelleştirmenize olanak tanır.

• Gradle scales - Gradle, basit ve tek proje derlemelerinden çok büyük kurumsal çoklu proje derlemelerine kadar verimliliklerini kolayca artırabilir.

• Multi-project builds- Gradle çoklu proje yapılarını destekler ve kısmi yapıları destekler. Bir alt proje oluşturursanız, Gradle bağlı olduğu tüm alt projeleri oluşturmaya özen gösterir.

• Different ways to manage your builds - Gradle, bağımlılıklarınızı yönetmek için farklı stratejileri destekler.

• Gradle is the first build integration tool- Gradle, ANT görevleriniz, bağımlılıkları yayınlamak ve almak için Maven ve lvy depo altyapısı için tam olarak desteklenir. Gradle ayrıca bir Maven pom.xml dosyasını Gradle betiğine dönüştürmek için bir dönüştürücü sağlar.

• Ease of migration- Gradle, sahip olduğunuz herhangi bir yapıya kolayca uyum sağlayabilir. Bu nedenle, Gradle yapınızı her zaman canlı betik oluşturabileceğiniz aynı dalda geliştirebilirsiniz.

• Gradle Wrapper- Gradle Wrapper, Gradle'ın kurulu olmadığı makinelerde Gradle kurulumlarını gerçekleştirmenize olanak tanır. Bu, sunucuların sürekli entegrasyonu için kullanışlıdır.

• Free open source - Gradle açık kaynaklı bir projedir ve Apache Yazılım Lisansı (ASL) altında lisanslanmıştır.

• Groovy- Gradle'ın yapı senaryosu Groovy'de yazılmıştır. Gradle'ın tüm tasarımı, katı bir çerçeve olarak değil, bir dil olarak kullanılmaya yöneliktir. Ve Groovy, bazı soyutlamalarla kendi senaryonuzu yazmanıza izin verir. Gradle API'sinin tamamı, Groovy dilinde tamamen tasarlanmıştır.

Neden Groovy?

Gradle API'sinin tamamı, Groovy dili kullanılarak tasarlanmıştır. Bu, dahili DSL'nin XML'e göre bir avantajıdır. Gradle, özünde genel amaçlı inşa aracıdır; ana odak noktası Java projeleridir. Bu tür projelerde, ekip üyeleri Java'ya çok aşina olacaktır ve bir yapının tüm ekip üyeleri için olabildiğince şeffaf olması daha iyidir.

Python, Groovy veya Ruby gibi diller, çerçeve oluşturmak için daha iyidir. Groovy'nin seçilmesinin nedeni, Java kullanan kişiler için en büyük şeffaflığı sunduğu için. Groovy'nin temel sözdizimi Java ile aynıdır. Groovy bunun üzerine çok daha fazlasını sağlar.

Gradle, java tabanlı bir yapı aracıdır. Gradle çerçeve işini kurmadan önce kurulması gereken bazı ön koşullar vardır.

Önkoşullar

JDK ve Groovy, Gradle kurulumu için önkoşullardır.

• Gradle, JDK sürüm 6 veya üzerinin sisteminize yüklenmesini gerektirir. Yüklenen ve JAVA_HOME çevresel değişkenine ayarlanan JDK kitaplıklarını kullanır.

• Gradle kendi Groovy kitaplığını taşır, bu nedenle Groovy'yi açıkça yüklememize gerek yoktur. Yüklenmişse, bu Gradle tarafından göz ardı edilir.

Gradle'ı sisteminize kurma adımları aşağıdadır.

Adım 1 - JAVA Kurulumunu Doğrulayın

Öncelikle sisteminizde Java Yazılım Geliştirme Kiti (SDK) kurulu olması gerekir. Bunu doğrulamak için yürütünJava –version üzerinde çalıştığınız platformlardan herhangi birinde komut verin.

Windows'ta -

Java kurulumunu doğrulamak için aşağıdaki komutu yürütün. Sistemime JDK 1.8 kurdum.

C:\> java -version

Çıktı -

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'ta -

Java kurulumunu doğrulamak için aşağıdaki komutu yürütün. Sistemime JDK 1.8 kurdum.

$ java - version

Çıktı -

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)

Bu öğreticinin okuyucularının sistemlerinde Java SDK sürüm 1.8.0_66 kurulu olduğunu varsayıyoruz.

Adım 2 - Gradle Derleme Dosyasını İndirin

Gradle'ın en son sürümünü Gradle'ı İndir bağlantısından indirin . Referans sayfasında,Complete Distributionbağlantı. Bu adım, herhangi bir platform için ortaktır. Bunun için, tüm dağıtım dosyasını İndirilenler klasörünüze alacaksınız.

Adım 3 - Gradle için Ortamı Ayarlayın

Ortamın kurulması, dağıtım dosyasını çıkarmamız, kitaplık dosyalarını uygun konuma kopyalamamız gerektiği anlamına gelir. KurulumGRADLE_HOME ve PATH çevresel değişkenler.

Bu adım platforma bağlıdır.

Windows'ta -

Adlı indirilen zip dosyasını çıkarın gradle-2.11-all.zip ve dağıtım dosyalarını şuradan kopyalayın Downloads\gradle-2.11\ -e C:\gradle\ yer.

Bundan sonra ekleyin C:\gradle ve C:\gradle\bin dizinlere GRADLE_HOME ve PATHsistem değişkenleri. Verilen talimatı izleyin yaniright click on my computers -> click on properties -> advanced system settings -> click on environmental variables. Orada, sistem değişkenlerini oluşturmak ve düzenlemek için bir iletişim kutusu bulacaksınız. GRADLE_HOME değişkeni oluşturmak için yeni düğmeye tıklayın (sol taraftaki ekran görüntüsünü izleyin). Mevcut Path sistem değişkenini düzenlemek için Düzenle'ye tıklayın (sağ taraftaki ekran görüntüsünü izleyin). Aşağıda verilen ekran görüntülerini izleyin.

Linux'ta -

Adlı indirilen zip dosyasını çıkarın gradle-2.11-all.zip o zaman adında çıkarılmış bir dosya bulacaksınız gradle-2.11.

Dağıtım dosyalarını şuradan taşımak için aşağıdakileri kullanabilirsiniz: Downloads/gradle-2.11/ -e /opt/gradle/yer. Bu işlemi İndirilenler dizininden gerçekleştirin.

$ sudo mv gradle-2.11 /opt/gradle

~ / .Bashrc dosyasını düzenleyin ve aşağıdaki içeriği ona yapıştırın ve kaydedin.

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

Yürütmek için aşağıdaki komutu yürütün ~/.bashrc dosya.

$ source ~/.bashrc

4. Adım: Gradle kurulumunu doğrulayın

Windows'ta:

Komut isteminde aşağıdaki komutu çalıştırabilirsiniz.

C:\> gradle –v

Çıktı: orada Gradle sürümünü bulacaksınız.

------------------------------------------------------------
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'ta:

Aşağıdaki komutu terminalde çalıştırabilirsiniz.

$ gradle –v

Çıktı: orada Gradle sürümünü bulacaksınız.

------------------------------------------------------------
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, iki şeyi ele almak için bir betik dosyası oluşturur; Biriprojects ve diğeri tasks. Her Gradle yapısı bir veya daha fazla projeyi temsil eder. Bir proje, bir kitaplık JAR'ı veya bir web uygulamasını temsil eder veya diğer projeler tarafından üretilen JAR'lardan birleştirilmiş bir ZIP'i temsil edebilir. Basit bir deyişle, bir proje farklı görevlerden oluşur. Görev, bir yapının gerçekleştirdiği bir iş anlamına gelir. Bir görev, bazı sınıfları derliyor, bir JAR oluşturuyor, Javadoc oluşturuyor veya bazı arşivleri bir depoda yayınlıyor olabilir.

Gradle kullanır Groovy language senaryo yazmak için.

Derleme Komut Dosyası Yazma

Gradle, yapıları açıklamak için bir Etki Alanına Özgü Dil (DSL) sağlar. Bu, bir yapıyı tanımlamayı kolaylaştırmak için Groovy dilini kullanır. Gradle'ın her derleme komut dosyası UTF-8 kullanılarak kodlanır, çevrimdışı kaydedilir ve build.gradle olarak adlandırılır.

build.gradle

Groovy betiği kullanarak görevleri ve projeleri açıklıyoruz. Gradle komutunu kullanarak bir Gradle derlemesi çalıştırabilirsiniz. Bu komut adında bir dosya ararbuild.gradle. Aşağıdaki örneğe bir göz atın.tutorialspoint. Aşağıdaki komut dosyasını kopyalayıp adlı bir dosyaya kaydedin.build.gradle. Bu derleme betiği, tutorialspoint dizesini yazdırmak için kullanılan bir görev adı olan merhaba tanımlar.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Komut isteminde aşağıdaki komutu yürütün. Yukarıdaki betiği çalıştırır. Bunu build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q hello

Çıktı:

tutorialspoint

Görevin ANT'nin hedefine benzer şekilde çalıştığını düşünüyorsanız, bu doğru - Gradle görevi ANT hedefine eşdeğerdir.

Bir kısayol belirterek bu merhaba görevini basitleştirebilirsiniz (bir <<) için doLastBeyan. Bu kısayolu yukarıdaki göreve eklersenizhello aşağıdaki komut dosyası gibi görünecektir.

task hello << {
   println 'tutorialspoint'
}

Yukarıda olduğu gibi, yukarıdaki komut dosyasını kullanarak çalıştırabilirsiniz. gradle –q hello komut.

Grade komut dosyası esas olarak iki gerçek Nesne kullanır, biri Proje Nesnesi ve diğeri Komut Dosyası Nesnesidir.

Project Object- Her komut dosyası bir veya birden çok projeyi açıklar. Yürütme sırasında bu komut dosyaları Proje Nesnesini yapılandırır. Yapı betiğinizde Proje Nesnesine temsil edilen bazı yöntemleri çağırabilir ve özelliği kullanabilirsiniz.

Script Object- Gradle, Script Arayüzünü uygulayan ve ardından çalıştıran sınıflara kod kodunu aldı. Bu, komut dosyası arabirimi tarafından bildirilen tüm özelliklerin ve yöntemlerin komut dosyanızda mevcut olduğu anlamına gelir.

Aşağıdaki tablo şu listeyi tanımlar standard project properties. Tüm bu özellikler, derleme komut dosyanızda mevcuttur.

Harika Temeller

Gradle derleme komut dosyaları tam uzunlukta Groovy API'sini kullanır. Başlangıç ​​olarak aşağıdaki örneklere bir göz atın.

Aşağıdaki örnek, bir dizeyi büyük harfe dönüştürmeyi açıklamaktadır.

Aşağıdaki kodu kopyalayın ve şuraya kaydedin: build.gradle dosya.

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q upper

Çıktı:

Original: TUTORIALS point
Upper case: TUTORIALS POINT

Aşağıdaki örnek, örtük bir parametrenin ($ it) değerini 4 kez yazdırmayı açıklar.

Aşağıdaki kodu kopyalayıp şuraya kaydedin: build.gradle dosya.

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu build.gradle dosyasının depolandığı yerde yürütmelisiniz.

$ gradle –q count

Çıktı:

0 1 2 3

Groovy dili, aşağıda tartışılan bazı önemli özelliklerde birçok özellik sağlar.

Groovy JDK Yöntemleri

Groovy, standart Java sınıflarına birçok yararlı yöntem ekler. Örneğin, JDK'nın yinelenebilir API'si bireach() Yinelenebilir Arabirimin öğeleri üzerinde yinelenen yöntem.

Aşağıdaki kodu kopyalayıp şuraya kaydedin: build.gradle dosya.

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu, build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q groovyJDK

Çıktı:

M
a
r
c

Emlak Erişimcileri

Referansını belirterek belirli bir özelliğin uygun alıcı ve ayarlayıcı yöntemlerine otomatik olarak erişebilirsiniz.

Aşağıdaki kod parçası, bir özelliğin alıcı ve ayarlayıcı yöntemlerinin sözdizimlerini tanımlar buildDir.

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

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

Yöntem Çağrılarında İsteğe Bağlı Parantezler

Groovy, yöntem çağırmada parantezlerin isteğe bağlı olduğu özel bir özellik içerir. Bu özellik Gradle komut dosyası için de geçerlidir.

Aşağıdaki söz dizimine bir göz atın. Bu, çağıran bir yöntemi tanımlarsystemProperty nın-nin test nesne.

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

Yöntemin Son Parametresi Olarak Kapanış

Gradle DSL, birçok yerde kapatma kullanır. Bir yöntemin son parametresi bir kapanışsa, kapanışı yöntem çağrısından sonra yerleştirebilirsiniz.

Aşağıdaki kod parçası, Closure'ların repositories () yöntem parametreleri olarak kullandığı sözdizimlerini tanımlar.

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

Varsayılan İçe Aktarmalar

Gradle, Gradle komut dosyalarına otomatik olarak bir dizi içe aktarma ifadesi ekler. Aşağıdaki liste, Gradle komut dosyasına varsayılan içe aktarma paketlerini gösterir.

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 build script bir veya daha fazla Projeyi açıklar. Her proje farklı görevlerden oluşur. Görev, bir yapının gerçekleştirdiği bir iş parçasıdır. Görev, bazı sınıfları derlemek, sınıf dosyalarını ayrı hedef klasörde depolamak, JAR oluşturmak, Javadoc oluşturmak veya bazı başarıları bir havuzda yayınlamak olabilir.

Bu bölüm, görevin ne olduğu ve bir görevin nasıl oluşturulup yürütüleceğini açıklar.

Görevleri Tanımlama

Görev, komut dosyası oluşturmak için bir görevi tanımlamak için kullanılan bir anahtar sözcüktür. Adlı bir görevi temsil eden aşağıdaki örneğe bir göz atınhello bu yazdırır tutorialspoint. Aşağıdaki komut dosyasını kopyalayıp adlı bir dosyaya kaydedin.build.gradle. Bu derleme betiği, tutorialspoint dizesini yazdırmak için kullanılan bir görev adı merhaba tanımlar.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Komut isteminde aşağıdaki komutu yürütün. Yukarıdaki betiği çalıştırır. Bunu build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q hello

Çıktı:

tutorialspoint

Bir kısayol belirterek bu merhaba görevini basitleştirebilirsiniz (bir <<) için doLastBeyan. Bu kısayolu yukarıdaki göreve eklersenizhello aşağıdaki komut dosyası gibi görünecektir.

task hello << {
   println 'tutorialspoint'
}

Yukarıdaki komut dosyasını kullanarak çalıştırabilirsiniz. gradle –q hello komut.

İşte bir görevi tanımlamanın bazı varyasyonları, ona bir göz atın. Aşağıdaki örnek bir görevi tanımlarhello.

Aşağıdaki kodu kopyalayıp şuraya kaydedin: build.gradle dosya.

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu, build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q hello

Çıktı:

tutorialspoint

Görev adları için dizeleri de kullanabilirsiniz. Aynı merhaba örneğine bir göz atın. Burada String'i görev olarak kullanacağız.

Aşağıdaki kodu kopyalayıp şuraya kaydedin: build.gradle dosya.

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu, build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q hello

Çıktı:

tutorialspoint

Bir görevi tanımlamak için alternatif sözdizimi de kullanabilirsiniz. Bu, bir görevi tanımlamak için create () yöntemini kullanıyor. Aşağıda verilen aynı merhaba örneğine bir göz atın.

Aşağıdaki kodu kopyalayın ve şuraya kaydedin: build.gradle dosya.

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu, build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q hello

Çıktı:

tutorialspoint

Görevleri Bulma

Derleme dosyasında tanımladığınız görevleri bulmak istiyorsanız, ilgili standart proje özelliklerini kullanmanız gerekir. Bu, her görevin, özellik adı olarak görev adı kullanılarak projenin bir özelliği olarak mevcut olduğu anlamına gelir.

Görevlere özellik olarak erişen aşağıdaki koda bir göz atın.

Aşağıdaki kodu kopyalayın ve şuraya kaydedin: build.gradle dosya.

task hello

println hello.name
println project.hello.name

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu, build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q hello

Çıktı:

hello
hello

Görevler koleksiyonu aracılığıyla tüm özellikleri de kullanabilirsiniz.

Aşağıdaki kodu kopyalayıp şuraya kaydedin: build.gradle dosya.

task hello

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu, build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q hello

Çıktı:

hello
hello

Görevleri kullanarak görev yoluna da erişebilirsiniz. Bunun için getByPath () yöntemini bir görev adı veya göreceli bir yol veya mutlak bir yolla çağırabilirsiniz.

Aşağıdaki kodu kopyalayın ve şuraya kaydedin: build.gradle dosya.

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu, build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q hello

Çıktı:

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

Görevlere Bağımlılıklar Ekleme

Bir görevi başka bir göreve bağımlı hale getirebilirsiniz, yani bir görev tamamlandığında yalnızca diğer görev başlayacaktır. Her görev, görev adı ile farklıdır. Görev adlarının toplanması, görevler koleksiyonu tarafından belirtilir. Başka bir projedeki bir göreve atıfta bulunmak için, projenin yolunu ilgili görev adına önek olarak kullanmalısınız.

TaskX'ten taskY'ye bir bağımlılık ekleyen aşağıdaki örnek.

Aşağıdaki kodu kopyalayın ve şuraya kaydedin: build.gradledosya. Aşağıdaki koda bir göz atın.

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu yürütmelisiniz,build.gradle dosya depoları.

C:\> gradle –q taskY

Çıktı:

taskX
taskY

Yukarıdaki örnek, adlarını kullanarak göreve bağımlılık eklemektir. Görev bağımlılığını elde etmenin, bağımlılığı bir Task nesnesi kullanarak tanımlayan başka bir yolu vardır.

TaskX'e bağımlı olan aynı taskY örneğini alalım, ancak görev referans adları yerine görev nesneleri kullanıyoruz.

Aşağıdaki kodu kopyalayıp şuraya kaydedin: build.gradle dosya.

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

Komut isteminde aşağıdaki komutu yürütün. Bunu build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q taskY

Çıktı:

taskX
taskY

Yukarıdaki örnek, adlarını kullanarak göreve bağımlılık eklemektir. Bir Task nesnesi kullanarak bağımlılığı tanımlayan görev bağımlılığını elde etmenin başka bir yolu vardır.

Burada, taskY'nin taskX'e bağlı olduğu örneğini alıyoruz, ancak görev referans adları yerine görev nesneleri kullanıyoruz. İçine bir bakın.

Aşağıdaki kodu kopyalayın ve şuraya kaydedin: build.gradledosya. Aşağıdaki koda bir göz atın.

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

Komut isteminde aşağıdaki komutu yürütün. Yukarıda verilen betiği çalıştırır. Bunu yürütmelisiniz,build.gradle dosya depoları.

C:\> gradle –q taskX

Çıktı:

lib1
lib2
taskX

Göreve Açıklama Ekleme

Görevinize bir açıklama ekleyebilirsiniz. Bu açıklama yürütülürken görüntülenirGradle tasks. Bu, açıklama anahtar sözcüğünü kullanarak mümkündür.

Aşağıdaki kodu kopyalayıp şuraya kaydedin: build.gradledosya. Aşağıdaki koda bir göz atın.

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

Komut isteminde aşağıdaki komutu yürütün. Bunu build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q copy

Komut başarıyla yürütülürse, aşağıdaki çıktıyı alacaksınız.

description applied

Görevleri Atlama

Atlama görevleri, bir yüklem kapanışı geçirilerek yapılabilir. Bu, yalnızca bir görev yöntemi veya birStopExecutionException bir görevin fiili çalışması yürütülmeden önce.

Aşağıdaki kodu kopyalayıp şuraya kaydedin: build.gradle dosya.

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()
   }
}

Komut isteminde aşağıdaki komutu yürütün. Bunu build.gradle dosyasının depolandığı yerde yürütmelisiniz.

C:\> gradle –q eclipse

Görev Yapısı

Gradle, görevlerle çalışırken farklı aşamalara sahiptir. Her şeyden önce, doğrudan bir görevin kapanışında belirtilen kodun yürütüldüğü bir yapılandırma aşaması vardır. Konfigürasyon bloğu, yalnızca daha sonra fiilen yürütülen görevler için değil, mevcut her görev için yürütülür.

Yapılandırma aşamasından sonra, yürütme aşaması, kodu doFirst veya doLast gerçekte yürütülen bu görevlerin kapanışları.

Gradle build komut dosyası, projeler oluşturmak için bir süreci tanımlar; her proje bazı bağımlılıklar ve bazı yayınlar içerir. Bağımlılıklar, diğer projelerden gerekli JAR dosyası ve sınıf yolunda JDBC JAR veya Eh-cache JAR gibi harici JAR'lar gibi projenizi oluşturmayı destekleyen şeyler anlamına gelir. Yayınlar, test sınıfı dosyaları ve savaş dosyaları gibi derleme dosyaları gibi projenin sonuçları anlamına gelir.

Projelerin çoğu bağımsız değildir. Kaynak dosyaları derlemek ve test etmek için diğer projeler tarafından oluşturulmuş dosyalara ihtiyaçları vardır. Örneğin, projede Hazırda Bekletme özelliğini kullanmak için, sınıf yoluna bazı Hazırda Bekletme JAR'larını dahil etmeniz gerekir. Gradle, indirilmesi gereken bağımlılıkları tanımlamak için bazı özel komut dosyaları kullanır.

Gradle, sonuçları bir yerde oluşturmak ve yayınlamakla ilgilenir. Yayınlama, tanımladığınız göreve dayanır. Dosyaları yerel dizine kopyalamak veya uzak bir Maven veya lvy havuzuna yüklemek isteyebilir veya aynı çoklu proje yapısında başka bir projedeki dosyaları kullanabilirsiniz. Görevi yayınlama sürecine yayın diyebiliriz.

Bağımlılıklarınızı Bildirmek

Bağımlılık yapılandırması, bağımlılık kümesini tanımlamaktan başka bir şey değildir. Bu özelliği, web'den indirmek istediğiniz harici bağımlılıkları bildirmek için kullanabilirsiniz. Bu, aşağıdaki gibi farklı standartları tanımlar.

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.+'
}

Bağımlılık Yapılandırmaları

Bağımlılık yapılandırması, bir dizi bağımlılığı tanımlamaktan başka bir şey değildir. Bu özelliği web'den indirmek istediğiniz harici bağımlılıkları bildirmek için kullanabilirsiniz. Bu, aşağıdaki farklı standart konfigürasyonları tanımlar.

• Compile - Projenin üretim kaynağını derlemek için gerekli olan bağımlılıklar.

• Runtime- Çalışma zamanında üretim sınıflarının gerektirdiği bağımlılıklar. Varsayılan olarak, derleme zamanı bağımlılıklarını da içerir.

• Test Compile- Projenin test kaynağını derlemek için gereken bağımlılıklar. Varsayılan olarak, derlenmiş üretim sınıflarını ve derleme zamanı bağımlılıklarını içerir.

• Test Runtime- Testleri çalıştırmak için gereken bağımlılıklar. Varsayılan olarak, çalışma zamanı ve test derleme bağımlılıklarını içerir.

Dış Bağımlılıklar

Dış bağımlılıklar, bağımlılık türlerinden biridir. Bu, mevcut yapının dışında oluşturulan ve Maven merkezi veya kurumsal bir Maven veya lvy deposu veya yerel dosya sistemi I dizini gibi bir tür havuzda depolanan bazı dosyalara bağımlılıktır.

Aşağıdaki kod parçacığı, harici bağımlılığı tanımlamak içindir. Bu kodu şurada kullanınbuild.gradle dosya.

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

Dış bağımlılık, dış bağımlılıkları bildiriyor ve kısayol formu "grup: ad: sürüm" gibi görünüyor.

Depolar

Dış bağımlılıklar eklerken. Gradle onları bir depoda arar. Depo, gruba, ada ve sürüme göre düzenlenmiş bir dosya koleksiyonudur. Varsayılan olarak, Gradle herhangi bir depo tanımlamaz. En az bir depoyu açıkça tanımlamamız gerekiyor. Aşağıdaki kod parçacığı, maven deposunun nasıl tanımlanacağını tanımlar. Bu kodu şurada kullanınbuild.gradle dosya.

repositories {
   mavenCentral()
}

Aşağıdaki kod uzak maven'i tanımlamaktır. Bu kodu şurada kullanınbuild.gradle dosya.

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

Yapıları Yayınlama

Bağımlılık yapılandırmaları da dosyaları yayınlamak için kullanılır. Yayınlanan bu dosyalara yapay nesneler denir. Genellikle, yapıları tanımlamak için eklentiler kullanırız. Ancak, Gradle'a eserleri nerede yayınlayacağını söylemeniz gerekir. Bunu, arşivleri karşıya yükleme görevine ekleyerek başarabilirsiniz. Maven deposunu yayınlamak için aşağıdaki sözdizimine bir göz atın. Yürütürken, Gradle proje gereksinimlerine göre bir Pom.xml oluşturacak ve yükleyecektir. Bu kodu şurada kullanınbuild.gradle dosya.

apply plugin: 'maven'

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

Eklenti, görevler kümesinden başka bir şey değildir; görevleri derlemek, etki alanı nesnelerini ayarlamak, kaynak dosyaları ayarlamak gibi hemen hemen tüm yararlı görevler eklentiler tarafından gerçekleştirilir. Bir projeye bir eklenti uygulamak, eklentinin projenin yeteneklerini genişletmesine izin vermek anlamına gelir. Eklentiler aşağıdaki gibi şeyler yapabilir:

• Temel Gradle modelini genişletin (örneğin, yapılandırılabilen yeni DSL öğeleri ekleyin).
• Projeyi dönüşümlere göre yapılandırın (ör. Yeni görevler ekleyin veya mantıklı varsayılanları yapılandırın).
• Spesifik konfigürasyonu uygulayın (ör. Kurumsal havuzlar ekleyin veya standartları uygulayın).

Eklenti Türleri

Gradle'da iki tür eklenti vardır: komut dosyası eklentileri ve ikili eklentiler. Komut dosyası eklentileri, yapıyı değiştirmek için bildirimsel bir yaklaşım sağlayan ek bir yapı betiğidir. Bu genellikle bir yapı içinde kullanılır. İkili eklentiler, eklenti arayüzünü uygulayan ve yapıyı değiştirmek için programlı bir yaklaşım benimseyen sınıflardır. İkili eklentiler, proje hiyerarşisiyle birlikte bir yapı komut dosyasıyla veya harici olarak bir eklenti JAR'da bulunabilir.

Eklentileri Uygulama

Project.apply()API yöntemi, belirli eklentiyi uygulamak için kullanılır. Aynı eklentiyi birden çok kez kullanabilirsiniz. İki tür eklenti vardır, biri komut dosyası eklentisi ve ikincisi ikili eklentidir.

Komut Dosyası Eklentileri

Komut dosyası eklentileri, yerel dosya sistemindeki bir komut dosyasından veya uzak bir konumdan uygulanabilir. Dosya sistemi konumları proje dizinine göredir, uzak komut dosyası konumları ise HTTP URL'sini belirtir. Aşağıdaki kod parçacığına bir göz atın. Uygulamak için kullanılırother.gradlederleme betiğine eklenti. Bu kodu şurada kullanınbuild.gradle dosya.

apply from: 'other.gradle'

İkili Eklentiler

Her eklenti, bazı temel eklentilerin onu uygulamak için kısa adlar kullandığı ve bazı Topluluk eklentilerinin eklenti kimliği için tam nitelikli adı kullandığı eklenti kimliğiyle tanımlanır. Bir süre eklenti sınıfını belirlemeye izin verir.

Aşağıdaki kod parçacığına bir göz atın. Java eklentisinin türünü kullanarak nasıl uygulanacağını gösterir. Bu kodu şurada kullanınbuild.gradle dosya.

apply plugin: JavaPlugin

Kısa ad kullanarak çekirdek eklenti uygulamak için aşağıdaki koda bir göz atın. Bu kodu şurada kullanınbuild.gradle dosya.

plugins {
   id 'java'
}

Kısa ad kullanarak topluluk eklentisi uygulamak için aşağıdaki koda bir göz atın. Bu kodu şurada kullanınbuild.gradle dosya.

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

Özel Eklentiler Yazma

Özel bir eklenti oluştururken, bir eklenti uygulaması yazmanız gerekir. Gradle, eklentiyi başlatır ve Plugin.apply () yöntemini kullanarak eklenti örneğini çağırır. Aşağıdaki örnek, projeye bir merhaba görevi ekleyen bir karşılama eklentisi içerir. Aşağıdaki koda bir göz atın. Bu kodu şurada kullanınbuild.gradle dosya.

apply plugin: GreetingPlugin

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

Yukarıdaki komut dosyasını yürütmek için aşağıdaki kodu kullanın.

C:\> gradle -q hello

Çıktı:

Hello from the GreetingPlugin

Derlemeden Girdi Alma

Eklentilerin çoğu, yapı komut dosyasından yapılandırma desteğine ihtiyaç duyar. Gradle projesi, eklentilere aktarılan tüm ayarların ve özelliklerin izlenmesine yardımcı olan ilişkili bir ExtensionContainer nesnesine sahiptir.

Projeye basit bir uzantı nesnesi ekleyelim. Burada projeye selamlamayı yapılandırmanıza izin veren bir selamlama uzantısı nesnesi ekliyoruz. Bu kodu şurada kullanınbuild.gradle dosya.

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

Yukarıdaki komut dosyasını yürütmek için aşağıdaki kodu kullanın.

C:\> gradle -q hello

Çıktı:

Hi from Gradle

Bu örnekte, TebrikPlugin, message adlı bir alana sahip, düz, eski bir Groovy nesnesidir. Uzantı nesnesi, tebrik adıyla eklenti listesine eklenir. Bu nesne daha sonra uzantı nesnesiyle aynı ada sahip bir proje özelliği olarak kullanılabilir hale gelir.

Gradle, her uzantı nesnesi için bir yapılandırma kapanışı ekler, böylece ayarları bir arada gruplandırabilirsiniz. Aşağıdaki koda bir göz atın. Bu kodu şurada kullanınbuild.gradle dosya.

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
}

Yukarıdaki komut dosyasını yürütmek için aşağıdaki kodu kullanın.

C:\> gradle -q hello

Çıktı:

Hello from Gradle

Standart Gradle Eklentileri

Gradle dağıtımına dahil olan farklı eklentiler vardır.

Dil Eklentileri

Bu eklentiler, JVM'de derlenip çalıştırılabilen çeşitli diller için destek ekler.

Kuluçka Dil Eklentileri

Bu eklentiler, çeşitli diller için destek ekler.

Gradle, derleme betiğini yürütmek için bir komut satırı sağlar. Aynı anda birden fazla görevi yürütebilir. Bu bölüm, farklı seçenekler kullanılarak birden çok görevin nasıl yürütüleceğini açıklar.

Birden Fazla Görevi Yürütme

Tek bir yapı dosyasından birden çok görevi yürütebilirsiniz. Gradle bu derleme dosyasını kullanarakgradle command. Bu komut, her görevi listelendikleri sıraya göre derler ve her görevi farklı seçenekler kullanarak bağımlılıklarla birlikte yürütür.

Example- Dört görev vardır - görev1, görev2, görev3 ve görev4. Görev3 ve görev4, görev 1 ve görev2'ye bağlıdır. Aşağıdaki şemaya bir göz atın.

Yukarıdaki 4 görev, bir ok sembolü ile temsil edilen birbirine bağlıdır. Aşağıdaki koda bir göz atın. Kopyala yapıştırabilirbuild.gradle dosya.

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

Yukarıdaki görevi derlemek ve yürütmek için aşağıdaki kodu kullanabilirsiniz.

C:\> gradle task4 test

Çıktı:

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

BUILD SUCCESSFUL

Total time: 1 secs

Görevleri Dışlama

Bir görevi yürütmeden hariç tutarken, gradle komutuyla birlikte –x seçeneğini kullanabilir ve hariç tutmak istediğiniz görevin adını belirtebilirsiniz.

Task4'ü yukarıdaki komut dosyasından hariç tutmak için aşağıdaki komutu kullanın.

C:\> gradle task4 -x test

Çıktı:

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Bir Hata Oluştuğunda Oluşturmaya Devam Etme

Gradle, herhangi bir görev başarısız olur olmaz, yürütmeyi durdurur ve derleme başarısız olur. Bir hata oluştuğunda bile yürütmeye devam edebilirsiniz. Bunun için gradle komutuyla birlikte –continue seçeneğini kullanmalısınız. Her görevi bağımlılıkları ile birlikte ayrı ayrı ele alır. Ve asıl önemli nokta, karşılaşılan her arızayı yakalayacak ve yapının yürütülmesinin sonunda rapor edecek olmasıdır. Bir görev başarısız olursa, sonraki bağımlı görevlerin de yürütülmeyeceğini varsayalım.

Hangi Yapının Çalıştırılacağını Seçme

Gradle komutunu çalıştırdığınızda, mevcut dizinde bir yapı dosyası arar. Mutlak yolla birlikte belirli bir yapı dosyasını seçmek için –b seçeneğini kullanabilirsiniz. Aşağıdaki örnek bir proje merhaba seçerkenmyproject.gradle bulunan dosya subdir/ içine bir göz atın.

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

Yukarıdaki komut dosyasını çalıştırmak için aşağıdaki komutu kullanabilirsiniz.

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

Çıktı:

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

Yapı Bilgilerinin Elde Edilmesi

Gradle, görev ve proje ile ilgili bilgi ayrıntılarını almak için çeşitli yerleşik görevler sağlar. Bu, derlemenizin yapısını ve bağımlılıklarını anlamak ve sorunları gidermek için yararlı olabilir. Projenize bu raporları oluşturacak görevler eklemek için proje raporu eklentisini kullanabilirsiniz.

Projeleri Listeleme

Seçili projenin proje hiyerarşisini ve alt projelerini kullanarak listeleyebilirsiniz. gradle –q projectskomut. İşte örnek, yapı dosyasındaki tüm projeyi listelemek için aşağıdaki komutu kullanın.

C:\> gradle -q projects

Çıktı:

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

Rapor, belirtilmişse her projenin açıklamasını gösterir. Açıklamayı belirtmek için aşağıdaki komutu kullanabilirsiniz. Yapıştırınbuild.gradle dosya.

description = 'The shared API for the application'

Listeleme Görevleri

Aşağıdaki komutu kullanarak birden çok projeye ait tüm görevleri listeleyebilirsiniz.

C:\> gradle -q tasks

Çıktı:

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

Tüm görevlerin bilgilerini görüntülemek için aşağıdaki komutu kullanabilirsiniz.

C:\> gradle -q tasks --all

Çıktı:

------------------------------------------------------------
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'.

Aşağıda, bir tablo açıklamasındaki farklı seçeneklerdeki bazı komutların listesi verilmiştir.

Bu bölüm, Gradle derleme dosyası kullanarak bir java projesinin nasıl oluşturulacağını açıklar.

Öncelikle, derleme betiğine java eklentisi eklemeliyiz çünkü Java kaynak kodunu derlemek, birim testleri çalıştırmak, Javadoc oluşturmak ve bir JAR dosyası oluşturmak için görevler sağlar. Aşağıdaki satırı kullanınbuild.gradle dosya.

apply plugin: 'java'

Java Varsayılan Proje Düzeni

Yapınıza bir eklenti eklediğinizde, Java projenizin belirli bir kurulumunu (Maven'e benzer) varsayar. aşağıdaki dizin yapısına bir göz atın.

• src / main / java, Java kaynak kodunu içerir
• src / test / java, Java testlerini içerir

Bu kurulumu izlerseniz, aşağıdaki yapı dosyası bir Java projesini derlemek, test etmek ve paketlemek için yeterlidir.

Oluşturmayı başlatmak için komut satırına aşağıdaki komutu yazın.

C:\> gradle build

SourceSetsfarklı bir proje yapısı belirtmek için kullanılabilir. Örneğin, kaynaklar birsrc klasör yerine src/main/java. Aşağıdaki dizin yapısına bir göz atın.

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

init Görev Yürütme

Gradle henüz birden fazla proje şablonunu desteklemiyor. Ama birinityeni bir Gradle projesinin yapısını oluşturmak için görev. Ek parametreler olmadan bu görev, gradle sarmalayıcı dosyalarını içeren bir Gradle projesi oluşturur.build.gradle ve settings.gradle dosya.

Eklerken --type parametre ile java-library değer olarak, bir java proje yapısı oluşturulur ve build.gradledosya Junit ile belirli bir Java şablonu içerir. Aşağıdaki koda bir göz atınbuild.gradle dosya.

apply plugin: 'java'

repositories {
   jcenter()
}

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

Depolar bölümünde bağımlılıkların nerede bulunacağını tanımlar. Jcenterbağımlılıklarınızı çözmek içindir. Bağımlılıklar bölümü, dış bağımlılıklar hakkında bilgi sağlamak içindir.

Java Sürümünü Belirtme

Genellikle, bir Java projesinin bir sürümü ve üzerinde derlendiği bir hedef JRE vardır. version ve sourceCompatibility özellik şurada ayarlanabilir: build.gradle dosya.

version = 0.1.0
sourceCompatibility = 1.8

Yapı yürütülebilir bir Java uygulamasıysa, MANIFEST.MF dosya ana yöntemle sınıfın farkında olmalıdır.

apply plugin: 'java'

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

Example:

Aşağıdaki ekran görüntüsünde gösterildiği gibi bir dizin yapısı oluşturun.

Aşağıda verilen java kodunu App.java dosyasına kopyalayın ve 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!" );
   }
}

Aşağıda verilen java kodunu AppTset.java dosyasına kopyalayın ve 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!" );
   }
}

Aşağıdaki kodu build.gradle dosyasına kopyalayın ve consumerbanking\ dizin.

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

Yukarıdaki betiği derlemek ve yürütmek için aşağıda verilen komutları kullanın.

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

İlgili dizinlerdeki tüm sınıf dosyalarını kontrol edin ve kontrol edin consumerbanking\build\lib klasör consumerbanking.jar dosya.

Bu bölüm, bir Groovy projesinin nasıl derlenip yürütüleceğini açıklar. build.gradle dosya.

Groovy Eklentisi

Gradle için Groovy eklentisi, Java eklentisini genişletir ve Groovy programları için görevler sağlar. Harika eklenti uygulamak için aşağıdaki satırı kullanabilirsiniz.

apply plugin: 'groovy'

Tam derleme komut dosyası dosyası aşağıdaki gibidir. Aşağıdaki kodu içine kopyalayınbuild.gradle dosya.

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

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

Derleme komut dosyasını yürütmek için aşağıdaki komutu kullanabilirsiniz.

gradle build

Groovy Projelerinin Varsayılan Proje Düzeni

Groovy eklentisi, Groovy projenizin belirli bir kurulumunu varsayar.

• src / main / groovy, Groovy kaynak kodunu içerir
• src / test / groovy, Groovy testlerini içerir
• src / main / java, Java kaynak kodunu içerir
• src / test / java, Java testlerini içerir

İlgili dizini kontrol edin build.gradle derleme klasörü için dosya yerleri.

Test görevi, test kaynak kümesindeki tüm birim testlerini otomatik olarak algılar ve yürütür. Ayrıca, testin yürütülmesi tamamlandığında bir rapor oluşturur. JUnit ve TestNG desteklenen API'lerdir.

Test görevi, Test.getDebug()JVM'nin bir hata ayıklayıcıyı beklemesi için başlatılacak şekilde ayarlanabilen yöntem. Yürütmeye geçmeden önce, hata ayıklayıcı gönderisini şu şekilde ayarlar:5005.

Test Algılama

Test Taskderlenen test sınıflarını inceleyerek hangi sınıfların test sınıfları olduğunu algılar. Varsayılan olarak tüm .class dosyalarını tarar. Özel dahil etme / hariç tutma ayarlayabilirsiniz, yalnızca bu sınıflar taranacaktır. Kullanılan test çerçevesine (JUnit / TestNG) bağlı olarak, test sınıfı algılama farklı kriterler kullanır.

JUnit kullanırken, hem JUnit 3 hem de 4 test sınıflarını tarıyoruz. Aşağıdaki kriterlerden herhangi biri eşleşirse, sınıf bir JUnit test sınıfı olarak kabul edilir -

• Sınıf veya süper sınıf, TestCase veya GroovyTestCase'i genişletir
• Sınıf veya bir süper sınıfa @RunWith ile açıklama eklenir
• Sınıf veya bir süper sınıf, @Test ile açıklanmış bir yöntem içerir
• TestNG kullanırken, @Test ile açıklanmış yöntemleri tararız

Note- Soyut sınıflar çalıştırılmaz. Gradle ayrıca miras ağacını test sınıf yolunda jar dosyalarına tarar.

Test sınıfı algılamayı kullanmak istemiyorsanız, ayarlayarak devre dışı bırakabilirsiniz. scanForTestClasses yanlış.

Test Gruplaması

JUnit ve TestNG, karmaşık test yöntemlerinin gruplandırılmasına izin verir. Gruplama için, JUnit test sınıfları ve yöntemleri JUnit 4.8, kategori kavramını sunar. Test görevi, dahil etmek ve hariç tutmak istediğiniz JUnit kategorilerinin spesifikasyonuna izin verir.

Test yöntemlerini gruplamak için build.gradle dosyasında aşağıdaki kod parçacığını kullanabilirsiniz.

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

Belirli Testleri Dahil Et ve Hariç Tut

Test sınıfta include ve excludeyöntem. Bu yöntemler, gerçekte hangi testlerin çalıştırılması gerektiğini belirlemek için kullanılabilir.

Yalnızca dahil edilen testleri çalıştırın -

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

Hariç tutulan testleri atla -

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

Örnek build.gradle dosyası aşağıda gösterildiği gibi farklı yapılandırma seçeneklerini gösterir.

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 )
   }
}

Bazı test görevlerini yürütmek için aşağıdaki komut sözdizimini kullanabilirsiniz.

gradle <someTestTask> --debug-jvm

Gradle, en küçük ve en büyük projeleri kolayca halledebilir. Küçük projelerin tek bir yapı dosyası ve bir kaynak ağacı vardır. Daha küçük, birbirine bağlı modüllere bölünmüş bir projeyi sindirmek ve anlamak çok kolaydır. Gradle, çok projeli derleme olan bu senaryoyu mükemmel şekilde destekler.

Çoklu Proje Oluşturma Yapısı

Bu tür yapılar tüm şekil ve boyutlarda olabilir, ancak bazı ortak özellikleri vardır -

• Bir settings.gradle dosyayı projenin kök veya ana dizinindeki.

• Bir build.gradle kök veya ana dizindeki dosya.

• Kendine ait alt dizinleri *.gradle derleme dosyaları (bazı çok projeli derlemeler, alt proje derleme komut dosyalarını atlayabilir).

Derleme dosyasındaki tüm projeleri listelemek için aşağıdaki komutu kullanabilirsiniz.

C:\> gradle -q projects

Çıktı:

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

Rapor, belirtilmişse her projenin açıklamasını gösterir. Açıklamayı belirtmek için aşağıdaki komutu kullanabilirsiniz. Yapıştırınbuild.gradle dosya.

description = 'The shared API for the application'

Genel Yapı Yapılandırması Belirtme

İçinde build.gradle root_project dosyasında, genel konfigürasyonlar tüm projelere veya sadece alt projelere uygulanabilir.

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

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

Bu ortak bir com.example.gradle grup ve 0.1.0tüm projelere sürüm. subprojects kapatma, tüm alt projeler için ortak yapılandırmaları uygular, ancak kök projeye uygulamaz. allprojects kapanış yapar.

Projeye Özgü Yapılandırmalar ve Bağımlılıklar

Çekirdek ui ve util alt projelerin de kendi build.gradle dosya, kök projenin genel konfigürasyonu tarafından henüz uygulanmamış özel ihtiyaçları varsa.

Örneğin, kullanıcı arabirimi projesi genellikle çekirdek projeye bağımlıdır. Dolayısıyla kullanıcı arabirimi projesinin kendibuild.gradle dosya bu bağımlılığı belirtmek için.

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

Proje bağımlılıkları proje yöntemi ile belirtilir.

Gradle, yapı oluşturma depolarını dağıtmanın birkaç yolunu sunar. Eserleriniz için imzaları bir Maven deposuna dağıtırken, yayınlanan POM dosyasını da imzalamak isteyeceksiniz.

Maven-publish Eklentisini kullanma

maven-publishvarsayılan olarak Gradle tarafından sağlanan eklenti. Gradle komut dosyasını yayınlamak için kullanılır. Aşağıdaki koda bir göz atın.

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

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

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

Birkaç yayınlama seçeneği vardır, Java ve maven-publisheklenti uygulandı. Aşağıdaki koda bir göz atın, projeyi uzak bir depoya yerleştirecektir.

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/"
      }
   }
}

Bir Projeyi Maven'den Gradle'a Dönüştürme

Apache Maven'i dönüştürmek için özel bir komut var pom.xml Dosyaları Gradle derleme dosyalarına çevirin, eğer kullanılan tüm Maven eklentileri bu görev tarafından biliniyorsa.

Bu bölümde aşağıdaki pom.xmlmaven yapılandırması bir Gradle projesine dönüştürülecek. İçine bir bakın.

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

Aşağıdaki Gradle yapılandırmasıyla sonuçlanan komut satırında aşağıdaki komutu kullanabilirsiniz.

C:\> gradle init --type pom

init görevi sarmalayıcı görevine bağlıdır, böylece bir Gradle sarmalayıcısı oluşturulur.

Sonuç build.gradle dosya buna benzer görünüyor -

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

Bu bölüm tutulma ve Gradle'ın entegrasyonunu açıklar. Tutulmaya Gradle eklentisi eklemek için aşağıda verilen adımları izleyin.

Adım 1 - Eclipse Marketplace'i açın

Öncelikle sisteminize kurulu olan tutulmayı açın. Yardıma gidin -> EclipseMarketplace'e tıklayın. Aşağıdaki ekran görüntüsüne bir göz atın.

Adım 2 - Buildship Eklentisini Kurun

Eclipse Marketplace'e tıkladıktan sonra aşağıdaki ekran görüntüsünü bulacaksınız. Burada sol taraftaki arama çubuğuna yazınbuildship. Buildship, bir Gradle entegrasyon eklentisidir. Yapım gemisini ekranınızda bulduğunuzda sağ taraftaki kur'a tıklayın. Aşağıdaki ekran görüntüsüne bir göz atın.

Bundan sonra, aşağıdaki ekran görüntüsünü burada bulacaksınız, onay düğmesine tıklayarak yazılım kurulumunu onaylamanız gerekir. Aşağıdaki ekran görüntüsüne bir göz atın.

Bundan sonra, aşağıdaki ekranda lisans sözleşmesini kabul et seçeneğine tıklamanız ve bitir seçeneğine tıklamanız gerekir. Aşağıdaki ekran görüntüsüne bir göz atın.

Yüklemesi biraz zaman alacak. Aşağıdaki ekran görüntüsüne bir göz atın.

Bundan sonra, Eclipse'in yeniden başlatılmasını isteyecektir. Orada seçeceksinYes.

Adım 3 - Gradle Eklentisini Doğrulama

Doğrulama sırasında verilen prosedürü izleyerek yeni bir proje oluşturacağız. Tutulmada dosyaya gidin -> yeniye tıklayın-> diğer projelere tıklayın. Orada aşağıdaki ekranı bulacaksınız. Gradle projesini seçin ve ileriye tıklayın. Aşağıdaki ekran görüntüsüne bir göz atın.

Sonraki butona tıkladıktan sonra aşağıdaki ekranı göreceksiniz. Orada yerel dosya sisteminin Gradle ev dizini yolunu sağlayacaksınız ve bir sonraki düğmesine tıklayacaksınız. Aşağıdaki ekran görüntüsüne bir göz atın.

Aşağıdaki ekran görüntüsüne bir göz atın, burada Gradle projesinin adını sağlayacaksınız. Bu eğitimde kullanıyoruzdemoproject ve bitir düğmesine tıklayın.

Aşağıdaki ekran görüntüsüne bir göz atın, projeyi onaylamamız gerekiyor. Bunun için aşağıdaki ekranda bitir butonuna tıkladık.

Adım 4 - Dizin Yapısını Doğrulama

Gradle eklentisinin başarıyla kurulmasından sonra, lütfen aşağıdaki ekran görüntüsünde gösterildiği gibi varsayılan dosyalar ve klasörler için demo proje dizin yapısını kontrol edin.