Java alkalmazás építése fokozattal
1. Áttekintés
Ez az oktatóanyag gyakorlati útmutatót tartalmaz arról, hogyan lehet Java alapú projektet felépíteni a Gradle segítségével.
Megmagyarázzuk a projektstruktúra manuális létrehozásának, a kezdeti konfigurálás végrehajtásának, valamint a Java beépülő modul és a JUnit-függőség hozzáadásának lépéseit. Ezután elkészítjük és futtatjuk az alkalmazást.
Végül az utolsó szakaszban példát adunk arra, hogyan lehet ezt megtenni a Gradle Build Init beépülő modullal. Néhány alapvető bevezetés megtalálható a Bevezetés a fokozatba című cikkben is.
2. Java projekt felépítése
Mielőtt manuálisan létrehoznánk egy Java-projektet és előkészítenénk az építkezéshez, telepítenünk kell a Gradle-t.
Kezdjük el létrehozni a projektmappát a névvel ellátott PowerShell konzol segítségével gradle-worker-app:
> mkdir gradle-alkalmazott-alkalmazás
Ezután keressük meg a projekt mappát, és hozzunk létre almappákat:
> mkdir src / main / java / alkalmazott
A kapott kimenet látható:
Könyvtár: D: \ gradle-worker-app \ src \ main \ java mód LastWriteTime hossznév ---- ------------- ------ ---- d-- --- 2020.04.10. 12:14 alkalmazott
A fenti projektszerkezeten belül hozzunk létre két osztályt. Az egyik egyszerű Munkavállaló osztály olyan adatokkal, mint név, e-mail cím és születési év:
public class Alkalmazott {String név; String emailAddress; int yearOfBirth; }
A második a fő Alkalmazotti alkalmazás osztály, amely nyomtat Munkavállaló adat:
public class EmployeeApp {public static void main (String [] args) {Alkalmazott alkalmazott = new Employee (); alkalmazott.név = "János"; worker.emailAddress = "[email protected]"; alkalmazott.születési év = 1978; System.out.println ("Név:" + alkalmazott.név); System.out.println ("E-mail cím:" + alkalmazott.emailAddress); System.out.println ("Születési év:" + alkalmazott.évSzületés); }}
3. Készítsen Java projektet
Mellettfelépítjük a Java projektünket, létrehozunk egy épít.gradle konfigurációs fájl a projekt gyökérmappájában.
A következő a PowerShell parancssorban található:
Echo> build.gradle
A bemeneti paraméterekkel kapcsolatos következő lépést kihagyjuk:
parancsmag írása-kimenete a parancsfájl 1. pozíciójában. Adja meg a következő paraméterek értékeit: InputObject [0]:
Ahhoz, hogy egy építkezés sikeres legyen, hozzá kell adnunk a Alkalmazásbővítmény:
bővítmények {id 'application'}
Ezután alkalmazunk egy alkalmazás plugint és adjon hozzá egy teljesen minősített főosztály nevet:
plugin alkalmazása: 'application' mainClassName = 'worker.EmployeeApp'
Minden projekt áll feladatok. A feladat egy olyan munkadarabot képvisel, amelyet egy build végez, például a forráskód összeállítását.
Például felvehetünk egy feladatot a konfigurációs fájlba, amely üzenetet nyomtat a befejezett projektkonfigurációról:
println 'Ezt a konfigurációs fázis alatt hajtják végre' feladat konfigurálva {println 'A projekt konfigurálva'}
Általában, fokozatépítés az elsődleges és a leggyakrabban használt feladat. Ez a feladat JAR fájlba állítja össze, teszteli és állítja össze a kódot. Az összeállítást a következő gépeléssel kezdjük:
> fokozatépítés
A kimenet végrehajtásához hajtsa végre a fenti parancsot:
> Projekt konfigurálása: Ezt a konfigurációs szakaszban hajtják végre. A projekt konfigurálva BUILD SUCCESSFUL 1s alatt 2 végrehajtható feladat: 2 naprakész
Az összeállítási eredmények megtekintéséhez nézzük meg az almappákat tartalmazó build mappát:osztályok, disztribúciók, libek és jelentések. Gépelés a Fa / F megadja a build mappa felépítését:
Ild───építési │ ├─── osztályok │ │ └───java │ │ ├──── fő │ │ │ └ ─ ─ ─ alkalmazott │ │ │ Employee.class │ │ │ EmployeeApp.class │ │ │ │ │ └───teszt │ │ └───munkavállaló │ │ EmployeeAppTest.class │ │ │ ├─── Distribúciók │ │ gradle-worker-app.tar │ │ gradle-employee-app.zip │ ├───libs │ │ gradle-worker-app.jar │ │ │ ├───jelentések │ │ └───tesztek │ │ └────teszt │ │ │ index.html │ │ │ │ │ ├──── osztályok .EmployeeAppTest.html
Mint láthatja, a osztályok almappában két fordított található .osztály korábban létrehozott fájlokat. A eloszlások az almappában található az alkalmazás jar csomag archivált változata. És libs megőrzi alkalmazásunk jar fájlját.
Általában én jelentések, vannak olyan fájlok, amelyek a JUnit tesztek futtatásakor jönnek létre.
Most minden készen áll a Java projekt futtatására gépeléssel fokozatfutás.Az alkalmazás kilépéskor történő végrehajtásának eredménye:
> Projekt konfigurálása: Ezt a konfigurációs szakaszban hajtják végre. A projekt konfigurálva van.
3.1. Építés Gradle Wrapper használatával
A Gradle Wrapper egy olyan szkript, amely a Gradle deklarált verzióját hívja meg.
Először definiáljunk egy csomagoló feladatot a épít.gradle fájl:
feladatburkoló (típus: Wrapper) {gradleVersion = '5.3.1'}
Futtassuk ezt a feladatot a gradle burkoló a Power Shell-től:
> Projekt konfigurálása: Ezt a konfigurációs fázisban hajtják végre. A projekt BUILD SIKERES 1 másodperc alatt konfigurálható 1 műveletre alkalmas feladat: 1 végrehajtva
Számos fájl jön létre a projekt mappában, beleértve a / gradle / wrapper elhelyezkedés:
│ gradlew │ gradlew.bat │ ├───gradle │ └───wrapper │ gradle-wrapper.jar │ gradle-wrapper.properties
- gradlew: a Gradle feladatok Linuxon történő létrehozásához használt shell szkript
- gradlew.bat: a .denevér parancsfájl, amelyet a Windows felhasználók Gradle feladatok létrehozásához hoztak létre
- gradle-wrapper.jar: egy csomagolással futtatható korsó az alkalmazásunkhoz
- gradle-wrapper.tulajdonságok: tulajdonságfájl a burkolat konfigurálásához
4. Adja hozzá a Java-függőségeket, és futtasson egy egyszerű tesztet
Először is, a konfigurációs fájlunkban be kell állítanunk egy távoli adattárat, ahonnan a függőségi edényeket letöltjük. Leggyakrabban ezek az adattárak is mavenCentral () vagy jcenter (). Válasszuk a másodikat:
adattárak {jcenter ()}
A létrehozott adattárakkal ezután megadhatjuk, hogy mely függőségeket töltsük le. Ebben a példában hozzáadjuk az Apache Commons és a JUnit könyvtárakat. A megvalósításhoz adja hozzá testVégrehajtás és testRuntime alkatrészek a függőségek konfigurációjában.
Egy további tesztblokkra épít:
függőségek {compile group: 'org.apache.commons', név: 'commons-lang3', verzió: '3.10' testImplementation ('junit: junit: 4.13') testRuntime ('junit: junit: 4.13')} teszt {useJUnit ()}
Ha ez megtörtént, próbáljuk ki a JUnit munkáját egy egyszerű teszten. Navigáljon a src mappát, és készítsen almappákat a teszthez:
src> mkdir teszt / java / alkalmazott
Az utolsó almappán belül hozzunk létre EmployeeAppTest.java:
public class EmployeeAppTest {@Test public void testData () {Employee testEmp = this.getEmployeeTest (); assertEquals (testEmp.név, "John"); assertEquals (testEmp.emailAddress, "[email protected]"); assertEquals (testEmp.yearOfBirth, 1978); } privát alkalmazott getEmployeeTest () {alkalmazott alkalmazott = új alkalmazott (); alkalmazott.név = "János"; worker.emailAddress = "[email protected]"; alkalmazott.születési év = 1978; visszatérő alkalmazott; }}
A korábbihoz hasonlóan futtassunk a gradle tiszta teszt parancssorból, és a tesztnek kiadás nélkül kell eltelnie.
5. Java projekt inicializálása a Gradle használatával
Ebben a részben elmagyarázzuk a Java alkalmazás létrehozásának és felépítésének lépéseit, amelyeket eddig átéltünk. A különbség az, hogy ezúttal a Gradle Build Init beépülő modul segítségével dolgozunk.
Hozzon létre egy új projektmappát, és nevezze el gradle-java-példa. Ezután váltson az üres projektmappára, és futtassa az init szkriptet:
> gradle init
Gradle néhány kérdést tesz fel nekünk, és lehetőséget kínál a projekt létrehozására. Az első kérdés az, hogy milyen típusú projektet szeretnénk létrehozni:
Válassza ki a generálni kívánt projekt típusát: 1: alap 2: cpp-alkalmazás 3: cpp-könyvtár 4: groovy-alkalmazás 5: groovy-könyvtár 6: java-alkalmazás 7: java-könyvtár 8: kotlin-alkalmazás 9: kotlin-könyvtár 10: scala-library Select build script DSL: 1: groovy 2: kotlin Enter selection [1..10] 6
Válassza ki a 6. opciót a projekt típusához, majd az első opciót (groovy) a build szkripthez.
Ezután megjelenik a kérdések listája:
A teszt keretrendszerének kiválasztása: 1: junit 2: testng 3: spock Kiválasztás megadása (alapértelmezett: junit) [1..3] 1 Projekt neve (alapértelmezett: gradle-java-example): Forráscsomag (alapértelmezett: gradle.java.example) : alkalmazott SIKER ÉPÍTÉS 57m 45s-ben 2 cselekvőképes feladat: 2 végrehajtva
Itt a teszt keretrendszerhez az első opciót, a junit-t választjuk. Válassza ki a projektünk alapértelmezett nevét, és írja be az „alkalmazott” kifejezést a forráscsomag neveként.
A teljes könyvtárstruktúra megtekintéséhez / src projekt mappák, írjuk be Fa / F a Power Shellben:
├───main │ ├───java │ │ └─── alkalmazotti │ │ App.java │ │ │ └───források └───teszt ├───java │ └─── alkalmazottak │ AppTest. java │ └───források
Végül, ha a projektet együtt építjük fokozatfutás, kapunk "Helló Világ" kilépéskor:
> Feladat: futtassa a Hello world-t. SIKER ÉPÍTÉS 1 másodperc alatt 2 végrehajtható feladat: 1 végrehajtott, 1 naprakész
6. Következtetés
Ebben a cikkben két módszert mutattunk be egy Java alkalmazás létrehozására és felépítésére a Gradle segítségével. Tény, hogy mi elvégeztük a manuális munkát, és időbe telt, míg az alkalmazásokat a parancssorból kezdtük el összeállítani és felépíteni. Ebben az esetben figyelnünk kell néhány szükséges csomag és osztály importálására, ha az alkalmazás több könyvtárat használ.
A másik oldalon a Gradle benne A script rendelkezik olyan funkciókkal, amelyek elősegítik a projektünk könnyű csontvázat, valamint a Gradle-hez társított néhány konfigurációs fájlt.
A cikk forráskódja elérhető a GitHub oldalon.