Understand wide set of tools to work with to create applications that have dependency injection and inversion of control.

spring.tar.gz

Run TennisPlayerWeb-02

Run Lesson 13

Run TennisPlayerWeb-05

Run TennisPlayerWeb-09

Run TennisPlayerWeb-10

Run TennisPlayerWeb-13

Run UnitTesting-07

Run UnitTesting-09

Become a Spring Boot Developer

Expertise in the Spring framework is highly sought after and will help open up a lot of job opportunities for you. Here you will get familiar with Spring 5 and Spring Boot 2 to add dependency injection into your applications.

You will start with the basics of Spring like dependency injection, auto-wiring, and constructor injection. After the basics are out of the way you’ll move onto Spring Boot, Spring MVC, Spring JDBC, and Spring Data JPA.

Lastly, you’ll delve into Spring’s support for AOP, unit testing, and the MVC architecture.

The Complete Guide to Spring 5 and Spring Boot 2



# What is the purpose of the `@Component` annotation?

`@Component` annotation is used to define a bean. This annotation is placed on a Java class. The XML file contains the `<context: component-scan>` tag to enable component scanning. Spring container scans the package (and its sub-packages) specified in the `component-scan` tag.  It will register all classes marked with the `@Component` annotation as beans.

Using the `@Component` annotation can save a lot of time spent in writing lengthy bean definition code in XML.


# What is the difference between `@Component`, `@Service`, `@Repository`, and `@Controller`?

A typical application is divided into layers. The `@Component` annotation is generic and denotes any Spring-managed bean. It can be used in any layer of the application, whereas the other three are specific to layers. `@Controller` is used in the web layer, `@Service` is used on classes in the business layer and `@Repository` is used in the data layer and provides the additional functionality of making unchecked exceptions translated as Spring _DataAccessException_.



# Why is `@Primary` annotation used?

When two beans of the same type qualify to be autowired, then `@Primary` annotation is used to break the tie. Suppose there are two implementations of the `Engine` interface, `CombustionEngine` and `ElectricEngine`. The class `Vehicle` has a dependency on the `Engine` interface. If both implementations have the `@Component` annotation, then a compiler error will occur stating that more than one bean of the same type was found. In this case, we can guide Spring to use either `CombustionEngine` or `ElectricEngine` as the primary choice by using the `@Primary` annotation.

# Why is `@Qualifier` annotation used?

If more than one bean of the same type exists, we can choose the bean to be autowired using the `@Qualifier` annotation. The bean having this annotation qualifies to be autowired. 

# Which annotations takes precedence: `@Primary` or `@Qualifier`?

When both the `@Primary` and `@Qualifer` annotations are present, then `@Qualifier` takes precedence. `@Primary` defines a default value, and bean marked with this annotation will be used unless otherwise indicated. `@Qualifier` annotation is specific and is used when a particular bean is needed.

Suppose there are two beans of the same type and one is used in 90% of the cases, then it makes sense to make it the default choice by using the `@Primary` annotation. The `@Autowired` that needs the other bean can use the `@Qualifier` annotation while all other `@Autowired` will automatically choose the bean marked with `@Primary`.

# Why is the `@Required` annotation used?

`@Required` is a method-level annotation. It is used on setter methods and makes setter injection of the property mandatory. The `BeanInitializationException` is thrown if the property value is not initialized. If a setter method has `@Autowired` annotation on it, then `@Required` is not needed.

This annotation has been deprecated because constructor injection is used for setting all mandatory dependencies.

# What is the purpose of `@Autowired` annotation?

`@Autowired` annotation specifies where and how autowiring is done. This annotation can be used on setter methods, with a constructor argument, on a property as well as on methods with multiple arguments. By default, autowiring is done by type.

# Both `@Bean` and `@Component` annotations create beans. What is the difference between the two?

Some differences between the two annotations are:
* `@Component` enables Spring to auto-detect and auto-configure beans while `@Bean` is used to explicitly declare a bean rather than letting Spring auto-detect it.
* `@Component` is a class level annotation while `@Bean` is a method level annotation.
* Since the `@Component` annotation is used on a class, it keeps the bean definition and class declarations together while `@Bean` decouples them.



# What is the difference between `@Inject` and `@Autowired` in Spring? Which one to use under which condition?

Both these annotations perform the same function and are used for dependency injection by type. The order of dependency injection of both the annotations is as follows:
1. By type
2. Using `@Qualifer` annotation
3. By name.

The only difference between both annotations is that `@Inject` is a CDI annotation which makes it framework-independent and `@Autowired` is a Spring framework annotation. Thus using `@Inject` may be helpful if the application is moved to another framework.

Learn about a few interview questions regarding Spring annotations.

Before We Begin

Introduction

Spring Basics

Spring In-depth

Spring Boot

Spring JDBC

Spring Data JPA

Spring Aspect Orientated Programming (AOP)

Spring MVC

Unit Testing in Spring

Interview Questions

Conclusion

Spring Annotations

What is the purpose of the `@Component` annotation?

What is the difference between `@Component`, `@Service`, `@Repository`, and `@Controller`?