Bài 4: ApplicationContext và BeanFactory

1. Định nghĩa ApplicationContext và BeanFactory

BeanFactory và ApplicationContext là hai interface chính trong Spring Framework, cung cấp các cơ chế để quản lý và cấu hình các beans.

• BeanFactory: Là interface cốt lõi trong Spring để quản lý các beans. Nó cung cấp cơ chế IoC (Inversion of Control) để khởi tạo, cấu hình, và quản lý các beans. BeanFactory là lightweight container, chỉ khởi tạo các beans khi cần thiết (lazy initialization).

• ApplicationContext: Là interface mở rộng của BeanFactory, cung cấp nhiều tính năng cao cấp hơn như event propagation, declarative mechanisms để tạo một bean, và khả năng tích hợp với các công cụ enterprise. ApplicationContext khởi tạo tất cả các beans ngay khi container được khởi động (eager initialization).

2. Sự khác biệt giữa ApplicationContext và BeanFactory

• Khởi tạo beans:

  • BeanFactory: Lazy initialization, chỉ khởi tạo beans khi được yêu cầu.

  • ApplicationContext: Eager initialization, khởi tạo tất cả beans ngay khi container khởi động.

• Event handling:

  • BeanFactory: Không hỗ trợ cơ chế event handling.

  • ApplicationContext: Hỗ trợ cơ chế event handling thông qua ApplicationEvent và ApplicationListener.

• Internationalization:

  • BeanFactory: Không hỗ trợ.

  • ApplicationContext: Hỗ trợ tích hợp với các message source để hỗ trợ i18n (internationalization).

• Integration với các công cụ enterprise:

  • BeanFactory: Không hỗ trợ tích hợp với các công cụ enterprise như JNDI.

  • ApplicationContext: Hỗ trợ tích hợp với các công cụ enterprise.

• Annotation processing:

  • BeanFactory: Không hỗ trợ đầy đủ các annotation như @Autowired.

  • ApplicationContext: Hỗ trợ đầy đủ các annotation của Spring.

3. Các loại ApplicationContext

Spring cung cấp một số implementation của ApplicationContext, phù hợp với các nhu cầu khác nhau:

• ClassPathXmlApplicationContext: Load cấu hình từ một hoặc nhiều file XML nằm trong classpath.

• FileSystemXmlApplicationContext: Load cấu hình từ một hoặc nhiều file XML nằm trong hệ thống file.

• AnnotationConfigApplicationContext: Load cấu hình từ các class Java được đánh dấu bằng annotation.

• WebApplicationContext: Một extension của ApplicationContext dành cho các ứng dụng web.

4. Cách sử dụng ApplicationContext và BeanFactory

4.1. Sử dụng BeanFactory

BeanFactory chủ yếu được sử dụng trong các ứng dụng có yêu cầu tài nguyên thấp và không cần các tính năng nâng cao của ApplicationContext.

// HelloWorld.java
public class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Your Message: " + message);
    }
}

// applicationContext.xml
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="helloWorld" class="com.example.HelloWorld">
        <property name="message" value="Hello Spring!"/>
    </bean>

</beans>

// MainApp.java
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class MainApp {
    public static void main(String[] args) {
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        HelloWorld helloWorld = (HelloWorld) factory.getBean("helloWorld");
        helloWorld.getMessage();
    }
}

4.2. Sử dụng ApplicationContext

ApplicationContext được sử dụng trong các ứng dụng enterprise và web, cung cấp nhiều tính năng cao cấp hơn BeanFactory.

// HelloWorld.java
@Component
public class HelloWorld {
    private String message;

    @Value("Hello Spring!")
    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Your Message: " + message);
    }
}

// AppConfig.java
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

// MainApp.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        HelloWorld helloWorld = context.getBean(HelloWorld.class);
        helloWorld.getMessage();
    }
}

5. Kết luận

Trong bài viết này, chúng ta đã tìm hiểu về sự khác biệt giữa ApplicationContext và BeanFactory, cũng như các loại ApplicationContext khác nhau. ApplicationContext cung cấp nhiều tính năng cao cấp hơn BeanFactory và thường được sử dụng trong các ứng dụng enterprise. BeanFactory thích hợp cho các ứng dụng đơn giản với yêu cầu tài nguyên thấp. Việc hiểu rõ sự khác biệt và cách sử dụng của hai interface này giúp chúng ta lựa chọn công cụ phù hợp cho các tình huống cụ thể trong phát triển ứng dụng Spring.

Trong bài viết tiếp theo, chúng ta sẽ tìm hiểu về Aspect-Oriented Programming (AOP) trong Spring, một công cụ mạnh mẽ để quản lý các cross-cutting concerns như logging và transaction management.