Most important feature of Spring Framework is Dependency Injection. To understand Dependency Injection, you need to understand the concept of a Dependency.
You will learn
- What is a Dependency?
- How are applications built? How is one layer dependent on another?
- How is a class dependent on another?
- How does the Spring Framework do Dependency Injection?
In this article, we have a look at what a dependency is in general terms, and then in the context of the Spring framework.
Spring Framework
This is the second article in a series of articles on Spring Framework:
- 1 - Introduction To Spring Framework
- 2 - What Is A Dependency?
- 3 - What Is Dependency Injection?
- 4 - What Is Component Scan?
- 5 - Architecture of Spring Framework - Modularity and Spring Modules
- 6 - What Are Spring Projects?
- 7 - Introduction To Spring Batch
Dependencies At A High Level
We build enterprise applications in multiple layers: 
A typical Java application will have three layers in its architecture: web, business and data.
- The web layer
- The business layer
- The data layer
In the above scenario:
- Web Layer depends on Business Layer. The business layer is a dependency for the web layer.
- Business layer depends on Data Layer. The data layer is a dependency for the business layer.
Dependencies At Class Level
Let’s look at an example:
@Service public class ClientBOImpl implemented ClientBO { @Autowired ProductDO productDO; @Autowired ClientDO clientDo; @Override public Amount getClientProductsSum(long cliendId) { //... } @Override public void saveChangedProducts(long clientId, List<Product> userEnteredProducts) { //... } //... } ClientBOImpl is the business class, and it makes use of two data layer classes - ProductDO and ClientDO.
Let’s now have a look at the business logic within ````ClientBOImpl```:
getClientProductsSum(): This returns the sum of all products for a given client.saveChangedProducts(): When products are modified on the application page, this method is called.
Both methods in ClientBOImpl need either ProductDO or ClientDO. ProductDO and ClientDO are dependencies of ClientBOImpl.
Inputs/Outputs Are Not Dependencies
If you look at public Amount getClientProductsSum(long clientId), clientId is merely an input, not a dependency. Similarly, the total calculated amount returned by getClientProductsSum is an output, not a dependency.
A Few More Examples Of Dependencies
Example-1
Have a look at the following code:
@Component public class ComplexAlgorithmImpl { @Autowired private SortAlgorithm sortAlgorithm; //... } public interface SortAlgorithm { public int[] sort(int[] numbers); } @Component public class QuickSortAlgorithm implements SortAlogrithm { //... } ComplexAlgorithmImpl performs a lot of complex logic, and sorting is one of the steps.
The SortAlgorithm is a dependency of ComplexAlgorithmImpl.
Since SortAlgorithm is an interface, you can easily change the actual sort algorithm used by ComplexAlgorithmImpl, without changing its code.
Example-2
Consider the following code:
import java.sql.ResultSet; @Repository public class PersonJdbcDao { @Autowired JdbcTemplate jdbcTemplate; class PersonRowMapper implements RowMapper<Person> { @Override public Person mapRow(ResultSet rs, int rowNum) throws SQLException { //... } //... } } To execute a query on the database, PersonJdbcDao needs JdbcTemplate. Therefore, JdbcTemplate is a dependency of PersonJdbcDao.
Let’s look at a simple method:
public Person findById(int id) { return jdbcTemplate.queryForObject(//...); } id is the input for this method, and the output returned is of type Person.
In the above method, we are making use of a dependeny jdbcTemplate . The inputs and outputs are not dependencies.
Do check out our video on the same topic:
Summary
In this article, we focused on the most important concept in Spring Framework - a dependency.
Just Released
