streamalism.org

1. Introduksjon

Fabrikkmetoder kan være en nyttig teknikk for å skjule kompleks skapelseslogikk i en enkelt metodeanrop.

Mens vi ofte lager bønner om våren ved hjelp av konstruktør eller feltinjeksjon, vi kan også lage vårbønner ved bruk av fabrikkmetoder.

I denne opplæringen vil vi fordype oss i å lage vårbønner ved å bruke både instans og statiske fabrikkmetoder.

2. Instansfabrikkemetode

En standardimplementering av fabrikkmetodemønsteret er å lage en forekomstmetode som returnerer ønsket bønne.

I tillegg vi kan konfigurere våren til å lage ønsket bønne med eller uten argumenter.

2.1. Uten argumenter

Vi kan lage en Foo klasse som representerer bønnen vår blir til:

offentlig klasse Foo {}

Deretter lager vi en InstanceFooFactory klasse som inkluderer en fabrikkmetode, createInstance, som skaper vår Foo bønne:

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

Etter det konfigurerer vi våren:

1. Lag en bønne for fabrikklassen vår (InstanceFooFactory)
2. Bruke fabrikk-bønne attributt som referanse til vår fabrikkbønne
3. Bruke fabrikk-metode attributt for å referere til vår fabrikkmetode (createInstance)

Ved å bruke dette på en XML-konfigurasjon, ender vi opp med:

Til slutt autowire vi ønsket Foo bønne. Våren vil da lage vår bønne ved hjelp av vår createInstance fabrikk metode:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / instance-config.xml") offentlig klasse InstanceFooFactoryIntegrationTest {@Autowired private Foo foo; @Test offentlig ugyldighet gittValidInstanceFactoryConfig_whenCreateFooInstance_thenInstanceIsNotNull () {assertNotNull (foo); }}

2.2. Med argumenter

Vi kan også gi argumenter for vår fabrikkmetode ved å bruke konstruktør-arg element i vårkonfigurasjonen.

Først lager vi en klasse, Bar, som bruker et argument:

public class Bar {private String name; public Bar (String name) {this.name = name; } // ... getters & setters}

Deretter oppretter vi en forekomstfabrikklasse, InstanceBarFactory, med en fabrikkmetode som godtar et argument og returnerer en Bar bønne:

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

Til slutt legger vi til en konstruktør-arg element til vår Bar bønne definisjon:

Vi kan deretter autoledre vår Bar bønne på samme måte som vi gjorde for vår Foo bønne:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / instance-bar-config.xml") public class InstanceBarFactoryIntegrationTest {@Autowired private Bar instance; @Test offentlig ugyldighet gittValidInstanceFactoryConfig_whenCreateInstance_thenNameIsCorrect () {assertNotNull (forekomst); assertEquals ("someName", instance.getName ()); }}

3. Statisk fabrikkmetode

Vi kan også konfigurere våren til å bruke en statisk metode som en fabrikkmetode.

Selv om fabrikkmetoder for eksempel bør foretrekkes, kan denne teknikken være nyttig hvis vi har eksisterende, eldre statiske metoder som produserer ønskede bønner. For eksempel, hvis en fabrikkmetode returnerer en singleton, kan vi konfigurere Spring til å bruke denne singleton-fabrikkmetoden.

I likhet med for eksempel fabrikkmetoder, kan vi konfigurere statiske metoder med og uten argumenter.

3.1. Uten argumenter

Bruke vår Foo klasse som ønsket bønne, kan vi lage en klasse, SingletonFooFactory, som inkluderer en createInstance fabrikkmetode som returnerer en singleton-forekomst av Foo:

offentlig klasse SingletonFooFactory {privat statisk finale Foo INSTANCE = ny Foo (); offentlig statisk Foo createInstance () {return INSTANCE; }}

Denne gangen, vi trenger bare å lage en bønne. Denne bønnen krever bare to attributter:

1. klasse - erklærer vår fabrikklasse (SingletonFooFactory)
2. fabrikk-metode - erklærer den statiske fabrikkmetoden (createInstance)

Ved å bruke dette på vår XML-konfigurasjon får vi:

Til slutt autowire vi Foo bønne med samme struktur som før:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / static-foo-config.xml") offentlig klasse SingletonFooFactoryIntegrationTest {@Autowired private Foo singleton; @Test offentlig ugyldighet gittValidStaticFactoryConfig_whenCreateInstance_thenInstanceIsNotNull () {assertNotNull (singleton); }}

3.2. Med argumenter

Samtidig som vi bør unngå å endre tilstanden til statiske objekter - som vår singleton - når det er mulig, kan vi fremdeles sende argumenter til vår statiske fabrikkmetode.

For å gjøre dette oppretter vi en ny fabrikkmetode som godtar de ønskede argumentene:

offentlig klasse SingletonBarFactory {privat statisk finale Bar INSTANCE = new Bar ("unnamed"); public static Bar createInstance (String name) {INSTANCE.setName (name); retur INSTANCE; }}

Etter det konfigurerer vi våren til å passere ønsket argument ved hjelp av konstruktør-arg element:

Til slutt autowire vi Bar bønne med samme struktur som før:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / static-bar-config.xml") offentlig klasse SingletonBarFactoryIntegrationTest {@Autowired private Bar instans; @Test offentlig ugyldighet gittValidStaticFactoryConfig_whenCreateInstance_thenNameIsCorrect () {assertNotNull (forekomst); assertEquals ("someName", instance.getName ()); }}

4. Konklusjon

I denne artikkelen så vi på hvordan du konfigurerer Spring til å bruke instans- og statiske fabrikkmetoder - både med og uten argumenter.

Mens det er mer vanlig å lage bønner gjennom konstruksjon og feltinjeksjon, kan fabrikkmetoder være nyttige for komplekse trinn for opprettelse og eldre kode.

Koden som brukes i denne artikkelen finner du på GitHub.