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 a configuration file?

A configuration file is an XML file that describes the different classes in the application and how they are linked to one another. XML configuration files can get lengthy and difficult to manage in large projects. Annotation based approach is easier and cleaner.





# How are beans configured in the Spring container?

Configuration metadata can be provide in the following ways:

* __XML based configuration__: In XML config files, beans are defined using the `<bean>` tag containing a number of different configuration options. For example, the following XML configuration defines two beans and specifies constructor injection to inject the `myDependency` bean in `myBean`.

* __Annotation based configuration__: In this approach, annotations are used. The `@Component` as well as some other annotations can be used to define beans. This approach makes the XML file smaller. The `<context:component-scan/>` tag defines the package where Spring searches for classes with the `@Component` annotation and automatically registers beans.<

   ```xml
   <context:component-scan base-package "io.datajek.spring"/>
   ```
__MyBean__ and __MyDependency__ classes will be registered as beans if they are annotated with `@Component` annotation.


* __Java based configuration__: This approach eliminates XML altogether. The `@Configuration` annotation on a class defines it as a configuration class. Beans can be manually defined using the `@Bean` annotation or the `@ComponentScan` annotation can be used to automatically detect beans defined using annotations. For example:

   ```java
   @Configuration
   @ComponentScan("io.datajek.spring")
   public class MyConfig {
    
   }
   ```
   All classes marked with `@Component` will be registered as beans after the component scan.

# What is the difference between XML and annotation configuration?

Traditionally, XML was used to set up the configuration. Annotations make the same task easier and more understandable. The result of both approaches is the same but less amount of code is written when using annotations.








# How is annotation based configuration enabled in Spring?

By default annotation based configuration is disabled. To enable annotation based configuration in XML file, the `<context:annotation-config/>` tag is used.





# Can there be multiple configuration files in a project?

Large projects can have multiple configuration files. They can be loaded using the `@Import` annotation and mentioning the list of files after the `@Configuration` annotation.

```java
@Configuration
@Import({VehicleConfig.class, EngineConfig.class})
public class ApplicationConfig {

```
Multiple config files can also be imported in a single XML file using the `<import>` tag.</p>

```xml
<import resource="vehicle.xml"/>
<import resource="engine.xml"/>
```



# What is a component scan?

The component scan is the process in which Spring searches for beans. Spring needs to know the location (package) to search for beans. Component scan can be defined in two ways:
* Using the `@Component` annotation and its sub-classes in which case Spring searches all the packages and sub-packages containing this annotation.
* Using XML configuration with `<context:component-scan>` tag specifying the base package.



# How is a component scan done in Spring Boot?

In Spring Boot, the `@SpringBootApplication` annotation triggers a component scan on the package  and its sub-packages where it is used.



# What is the difference between `context: annotation-config` and `context:component-scan` tags?

`<context: annotation-config>` enables the detection of dependency injection annotations like `@Autowired`, `@Qualifier`, `@PostConstruct`, and `@PreDestroy`.

`<context: component-scan>` specifies the base package for the component scan. Component scan is used for finding beans. This tag can recognize the dependency injection annotations mentioned above as well as bean annotations like `@Component`, `@Repository`, and `@Service` etc.

Learn about a few interview questions regarding Spring configuration and component scan.

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 Configuration and Component Scan

What is a configuration file?

How are beans configured in the Spring container?