Een Java-applicatie bouwen met Gradle

1. Overzicht

Deze tutorial biedt een praktische gids voor het bouwen van een op Java gebaseerd project met Gradle.

We leggen de stappen uit van het handmatig maken van een projectstructuur, het uitvoeren van de initiële configuratie en het toevoegen van de Java-plug-in en JUnit-afhankelijkheid. Vervolgens gaan we de applicatie bouwen en uitvoeren.

Ten slotte geven we in de laatste sectie een voorbeeld van hoe u dit kunt doen met de Gradle Build Init-plug-in. Een basisinleiding is ook te vinden in het artikel Inleiding tot Gradle.

2. Java-projectstructuur

Voordat we handmatig een Java-project maken en voorbereiden voor build, moeten we Gradle installeren.

Laten we beginnen met het maken van een projectmap met behulp van de PowerShell-console met naam gradle-medewerker-app:

> mkdir gradle-medewerker-app

Laten we daarna naar de projectmap gaan en submappen maken:

> mkdir src / main / java / medewerker

De resulterende output wordt getoond:

Directory: D: \ gradle-employee-app \ src \ main \ java Mode LastWriteTime Lengte Naam ---- ------------- ------ ---- d-- --- 4/10/2020 12:14 PM medewerker

Laten we binnen de bovenstaande projectstructuur twee klassen maken. Een daarvan is eenvoudig Werknemer klas met gegevens zoals naam, e-mailadres en geboortejaar:

openbare klasse Medewerker {Stringnaam; String emailAddress; int yearOfBirth; }

De tweede is de belangrijkste Medewerker App klasse die wordt afgedrukt Werknemer gegevens:

openbare klasse EmployeeApp {openbare statische leegte hoofd (String [] args) {Werknemer werknemer = nieuwe werknemer (); employee.name = "John"; employee.emailAddress = "[e-mail beveiligd]"; employee.yearOfBirth = 1978; System.out.println ("Naam:" + medewerker.naam); System.out.println ("E-mailadres:" + medewerker.emailAddress); System.out.println ("Geboortejaar:" + employee.yearOfBirth); }}

3. Bouw een Java-project

Naastbouwen we ons Java-project, we maken een build.gradle configuratiebestand in de hoofdmap van het project.

Het volgende staat in de PowerShell-opdrachtregel:

Echo> build.gradle

We slaan de volgende stap met betrekking tot de invoerparameters over:

cmdlet Write-Output op positie 1 van de opdrachtpijplijn Geef waarden op voor de volgende parameters: InputObject [0]:

Om een ​​build succesvol te laten zijn, moeten we het Applicatie-plug-in:

plug-ins {id 'applicatie'}

Vervolgens passen we een applicatie-plug-in toe en voeg een volledig gekwalificeerde naam van de hoofdklasse toe:

pas plug-in toe: 'applicatie' mainClassName = 'werknemer.EmployeeApp'

Elk project bestaat uit taken. Een taak vertegenwoordigt een stuk werk dat een build uitvoert, zoals het compileren van de broncode.

We kunnen bijvoorbeeld een taak toevoegen aan het configuratiebestand die een bericht afdrukt over de voltooide projectconfiguratie:

println 'Dit wordt uitgevoerd tijdens de configuratiefase' taak geconfigureerd {println 'Het project is geconfigureerd'}

Meestal geleidelijke opbouw is de primaire taak en de meest gebruikte taak. Deze taak compileert, test en assembleert de code in een JAR-bestand. De build wordt gestart door te typen:

> geleidelijke opbouw 

Voer de bovenstaande opdracht uit om uit te voeren:

> Configureer project: Dit wordt uitgevoerd tijdens de configuratiefase Het project wordt geconfigureerd SUCCESVOL BOUWEN in 1s 2 uitvoerbare taken: 2 up-to-date

Om de build-resultaten te zien, kijken we naar de build-map die submappen bevat:klassen, distributies, libs en rapporten. Typ het Boom / F geeft de structuur van de build-map:

├───build │ ├───classes │ │ └───java │ │ ├───main │ │ │ └───medewerker │ │ │ Employee.class │ │ │ EmployeeApp.class │ │ │ │ │ └───test │ │ └───medewerker │ │ EmployeeAppTest.class │ │ │ ├───verdelingen │ │ gradle-employee-app.tar │ │ gradle-employee-app.zip │ ├───libs │ │ gradle-employee-app.jar │ │ │ ├───reports │ │ └───tests │ │ └───test │ │ │ index.html │ │ │ │ │ ├───classes │ │ │ medewerker .EmployeeAppTest.html

Zoals u kunt zien, is de klassen submap bevat twee gecompileerde .klasse bestanden die we eerder hebben gemaakt. De distributies submap bevat een gearchiveerde versie van het jar-pakket van de toepassing. En libs bewaart het jar-bestand van onze applicatie.

Meestal i n rapporten, zijn er bestanden die worden gegenereerd bij het uitvoeren van JUnit-tests.

Nu is alles klaar om het Java-project uit te voeren door te typen geleidelijke rennen.Het resultaat van het uitvoeren van de applicatie bij het afsluiten:

> Configureer project: Dit wordt uitgevoerd tijdens de configuratiefase Het project wordt geconfigureerd> Taak: run Naam: John E-mailadres: [email protected] Geboortejaar: 1978 SUCCESVOL BOUWEN in 1 seconde 2 uitvoerbare taken: 1 uitgevoerd, 1 up-to-date 

3.1. Bouw met Gradle Wrapper

De Gradle Wrapper is een script dat een gedeclareerde versie van Gradle aanroept.

Laten we eerst een wrapper-taak definiëren in het build.gradle het dossier:

taak wrapper (type: Wrapper) {gradleVersion = '5.3.1'}

Laten we deze taak uitvoeren met gradle wrapper van Power Shell:

> Configureer project: Dit wordt uitgevoerd tijdens de configuratiefase Het project is geconfigureerd SUCCESVOL BOUWEN in 1s 1 uitvoerbare taak: 1 uitgevoerd

Er worden verschillende bestanden gemaakt onder de projectmap, inclusief de bestanden onder / gradle / wrapper plaats:

│ gradlew │ gradlew.bat │ ├───gradle │ └───wrapper │ gradle-wrapper.jar │ gradle-wrapper.properties
  • gradlew: het shellscript dat wordt gebruikt om Gradle-taken op Linux te maken
  • gradlew.bat: een .knuppel script waarmee Windows-gebruikers Gradle-taken kunnen maken
  • gradle-wrapper.jar: een in een wrapper uitvoerbare pot van onze applicatie
  • gradle-wrapper.properties: eigenschappenbestand voor het configureren van de wrapper

4. Voeg Java-afhankelijkheden toe en voer een eenvoudige test uit

Ten eerste moeten we in ons configuratiebestand een externe repository instellen van waaruit we afhankelijkheidspotten downloaden. Meestal zijn deze repositories dat ook mavenCentral () of jcenter (). Laten we de tweede kiezen:

opslagplaatsen {jcenter ()}

Als onze repositories zijn gemaakt, kunnen we vervolgens specificeren welke afhankelijkheden moeten worden gedownload. In dit voorbeeld voegen we Apache Commons en JUnit-bibliotheek toe. Voeg toe om te implementeren testImplementation en testRuntime onderdelen in de afhankelijkheden configuratie.

Het bouwt voort op een extra testblok:

afhankelijkheden {compileer groep: 'org.apache.commons', naam: 'commons-lang3', versie: '3.10' testImplementation ('junit: junit: 4.13') testRuntime ('junit: junit: 4.13')} test {useJUnit ()}

Als dat is gebeurd, laten we het werk van JUnit eens proberen met een eenvoudige test. Navigeer naar het src map en maak de submappen voor de test:

src> mkdir test / java / medewerker

Laten we in de laatste submap EmployeeAppTest.java:

openbare klasse EmployeeAppTest {@Test openbare ongeldige testData () {Employee testEmp = this.getEmployeeTest (); assertEquals (testEmp.name, "John"); assertEquals (testEmp.emailAddress, "[email protected]"); assertEquals (testEmp.yearOfBirth, 1978); } privémedewerker getEmployeeTest () {Medewerker medewerker = nieuwe medewerker (); employee.name = "John"; employee.emailAddress = "[e-mail beveiligd]"; employee.yearOfBirth = 1978; terugkeer werknemer; }}

Laten we, net als voorheen, een geleidelijke schone test vanaf de opdrachtregel en de test zou zonder problemen moeten slagen.

5. Initialisatie van Java-projecten met Gradle

In dit gedeelte leggen we de stappen uit voor het maken en bouwen van een Java-applicatie die we tot nu toe hebben doorlopen. Het verschil is dat we deze keer werken met de hulp van de Gradle Build Init Plugin.

Maak een nieuwe projectmap en geef deze een naam gradle-java-voorbeeld. Schakel vervolgens over naar die lege projectmap en voer het init-script uit:

> gradle init

Gradle stelt ons enkele vragen en biedt opties voor het maken van een project. De eerste vraag is welk type project we willen genereren:

Selecteer het type project om te genereren: 1: basis 2: cpp-applicatie 3: cpp-bibliotheek 4: groovy-applicatie 5: groovy-bibliotheek 6: java-applicatie 7: java-bibliotheek 8: kotlin-applicatie 9: kotlin-bibliotheek 10: scala-library Selecteer build-script DSL: 1: groovy 2: kotlin Voer selectie in [1..10] 6

Selecteer optie 6 voor het type project en vervolgens de eerste optie (groovy) voor het build-script.

Vervolgens verschijnt een lijst met vragen:

Testframework selecteren: 1: junit 2: testng 3: spock Selectie invoeren (standaard: junit) [1..3] 1 Projectnaam (standaard: gradle-java-example): Bronpakket (standaard: gradle.java.example) : werknemer SUCCESVOL BOUWEN in 57m 45s 2 uitvoerbare taken: 2 uitgevoerd

Hier selecteren we de eerste optie, junit, voor het testraamwerk. Selecteer de standaardnaam voor ons project en typ "medewerker" als de naam van het bronpakket.

Om de volledige directorystructuur binnenin te zien / src projectmappen, laten we typen Boom / F in Power Shell:

├───main │ ├───java │ │ └───medewerker │ │ App.java │ │ │ └───bronnen └───test ├───java │ └───medewerker │ AppTest. java │ └───bronnen

Ten slotte, als we het project bouwen met geleidelijk rennen, we krijgen "Hallo Wereld" bij het verlaten:

> Taak: voer Hallo wereld uit. BOUW SUCCESVOL in 1s 2 uitvoerbare taken: 1 uitgevoerd, 1 up-to-date

6. Conclusie

In dit artikel hebben we twee manieren gepresenteerd om een ​​Java-applicatie te maken en te bouwen met Gradle. Het is een feit dat we het handmatige werk hebben gedaan en het kostte tijd om vanaf de opdrachtregel te beginnen met het compileren en bouwen van applicaties. In dit geval moeten we letten op het importeren van enkele vereiste pakketten en klassen als de toepassing meerdere bibliotheken gebruikt.

Aan de andere kant, de Grijpen in het script heeft functies die een licht skelet van ons project genereren, evenals enkele van de configuratiebestanden die aan Gradle zijn gekoppeld.

De broncode voor dit artikel is beschikbaar op GitHub.