Úvod do Apache Commons Lang 3
1. Prehľad
Knižnica Apache Commons Lang 3 je populárny komplexný balík tried nástrojov, ktorý je zameraný na rozšírenie funkčnosti Java API.
Repertoár knižnice je veľmi bohatý, od manipulácie s reťazcami, poľami a číslami, reflexie a súbežnosti až po implementácie niekoľkých usporiadaných dátových štruktúr, ako sú páry a trojice (všeobecne známe ako n-tice).
V tomto návode podrobne sa ponoríme do najužitočnejších tried knižnice.
2. Mavenova závislosť
Ako obvykle, aby sme mohli začať používať Apache Commons Lang 3, najskôr musíme pridať závislosť Maven:
org.apache.commons commons-lang3 3.8 3. The StringUtils Trieda
Prvá trieda úžitkovosti, ktorej sa budeme v tomto úvodnom súhrne venovať, je StringUtils.
Ako naznačuje jeho názov, StringUtils umožňuje nám vykonať kopu bezpečných stringy operácie, ktoré dopĺňajú / rozširujú tie, ktoré java.lang.String poskytuje z krabice.
Začnime predstavovať množinu úžitkových metód, ktoré v danom prípade vykonávajú niekoľko kontrol povrázok, napríklad určenie, či povrázok je prázdne, prázdne, malé, veľké, alfanumerické a tak ďalej:
@Test public void whenCalledisBlank_thenCorrect () {assertThat (StringUtils.isBlank ("")). IsTrue (); } @Test public void whenCalledisEmpty_thenCorrect () {assertThat (StringUtils.isEmpty ("")). IsTrue (); } @Test public void whenCalledisAllLowerCase_thenCorrect () {assertThat (StringUtils.isAllLowerCase ("abd")). IsTrue (); } @Test public void whenCalledisAllUpperCase_thenCorrect () {assertThat (StringUtils.isAllUpperCase ("ABC")). IsTrue (); } @Test public void whenCalledisMixedCase_thenCorrect () {assertThat (StringUtils.isMixedCase ("abC")). IsTrue (); } @Test public void whenCalledisAlpha_thenCorrect () {assertThat (StringUtils.isAlpha ("abc")). IsTrue (); } @Test public void whenCalledisAlphanumeric_thenCorrect () {assertThat (StringUtils.isAlphanumeric ("abc123")). IsTrue (); } Samozrejme, že StringUtils trieda implementuje mnoho ďalších metód, ktoré sme tu pre jednoduchosť vynechali.
Pre niektoré ďalšie dodatočné metódy, ktoré kontrolujú alebo používajú určitý typ konverzného algoritmu na daný typ povrázok, prosím skontrolujte tento návod.
Tie, ktorým sme sa venovali vyššie, sú skutočne priame, takže jednotkové testy by mali byť samozrejmé.
4. The ArrayUtils Trieda
The ArrayUtils trieda implementuje dávku užitočných metód, ktoré nám umožňujú spracovávať a kontrolovať polia v mnohých rôznych tvaroch a formách.
Začnime s dvoma preťaženými implementáciami toString () metóda, ktorá vráti a povrázok zastúpenie daného pole a konkrétny povrázok keď pole je null:
@Test public void whenCalledtoString_thenCorrect () {String [] array = {"a", "b", "c"}; assertThat (ArrayUtils.toString (pole)) .isEqualTo ("{a, b, c}"); } @Test public void whenCalledtoStringIfArrayisNull_thenCorrect () {assertThat (ArrayUtils.toString (null, "Array je null")) .isEqualTo ("Array je null"); } Ďalej tu máme hasCode () a mapovať() metódy.
Prvý generuje vlastnú implementáciu hashCode pre pole, zatiaľ čo druhý prevádza pole do a Mapa:
@Test public void whenCalledhashCode_thenCorrect () {String [] array = {"a", "b", "c"}; assertThat (ArrayUtils.hashCode (pole)) .isEqualTo (997619); } @Test public void whenCalledtoMap_thenCorrect () {String [] [] array = {{"1", "one",}, {"2", "two",}, {"3", "three"}}; Mapová mapa = nová HashMap (); map.put ("1", "jeden"); map.put ("2", "dva"); map.put ("3", "tri"); assertThat (ArrayUtils.toMap (pole)) .isEqualTo (mapa); }Na záver sa pozrime na isSameLength () a indexOf () metódy.
Prvé sa používa na kontrolu, či majú dve polia rovnakú dĺžku, a druhé na získanie indexu daného prvku:
@Test public void whenCalledisSameLength_thenCorrect () {int [] pole1 = {1, 2, 3}; int [] pole2 = {1, 2, 3}; assertThat (ArrayUtils.isSameLength (pole1, pole2)) .isTrue (); } @Test public void whenCalledIndexOf_thenCorrect () {int [] pole = {1, 2, 3}; assertThat (ArrayUtils.indexOf (pole, 1, 0)) .isEqualTo (0); } Rovnako ako v prípade StringUtils trieda, ArrayUtils implementovať oveľa viac ďalších metód. Viac sa o nich dozviete v tomto tutoriále.
V tomto prípade sme predviedli iba tie najreprezentatívnejšie.
5. NumberUtils Trieda
Ďalším kľúčovým komponentom Apache Commons Lang 3 je trieda NumberUtils.
Podľa očakávania, trieda poskytuje veľké množstvo užitočných metód zameraných na spracovanie a manipuláciu s numerickými typmi.
Pozrime sa na preťažené implementácie porovnať () metóda, ktorá porovnáva rovnosť rôznych primitívov, ako napr int a dlho:
@Test public void whenCalledcompareWithIntegers_thenCorrect () {assertThat (NumberUtils.compare (1, 1)) .isEqualTo (0); } @Test public void whenCalledcompareWithLongs_thenCorrect () {assertThat (NumberUtils.compare (1L, 1L)) .isEqualTo (0); }Okrem toho existujú implementácie porovnať () ktoré operujú bajt a krátky, ktoré fungujú veľmi podobne ako vyššie uvedené príklady.
Ďalej v tejto recenzii sú createNumber () a isDigit () metódy.
Prvý z nich umožňuje vytvoriť číselné vyjadrenie a povrázok, zatiaľ čo druhá kontroluje, či a povrázok sa skladá iba z číslic:
@Test public void whenCalledcreateNumber_thenCorrect () {assertThat (NumberUtils.createNumber ("123456")) .isEqualTo (123456); } @Test public void whenCalledisDigits_thenCorrect () {assertThat (NumberUtils.isDigits ("123456")). IsTrue (); } Pokiaľ ide o nájdenie kombinácie a maximálnych hodnôt dodaného poľa, NumberUtils triedy poskytuje silnú podporu pre tieto operácie prostredníctvom preťažených implementácií min () a max () metódy:
@Test public void whenCalledmaxwithIntegerArray_thenCorrect () {int [] pole = {1, 2, 3, 4, 5, 6}; assertThat (NumberUtils.max (pole)) .isEqualTo (6); } @Test public void whenCalledminwithIntegerArray_thenCorrect () {int [] pole = {1, 2, 3, 4, 5, 6}; assertThat (NumberUtils.min (pole)). isEqualTo (1); } @Test public void whenCalledminwithByteArray_thenCorrect () {byte [] pole = {1, 2, 3, 4, 5, 6}; assertThat (NumberUtils.min (pole)) .isEqualTo ((bajt) 1); }6. The Zlomok Trieda
Práca s zlomkami je v poriadku a dobrá, keď používame pero a kúsok papiera. Musíme však pri písaní kódu prejsť zložitosťou tohto procesu? Nie naozaj.
The Zlomok trieda robí sčítanie, odčítanie a násobenie zlomkov vo vánku:
@Test public void whenCalledgetFraction_thenCorrect () {assertThat (Fraction.getFraction (5, 6)). IsInstanceOf (Fraction.class); } @Test public void givenTwoFractionInstances_whenCalledadd_thenCorrect () {Fraction fraction1 = Fraction.getFraction (1, 4); Frakčná frakcia2 = Fraction.getFraction (3, 4); assertThat (zlomok1.add (zlomok2) .toString ()). isEqualTo ("1/1"); } @Test public void givenTwoFractionInstances_whenCalledsubstract_thenCorrect () {Fraction fraction1 = Fraction.getFraction (3, 4); Frakčná frakcia2 = Fraction.getFraction (1, 4); assertThat (zlomok1.odber (zlomok2) .toString ()). isEqualTo ("1/2"); } @Test public void givenTwoFractionInstances_whenCalledmultiply_thenCorrect () {Fraction fraction1 = Fraction.getFraction (3, 4); Frakčná frakcia2 = Fraction.getFraction (1, 4); assertThat (zlomok1.multiplyBy (zlomok2) .toString ()). isEqualTo ("3/16"); }Zatiaľ čo operácie so zlomkami nie sú určite najčastejšou úlohou, ktorú budeme musieť zvládnuť v našej každodennej vývojovej práci, Zlomok triedy poskytuje cennú podporu pre vykonávanie týchto operácií priamym spôsobom.
7. The SystemUtils Trieda
Niekedy potrebujeme získať nejaké dynamické informácie o rôznych vlastnostiach a premenných základnej platformy Java alebo operačného systému.
Apache Commons Lang 3 poskytuje Trieda SystemUtils za to, že ste to dosiahli bezbolestným spôsobom.
Uvažujme napríklad o getJavaHome (), getUserHome () a isJavaVersionAtLeast () metódy:
@Test public void whenCalledgetJavaHome_thenCorrect () {assertThat (SystemUtils.getJavaHome ()) .isEqualTo (nový súbor ("cesta / k / jave / jdk")); } @Test public void whenCalledgetUserHome_thenCorrect () {assertThat (SystemUtils.getUserHome ()) .isEqualTo (nový súbor ("cesta / k / používateľovi / domovu")); } @Test public void whenCalledisJavaVersionAtLeast_thenCorrect () {assertThat (SystemUtils.isJavaVersionAtLeast (JavaVersion.JAVA_RECENT)). IsTrue (); }Existuje niekoľko ďalších užitočných metód, ktoré SystemUtils triedne náradie. Vynechali sme ich, aby boli príklady krátke.
8. Triedy Lazy Initialization a Builder
Jedným z najatraktívnejších aspektov Apache Commons Lang 3 je implementácia niektorých známych návrhových vzorov vrátane lenivej inicializácie a vzorov stavačov..
Povedzme napríklad, že sme vytvorili drahý Používateľ triedy (nezobrazuje sa pre stručnosť) a chcú odložiť jeho vytvorenie inštancie, kým to skutočne nebude potrebné.
V takom prípade všetko, čo musíme urobiť, je rozšíriť parametrizovanú abstraktnú triedu LazyInitializer a prepísať jej inicializovať () metóda:
verejná trieda UserInitializer rozširuje LazyInitializer {@Override protected User initialize () {return new User ("John", "[email protected]"); }}Teraz, ak sa chceme dostať do nákladov Používateľ objekt, keď je to potrebné, jednoducho zavoláme UserInitializer's get () metóda:
@ Test public void whenCalledget_thenCorrect () vyvolá ConcurrentException {UserInitializer userInitializer = nový UserInitializer (); assertThat (userInitializer.get ()). isInstanceOf (User.class); }The dostať () metóda je implementácia idiómu dvojitej kontroly (bezpečná pre vlákna) pre inštančné pole, ako je uvedené v „Efektívna Java“ od Joshua Blocha, položka 71:
súkromná nestála inštancia používateľa; User get () {if (instance == null) {synchronized (this) {if (instance == null) instance = new User ("John", "[email protected]"); }}} návratová inštancia; }Apache Commons Lang 3 navyše implementuje triedu HashCodeBuilder, ktorá nám umožňuje generovať hashCode () implementácie dodaním staviteľovi rôzne parametre založené na typickom plynulom API:
@ Test public void whenCalledtoHashCode_thenCorrect () {int hashcode = new HashCodeBuilder (17, 37) .append ("John") .append ("[email protected]") .toHashCode (); assertThat (hashcode) .isEqualTo (1269178828); }Môžeme urobiť niečo podobné s BasicThreadFactory triedy a vytvorte vlákna démona so vzorom pomenovania a prioritou:
@Test public void whenCalledBuilder_thenCorrect () {BasicThreadFactory factory = new BasicThreadFactory.Builder () .namingPattern ("workerthread-% d") .daemon (true) .priority (Thread.MAX_PRIORITY) .build (); assertThat (továreň) .isInstanceOf (BasicThreadFactory.class); }9. The ConstructorUtils Trieda
Reflection je občanom prvej triedy v serveri Apache Commons Lang 3.
Knižnica obsahuje niekoľko tried reflexie, čo nám umožňuje reflexívny prístup a manipuláciu s poľami a metódami tried.
Povedzme napríklad, že sme implementovali naivitu Používateľ trieda domény:
public class User {private String name; súkromný reťazcový e-mail; // štandardné konštruktory / getre / setre / toString}Za predpokladu, že jeho parametrizovaný konštruktor je verejné, môžeme k nej ľahko získať prístup pomocou ConstructorUtils trieda:
@Test public void whenCalledgetAccessibleConstructor_thenCorrect () {assertThat (ConstructorUtils .getAccessibleConstructor (User.class, String.class, String.class)) .isInstanceOf (Constructor.class); } Alternatívne k inštancii štandardnej triedy prostredníctvom konštruktorov môžeme vytvoriť reflexívne Používateľ inštancie jednoduchým zavolaním na invokeConstructor () a invokeExactConstructor () metódy:
@Test public void whenCalledinvokeConstructor_thenCorrect () vyvolá výnimku {assertThat (ConstructorUtils.invokeConstructor (User.class, "name", "email")) .isInstanceOf (User.class); } @Test public void whenCalledinvokeExactConstructor_thenCorrect () vyvolá výnimku {String [] args = {"name", "email"}; Class [] parameterTypes = {String.class, String.class}; assertThat (ConstructorUtils.invokeExactConstructor (User.class, args, parameterTypes)) .isInstanceOf (User.class); } 10. The FieldUtils Trieda
Podobne môžeme použiť metódy z FieldUtils trieda na reflexívne čítanie / zápis do triedných polí.
Predpokladajme, že chceme získať pole Používateľ trieda, prípadne pole, ktoré trieda dedí zo supertriedy.
V takom prípade môžeme vyvolať getField () metóda:
@Test public void whenCalledgetField_thenCorrect () {assertThat (FieldUtils.getField (User.class, "name", true) .getName ()) .isEqualTo ("name"); } Prípadne ak by sme chceli použiť obmedzujúcejší rozsah odrazu a dostali by sme iba pole deklarované v Používateľ triedy a nededí sa zo supertriedy, jednoducho by sme použili getDeclaredField () metóda:
@Test public void whenCalledgetDeclaredFieldForceAccess_thenCorrect () {assertThat (FieldUtils.getDeclaredField (User.class, "name", true) .getName ()) .isEqualTo ("name"); }Okrem toho môžeme použiť getAllFields () metóda na získanie počtu polí odrazenej triedy a zápis hodnoty do deklarovaného poľa alebo poľa definovaného v hierarchii s writeField () a writeDeclaredField () metódy:
@Test public void whenCalledgetAllFields_thenCorrect () {assertThat (FieldUtils.getAllFields (User.class) .length) .isEqualTo (2); } @Test public void whenCalledwriteField_thenCorrect () hodí IllegalAccessException {FieldUtils.writeField (užívateľ, "meno", "Julie", pravda); assertThat (FieldUtils.readField (user, "name", true)) .isEqualTo ("Julie"); } @Test public void givenFieldUtilsClass_whenCalledwriteDeclaredField_thenCorrect () hodí IllegalAccessException {FieldUtils.writeDeclaredField (užívateľ, "meno", "Julie", pravda); assertThat (FieldUtils.readField (user, "name", true)) .isEqualTo ("Julie"); }11. The MethodUtils Trieda
V rovnakom duchu môžeme použiť reflexiu metód triedy s MethodUtils trieda.
V tomto prípade je viditeľnosť Používateľ trieda' getName () metóda je verejné. Takže k nej máme prístup pomocou getAccessibleMethod () metóda:
@ Test public void whenCalledgetAccessibleMethod_thenCorrect () {assertThat (MethodUtils.getAccessibleMethod (User.class, "getName")) .isInstanceOf (Method.class); } Pokiaľ ide o metódy reflexného vyvolania, môžeme použiť invokeExactMethod () a invokeMethod () metódy:
@Test public void whenCalledinvokeExactMethod_thenCorrect () vyvolá výnimku {assertThat (MethodUtils.invokeExactMethod (nový používateľ ("John", "[chránený e-mailom]"), "getName")) .isEqualTo ("John"); } @Test public void whenCalledinvokeMethod_thenCorrect () vyvolá výnimku {User user = new User ("John", "[email protected]"); Object method = MethodUtils.invokeMethod (user, true, "setName", "John"); assertThat (user.getName ()). isEqualTo ("John"); }12. The MutableObject Trieda
Aj keď nemennosť je kľúčovou vlastnosťou dobrého objektovo orientovaného softvéru, mali by sme ho predvolene používať v každom možnom prípade, bohužiaľ niekedy musíme narábať s premenlivými objektmi.
Vytvorenie premenlivých tried navyše vyžaduje veľa štandardného kódu, ktorý môže väčšina IDE generovať prostredníctvom automaticky generovaných nastavovacích nástrojov.
Za týmto účelom Apache Commons Lang 3 poskytuje MutableObject trieda, jednoduchá trieda obalov na vytváranie premenlivých objektov s minimálnym rozruchom:
@BeforeClass public static void setUpMutableObject () {mutableObject = nový MutableObject ("počiatočná hodnota"); } @Test public void whenCalledgetValue_thenCorrect () {assertThat (mutableObject.getValue ()). IsInstanceOf (String.class); } @Test public void whenCalledsetValue_thenCorrect () {mutableObject.setValue ("Ďalšia hodnota"); assertThat (mutableObject.getValue ()). isEqualTo ("Ďalšia hodnota"); } @Test public void whenCalledtoString_thenCorrect () {assertThat (mutableObject.toString ()). IsEqualTo ("Iná hodnota"); } Je to samozrejme iba príklad toho, ako používať MutableObject trieda.
Ako všeobecné pravidlo mali by sme sa vždy usilovať o vytvorenie nemenných tried, alebo v najhoršom prípade zabezpečiť iba požadovanú úroveň premenlivosti.
13. The MutablePair Trieda
Je zaujímavé, že Apache Commons Lang 3 poskytuje silnú podporu pre n-tice vo forme párov a trojíc.
Predpokladajme teda, že musíme vytvoriť premenlivú dvojicu usporiadaných prvkov.
V takom prípade by sme použili MutablePair trieda:
private static MutablePair mutablePair; @BeforeClass public static void setUpMutablePairInstance () {mutablePair = nový MutablePair ("leftElement", "rightElement"); } @Test public void whenCalledgetLeft_thenCorrect () {assertThat (mutablePair.getLeft ()). IsEqualTo ("leftElement"); } @Test public void whenCalledgetRight_thenCorrect () {assertThat (mutablePair.getRight ()). IsEqualTo ("rightElement"); } @Test public void whenCalledsetLeft_thenCorrect () {mutablePair.setLeft ("newLeftElement"); assertThat (mutablePair.getLeft ()). isEqualTo ("newLeftElement"); } Najdôležitejším detailom, ktorý tu stojí za zdôraznenie, je čisté API triedy.
Umožňuje nám nastavovať a pristupovať k ľavému a pravému objektu zabalenému dvojicou prostredníctvom štandardných nastavovačov / hľadačov.
14. The ImmutablePair Trieda
Nie je prekvapením, že existuje aj nemenný náprotivok implementácie MutablePair triedy, tzv ImmutablePair:
private static ImmutablePair immutablePair = nový ImmutablePair ("leftElement", "rightElement"); @Test public void whenCalledgetLeft_thenCorrect () {assertThat (immutablePair.getLeft ()). IsEqualTo ("leftElement"); } @Test public void whenCalledgetRight_thenCorrect () {assertThat (immutablePair.getRight ()). IsEqualTo ("rightElement"); } @Test public void whenCalledof_thenCorrect () {assertThat (ImmutablePair.of ("leftElement", "rightElement")) .isInstanceOf (ImmutablePair.class); } @Test (očakáva sa = UnsupportedOperationException.class) public void whenCalledSetValue_thenThrowUnsupportedOperationException () {immutablePair.setValue ("newValue"); } Ako by sme mohli očakávať od nemennej triedy, akýkoľvek pokus o zmenu vnútorného stavu páru prostredníctvom setValue () metóda bude mať za následok hod UnsupportedOperationException výnimkou.
15. The Triple Trieda
Posledná trieda nástrojov, ktorá sa tu bude pozerať, je Triple.
Pretože je trieda abstraktná, môžeme vytvárať Triple inštancie pomocou z () statická továrenská metóda:
@BeforeClass public static void setUpTripleInstance () {triple = Triple.of ("leftElement", "middleElement", "rightElement"); } @Test public void whenCalledgetLeft_thenCorrect () {assertThat (triple.getLeft ()). IsEqualTo ("leftElement"); } @Test public void whenCalledgetMiddle_thenCorrect () {assertThat (triple.getMiddle ()). IsEqualTo ("middleElement"); } @Test public void whenCalledgetRight_thenCorrect () {assertThat (triple.getRight ()). IsEqualTo ("rightElement"); }Existujú tiež konkrétne implementácie pre premenlivé aj nemenné trojčatá prostredníctvom MutableTriple a ImmutableTriple triedy.
Ich inštancie môžeme vytvoriť pomocou parametrizovaných konštruktorov, a nie pomocou statickej továrenskej metódy.
V takom prípade ich iba preskočíme, pretože ich API vyzerajú veľmi podobne ako API MutablePair a ImmutablePair triedy.
16. Záver
V tomto výučbe sme sa podrobne zaoberali niektorými z najužitočnejších tried nástrojov, ktoré poskytuje Apache Commons Lang 3 vypnutý polička .
Knižnica implementuje mnoho ďalších obslužných tried, ktoré sa oplatí pozrieť. Tu sme práve predstavili najužitočnejšie z nich na základe dosť názorného kritéria.
Úplné knižničné API nájdete v oficiálnych Javadocs.
Ako obvykle sú všetky ukážky kódu zobrazené v tomto tutoriáli dostupné na GitHub.
