Isang mabilis na pagpapakilala sa Gradle

Panimula

Ang paksa ng pagsusuring ito ay ang Gradle automatic build system. Sa English, ang mga build system ay tinatawag na Build Tools . Bakit kailangan pa ito? Ang manu-manong pagbuo ng mga proyekto sa Java ay isang medyo labor-intensive na proseso. Kinakailangang ipahiwatig nang tama ang mga aklatan at balangkas na kailangan ng proyekto at kung saan nakasalalay ang proyekto. Dito maaari mong basahin ang isang mahusay na artikulo sa Habré: " Paggawa gamit ang Java sa command line ." Maaga o huli magsisimula kang lumikha ng ilang mga script upang i-automate ang prosesong ito. Ngayon isipin na ang lahat ng mga developer sa buong mundo ay gumagawa nito at lahat ay nagsusulat muli kung ano ang naisulat na ng isang tao para sa kanilang proyekto. At pagkatapos ay lumitaw ang mga sistema ng pagpupulong ng proyekto na nag-automate sa prosesong ito. Bilang karagdagan, sa isang banda, pinapayagan ka nilang mag-assemble ng isang proyekto sa paraang gusto mo, sa kabilang banda, binibigyan ka nila ng higit pa o mas kaunting standardized na mga tool. Ang isang alternatibo sa Gradle ay ang Maven automated build system. Ang dalawang sistema ng pagpupulong na ito ay, sa isang banda, magkaiba, ngunit sa kabilang banda, mayroon silang maraming pagkakatulad. Mayroong materyal sa paksang ito sa website ng Gradle: " Paglipat mula sa Maven patungong Gradle ". Gaya ng nakasaad sa tutorial na ito, may magkaibang pananaw sina Gradle at Maven kung paano bumuo ng isang proyekto. Ang Gradle ay batay sa isang graph ng mga gawain, na maaaring depende sa isa't isa. Ang mga gawain ay gumagawa ng ilang uri ng gawain. Gumagamit si Maven ng isang modelo ng ilang mga yugto, kung saan ang ilang "mga layunin" ay nakalakip. Ang mga layuning ito ay kung saan tapos ang ilang gawain. Gayunpaman, sa magkakaibang mga diskarte na ito, ang parehong mga build system ay sumusunod sa parehong kumbensyon at ang pamamahala ng dependency ay magkatulad. Upang simulan ang paggamit ng Gradle kailangan mong i-download ito. Sa Google o Yandex ipinapasok namin ang "Gradle Build Tool" at sa mga unang resulta makikita namin ang opisyal na website: https://gradle.org . Sa pangunahing pahina ng Gradle mayroong isang link na may tekstong "Docs", na humahantong sa dokumentasyon ng Gradle . Una, kailangan naming i-install (I-install) ang Gradle, kaya interesado kami sa seksyong " Pag-install ng Gradle " ng dokumentasyon. Mayroong maraming mga paraan ng pag-install, kabilang ang "makalumang paraan" na paraan, i.e. mano-mano (" Manu-manong pag-install "). Ayon sa mga tagubilin, mag-download ng file na may uri na " binary-only ", na magkakaroon ng pangalan tulad ng gradle-5.1.1-bin.zip. Susunod, i-unpack ang archive at i-configure ang PATH environment variable ayon sa mga tagubilin. Ang pangunahing bagay ay pagkatapos isagawa ang mga tagubilin, gradle -vipinapakita ng utos ang bersyon ng naka-install na Gradle. Maaaring may problema na kapag tinutukoy ang lokasyon, makikita ng system ang Gradle na hindi kung saan mo gusto. Samakatuwid, sa Windows maaari mong gawin (sa *nix mayroong mga analogue): for %i in (gradle.bat) do @echo. %~$PATH:i Ngayon, marahil, maaari tayong magsimulang makilala.

Pagsisimula ng proyekto ng Gradle

Gusto kong agad na tandaan na ang Gradle ay tungkol sa pagsasagawa ng mga gawain na tinatawag na mga gawain (tatawagin ko silang mga gawain). Ang mga gawain ay ibinibigay ng iba't ibang mga plugin . Pinapayuhan ko kayong magbasa nang higit pa tungkol sa mga plugin sa opisyal na dokumentasyon: " Paggamit ng Gradle Plugin ". Mayroong isang set ng "Mga Core na Plugin" na palaging available kapag naka-install ang Gradle. Mayroong iba't ibang kategorya ng mga plugin na ito, ngunit interesado kami sa kategoryang " Utility ". Kasama sa set na ito ang plugin na " Build Init Plugin ", na nagbibigay ng mga gawain para sa pagsisimula ng isang proyekto ng Gradle. Kami ay interesado sa paglikha ng isang uri ng proyekto: " java-application ". Patakbuhin natin ang gawaing Gradle: gradle init --type java-application Sagutin natin ang ilang tanong habang nasa daan, halimbawa, na gusto nating gamitin ang Groovy DSL (karaniwang wika sa paglalarawan ng gawain para sa Gradle) at ang balangkas ng pagsubok ng JUnit (pag-uusapan natin ito sa isa pang pagsusuri). Pagkatapos ng paglikha, matatanggap namin ang sumusunod na hanay ng mga file: Una, pagkatapos ng pagsisimula ay nakakatanggap kami ng espesyal na wrapper na na-pre-configure para sa aming bersyon ng Gradle - isa itong espesyal na script. Pinapayuhan ko kayong magbasa nang higit pa tungkol dito sa opisyal na dokumentasyon - " The Gradle Wrapper ". Pangalawa, nakikita natin ang Gradle Build Script - ang build.gradle file. Ito ang pangunahing file, na naglalarawan kung aling mga library at framework ang ginagamit ng aming proyekto, kung aling mga plugin ang kailangang konektado sa proyekto at naglalarawan ng iba't ibang mga gawain. Pinapayuhan ko kayong magbasa nang higit pa tungkol sa file na ito sa opisyal na dokumentasyon: " Bumuo ng Mga Pangunahing Kaalaman sa Script ".

Mga Plugin at Mga Gawain

Kung titingnan natin ngayon ang mga nilalaman ng Build Script, makikita natin ang seksyon ng mga plugin:

plugins {
    id 'java'
    id 'application'
}

Ito ang parehong mga plugin na napag-usapan namin kanina. At kung may mga plugin, may mga gawain na magagamit na ngayon sa amin. Maaari nating patakbuhin ang utos ng gradle tasks at tingnan kung ano ang maaari nating gawin ngayon sa proyekto: Halimbawa, sa pamamagitan ng pagsasagawa, gradle runilulunsad namin ang pangunahing klase ng aming java application: Tulad ng nakikita natin, ganoon din ang nakasulat sa ibaba. 2 actionable tasks: 1 executed, 1 up-to-date Ano ang ibig sabihin nito? Nangangahulugan ito na may kabuuang 2 gawain ang natapos: Bukod dito, 1 ang aktwal na natapos, at ang isa ay hindi naisakatuparan, dahil... ito ay napapanahon, ibig sabihin, ang estado ay napapanahon at walang nagawa. Maaari nating isagawa ang tinatawag na "Dry Run": gradle run -m Ipatupad natin ang utos na ito, makikita natin kung anong mga gawain ang isasagawa upang maisagawa ang gawain sa pagtakbo: Gaya ng nakikita natin, kabuuang 4 na gawain ang nakumpleto: bago isagawa ang run, isinagawa nito ang mga klase ng dependency task. Ang mga klase mismo ay may 2 dependencies at samakatuwid ay nagsagawa din ito ng compileJava at processResources. Kapag nagsagawa kami ng isang gawain, magagawa namin ito habang tinitingnan ang isang partikular na antas ng mga log (ang antas ng pag-log ay tumutukoy kung gaano kahalaga ang mga mensahe na gusto naming makita). Halimbawa, magagawa natin gradle run -i. Magpapakita rin ito sa amin ng mga mensaheng nagbibigay-kaalaman tulad ng:

Task :classes UP-TO-DATE
Skipping task ':classes' as it has no actions.

Para sa karagdagang impormasyon tungkol sa pag-log in sa Gradle, ipinapayo ko sa iyo na sumangguni sa opisyal na dokumentasyon: " Gradle Logging ". Tulad ng nakikita natin, ang gawain sa mga klase ay nilaktawan dahil ito ay UP-TO-DATE , iyon ay, ang estado ay kasalukuyang, walang kailangang gawin, kaya walang mga aksyon. Ito ay dahil bilang default, ang Gradle ay may " Up-to-date na mga pagsusuri " o ang tinatawag na incremental build. Maaari kang magbasa nang higit pa tungkol sa mekanismong ito sa dokumentasyon ng Gradle: " Mga napapanahong pagsusuri (AKA Incremental Build) ". Ngunit ang mekanismong ito ay maaaring hindi paganahin sa pamamagitan ng pagsasagawa ng isang gawain na tumutukoy sa --rerun-tasks flag. Halimbawa, gradle run --rerun-tasks. Pagkatapos ay makikita natin ang: 2 naaaksyunan na gawain: 2 naisakatuparan Gaya ng nakikita mo, ang bilang ng mga naisagawang gawain ay isinasaalang-alang lamang ang unang antas ng graph, iyon ay, ang mismong gawain sa pagpapatakbo at ang mga gawaing kung saan ito direktang nakasalalay, iyon ay , mga klase. Ang mga gawain kung saan nakasalalay ang mga klase ay hindi binibilang dito (bagaman ang mga ito ay isinasagawa kapag ang gawain ng mga klase ay naisakatuparan). Dapat mo ring basahin ang tungkol sa mga gawain:

• " Authoring Tasks ": Inilalarawan kung paano lumikha ng iyong sariling mga gawain.
• " Writing Custom Gradle Tasks ": Isang sunud-sunod na gabay sa paggawa ng mga gawain.
• " Build Script Basics ": Mga Pangunahing Kaalaman tungkol sa mga gawain at paggamit ng mga ito.

Dependencies

Ang isa sa mga pangunahing gawain ng anumang build system ay ang pamamahala ng mga dependency, iyon ay, kung aling mga library/framework ang kailangan ng aming proyekto. Dapat tiyakin ng build system na available ang mga ito sa tamang oras at tipunin ang panghuling artifact ng aming aplikasyon sa tamang paraan. Bilang default, pagkatapos ng gradle init para sa java-application makikita natin ang sumusunod na content sa build script:

dependencies {
    implementation 'com.google.guava:guava:26.0-jre'
    testImplementation 'junit:junit:4.12'
}

Dito ay agad na malinaw kung ano ang aming ikinonekta. Ngunit nang walang ilang pag-unawa, hindi malinaw kung ano ang pagpapatupad at testImplementation? Dito kailangan nating bumaling muli sa dokumentasyon ng Gradle, dahil mahusay ang pagkakasulat ng dokumentasyon ni Gradle. Ito ay tinatawag na " Managing Dependency Configurations ". Gaya ng nakasaad sa dokumentasyon, ang bawat dependency ay idineklara na may partikular na saklaw - ang lugar kung saan magiging available ang dependency na ito. Ang saklaw na ito ay itinalaga ng ilang configuration, na ang bawat isa ay may natatanging pangalan. Kawili-wili rin na maraming Gradle plugin ang nagdaragdag ng mga paunang natukoy na configuration. Upang malaman kung anong mga configuration ang mayroon tayo maaari nating patakbuhin: gradle --console plain dependencies Sa ganitong paraan makikita natin ang isang listahan ng lahat ng magagamit na mga configuration at ang kanilang mga dependency. Maaari naming i-filter ang listahang ito upang ang mga available na configuration lang ang aming makita: gradle --console plain dependencies | find " - " Paano namin malalaman kung ano ang gagamitin? Kailangan mong gumawa ng kaunting pagbabasa dito. kasi Ginagamit namin ang plugin na "Java", kaya magsimula tayo sa dokumentasyon nito at sa seksyong " Pamamahala ng dependency ". Dito makikita natin na dati ay mayroong configuration (aka saklaw) na tinatawag na "compile" at ang ibig sabihin ay "dependency na kailangan sa panahon ng compilation". Ngunit pagkatapos ay pinalitan ito (sa English Superseded) ng pagpapatupad. Maaari kang magbasa nang higit pa tungkol sa pagpapalit sa seksyong " API at paghihiwalay ng pagpapatupad ". Lumalabas na ang dependency na ito ay nasa "compile classpath". Ngunit kung minsan gusto nating maisama ang ating dependency sa panghuling artifact. Para saan? Halimbawa, magkakaroon tayo ng executable jar, na dapat maglaman ng lahat ng kailangan. Ano ang dapat nating gawin? Una, walang ganoong suporta "sa labas ng kahon" (iyon ay, bilang default, nang walang anumang karagdagang mga aksyon). Ipinaliwanag ito sa katotohanang gusto ng lahat na kolektahin ang archive sa kanilang sariling paraan, at sinusubukan ni Gradle na maging minimalistic. Hindi rin namin magagamit ang mga archive ng jar sa classpath (nang walang karagdagang manipulasyon sa code), dahil hindi ito gumagana sa ganoong paraan (Tingnan ang " Oracle: Pagdaragdag ng Mga Klase sa Classpath ng JAR File " para sa higit pang mga detalye). Samakatuwid, ang pinakamagandang paraan ay ang sumusunod na code sa build script:

jar {
    manifest {
        attributes 'Main-Class': 'jrgradle.App'
    }
    from configurations.compileClasspath.collect { it.isDirectory() ? it : zipTree(it) }
}

Sa mga setting ng jar task ay tinukoy namin kung ano ang idaragdag sa jar file manifest (tingnan ang " Oracle: Setting ng Entry Point ng Application "). At pagkatapos ay sinasabi namin na ang lahat ng mga dependency na kailangan para sa pagsasama ay isasama sa garapon. Ang isang alternatibo ay ang paggamit ng " Gradle Shadow Plugin ". Maaaring mukhang kumplikado, ngunit ang ibang mga plugin ay maaaring gawing mas madali ang buhay. Halimbawa, kapag lumilikha ng isang web application (kumpara sa isang regular na tumatakbong java application), gagamit kami ng isang espesyal na plugin - " Gradle War Plugin ", na may ibang pag-uugali at ang aming buhay ay magiging mas madali doon (lahat ng kinakailangang dependency ay ilalagay sa isang hiwalay na espesyal na direktoryo ng mismong plugin . Ang ganitong gawain ay kinokontrol ng kung paano dapat idisenyo ang mga web application. Ngunit iyon ay isang ganap na kakaibang kuwento).

Mga resulta

Ang Gradle ay isang mahusay na pagpipilian para sa mga sistema ng pagbuo ng proyekto. Ito ay kinumpirma ng katotohanan na ito ay ginagamit ng mga developer ng mga kilalang proyekto tulad ng Spring at Hibernate. Tanging ang pinakapangunahing mga bagay ang tinalakay sa itaas. Sa likod ng mga ito ay nakatago ang isang milyong feature at pagkakataon na mayroon ang mga developer. Sinusuportahan din ng Gradle ang paglikha ng mga multi-module na proyekto, na hindi saklaw sa pagsusuring ito, ngunit ang Gradle mismo ay may napakahusay na tutorial: " Paglikha ng Mga Multi-project Builds ". Umaasa ako na ipinakita din ng pagsusuri na ito na ang dokumentasyon ni Gradle ay nakasulat sa 5+ at madali mong mahahanap ang kailangan mo kung naiintindihan mo kung saan titingnan. At darating ito kapag naunawaan mo ang mga pangunahing kaalaman. Bilang karagdagan, ang Gradle ay may mahusay na mga tutorial. Gusto kong tapusin sa isang maliit na listahan ng kung ano pa ang makikita mo gamit ang Gradle:

• Gradle Training (Kadalasan libre).
• Gradle para sa Android at Java
• Pagbuo ng mga Java Web Application
• Evgeniy Borisov — Power of Gradle (2013)

#Viacheslav