19.6.2. Java Classes

<beans>
<bean id="engine" class="com.example.Engine"/>
<bean id="car" class="com.example.Car">
<constructor-arg ref="engine"/>
</bean>
</beans>

In Spring, you can define your application's beans and their dependencies in an XML configuration file. In the example, we have defined two beans: one for the 'Engine' class and another for the 'Car' class. The 'Car' bean references the 'Engine' bean through a constructor argument, indicating that when the Spring container creates a 'Car' object, it needs to also create an 'Engine' object to inject into it.

Think of the XML configuration as a recipe in a cookbook. Just as a recipe specifies the ingredients needed to make a dish, the XML configuration outlines the ingredients (beans) required to create your application (the dish).

ApplicationContext context = new ClassPathXmlApplicationContext(
"beans.xml");
Car car = context.getBean("car", Car.class);
car.drive();

Once the XML configuration file (beans.xml) is defined, you use the ApplicationContext to load this configuration. The 'ClassPathXmlApplicationContext' reads the beans defined in the XML file. By calling 'getBean' with the ID 'car', you request an instance of the 'Car' class. Once retrieved, you can invoke its methods, such as 'drive', which will start the engine and simulate driving the car.

Imagine walking into a restaurant and placing an order (the getBean request). The chef (ApplicationContext) prepares your dish (creates the object) based on the recipe (beans.xml) and serves it to you so that you can enjoy it (using the car to drive).

@Component
class Engine {
public void start() {
System.out.println("Engine started.");
}
}
@Component
class Car {
private final Engine engine;
@Autowired
public Car(Engine engine) {
this.engine = engine;
}
public void drive() {
engine.start();
System.out.println("Driving...");
}
}

In annotation-based configuration, you can specify the beans directly in your classes using annotations like @Component. The @Autowired annotation tells Spring to inject the 'Engine' instance into the 'Car' constructor. This is a more modern and less verbose way to configure beans compared to XML. By using annotations, you can also enjoy type safety and a more streamlined configuration process.

Think of annotation-based configuration as having a special menu in a restaurant where each dish has a precise recipe already understood by the kitchen staff (Spring). Instead of writing down the recipe on paper, you just place your order, and the staff knows exactly what to prepare, efficiently using their expertise (automatically handling dependencies).

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
Car car = context.getBean(Car.class);
car.drive();

In the main class, we create an 'AnnotationConfigApplicationContext', which is a Spring container that can process annotation-based configurations. By passing the configuration class (AppConfig.class), we instruct Spring to scan the classes for any defined beans. Once we retrieve the 'Car' class bean from the context, we can execute the 'drive' method, which again starts the engine and makes the car move.

This can be likened to going to a food truck that specializes in gourmet meals (the AnnotationConfigApplicationContext). You mention what you want (the AppConfig) and the staff (Spring) quickly prepares your meal (fetches the car that’s ready to drive) without needing to reference a detailed menu every time.

--