Spring – Annotation-based Inversion of Control (IoC)

Spring – Annotation-based Inversion of Control (IoC)

We have previously discussed an example of Spring IoC (Inversion of Control). In the previous case, we have used the bean-configuration file to define the bean information. If we want to change the existing bean or set a new bean in the bean-config file, we need to write the complete details of that particular bean. Although we have set only one bean in the bean-config file, if there were several beans, it would create a lot of mess in the bean-config file.

To overcome the above disadvantage of XML-based configuration, we use annotation-based configuration.

We are going to use the @Component annotation in the bean and <context:component-scan>…<context:component-scan> in the bean-config file (applicationContext) to access the annotation-based configuration.

@Component- It is used to denote a class as Component, which means using the annotation-based configuration, the Spring container will auto-detect these classes for dependency injection.

The Component performs some specific operations. It is a parent stereotype annotation. The Spring framework provides three other specific annotations taht can be used to define a class as a Component.

Following are the sub annotations of @Component:

  • @Service – It is used to denote a Component as a Service and also handles the business logic.
  • @Repository – It is used to denote a Component as a Repository and also handles the data access logic.
  • @Controller – It is used to denote a Component as a Spring MVC Controller.

Following code shows how to use the @Component annotation:

public class Jio_Sim implements Sim {
public String calling() { }

Example of Annotation-based Inversion of Control (IoC)

Now, we are going to create an example of the annotation-based configuration. In this example, we have defined an interface Sim, that contains an unimplemented method. The class Jio_Sim implements the Sim interface and its unimplemented method.

Following are the steps to create an example of the annotation-based configuration:


public interface Sim {
public String calling();


import org.springframework.stereotype.Component;
public class Jio_Sim implements Sim {
public String calling() {
return "Annotattion based Configuration : Calling using Jio Sim  ";

The <context:component-scan> property enables the auto-scanning feature in the Spring framework. It contains an attribute base-package, used to add the base package where all the files are stored.  The Spring container scans the provided base package and finds out the bean class annotated with @Component.





import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App 
public static void main( String[] args )
ClassPathXmlApplicationContext ApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Sim s = ApplicationContext.getBean("mySim", Sim.class);



Default Component Names

In the above example, we have explicitly provided the Component name -@Component("mySim") in the Jio_Sim.java class.

By default, the Spring container will lower case the first character of the Component class name, as shown below:

Jio_Sim is the Component class name.

public class Jio_Sim implements Sim{ }
Sim s = ApplicationContext.getBean("jio_Sim", Sim.class); 

We can retrieve the Component by providing either an implicit or explicit Component name. In both cases, the output will be the same.