streamalism.org

1. Úvod

Továrenské metódy môžu byť užitočnou technikou na skrytie zložitej logiky vytvárania v rámci jedného volania metódy.

Aj keď na jar bežne vyrábame fazuľu pomocou konštruktora alebo injektáže poľa, môžeme tiež vyrobiť jarné bôby pomocou továrenských metód.

V tomto výučbe sa ponoríme do vytvárania jarných bôbov pomocou inštančných aj statických továrenských metód.

2. Výrobná metóda inštancie

Štandardnou implementáciou vzoru továrenskej metódy je vytvorenie inštančnej metódy, ktorá vráti požadovaný fazuľa.

Navyše, môžeme nakonfigurovať Spring, aby vytvoril náš požadovaný fazuľa s argumentmi alebo bez nich.

2.1. Bez argumentov

Môžeme vytvoriť Foo trieda, ktorá predstavuje našu fazuľu, ktorá sa vytvára:

verejná trieda Foo {}

Potom vytvoríme InstanceFooFactory trieda, ktorá obsahuje továrenskú metódu, createInstance, ktorý vytvára našu Foo fazuľa:

public class InstanceFooFactory {public Foo createInstance () {return new Foo (); }}

Potom nakonfigurujeme jar:

1. Vytvorte fazuľu pre našu továrenskú triedu (InstanceFooFactory)
2. Použi továrenská fazuľa atribút ako odkaz na našu továrenskú fazuľu
3. Použi továrenská metóda atribút odkazujúci na našu továrenskú metódu (createInstance)

Ak to aplikujeme na jarnú konfiguráciu XML, skončíme s:

Napokon autowire požadujeme Foo fazuľa. Jar potom vytvorí našu fazuľu pomocou našej createInstance továrenská metóda:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / instance-config.xml") verejná trieda InstanceFooFactoryIntegrationTest {@Autowired private Foo foo; @Test public void givenValidInstanceFactoryConfig_whenCreateFooInstance_thenInstanceIsNotNull () {assertNotNull (foo); }}

2.2. S argumentmi

Môžeme tiež poskytnúť argumenty k našej metóde inštancie továrne pomocou konštruktér-arg element v našej jarnej konfigurácii.

Najskôr vytvoríme triedu, Bar, ktorý využíva argument:

public class Bar {private String name; public Bar (názov reťazca) {this.name = name; } // ... zakladatelia a zakladatelia}

Ďalej vytvoríme inštančnú továrenskú triedu, InstanceBarFactory, s továrenskou metódou, ktorá prijme argument a vráti a Bar fazuľa:

public class InstanceBarFactory {public Bar createInstance (String name) {return new Bar (name); }}

Na záver pridáme a konštruktér-arg prvok k nášmu Bar fazuľa definícia:

Potom môžeme autowire naše Bar fazuľa rovnakým spôsobom ako pre našu Foo fazuľa:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / instance-bar-config.xml") verejná trieda InstanceBarFactoryIntegrationTest {@Autowired súkromná inštancia Baru; @Test public void givenValidInstanceFactoryConfig_whenCreateInstance_thenNameIsCorrect () {assertNotNull (inštancia); assertEquals ("someName", instance.getName ()); }}

3. Statická továrenská metóda

Môžeme tiež nakonfigurovať Spring, aby používal statickú metódu ako továrenskú metódu.

Aj keď by sa mali uprednostňovať inštančné továrenské metódy, táto technika môže byť užitočná, ak máme existujúce staršie statické metódy, ktoré produkujú požadované fazule. Napríklad ak továrenská metóda vráti singleton, môžeme nakonfigurovať Spring, aby používal túto singletonovú továrenskú metódu.

Podobne ako v prípade inštančných metód môžeme konfigurovať statické metódy s argumentmi aj bez nich.

3.1. Bez argumentov

Pomocou nášho Foo triedu ako našu požadovanú fazuľu, môžeme vytvoriť triedu, SingletonFooFactory, ktorý zahŕňa a createInstance továrenská metóda, ktorá vráti jednotlivú inštanciu súboru Foo:

public class SingletonFooFactory {private static final Foo INSTANCE = new Foo (); public static Foo createInstance () {return INSTANCE; }}

Tentokrát, nám stačí vytvoriť jednu fazuľu. Táto fazuľa vyžaduje iba dva atribúty:

1. trieda - deklaruje našu továrenskú triedu (SingletonFooFactory)
2. továrenská metóda - deklaruje statickú továrenskú metódu (createInstance)

Ak to použijeme na našu jarnú konfiguráciu XML, dostaneme:

Napokon autowire naše Foo fazuľa s rovnakou štruktúrou ako predtým:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / static-foo-config.xml") verejná trieda SingletonFooFactoryIntegrationTest {@Autowired private Foo singleton; @Test public void givenValidStaticFactoryConfig_whenCreateInstance_thenInstanceIsNotNull () {assertNotNull (singleton); }}

3.2. S argumentmi

Zatiaľ čo Mali by sme sa vyhnúť zmene stavu statických objektov - napríklad nášho singletonu - pokiaľ je to možné, stále môžeme odovzdať argumenty našej statickej továrenskej metóde.

Za týmto účelom vytvoríme novú továrenskú metódu, ktorá akceptuje naše požadované argumenty:

public class SingletonBarFactory {private static final Bar INSTANCE = new Bar ("unnamed"); verejná statická lišta createInstance (názov reťazca) {INSTANCE.setName (meno); návrat INSTANCE; }}

Potom nakonfigurujeme Spring na odovzdanie požadovaného argumentu pomocou konštruktér-arg element:

Napokon autowire naše Bar fazuľa s rovnakou štruktúrou ako predtým:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / static-bar-config.xml") verejná trieda SingletonBarFactoryIntegrationTest {@Autowired súkromná inštancia Baru; @Test public void givenValidStaticFactoryConfig_whenCreateInstance_thenNameIsCorrect () {assertNotNull (inštancia); assertEquals ("someName", instance.getName ()); }}

4. Záver

V tomto článku sme sa pozreli na to, ako nakonfigurovať Spring tak, aby používal inštančné a statické továrenské metódy - s argumentmi aj bez nich.

Aj keď je vytváranie fazule pomocou vkladania konštruktora a poľa bežnejšie, môžu byť užitočné továrenské metódy pre zložité kroky vytvárania a starší kód.

Kód použitý v tomto článku nájdete na GitHub.