Spring Dependency Injection With Examples

Today we will look into Spring Dependency Injection. Spring Framework core concepts are “Dependency Injection” and “Aspect Oriented Programming“. I have written earlier about Java Dependency Injection and how we can use Google Guice framework to automate this process in our applications.

Spring Dependency Injection

This tutorial is aimed to provide details about Spring Dependency Injection example with both annotation based configuration and XML file based configuration. I will also provide JUnit test case example for the application, since easy testability is one of the major benefits of dependency injection.

I have created spring-dependency-injection maven project whose structure looks like below image.

Let’s look at each of the components one by one.

Spring Dependency Injection – Maven Dependencies

I have added Spring and JUnit maven dependencies in pom.xml file, final pom.xml code is below.

Current stable version of Spring Framework is 4.0.0.RELEASE and JUnit current version is 4.8.1, if you are using any other versions then there might be a small chance that the project will need some change. If you will build the project, you will notice some other jars are also added to maven dependencies because of transitive dependencies, just like above image.

Spring Dependency Injection – Service Classes

Let’s say we want to send email message and twitter message to the users. For dependency injection, we need to have a base class for the services. So I have MessageService interface with single method declaration for sending message.

Now we will have actual implementation classes to send email and twitter message.

Now that our services are ready, we can move on to Component classes that will consume the service.

Spring Dependency Injection – Component Classes

Let’s write a consumer class for above services. We will have two consumer classes – one with Spring annotations for autowiring and another without annotation and wiring configuration will be provided in the XML configuration file.

Few important points about MyApplication class:

  • @Component annotation is added to the class, so that when Spring framework will scan for the components, this class will be treated as component. @Component annotation can be applied only to the class and it’s retention policy is Runtime. If you are not not familiar with Annotations retention policy, I would suggest you to read java annotations tutorial.
  • @Autowired annotation is used to let Spring know that autowiring is required. This can be applied to field, constructor and methods. This annotation allows us to implement constructor-based, field-based or method-based dependency injection in our components.
  • For our example, I am using method-based dependency injection. You can uncomment the constructor method to switch to constructor based dependency injection.

Now let’s write similar class without annotations.

A simple application class consuming the service. For XML based configuration, we can use implement either constructor-based spring dependency injection or method-based spring dependency injection. Note that method-based and setter-based injection approaches are same, it’s just that some prefer calling it setter-based and some call it method-based.

Spring Dependency Injection Configuration with Annotations

For annotation based configuration, we need to write a Configurator class that will be used to inject the actual implementation bean to the component property.

Some important points related to above class are:

  • @Configuration annotation is used to let Spring know that it’s a Configuration class.
  • @ComponentScan annotation is used with @Configuration annotation to specify the packages to look for Component classes.
  • @Bean annotation is used to let Spring framework know that this method should be used to get the bean implementation to inject in Component classes.

Let’s write a simple program to test our annotation based Spring Dependency Injection example.

AnnotationConfigApplicationContext is the implementation of AbstractApplicationContext abstract class and it’s used for autowiring the services to components when annotations are used. AnnotationConfigApplicationContext constructor takes Class as argument that will be used to get the bean implementation to inject in component classes.

getBean(Class) method returns the Component object and uses the configuration for autowiring the objects. Context objects are resource intensive, so we should close them when we are done with it. When we run above program, we get below output.

Spring Dependency Injection XML Based Configuration

We will create Spring configuration file with below data, file name can be anything.

applicationContext.xml code:

Notice that above XML contains configuration for both constructor-based and setter-based spring dependency injection. Since MyXMLApplication is using setter method for injection, the bean configuration contains property element for injection. For constructor based injection, we have to use constructor-arg element.

The configuration XML file is placed in the source directory, so it will be in the classes directory after build.

Let’s see how to use XML based configuration with a simple program.

ClassPathXmlApplicationContext is used to get the ApplicationContext object by providing the configuration files location. It has multiple overloaded constructors and we can provide multiple config files also.

Rest of the code is similar to annotation based configuration test program, the only difference is the way we get the ApplicationContext object based on our configuration choice.

When we run above program, we get following output.

Notice that some of the output is written by Spring Framework. Since Spring Framework uses log4j for logging purpose and I have not configured it, the output is getting written to console.

Spring Dependency Injection JUnit Test Case

One of the major benefit of dependency injection in spring is the ease of having mock service classes rather than using actual services. So I have combined all of the learning from above and written everything in a single JUnit 4 test class for dependency injection in spring.

The class is annotated with @Configuration and @ComponentScan annotation because getMessageService() method returns the MessageService mock implementation. That’s why getMessageService() is annotated with @Bean annotation.

Since I am testing MyApplication class that is configured with annotation, I am using AnnotationConfigApplicationContext and creating it’s object in the setUp() method. The context is getting closed in tearDown() method. test() method code is just getting the component object from context and testing it.

Do you wonder how Spring Framework does the autowiring and calling the methods that are unknown to Spring Framework. It’s done with the heavy use of Java Reflection that we can use to analyze and modify the behaviors of the classes at runtime.

Download the sample Spring Dependency Injection (DI) project from above URL and play around with it to learn more.

By admin

Leave a Reply

%d bloggers like this: