Membuat Kacang Musim Bunga Melalui Kaedah Kilang

1. Pengenalan

Kaedah kilang boleh menjadi teknik yang berguna untuk menyembunyikan logik penciptaan kompleks dalam satu panggilan kaedah.

Walaupun kita biasanya membuat kacang pada musim bunga dengan menggunakan konstruktor atau suntikan ladang, kita juga boleh membuat biji kacang menggunakan kaedah kilang .

Dalam tutorial ini, kami akan membuat pembuatan kacang kacang menggunakan kaedah kilang contoh dan statik.

2. Kaedah Kilang Instance

Pelaksanaan standard dari kaedah kaedah kilang adalah dengan membuat kaedah contoh yang mengembalikan kacang yang diinginkan.

Selain itu, kita dapat mengkonfigurasi Spring untuk membuat kacang yang kita inginkan dengan atau tanpa argumen .

2.1. Tanpa Hujah

Kita boleh membuat kelas Foo yang mewakili kacang yang kita buat:

public class Foo {}

Kemudian, kami membuat kelas InstanceFooFactory yang merangkumi kaedah kilang, createInstance , yang mencipta kacang Foo kami :

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

Selepas itu, kami mengkonfigurasi Spring:

  1. Buat kacang untuk kelas kilang kami ( InstanceFooFactory )
  2. Gunakan atribut kilang-kacang untuk merujuk kacang kilang kami
  3. Gunakan atribut kaedah kilang untuk merujuk kaedah kilang kami ( createInstance )

Menerapkan ini ke konfigurasi Spring XML, kami berakhir dengan:

Akhir sekali, kami mengautkan kacang Foo yang dikehendaki . Spring akan membuat kacang menggunakan kaedah kilang createInstance kami :

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

2.2. Dengan Hujah

Kami juga dapat memberikan argumen untuk kaedah kilang contoh kami menggunakan elemen konstruktor-arg dalam konfigurasi Spring kami.

Pertama, kami membuat kelas, Bar , yang menggunakan argumen:

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

Seterusnya, kami mewujudkan kelas kilang contoh, InstanceBarFactory , dengan kaedah kilang yang menerima hujah dan mengembalikan Bar kacang:

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

Akhir sekali, kami menambah pembina-arg elemen untuk kami Bar definisi kacang:

Kami kemudian boleh mengautkan biji Bar kami dengan cara yang sama seperti yang kami lakukan untuk kacang Foo kami :

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

3. Kaedah Kilang Statik

Kita juga boleh mengkonfigurasi Spring untuk menggunakan kaedah statik sebagai kaedah kilang.

Walaupun kaedah kilang contoh harus lebih disukai, teknik ini dapat berguna jika kita sudah ada, kaedah statik lama yang menghasilkan kacang yang diinginkan. Sebagai contoh, jika kaedah kilang mengembalikan singleton, kita dapat mengkonfigurasi Spring untuk menggunakan kaedah kilang singleton ini.

Sama seperti kaedah kilang contoh, kita dapat mengkonfigurasi kaedah statik dengan dan tanpa argumen.

3.1. Tanpa Hujah

Dengan menggunakan kelas Foo sebagai kacang yang kami mahukan, kami dapat membuat kelas, SingletonFooFactory , yang merangkumi kaedah kilang createInstance yang mengembalikan contoh tunggal Foo :

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

Kali ini, kita hanya perlu membuat sebiji kacang. Kacang ini hanya memerlukan dua sifat:

  1. kelas - menyatakan kelas kilang kami ( SingletonFooFactory )
  2. factory-method - menyatakan kaedah kilang statik ( createInstance )

Menerapkan ini pada konfigurasi Spring XML kami, kami mendapat:

Terakhir, kami mengautkan kacang Foo kami menggunakan struktur yang sama seperti sebelumnya:

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

3.2. Dengan Hujah

Walaupun kita tidak boleh mengubah keadaan objek statik - seperti singleton kita - jika boleh , kita masih boleh menyampaikan argumen ke kaedah kilang statik kita.

Untuk melakukan ini, kami membuat kaedah kilang baru yang menerima hujah yang kami mahukan:

public class SingletonBarFactory { private static final Bar INSTANCE = new Bar("unnamed"); public static Bar createInstance(String name) { INSTANCE.setName(name); return INSTANCE; } }

Selepas itu, kami mengkonfigurasi Spring untuk meneruskan argumen yang diinginkan menggunakan elemen konstruktor-arg :

Terakhir, kami mengautkan biji Bar kami menggunakan struktur yang sama seperti sebelumnya:

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("/factorymethod/static-bar-config.xml") public class SingletonBarFactoryIntegrationTest { @Autowired private Bar instance; @Test public void givenValidStaticFactoryConfig_whenCreateInstance_thenNameIsCorrect() { assertNotNull(instance); assertEquals("someName", instance.getName()); } }

4. Kesimpulan

Dalam artikel ini, kami melihat bagaimana mengkonfigurasi Spring untuk menggunakan kaedah kilang contoh dan statik - baik dengan dan tanpa argumen.

Walaupun membuat kacang melalui suntikan konstruktor dan ladang lebih biasa, kaedah kilang boleh berguna untuk langkah-langkah pembuatan kompleks dan kod warisan.

Kod yang digunakan dalam artikel ini boleh didapati di GitHub.