19.6. Dependency Injection Using Spring Framework

<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 configure your beans using an XML file. This configuration defines how the various components in your application interact with each other. In the XML code provided, two beans are defined. The first bean is an instance of the Engine class, and the second bean is an instance of the Car class that requires an Engine object to be passed to its constructor. This method enables Spring to manage the lifecycle of these objects, injecting the necessary dependencies at runtime.

Think of it like a recipe. The XML file is the recipe that tells the chef (Spring) how to prepare a dish (your application) using the right ingredients (beans). Just like a recipe lists the ingredients need to cook, the XML file lists the components needed for your application to run.

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

Once the beans are defined in the XML file, the next step is to load these configurations into your Java application. This is done using the ApplicationContext in the code snippet. The ClassPathXmlApplicationContext loads the beans.xml file, and getBean retrieves an instance of the Car class. After that, invoking drive() on the Car object utilizes the injected Engine object to perform its action.

Think of it like selecting a ready-made meal from a fridge. Here, beans.xml is your fridge filled with different meals (car objects). By saying context.getBean(), you're simply choosing a specific meal to eat (creating an instance of Car) and then enjoying it (calling the drive() method).

@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...");
}
}

Spring also allows you to configure your beans using annotations instead of XML. In this example, the @Component annotation marks both Engine and Car classes as Spring-managed components. The @Autowired annotation in the Car constructor tells Spring to inject the Engine dependency automatically. This approach makes the configuration more concise and readable while remaining effective in managing dependencies.

Imagine you are building a Lego model. Using annotations is like having pre-packaged Lego blocks where each block tells you what it is and how it connects to other blocks. Instead of following a lengthy manual (XML), you simply click the pieces together based on their design (annotations), making it quicker and easier to build.

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

To run the application with annotation-based configuration, you set up an AnnotationConfigApplicationContext. This context uses the AppConfig class containing your configuration settings. By calling context.getBean(Car.class), you retrieve an instance of the Car class, which, due to the annotations, has its dependencies automatically injected. Finally, invoking drive() allows the Car to utilize its Engine and start driving.

Continuing with the Lego model metaphor, this last step is like placing the completed Lego model on the table. Though it looks good, you still need to press a button to see it light up or perform some action (calling drive()). This last action brings the assembled parts into function, demonstrating how they work together.

--