Table of Contents

1. Introduction to Dependency Injection
2. Why Dependency Injection?
3. Types of Dependency Injection in Spring
   • Constructor Injection
   • Field Injection
   • Setter Injection
4. Comparing the Three Types
5. Choosing the Right Approach
6. Common Pitfalls and Best Practices
7. Conclusion

1. Introduction to Dependency Injection

Dependency Injection (DI) is a core design pattern used in the Spring Framework to manage object creation and wiring. It allows you to write loosely coupled and more maintainable code by removing the responsibility of managing dependencies from the classes themselves.

Spring Boot leverages this concept extensively using annotations and the Spring container (also called the ApplicationContext) to inject dependencies at runtime.

2. Why Dependency Injection?

Without DI, objects are responsible for instantiating their dependencies. This leads to tightly coupled code, making it difficult to test, extend, or maintain. DI allows us to:

• Separate configuration from application logic
• Promote code reusability and testability
• Simplify code by letting the framework handle wiring

For example, instead of:

Service service = new ServiceImpl();

With DI:

@Autowired
private Service service;

The Spring container injects ServiceImpl automatically.

3. Types of Dependency Injection in Spring

Spring supports three primary types of dependency injection:

3.1 Constructor Injection

Constructor injection is the recommended and most commonly used form. It makes dependencies immutable and helps with unit testing by ensuring all required dependencies are provided.

Example:

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void process() {
        userRepository.save(new User());
    }
}

If there’s only one constructor, the @Autowired annotation is optional.

3.2 Field Injection

Field injection directly injects dependencies into class fields. It’s concise but not recommended for serious applications due to testability and maintainability concerns.

Example:

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public void process() {
        userRepository.save(new User());
    }
}

This works but hides the actual dependencies, which may cause problems in larger applications or during testing.

3.3 Setter Injection

Setter injection allows injecting optional dependencies through setter methods. It’s useful when a dependency is not required for object creation but might be needed later.

Example:

@Service
public class UserService {

    private UserRepository userRepository;

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void process() {
        userRepository.save(new User());
    }
}

Setter injection makes dependencies optional and supports mutable objects.

4. Comparing the Three Types

5. Choosing the Right Approach

• Use constructor injection when possible. It ensures required dependencies are not null and promotes immutability.
• Avoid field injection in production code unless necessary (e.g., in test classes or configurations).
• Use setter injection for optional dependencies or when using frameworks that need default constructors (e.g., some serialization libraries).

6. Common Pitfalls and Best Practices

• Avoid circular dependencies: If two beans depend on each other via constructor injection, Spring will fail to instantiate them.
• Do not mix all injection types within the same class unless there’s a strong reason.
• Mark injected fields as final when using constructor injection to guarantee immutability.
• Use @Qualifier when multiple implementations of an interface are present: @Autowired @Qualifier("specificRepository") private UserRepository userRepository;
• For optional dependencies, use: public UserService(@Autowired(required = false) UserRepository repo) { ... } or @Autowired public void setRepo(@Nullable UserRepository repo) { ... }

7. Conclusion

Dependency Injection is at the heart of the Spring Boot programming model. Understanding the three forms—constructor, field, and setter injection—allows developers to write clean, testable, and maintainable applications. While all forms are supported, constructor injection is typically preferred due to its clarity and reliability.

Table of Contents

1. Introduction to @SpringBootApplication
2. Understanding What @SpringBootApplication Does
3. Breakdown of Combined Annotations
4. What is Auto-Configuration?
5. How Auto-Configuration Works
6. Disabling Auto-Configuration
7. Customizing Auto-Configuration
8. Common Auto-Configured Components
9. Best Practices
10. Conclusion

1. Introduction to @SpringBootApplication

When building a Spring Boot application, one of the first things you’ll encounter is the @SpringBootApplication annotation. It is the backbone of any Spring Boot app and is typically placed on the main class to denote it as the entry point.

Example:

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

This annotation streamlines the configuration process and serves as a powerful entry point for Spring Boot’s capabilities.

2. Understanding What @SpringBootApplication Does

@SpringBootApplication is a meta-annotation, meaning it’s composed of several other annotations that make it a compact yet powerful tool for application configuration.

Under the hood, it includes:

• @Configuration
• @EnableAutoConfiguration
• @ComponentScan

Each of these plays a critical role in setting up the application context.

3. Breakdown of Combined Annotations

@Configuration

Indicates that the class can be used by the Spring IoC container as a source of bean definitions.

@EnableAutoConfiguration

Tells Spring Boot to automatically configure your application based on the dependencies on the classpath. This is what enables Spring Boot to auto-configure database connections, web servers, security, etc., without manual setup.

@ComponentScan

Enables component scanning so that classes annotated with @Component, @Service, @Repository, and @Controller are automatically discovered and registered as beans.

4. What is Auto-Configuration?

Auto-configuration is a powerful feature in Spring Boot that automatically sets up your application context based on the libraries available on the classpath.

For example:

• If Spring MVC is in your classpath, Spring Boot configures a DispatcherServlet.
• If there’s an embedded database like H2, it will configure a DataSource for you.
• If Thymeleaf is present, it sets up the view resolver automatically.

You don’t have to define these beans explicitly unless you want to override the default behavior.

5. How Auto-Configuration Works

Spring Boot uses the @EnableAutoConfiguration annotation to load META-INF/spring.factories from the classpath. These factory files point to auto-configuration classes which Spring loads using @Conditional annotations.

Key mechanisms:

• @ConditionalOnClass: Activates config if a class is present
• @ConditionalOnMissingBean: Applies config only if no custom bean is defined
• @ConditionalOnProperty: Configures behavior based on property values

Example:

@ConditionalOnClass(DataSource.class)
@Bean
public DataSource dataSource() {
    return new HikariDataSource();
}

6. Disabling Auto-Configuration

Sometimes, auto-configuration may not be desired. You can disable specific configurations using:

@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })

Or use properties to disable certain behaviors in application.properties:

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

7. Customizing Auto-Configuration

You can override auto-configured beans simply by defining your own bean with the same type:

@Bean
public DataSource dataSource() {
    // custom DataSource setup
}

You can also influence auto-configuration using application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=secret

8. Common Auto-Configured Components

Some of the frequently auto-configured parts include:

• Embedded Tomcat, Jetty, or Undertow for web applications
• Spring MVC DispatcherServlet
• JPA EntityManagerFactory
• DataSource configuration
• Spring Security filter chains
• Logging (Logback, Log4j2) setup
• Message converters for REST APIs
• Error handling pages

Each of these has its own auto-configuration class.

9. Best Practices

• Place @SpringBootApplication on a class in the root package to enable component scanning for the whole project.
• Let Spring Boot auto-configure as much as possible to reduce boilerplate.
• Customize only when necessary to avoid configuration conflicts.
• Avoid disabling auto-configuration unless you have a specific use case.

10. Conclusion

The @SpringBootApplication annotation and Spring Boot’s auto-configuration capabilities dramatically reduce the amount of setup required to start a new Spring project. They provide sensible defaults and intelligent configurations that just work out of the box. Understanding how this mechanism works is essential for tweaking behavior, resolving conflicts, and building scalable and maintainable applications.

Table of Contents

1. Overview of Spring Boot Project Setup
2. What is Spring Initializr?
3. Generating a Spring Boot Project with Spring Initializr
4. Project Structure Explained
5. Importing the Project into an IDE
6. Running Your First Spring Boot Application
7. Verifying Setup and Troubleshooting
8. Conclusion

1. Overview of Spring Boot Project Setup

Setting up a traditional Spring application used to involve multiple steps like configuring XML files, setting up application servers, and managing dependencies manually. Spring Boot eliminates most of this boilerplate by providing a streamlined approach to project setup using Spring Initializr.

With Spring Boot, you can:

• Start a production-ready application quickly
• Include only the necessary dependencies
• Use embedded servers (Tomcat, Jetty)
• Leverage annotations and Java configuration over XML

2. What is Spring Initializr?

Spring Initializr is a web-based tool (also available as an API and IntelliJ plugin) that allows developers to generate a new Spring Boot project structure with a custom selection of dependencies, Java version, packaging type, and build tool.

You can access it at: https://start.spring.io

Spring Initializr provides:

• Pre-configured build files (Maven or Gradle)
• Auto-generated source code structure
• Starter dependencies
• Compatible setup with IntelliJ IDEA, Eclipse, VS Code, and other IDEs

3. Generating a Spring Boot Project with Spring Initializr

Follow these steps to generate your first Spring Boot project:

Step 1: Visit Spring Initializr

Go to https://start.spring.io

Step 2: Choose Project Settings

• Project: Maven or Gradle
• Language: Java
• Spring Boot Version: Latest stable version
• Group: com.example
• Artifact: demo
• Name: demo
• Description: Demo project for Spring Boot
• Package name: com.example.demo
• Packaging: Jar (preferred) or War
• Java version: Choose based on your local setup (e.g., 17 or 21)

Step 3: Add Dependencies

Start typing to search and add dependencies such as:

• Spring Web (for building REST APIs)
• Spring Boot DevTools (for hot reload)
• Spring Data JPA (for database access)
• MySQL Driver (if you’ll use MySQL)
• Spring Security, Thymeleaf, etc., as needed

Step 4: Generate and Download the Project

Click “Generate” to download a .zip file of the project.

Step 5: Extract the ZIP

Unzip the file to a desired folder on your local machine.

4. Project Structure Explained

After unzipping and opening the project, you’ll see:

demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       └── DemoApplication.java
│   │   └── resources/
│   │       ├── application.properties
│   │       ├── static/
│   │       └── templates/
│   └── test/
│       └── java/
│           └── com/example/demo/
│               └── DemoApplicationTests.java
├── pom.xml or build.gradle

• DemoApplication.java: Main class annotated with @SpringBootApplication
• application.properties: Configuration file
• static/: For static files (CSS, JS)
• templates/: For server-side templates like Thymeleaf
• pom.xml: Maven build file listing dependencies

5. Importing the Project into an IDE

IntelliJ IDEA

• Open IntelliJ
• Choose “Open” and select the root folder of the unzipped project
• IntelliJ will detect the Maven/Gradle project and import dependencies automatically

Eclipse or STS

• File → Import → Existing Maven/Gradle Project
• Choose the extracted project folder
• Wait for the build process to complete

6. Running Your First Spring Boot Application

Once imported, you can run your application:

Using IntelliJ

Right-click on DemoApplication.java → Run

Using Command Line

Navigate to the project folder and run:

./mvnw spring-boot:run

or for Gradle:

./gradlew bootRun

After a successful run, you’ll see output similar to:

Tomcat started on port(s): 8080 (http) with context path ''
Started DemoApplication in 2.345 seconds

Now visit: http://localhost:8080

7. Verifying Setup and Troubleshooting

Verify:

• Project runs without errors
• Tomcat starts on port 8080
• Application context loads successfully

Common Issues:

• Java version mismatch: Ensure you’re using the correct JDK version.
• Maven/Gradle not installed: Use the provided wrapper scripts (mvnw or gradlew)
• IDE not detecting dependencies: Force a Maven/Gradle reimport

8. Conclusion

Setting up a Spring Boot project has never been easier, thanks to Spring Initializr. In just a few clicks, you get a production-ready project structure complete with a modern build tool, embedded server, and dependency management. This setup forms the foundation for developing robust Spring Boot applications rapidly, reducing configuration overhead and improving your development speed.

Table of Contents

1. What is the Spring Framework?
2. Why Use Spring?
3. Core Concepts of Spring Framework
   • Inversion of Control (IoC)
   • Dependency Injection (DI)
   • Aspect-Oriented Programming (AOP)
4. Spring Modules Overview
5. Spring vs Traditional Java Development
6. Introduction to Spring Boot
7. Benefits of Spring Boot
8. Spring Boot Architecture
9. Key Annotations in Spring and Spring Boot
10. Spring Boot CLI and Initializr
11. Comparison: Spring vs Spring Boot
12. Conclusion

1. What is the Spring Framework?

Spring Framework is a powerful, feature-rich, and modular Java framework designed for building enterprise-level applications. It simplifies Java development by offering a comprehensive programming and configuration model for modern Java-based enterprise applications.

It is widely used to build web applications, RESTful APIs, microservices, data access layers, and more — and serves as a foundation for numerous other frameworks like Spring Boot, Spring Security, Spring Data, and Spring Cloud.

2. Why Use Spring?

Traditional Java development (especially with JEE/Java EE) can be cumbersome due to boilerplate code, tightly coupled components, and complex configurations.

Spring addresses these issues by:

• Reducing boilerplate code using Dependency Injection
• Supporting Aspect-Oriented Programming (AOP)
• Providing integration with other frameworks (Hibernate, JPA, JMS)
• Offering modularity and testability
• Supporting both XML and annotation-based configurations
• Simplifying unit testing via loose coupling

3. Core Concepts of Spring Framework

3.1 Inversion of Control (IoC)

IoC is a design principle where control of object creation and management is transferred from the program to the Spring container. This means you don’t instantiate classes directly; instead, Spring does it for you.

3.2 Dependency Injection (DI)

DI is the mechanism by which Spring achieves IoC. It allows you to inject dependencies (objects) into classes through:

• Constructor injection
• Setter injection
• Field injection

Example:

@Component
public class Car {
    private Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }
}

3.3 Aspect-Oriented Programming (AOP)

AOP enables separation of cross-cutting concerns (like logging, security, transactions) from business logic. Spring AOP allows you to define these concerns in reusable modules.

Example: Logging logic can be separated from core business logic and executed before/after certain methods using aspects.

4. Spring Modules Overview

Spring is divided into multiple modules such as:

• Spring Core: IoC and DI container
• Spring AOP: Aspect-oriented programming support
• Spring Data: Access and manage relational and NoSQL databases
• Spring MVC: Build web applications
• Spring Security: Authentication and authorization
• Spring Boot: Simplified Spring application setup and deployment

5. Spring vs Traditional Java Development

6. Introduction to Spring Boot

Spring Boot is an extension of the Spring Framework that simplifies the setup, configuration, and deployment of Spring applications. It eliminates boilerplate code and offers out-of-the-box features like:

• Embedded servers (Tomcat, Jetty)
• Auto-configuration
• Production-ready metrics and monitoring
• Opinionated starter dependencies

You can create a Spring Boot app with minimal setup and get running quickly, even for complex applications.

7. Benefits of Spring Boot

• No XML Configuration: Uses annotations and .properties/.yml files
• Standalone Applications: Run with java -jar command
• Embedded Servers: No need to deploy on external servers
• Auto-Configuration: Sensible defaults reduce manual configuration
• Spring Boot Starters: Pre-packaged dependencies for specific functionalities (e.g., spring-boot-starter-web, spring-boot-starter-data-jpa)
• DevTools: Built-in tools for hot reloading and faster development

8. Spring Boot Architecture

Spring Boot is built on top of the Spring framework. Key architectural components include:

• Spring Boot Starters: Dependency descriptors to simplify Maven/Gradle setup
• Spring Boot Auto Configuration: Automatically configures beans based on the classpath
• Spring Boot CLI: A command-line interface to run and test Spring Boot applications
• Embedded Web Servers: Tomcat/Jetty/Undertow bundled with the app

9. Key Annotations in Spring and Spring Boot

• @Component / @Service / @Repository: Marks classes as beans managed by Spring
• @Autowired: Injects dependencies automatically
• @Configuration: Declares a class as a source of bean definitions
• @Bean: Declares a bean method
• @SpringBootApplication: Combines @Configuration, @EnableAutoConfiguration, and @ComponentScan
• @RestController: Defines a REST controller
• @RequestMapping / @GetMapping / @PostMapping: Maps HTTP requests to handler methods

10. Spring Boot CLI and Initializr

Spring Boot CLI:

A tool to rapidly prototype applications using Groovy.

spring run app.groovy

Spring Initializr:

A web-based tool to bootstrap a Spring Boot project.

• Website: https://start.spring.io
• Choose project metadata, dependencies, and generate the project structure.

11. Comparison: Spring vs Spring Boot

12. Conclusion

Spring Framework and Spring Boot are cornerstones of modern Java development. While Spring provides a flexible foundation for building enterprise applications, Spring Boot makes development faster and simpler through auto-configuration and production-ready defaults. Together, they form a powerful toolkit for building robust, scalable, and maintainable Java applications.

As you proceed with Spring development, focus first on mastering dependency injection, annotation-based configuration, and Spring Boot project setup. These are the foundation blocks that will make the rest of the journey seamless.