Configuration & Properties

Externalize your settings. application.properties / application.yml hold configuration outside the code, @Value injects single values, and @ConfigurationProperties binds whole groups to typed objects.

Learn Configuration & Properties in our free Java course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick…

Part of the free Java course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Before You Start

You should understand Spring beans and dependency injection , since configuration values are injected into beans. No prior YAML knowledge is required.

What You'll Learn

The Big Idea — Dials on the Outside of the Box

💡 Analogy: Hardcoding settings is like soldering the volume at one level inside a sealed radio — to change it you must open and rebuild the device. Externalized configuration puts the dials on the outside : the same radio (your one build) runs anywhere, and you just turn the knobs ( application.properties , environment variables) for each room. @Value reads one dial; @ConfigurationProperties reads a whole labeled panel of related dials at once.

Build once, configure per environment — never recompile to change a value.

1️⃣ The Configuration Files

Spring Boot auto-loads application.properties (flat key=value ) or application.yml (nested). They are equivalent — a nested YAML key maps to a dotted property key.

2️⃣ Injecting Single Values — @Value

@Value("${key}") injects one property. Add a default after a colon — ${app.timeout:30} — so a missing key falls back gracefully.

3️⃣ Binding Groups — @ConfigurationProperties

For many related settings, @ConfigurationProperties(prefix = "app") binds the whole group — including nested objects and lists — to a typed class. Relaxed binding maps app.support-email to a supportEmail field.

🧠 Quick Recall

Answer: a default used only when app.timeout is missing.

Answer: app.support-email (relaxed binding maps kebab-case to camelCase).

Answer: so one build runs in every environment by changing values, not recompiling code.

🎯 YOUR TURN — Inject payment settings

Use @Value to inject an API URL, a currency (with a default), and a retry count.

🧩 MINI-CHALLENGE — Bind a storage group

Bind a storage.* group — including a list — with @ConfigurationProperties .

Common Errors

• ❌ Hardcoding settings in Java. Needs a rebuild to change. Fix: externalize to a properties/YAML file.
• ❌ Missing @Value default. A missing key fails startup. Fix: add ${key:default} .
• ❌ No getters/setters for @ConfigurationProperties. Binding fails silently. Fix: add accessors (or use a record/constructor binding).
• ❌ YAML indentation mistakes. Wrong structure or parse error. Fix: use consistent spaces, never tabs.
• ❌ Committing secrets to the file. Leaks credentials. Fix: use environment variables / a secrets manager.
• ❌ Scattering many @Value fields. Hard to maintain. Fix: group with @ConfigurationProperties .

Pro Tips

• 💡 Prefer @ConfigurationProperties for any group of related settings — it is type-safe and validatable.
• 💡 Keep secrets out of files — inject them via environment variables at runtime.
• 💡 Override per environment with command-line args or env vars rather than editing the build.
• 💡 Always supply defaults for optional values so missing keys don't break startup.

📋 Quick Reference

Element

Purpose

Note

application.properties

flat key=value

Auto-loaded

application.yml

nested config

Same keys

@Value("${k}")

inject one value

Single property

${k:default}

fallback value

If key missing

@ConfigurationProperties

bind a group

Typed object

prefix = "app"

group namespace

app.* keys

relaxed binding

kebab -> camel

support-email

List binding

CSV / YAML list

to List/array

override

env var / CLI arg

Per environment

📚 Resources / Keep Learning

• 📘 Spring Boot — externalized configuration (docs.spring.io)
• 📗 Type-safe @ConfigurationProperties (docs.spring.io)
• 📗 Using @Value (docs.spring.io)

❓ Frequently Asked Questions

🎉 Lesson Complete!

You can now externalize settings in application.properties or application.yml , inject single values with @Value and defaults, bind whole groups with @ConfigurationProperties , and override values per environment without recompiling.

Next up: Profiles & Environments — switching configuration with @Profile and spring.profiles.active .

Practice quiz

Continue this course

• Previous: DTOs & Mapping
• Next: Profiles & Environments

Related lessons

• dependency injection