Oprettelse af forårsbønner gennem fabriksmetoder

1. Introduktion

Fabriksmetoder kan være en nyttig teknik til at skjule kompleks oprettelseslogik inden for et enkelt metodekald.

Mens vi ofte opretter bønner om foråret ved hjælp af konstruktør eller feltinjektion, vi kan også oprette springbønner ved hjælp af fabriksmetoder.

I denne vejledning vil vi dykke ned i oprettelse af springbønner ved hjælp af både instans og statiske fabriksmetoder.

2. Instansfabriksmetode

En standardimplementering af fabriksmetodemønsteret er at oprette en instansmetode, der returnerer den ønskede bønne.

Derudover vi kan konfigurere Spring til at skabe vores ønskede bønne med eller uden argumenter.

2.1. Uden argumenter

Vi kan oprette en Foo klasse, der repræsenterer vores skabelse af bønner:

offentlig klasse Foo {}

Derefter opretter vi en InstanceFooFactory klasse, der inkluderer en fabriksmetode, createInstance, der skaber vores Foo bønne:

public class InstanceFooFactory {public Foo createInstance () {returner ny Foo (); }}

Derefter konfigurerer vi Spring:

  1. Opret en bønne til vores fabriksklasse (InstanceFooFactory)
  2. Brug fabriksbønne attribut til reference vores fabriksbønne
  3. Brug fabriksmetode attribut til reference vores fabriksmetode (createInstance)

Ved at anvende dette på en XML-konfiguration i foråret ender vi med:

Endelig autowire vi vores ønskede Foo bønne. Foråret vil derefter skabe vores bønne ved hjælp af vores createInstance fabriksmetode:

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

2.2. Med argumenter

Vi kan også give argumenter til vores instansfabriksmetode ved hjælp af konstruktør-arg element i vores forårskonfiguration.

Først opretter vi en klasse, Bar, der bruger et argument:

offentlig klassebar {privat strengnavn; offentlig bar (strengnavn) {this.name = navn; } // ... getters & setters}

Derefter opretter vi en instansfabriksklasse, InstanceBarFactory, med en fabriksmetode, der accepterer et argument og returnerer en Bar bønne:

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

Endelig tilføjer vi en konstruktør-arg element til vores Bar definition af bønner:

Vi kan derefter autoledre vores Bar bønne på samme måde som vi gjorde for vores Foo bønne:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / instance-bar-config.xml") offentlig klasse InstanceBarFactoryIntegrationTest {@Autowired privat barinstans; @Test offentlig ugyldighed givenValidInstanceFactoryConfig_whenCreateInstance_thenNameIsCorrect () {assertNotNull (instans); assertEquals ("someName", instance.getName ()); }}

3. Statisk fabriksmetode

Vi kan også konfigurere Spring til at bruge en statisk metode som en fabriksmetode.

Mens eksempler på fabriksmetoder bør foretrækkes, kan denne teknik være nyttig, hvis vi har eksisterende, ældre statiske metoder, der producerer ønskede bønner. For eksempel, hvis en fabriksmetode returnerer en singleton, kan vi konfigurere Spring til at bruge denne singleton-fabriksmetode.

Svarende til eksempelvis fabriksmetoder kan vi konfigurere statiske metoder med og uden argumenter.

3.1. Uden argumenter

Brug af vores Foo klasse som vores ønskede bønne, kan vi oprette en klasse, SingletonFooFactory, der inkluderer en createInstance fabriksmetode, der returnerer en singleton-forekomst af Foo:

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

Denne gang, vi behøver kun at skabe en bønne. Denne bønne kræver kun to attributter:

  1. klasse - erklærer vores fabriksklasse (SingletonFooFactory)
  2. fabriksmetode - erklærer den statiske fabriksmetode (createInstance)

Når vi anvender dette på vores XML-konfiguration i foråret, får vi:

Endelig autoriserer vi vores Foo bønne med samme struktur som før:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / static-foo-config.xml") offentlig klasse SingletonFooFactoryIntegrationTest {@Autowired privat Foo singleton; @Test offentligt ugyldigt givenValidStaticFactoryConfig_whenCreateInstance_thenInstanceIsNotNull () {assertNotNull (singleton); }}

3.2. Med argumenter

Mens vi bør undgå at ændre tilstanden for statiske objekter - som vores singleton - når det er muligt, kan vi stadig videregive argumenter til vores statiske fabriksmetode.

For at gøre dette opretter vi en ny fabriksmetode, der accepterer vores ønskede argumenter:

offentlig klasse SingletonBarFactory {privat statisk endelig Bar INSTANCE = ny Bar ("unavngiven"); offentlig statisk bjælke createInstance (strengnavn) {INSTANCE.setName (navn); returnere INSTANCE; }}

Derefter konfigurerer vi Spring til at passere i det ønskede argument ved hjælp af konstruktør-arg element:

Endelig autoriserer vi vores Bar bønne med samme struktur som før:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("/ factorymethod / static-bar-config.xml") offentlig klasse SingletonBarFactoryIntegrationTest {@Autowired privat barinstans; @Test offentlig ugyldighed givenValidStaticFactoryConfig_whenCreateInstance_thenNameIsCorrect () {assertNotNull (instans); assertEquals ("someName", instance.getName ()); }}

4. Konklusion

I denne artikel så vi på, hvordan vi konfigurerer Spring til at bruge instans- og statiske fabriksmetoder - både med og uden argumenter.

Mens oprettelse af bønner gennem konstruktion og feltinjektion er mere almindelig, kan fabriksmetoder være nyttige til komplekse oprettelsestrin og ældre kode.

Koden, der bruges i denne artikel, kan findes på GitHub.