LearnAI ToolsCareerPractice BuildsPlayContact
Framework26 Lessons~20 HoursIntermediateFree

Dependencies in Spring

A practical, project-organized guide to the Spring and Spring Boot dependency ecosystem. Learn what each major dependency does, when to use it, how to add it, and see a working example — across 26 lessons grouped by category, covering 30+ real-world Spring dependencies.

Start Learning →

What is This Course?

Every real Spring Boot application is really a small set of your own code sitting on top of a much larger stack of curated dependencies — "starters" for web, data, security, testing, messaging, and more. Knowing Spring itself is only half the job; knowing which dependency solves which problem, how to wire it in, and what it actually looks like in code is the other half.

This course is a project-organized field guide to that ecosystem. Instead of teaching Spring from scratch, it catalogs the dependencies you will reach for again and again — grouped by category — with the use case, the exact Maven/Gradle coordinates, the minimal configuration, and a working code example for each one.

Fun Fact

The spring-boot-starter-parent POM and Spring Boot's dependency management BOM exist specifically so you almost never have to specify a version number yourself — Spring Boot picks a tested, compatible version for every starter you add.

Where is This Used?

This knowledge applies directly any time you are assembling or maintaining a real Spring Boot codebase:

Starting New Projects

Pick the right starters from day one instead of bolting on dependencies later.

Integrating New Features

Add security, caching, or messaging to an existing app without guesswork.

Cleaning Up Bloated Projects

Recognize and remove dependencies that duplicate functionality or are unused.

Debugging Version Conflicts

Understand how Spring Boot's BOM resolves transitive dependency clashes.

Technical Interviews

Explain what a starter does and why you'd reach for it — a very common interview topic.

Scaling to Microservices

Know which Spring Cloud dependencies solve config, discovery, and routing.

Real-World Examples

Here are some practical scenarios this course prepares you for:

Example 1: Securing an API

Add spring-boot-starter-security and spring-boot-starter-oauth2-resource-server to protect REST endpoints with JWT.

Example 2: Production Monitoring

Wire in spring-boot-starter-actuator and Micrometer to expose health checks and metrics to Prometheus.

Example 3: Event-Driven Services

Use spring-kafka or spring-boot-starter-amqp to publish and consume messages between microservices.

Example 4: Reliable Test Suites

Combine spring-boot-starter-test with Testcontainers for real database integration tests.

Why Learn This?

Career

  • Dependency selection is a near-daily task for every Spring Boot developer
  • A very common system-design and interview topic ("what would you add for X?")
  • Signals real production experience, not just tutorial-level Spring knowledge
  • Directly useful for code review — spotting missing or redundant dependencies

Practical Skill

  • Turns "I know Spring" into "I know exactly what to add and why"
  • Saves hours of searching Maven Central and Stack Overflow per feature
  • Builds a mental map of the entire Spring/Spring Boot ecosystem at once
  • Makes reading any unfamiliar pom.xml or build.gradle far less intimidating

Broad Coverage

  • 30+ real dependencies across web, data, security, testing, and more
  • Every entry has a working example — not just a name and a description
  • Organized by category so you can jump straight to what you need
  • Covers both core Spring Boot starters and the wider Spring Cloud family

Ecosystem Fluency

  • Understand the starter naming convention so new starters feel familiar
  • See how Spring Boot auto-configuration reacts to what's on the classpath
  • Learn how Spring Boot manages versions so you rarely fight dependency hell
  • A natural companion to our Spring Framework and Spring Boot courses

Code Example

Here is the shape of what every lesson covers — a dependency, its coordinates, and a minimal working example. This one adds validation to a REST controller:

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
@RestController
@RequestMapping("/api/users")
public class UserController {
@PostMapping
public ResponseEntity<String> createUser(@Valid @RequestBody UserRequest request) {
return ResponseEntity.ok("User " + request.getName() + " created");
}
}
public class UserRequest {
@NotBlank(message = "Name is required")
private String name;
@Email(message = "Email must be valid")
private String email;
// getters and setters
}
What Happens

Click Run to see what this code prints.

What this demonstrates

One starter dependency (spring-boot-starter-validation) plus a handful of annotations (@Valid, @NotBlank, @Email) is enough to get full request validation — this is the pattern every lesson in this course follows for a different dependency.

Course Curriculum

Follow these 26 lessons sequentially — they move from dependency-management foundations through each major category to a final real-world project.

Learn in Sequence

Start with the foundations (starters, auto-configuration, Maven/Gradle) before jumping into any category — those first five lessons explain *why* a starter works the way it does, which makes every later lesson click faster. The category lessons can then be read in order or referenced individually as you need them.

Projects You'll Build

Apply your knowledge by building these real-world projects:

Frequently Asked Questions

Yes — this course assumes you already understand core Spring/Spring Boot concepts (beans, dependency injection, REST controllers). If you're new to those, start with our Spring Framework or Spring Boot course first.

No. The Spring Boot course teaches the framework itself. This course is a dedicated, categorized reference to the wider dependency ecosystem — 30+ individual dependencies each with a use case, setup, and example.

No — the goal is recognition and fluency, not memorization. After this course you'll know what category a problem falls into and where to look, which is how experienced developers actually work.

Both. Lesson 3 compares them directly, and every dependency example throughout the course is shown in Maven XML, with Gradle equivalents noted where the syntax differs meaningfully.

Our Hibernate and JSP courses pair well for the data and legacy-view layers, and Spring Cloud topics from lessons 21-22 are a good jumping-off point into dedicated microservices learning.

Key Takeaways & Summary

  • Spring Boot "starters" are curated dependency bundles named by convention (spring-boot-starter-*) that pull in everything a feature needs.
  • Auto-configuration reacts to what is on your classpath — adding a dependency is often the only step required to enable a feature.
  • Spring Boot's parent POM/BOM manages compatible versions for you, which is why you rarely specify a version number directly.
  • This 26-lesson course groups 30+ real dependencies by category — web, data, security, testing, messaging, cloud, and more — each with a use case, setup, and example.
  • The goal is fluency: knowing which dependency solves which problem, and how to wire it in confidently.
Ready to Start?

Begin with the Introduction lesson to understand how Spring dependency management works, then move through the categories — or jump straight to the category you need right now. Every lesson's example is meant to be copied into a real project and run.