streamalism.org

1. Oversikt

Denne opplæringen gir en praktisk veiledning om hvordan du bygger et Java-basert prosjekt ved hjelp av Gradle.

Vi forklarer trinnene for å lage en prosjektstruktur manuelt, utføre den opprinnelige konfigurasjonen og legge til Java-plugin-modulen og JUnit-avhengighet. Deretter bygger vi og kjører applikasjonen.

Til slutt, i den siste delen, vil vi gi et eksempel på hvordan du gjør dette med Gradle Build Init Plugin. Noen grunnleggende introduksjoner finner du også i artikkelen Introduksjon til Gradle.

2. Java-prosjektstruktur

Før vi oppretter et Java-prosjekt manuelt og forbereder det for bygging, må vi installere Gradle.

La oss begynne å lage en prosjektmappe ved hjelp av PowerShell-konsollen med navn grad-ansatt-app:

> mkdir gradle-ansatte-app

Etter det, la oss navigere til prosjektmappen og opprette undermapper:

> mkdir src / main / java / ansatt

Den resulterende effekten vises:

Katalog: D: \ gradle-employee-app \ src \ main \ java Mode LastWriteTime Lengde Navn ---- ------------- ------ ---- d-- --- 20.10.2020 12:14 ansatt

La oss lage to klasser innenfor prosjektstrukturen ovenfor. Den ene er enkel Ansatt klasse med data som navn, e-postadresse og fødselsår:

offentlig klasse ansatt {strengnavn; String e-postadresse; int yearOfBirth; }

Den andre er den viktigste Ansattes app klasse som skriver ut Ansatt data:

offentlig klasse EmployeeApp {offentlig statisk ugyldig hoved (String [] args) {Ansatt ansatt = ny ansatt (); ansatt.navn = "John"; ansatte.emailAddress = "[e-postbeskyttet]"; ansatt.årFødsel = 1978; System.out.println ("Navn:" + ansatt.navn); System.out.println ("E-postadresse:" + ansatt.emailAddress); System.out.println ("Fødselsår:" + ansatt.årFødsel); }}

3. Bygg et Java-prosjekt

Ved siden avbygge vårt Java-prosjekt, lager vi et build.gradle konfigurasjonsfilen i prosjektets rotmappe.

Følgende er i PowerShell-kommandolinjen:

Ekko> build.gradle

Vi hopper over neste trinn relatert til inngangsparametrene:

cmdlet Skriv ut på kommandorørledningsposisjon 1 Forsyningsverdier for følgende parametere: InputObject [0]:

For at en bygning skal lykkes, må vi legge til Programtillegg:

plugins {id 'applikasjon'}

Deretter bruker vi et programtillegg og legg til et fullt kvalifisert navn på hovedklassen:

bruk plugin: 'application' mainClassName = 'employee.EmployeeApp'

Hvert prosjekt består av oppgaver. En oppgave representerer et stykke arbeid som en build utfører, for eksempel å kompilere kildekoden.

For eksempel kan vi legge til en oppgave i konfigurasjonsfilen som skriver ut en melding om den fullførte prosjektkonfigurasjonen:

println 'Dette utføres under konfigurasjonsfasen' oppgave konfigurert {println 'Prosjektet er konfigurert'}

Som oftest, gradere bygge er den primære oppgaven og den mest brukte. Denne oppgaven kompilerer, tester og samler koden i en JAR-fil. Byggingen startes ved å skrive:

> gradle build 

Utfør kommandoen ovenfor for å sende ut:

> Konfigurer prosjekt: Dette utføres under konfigurasjonsfasen Prosjektet er konfigurert BYGG SUCCESSFUL i 1s 2 handlingsoppgaver: 2 oppdatert

For å se build-resultatene, la oss se på build-mappen som inneholder undermapper:klasser, distribusjoner, biblioteker og rapporter. Skrive Tre / F gir strukturen til byggemappen:

├ ─ build build build build ─ ass ─ cl ass ─ │ ─ ─ ─ ─ j ava │ ├ ─ ─ ─ ain ain │ │ ─ ─ ─ ─ employ employ │ │ Ansatt.klasse │ │ │ Ansattes app.klasse │ │ │ │ │ └───test │ │ └───medarbeider │ │ EmployeeAppTest.class │ │ │ ────distribusjoner │ │ gradle-employee-app.tar │ │ gradle-employee-app.zip │ ├───libs ibs │ gradle-employee-app.jar │ │ │ ├──── rapporter │ │ └─── tests │ │ └────test │ │ │ index.html │ │ │ │ │────klasser ass │ │ ansatt .EmployeeAppTest.html

Som du kan se, er klasser undermappen inneholder to kompilert .klasse filer vi tidligere opprettet. De distribusjoner undermappen inneholder en arkivert versjon av applikasjonsburkpakken. Og libs holder jar-filen til søknaden vår.

Vanligvis, jeg n rapporter, det er filer som genereres når du kjører JUnit-tester.

Nå er alt klart til å kjøre Java-prosjektet ved å skrive gradeløp.Resultatet av å kjøre applikasjonen ved avslutning:

> Konfigurer prosjekt: Dette utføres i løpet av konfigurasjonsfasen Prosjektet er konfigurert> Oppgave: kjør Navn: John E-postadresse: [e-postbeskyttet] Fødselsår: 1978 BYGG SUKSESFULL i 1s 2 handlingsoppgaver: 1 utført, 1 oppdatert 

3.1. Bygg med Gradle Wrapper

Gradle Wrapper er et manus som påkaller en erklært versjon av Gradle.

La oss først definere en innpakningsoppgave i build.gradle fil:

oppgaveinnpakning (type: Wrapper) {gradleVersion = '5.3.1'}

La oss kjøre denne oppgaven ved hjelp av gradle innpakning fra Power Shell:

> Konfigurer prosjekt: Dette utføres under konfigurasjonsfasen Prosjektet er konfigurert BYGG SUCCESSFUL i 1s 1 handlingsbar oppgave: 1 utført

Flere filer vil bli opprettet under prosjektmappen, inkludert filene under / gradering / innpakning plassering:

│ gradlew │ gradlew.bat │ ├─── gradle │ └─── wrapper │ gradle-wrapper.jar │ gradle-wrapper.properties

• gradlew: skallskriptet som ble brukt til å lage Gradle-oppgaver på Linux
• gradlew.bat: a .flaggermus skript som Windows-brukere skal lage Gradle-oppgaver
• gradle-wrapper.jar: en pakke som kan kjøres av applikasjonen vår
• gradle-wrapper.egenskaper: egenskapsfil for konfigurering av innpakningen

4. Legg til Java-avhengigheter og kjør en enkel test

Først, i konfigurasjonsfilen vår, må vi sette et eksternt lager hvor vi laster ned avhengighetskrukker. Oftest er disse depotene heller mavenCentral () eller jcenter (). La oss velge den andre:

repositories {jcenter ()}

Når lagringsplassene våre er opprettet, kan vi spesifisere hvilke avhengigheter som skal lastes ned. I dette eksemplet legger vi til Apache Commons og JUnit-biblioteket. For å implementere, legg til testImplementering og testRuntime deler i avhengighetskonfigurasjonen.

Den bygger på en ekstra testblokk:

avhengigheter {kompilere gruppe: 'org.apache.commons', navn: 'commons-lang3', versjon: '3.10' testImplementation ('junit: junit: 4.13') testRuntime ('junit: junit: 4.13')} test {useJUnit ()}

Når det er gjort, la oss prøve arbeidet til JUnit på en enkel test. Naviger til src mappen og lag undermappene for testen:

src> mkdir test / java / ansatt

La oss lage i den siste undermappen EmployeeAppTest.java:

offentlig klasse EmployeeAppTest {@Test public void testData () {Employee testEmp = this.getEmployeeTest (); assertEquals (testEmp.name, "John"); assertEquals (testEmp.emailAddress, "[email protected]"); assertEquals (testEmp.yearOfBirth, 1978); } privat ansatt getEmployeeTest () {ansatt ansatt = ny ansatt (); ansatt.navn = "John"; ansatte.emailAddress = "[e-postbeskyttet]"; ansatt.årFødsel = 1978; retur ansatt; }}

I likhet med før, la oss kjøre en gradere ren test fra kommandolinjen og testen skal bestå uten problem.

5. Initiering av Java-prosjekt ved hjelp av Gradle

I denne delen forklarer vi trinnene for å lage og bygge et Java-program som vi har gått gjennom så langt. Forskjellen er at vi denne gangen jobber med hjelp av Gradle Build Init Plugin.

Opprett en ny prosjektmappe og gi den navnet gradle-java-eksempel. Bytt deretter til den tomme prosjektmappen og kjør init-skriptet:

> gradering init

Gradle vil stille oss med få spørsmål og tilby muligheter for å lage et prosjekt. Det første spørsmålet er hvilken type prosjekt vi vil generere:

Velg type prosjekt som skal genereres: 1: grunnleggende 2: cpp-applikasjon 3: cpp-bibliotek 4: groovy-applikasjon 5: groovy-bibliotek 6: java-applikasjon 7: java-bibliotek 8: kotlin-applikasjon 9: kotlin-bibliotek 10: scala-bibliotek Velg bygg skript DSL: 1: groovy 2: kotlin Angi valg [1..10] 6

Velg alternativ 6 for prosjekttypen og deretter det første alternativet (groovy) for build-skriptet.

Deretter vises en liste med spørsmål:

Velg testrammeverk: 1: junit 2: testng 3: spock Angi valg (standard: junit) [1..3] 1 Prosjektnavn (standard: gradle-java-eksempel): Kildepakke (standard: gradle.java.example) : ansatt BYGG LYKTIG på 57m 45s 2 handlingsoppgaver: 2 utført

Her velger vi det første alternativet, junit, for testrammeverket. Velg standardnavnet for prosjektet vårt og skriv inn “ansatt” som navnet på kildepakken.

For å se den komplette katalogstrukturen i / src prosjektmapper, la oss skrive Tre / F i Power Shell:

├ ─ ─ ain ain ain ─ ─ ─ │ j ─ ava ava ─ ─ ─ ─ employ employ employ .j .j .j .j │ │ │ └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ est ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ employ T T AppTest. java │ └───ressurser

Til slutt, hvis vi bygger prosjektet med gradeløp, vi får "Hei Verden" ved avkjørsel:

> Oppgave: kjør Hello world. Bygg suksessfull på 1s 2 handlinger: 1 utført, 1 oppdatert

6. Konklusjon

I denne artikkelen har vi presentert to måter å lage og bygge en Java-applikasjon ved hjelp av Gradle. Faktum er at vi gjorde det manuelle arbeidet, og det tok tid å begynne å kompilere og bygge applikasjoner fra kommandolinjen. I dette tilfellet bør vi være oppmerksom på import av noen nødvendige pakker og klasser hvis applikasjonen bruker flere biblioteker.

På den andre siden, den Gradle i det script har funksjoner som genererer et lett skjelett av prosjektet vårt, samt noen av konfigurasjonsfilene tilknyttet Gradle.

Kildekoden for denne artikkelen er tilgjengelig på GitHub.