Konteks Aplikasi Musim Semi

1. Ikhtisar

Dalam tutorial ini, kita akan melihat antarmuka Spring ApplicationConext secara detail.

2. Antarmuka ApplicationContext

Salah satu fitur utama framework Spring adalah container IoC (Inversion of Control). Container Spring IoC bertanggung jawab untuk mengelola objek aplikasi. Ini menggunakan injeksi ketergantungan untuk mencapai inversi kendali.

Antarmuka BeanFactory dan ApplicationContext mewakili wadah Spring IoC . Di sini, BeanFactory adalah antarmuka root untuk mengakses container Spring. Ini menyediakan fungsi dasar untuk mengelola kacang.

Di sisi lain, ApplicationContext adalah sub-antarmuka dari BeanFactory . Oleh karena itu, ia menawarkan semua fungsi BeanFactory.

Selain itu, ini menyediakan lebih banyak fungsi khusus perusahaan . Fitur penting dari ApplicationContext adalah menyelesaikan pesan, mendukung internasionalisasi, acara penerbitan, dan konteks khusus lapisan aplikasi . Inilah mengapa kami menggunakannya sebagai container Spring default.

3. Apa itu Spring Bean?

Sebelum kita menyelami lebih dalam wadah ApplicationContext , penting untuk mengetahui tentang kacang Spring. Di Spring, bean adalah objek yang dibuat, dirakit, dan dikelola oleh container Spring .

Jadi, haruskah kita mengkonfigurasi semua objek aplikasi kita sebagai Spring beans? Nah, sebagai praktik terbaik, kita seharusnya tidak melakukannya.

Sesuai dokumentasi Spring, secara umum, kita harus mendefinisikan kacang untuk objek lapisan layanan, objek akses data (DAO), objek presentasi, objek infrastruktur seperti Hibernate SessionFactories, JMS Queues, dan sebagainya.

Selain itu, biasanya, kita tidak boleh mengonfigurasi objek domain berbutir halus dalam penampung. Biasanya tanggung jawab DAO dan logika bisnis untuk membuat dan memuat objek domain.

Jadi, mari kita tentukan kelas Java sederhana yang akan kita gunakan sebagai kacang musim semi dalam tutorial ini:

public class AccountService { @Autowired private AccountRepository accountRepository; // getters and setters }

4. Konfigurasi Kacang di Wadah

Seperti yang kita ketahui, tugas utama ApplicationContext adalah mengelola kacang.

Jadi, aplikasi harus menyediakan konfigurasi kacang ke wadah ApplicationContext . Oleh karena itu, konfigurasi kacang musim semi terdiri dari satu atau lebih definisi kacang. Selain itu, Spring mendukung berbagai cara mengkonfigurasi kacang.

4.1. Konfigurasi Berbasis Java

Pertama, kita akan mulai dengan konfigurasi berbasis Java karena ini adalah cara konfigurasi kacang yang terbaru dan paling disukai. Ini tersedia mulai Spring 3.0 dan seterusnya.

Konfigurasi Java biasanya menggunakan metode @Bean -annotated dalam kelas @Configuration . The @Bean penjelasan pada metode menunjukkan bahwa metode menciptakan kacang Spring. Selain itu, kelas yang dianotasi dengan @Configuration menunjukkan bahwa ia berisi konfigurasi kacang Spring.

Jadi, sekarang mari buat kelas konfigurasi untuk mendefinisikan kelas AccountService kita sebagai kacang Spring:

@Configuration public class AccountConfig { @Bean public AccountService accountService() { return new AccountService(accountRepository()); } @Bean public AccountRepository accountRepository() { return new AccountRepository(); } }

4.2. Konfigurasi Berbasis Anotasi

Spring 2.5 memperkenalkan konfigurasi berbasis anotasi sebagai langkah pertama untuk mengaktifkan konfigurasi kacang di Java.

Dalam pendekatan ini, pertama-tama kami mengaktifkan konfigurasi berbasis anotasi melalui konfigurasi XML. Kemudian, kami menggunakan satu set anotasi di kelas, metode, konstruktor, atau bidang Java kami untuk mengonfigurasi kacang. Beberapa contoh anotasi ini adalah @Component , @Controller , @Service , @Repository , @Autowired , dan @Qualifier .

Khususnya, kami juga menggunakan anotasi ini dengan konfigurasi berbasis Java. Selain itu, Spring terus menambahkan lebih banyak kemampuan ke anotasi ini dengan setiap rilis.

Jadi, sekarang, mari kita lihat contoh sederhana dari konfigurasi ini.

Pertama, kita akan membuat konfigurasi XML, user-bean-config.xml , untuk mengaktifkan anotasi:

Di sini, para penjelasan-config tag memungkinkan pemetaan berbasis penjelasan . Selain itu, tag pemindaian komponen memberi tahu Spring di mana harus mencari kelas beranotasi.

Kedua, kita akan membuat kelas UserService dan mendefinisikannya sebagai kacang Spring menggunakan anotasi @Component :

@Component public class UserService { // user service code }

Dan kemudian, kami akan menulis kasus uji sederhana untuk menguji konfigurasi ini:

ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext/user-bean-config.xml"); UserService userService = context.getBean(UserService.class); assertNotNull(userService);

4.3. Konfigurasi Berbasis XML

Terakhir, mari kita lihat konfigurasi berbasis XML. Ini cara tradisional mengkonfigurasi kacang di Spring.

Jelasnya, dalam pendekatan ini, kami melakukan semua pemetaan kacang dalam file konfigurasi XML .

Jadi, mari buat file konfigurasi XML, account-bean-config.xml , dan tentukan bean untuk kelas AccountService kita :

5. Jenis Konteks Aplikasi

Spring menyediakan berbagai jenis wadah ApplicationContext yang cocok untuk berbagai kebutuhan. Ini adalah implementasi dari antarmuka ApplicationContext . Jadi, mari kita lihat beberapa tipe umum dari ApplicationContext .

5.1. AnnotationConfigApplicationContext

First, let's see the AnnotationConfigApplicationContext class, which was introduced in Spring 3.0. It can take classes annotated with @Configuration, @Component, and JSR-330 metadata as input.

So, let's see a simple example of using the AnnotationConfigApplicationContext container with our Java-based configuration:

ApplicationContext context = new AnnotationConfigApplicationContext(AccountConfig.class); AccountService accountService = context.getBean(AccountService.class);

5.2. AnnotationConfigWebApplicationContext

AnnotationConfigWebApplicationContextis a web-based variant of AnnotationConfigApplicationContext.

We may use this class when we configure Spring's ContextLoaderListener servlet listener or a Spring MVC DispatcherServlet, in a web.xml file.

Moreover, from Spring 3.0 onward, we can also configure this application context container programmatically. All we need to do is to implement the WebApplicationInitializer interface:

public class MyWebApplicationInitializer implements WebApplicationInitializer { public void onStartup(ServletContext container) throws ServletException { AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext(); context.register(AccountConfig.class); context.setServletContext(container); // servlet configuration } }

5.3. XmlWebApplicationContext

If we use the XML based configuration in a web application, we can use the XmlWebApplicationContext class.

As a matter of fact, configuring this container is like the AnnotationConfigWebApplicationContext class only, which means we can configure it in web.xml or implement the WebApplicationInitializer interface:

public class MyXmlWebApplicationInitializer implements WebApplicationInitializer { public void onStartup(ServletContext container) throws ServletException { XmlWebApplicationContext context = new XmlWebApplicationContext(); context.setConfigLocation("/WEB-INF/spring/applicationContext.xml"); context.setServletContext(container); // Servlet configuration } }

5.4. FileSystemXMLApplicationContext

We use the FileSystemXMLApplicationContext class to load an XML-based Spring configuration file from the file system or from URLs. This class is useful when we need to load the ApplicationContext programmatically. In general, test harnesses and standalone applications are some of the possible use cases for this.

For example, let's see how we can create this Spring container and load the beans for our XML-based configuration:

String path = "C:/myProject/src/main/resources/applicationcontext/account-bean-config.xml"; ApplicationContext context = new FileSystemXmlApplicationContext(path); AccountService accountService = context.getBean("accountService", AccountService.class);

5.5. ClassPathXmlApplicationContext

In case we want to load an XML configuration file from the classpath, we can use the ClassPathXmlApplicationContext class. Similar to FileSystemXMLApplicationContext, it's useful for test harnesses as well as for application contexts embedded within JARs.

So, let's see an example of using this class:

ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext/account-bean-config.xml"); AccountService accountService = context.getBean("accountService", AccountService.class);

6. Additional Features of ApplicationContext

6.1. Message Resolution

The ApplicationContext interface supports message resolution and internationalization by extending the MessageSource interface. Furthermore, Spring provides two MessageSource implementations, ResourceBundleMessageSource and StaticMessageSource.

We can use the StaticMessageSource to programmatically add messages to the source. However, it supports basic internationalization and is more suitable for tests than production use.

On the other hand, ResourceBundleMessageSource is the most common implementation of MessageSource. It relies on the underlying JDK's ResouceBundle implementation. It also uses the JDK's standard message parsing provided by MessageFormat.

Now, let's see how can we use the MessageSource to read the messages from a properties file.

First, we'll create the messages.properties file on the classpath:

account.name=TestAccount

Second, we'll add a bean definition in our AccountConfig class:

@Bean public MessageSource messageSource() { ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource(); messageSource.setBasename("config/messages"); return messageSource; }

Third, we'll inject the MessageSource in the AccountService:

@Autowired private MessageSource messageSource;

Finally, we can use the getMessage method anywhere in the AccountService to read the message:

messageSource.getMessage("account.name", null, Locale.ENGLISH);

Spring also provides the ReloadableResourceBundleMessageSource class, which allows for reading files from any Spring resource location and supports hot reloading of bundle property files.

6.2. Event Handling

ApplicationContext supports event handling with the help of the ApplicationEvent class and the ApplicationListener interface. It supports built-in events like ContextStartedEvent, ContextStoppedEvent, ContextClosedEvent, and RequestHandledEvent. Moreover, it also supports custom events for business use cases.

7. Conclusion

In this tutorial, we've discussed various aspects of the ApplicationContext container in Spring. We've seen different examples of how to configure Spring beans in an AppicationContext. Also, we've seen how to create and use different types of ApplicationContext.

Seperti biasa, kode lengkap tersedia di GitHub.