Application.properties basics in Spring Boot - Deep Dive

Overview - Application.properties basics

What is it?

Application.properties is a simple text file used in Spring Boot projects to store configuration settings. These settings control how the application behaves, like server ports, database connections, or logging levels. It uses a key-value format where each line sets one property. This file helps keep configuration separate from code, making apps easier to manage and change.

Why it matters

Without application.properties, developers would have to hard-code settings inside the program, making it hard to change behavior without rewriting code. This file allows quick tweaks to important settings without touching the code, speeding up development and deployment. It also helps teams share consistent settings and supports different environments like testing or production easily.

Where it fits

Before learning application.properties, you should understand basic Spring Boot setup and Java properties file format. After mastering it, you can explore advanced configuration options like YAML files, profiles for different environments, and programmatic configuration with Java classes.

Mental Model

Core Idea

Application.properties is a simple list of instructions that tells your Spring Boot app how to behave without changing the code.

Think of it like...

It's like a remote control for your TV: instead of opening the TV and changing wires, you press buttons on the remote to change channels or volume. The properties file is the remote, and the app listens to it to know what to do.

┌───────────────────────────────┐
│ application.properties file    │
│ ┌───────────────────────────┐ │
│ │ server.port=8080          │ │
│ │ spring.datasource.url=... │ │
│ │ logging.level.root=INFO   │ │
│ └───────────────────────────┘ │
└───────────────┬───────────────┘
                │
                ▼
       ┌───────────────────┐
       │ Spring Boot App   │
       │ reads properties  │
       │ and configures    │
       │ itself accordingly│
       └───────────────────┘

Build-Up - 7 Steps

1

Foundation

What is application.properties file

Concept: Introduce the file and its purpose in Spring Boot.

The application.properties file is a plain text file placed in the src/main/resources folder of a Spring Boot project. It stores configuration settings as key-value pairs, like server.port=8080. Spring Boot automatically reads this file when the app starts and applies the settings.

Result

The app knows to use the settings from this file to configure itself at startup.

Understanding that this file is the central place for configuration helps separate code from settings, making apps flexible.

2

Foundation

Basic syntax and location

Concept: Learn the format and where to put the file.

Each line in application.properties has a key, an equals sign, and a value, for example: server.port=8080. The file must be placed in src/main/resources so Spring Boot can find it automatically. Comments start with # and are ignored.

Result

You can write simple settings that Spring Boot will read without extra code.

Knowing the exact file location and syntax prevents common errors where settings are ignored.

3

Intermediate

Common configuration properties

🤔Before reading on: do you think server.port=8080 changes the app's port or something else? Commit to your answer.

Concept: Explore frequently used properties like server port, datasource, and logging.

Some common properties include: - server.port=8080 to set the web server port - spring.datasource.url=jdbc:mysql://localhost/db to set database URL - logging.level.root=INFO to control logging detail These keys follow a naming pattern that Spring Boot recognizes and uses to configure components.

Result

The app runs on the specified port, connects to the database, and logs messages at the chosen level.

Recognizing common keys helps quickly customize app behavior without writing code.

4

Intermediate

Overriding defaults with properties

🤔Before reading on: do you think Spring Boot uses default settings if application.properties is missing? Yes or no?

Concept: Understand how properties override Spring Boot defaults.

Spring Boot has built-in default settings for many things. When you add application.properties, any matching keys override these defaults. For example, if you set server.port=9090, the app will use port 9090 instead of the default 8080. If a property is missing, the default remains.

Result

You control only what you want to change, leaving other defaults intact.

Knowing this prevents unnecessary configuration and helps focus on what really needs changing.

5

Intermediate

Using profiles for environment configs

🤔Before reading on: do you think one application.properties file can hold settings for all environments? Commit your guess.

Concept: Introduce profiles to manage different settings for dev, test, and prod.

Spring Boot supports profiles like 'dev' or 'prod' to load different properties files, e.g., application-dev.properties. You activate a profile by setting spring.profiles.active=dev. This lets you keep environment-specific settings separate and switch easily without changing code.

Result

Your app uses the right settings for the current environment automatically.

Understanding profiles helps manage complexity and avoid mistakes when deploying to different places.

6

Advanced

Property placeholders and references

🤔Before reading on: do you think you can reuse one property value inside another in application.properties? Yes or no?

Concept: Learn how to reference one property inside another using placeholders.

You can use ${property.name} syntax to refer to other properties. For example: app.name=MyApp welcome.message=Welcome to ${app.name} Spring Boot replaces placeholders with actual values at runtime. This avoids repeating values and keeps config DRY (Don't Repeat Yourself).

Result

Properties can build on each other, making configs cleaner and easier to maintain.

Knowing placeholders unlocks powerful ways to organize configuration and reduce errors.

7

Expert

How Spring Boot loads and merges properties

🤔Before reading on: do you think application.properties is the only source of configuration Spring Boot uses? Commit your answer.

Concept: Understand the order and merging of multiple property sources in Spring Boot.

Spring Boot loads properties from many places: application.properties, application-{profile}.properties, environment variables, command-line args, and more. It merges them with a priority order, where command-line args override environment variables, which override application.properties. This layered approach allows flexible configuration management.

Result

Your app's final configuration is a combination of many sources, with clear rules on which wins.

Understanding this merging prevents confusion when settings seem ignored and helps debug config issues.

Under the Hood

When Spring Boot starts, it uses a PropertySourcesLoader to read application.properties from the classpath. It parses each line into key-value pairs and stores them in a PropertySource object. These sources are combined with others like environment variables and command-line arguments in a PropertySources chain. When the app needs a config value, it queries this chain in priority order to get the effective value.

Why designed this way?

This design allows flexible, layered configuration that supports defaults, environment overrides, and runtime changes without code modification. It evolved to solve the problem of managing many settings across different environments and deployment methods, making apps easier to maintain and deploy.

┌───────────────────────────────┐
│ application.properties file    │
├───────────────────────────────┤
│ environment variables          │
├───────────────────────────────┤
│ command-line arguments         │
└───────────────┬───────────────┘
                │
                ▼
       ┌───────────────────┐
       │ PropertySources    │
       │ (merged settings) │
       └─────────┬─────────┘
                 │
                 ▼
       ┌───────────────────┐
       │ Spring Boot App   │
       │ uses config values│
       └───────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does changing application.properties require restarting the Spring Boot app to take effect? Commit yes or no.

Common Belief: Changing application.properties updates the app immediately without restart.

Reality: Spring Boot reads application.properties only at startup, so changes require restarting the app to apply.

Why it matters: Expecting live updates without restart can cause confusion and wasted debugging time.

Quick: Can you put any file name instead of application.properties and Spring Boot will read it automatically? Commit yes or no.

Common Belief: Spring Boot automatically reads any properties file in resources folder.

Reality: Only application.properties or application-{profile}.properties files are loaded automatically. Other files need manual loading.

Why it matters: Placing config in wrong files means settings are ignored, causing unexpected app behavior.

Quick: Does setting a property in application.properties always override environment variables? Commit yes or no.

Common Belief: Properties in application.properties have highest priority and override environment variables.

Reality: Environment variables have higher priority than application.properties and override them if both exist.

Why it matters: Misunderstanding priority leads to config conflicts and hard-to-find bugs.

Quick: Can you use complex data structures like lists or maps directly in application.properties? Commit yes or no.

Common Belief: You can easily define lists and maps in application.properties like in code.

Reality: application.properties supports only simple key-value pairs; complex structures require YAML or programmatic config.

Why it matters: Trying to put complex data in properties leads to errors or ignored settings.

Expert Zone

1

Spring Boot supports relaxed binding, so property keys can use dots, underscores, or camel case interchangeably, which many beginners miss.

2

Profiles can be combined by listing multiple active profiles separated by commas, allowing layered environment configs.

3

You can inject properties directly into Spring beans using @Value or @ConfigurationProperties, enabling type-safe configuration.

When NOT to use

For very complex configurations involving nested objects or lists, use application.yml (YAML) files or Java-based configuration classes instead. Also, avoid application.properties for secrets; use dedicated vaults or environment variables.

Production Patterns

In production, teams use multiple profiles (dev, test, prod) with separate properties files, override sensitive settings via environment variables or CI/CD pipelines, and use placeholders for common values. They also externalize configuration outside the packaged jar for easier updates.

Connections

Environment Variables

Builds-on and overrides

Knowing how environment variables override application.properties helps manage configuration securely and flexibly across deployment environments.

YAML Configuration Files

Alternative format

Understanding application.properties clarifies why YAML is preferred for complex nested configs, showing tradeoffs between simplicity and expressiveness.

Dependency Injection

Uses configuration values

Knowing how properties inject into beans connects configuration management with core Spring Boot programming patterns.

Common Pitfalls

#1 Changing application.properties but expecting immediate effect without restart.

Wrong approach:

Modify application.properties and test app without restarting.

Correct approach:

Modify application.properties and restart the Spring Boot application to apply changes.

Root cause:

Misunderstanding that Spring Boot reads properties only at startup.

#2 Placing application.properties in wrong folder so Spring Boot can't find it.

Wrong approach:

Put application.properties in src/main/java or root project folder.

Correct approach:

Place application.properties inside src/main/resources folder.

Root cause:

Not knowing Spring Boot loads config only from classpath resources.

#3 Trying to define complex lists or maps directly in application.properties.

Wrong approach:

my.list=one,two,three
my.map.key1=value1
my.map.key2=value2

Correct approach:

Use application.yml for complex structures or define multiple properties with indexed keys.

Root cause:

Assuming application.properties supports complex data types like YAML.

Key Takeaways

Application.properties is a simple text file that controls Spring Boot app settings without changing code.

It uses key-value pairs and must be placed in src/main/resources to be recognized automatically.

Properties override Spring Boot defaults but can themselves be overridden by environment variables or command-line arguments.

Profiles let you manage different settings for different environments by using separate properties files.

Understanding property loading order and placeholders helps avoid common configuration mistakes and enables flexible app behavior.

Practice

1. What is the primary purpose of the application.properties file in a Spring Boot project?

easy

A. To store configuration settings as key=value pairs

B. To write Java code for the application

C. To define HTML templates for the UI

D. To manage database schema migrations

Solution

1. Step 1: Understand the role of application.properties

   This file is used to store configuration settings in a simple key=value format.

2. Step 2: Compare with other options

   Writing Java code, defining HTML templates, or managing database migrations are done elsewhere, not in this file.

3. Final Answer:

   To store configuration settings as key=value pairs -> Option A

4. Quick Check:

   Config file = key=value pairs [OK]

Hint: Remember: properties file holds settings, not code or templates [OK]

Common Mistakes:

• Thinking it contains Java code
• Confusing it with HTML or template files
• Assuming it manages database migrations

2. Which of the following is the correct syntax to set the server port to 8081 in application.properties?

easy

A. server.port=8081

B. server-port: 8081

C. server_port=8081

D. port.server=8081

Solution

1. Step 1: Recall Spring Boot property syntax

   Spring Boot uses dot notation with key=value pairs in application.properties.

2. Step 2: Identify correct key for server port

   The correct key is server.port, and the value is set with an equals sign.

3. Final Answer:

   server.port=8081 -> Option A

4. Quick Check:

   Dot notation + equals sign = correct syntax [OK]

Hint: Use dot notation and equals sign for properties [OK]

Common Mistakes:

• Using underscores instead of dots
• Using colon instead of equals sign
• Swapping key parts order

3. Given this application.properties snippet:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=pass123

What will Spring Boot do with these properties when the app starts?

medium

A. Create a new database named 'mydb'

B. Ignore these properties because they are invalid

C. Start a web server on port 3306

D. Connect to MySQL database at localhost with given credentials

Solution

1. Step 1: Identify datasource properties

   The keys starting with spring.datasource configure database connection details.

2. Step 2: Understand Spring Boot behavior

   Spring Boot uses these to connect to the specified MySQL database with username and password.

3. Final Answer:

   Connect to MySQL database at localhost with given credentials -> Option D

4. Quick Check:

   Datasource properties = DB connection [OK]

Hint: Datasource keys configure DB connection automatically [OK]

Common Mistakes:

• Thinking it starts a web server on DB port
• Assuming properties are ignored
• Believing it creates the database automatically

4. What is wrong with this application.properties line?

server.port-8080

medium

A. The port number 8080 is invalid

B. The key and value are separated by a dash instead of equals sign

C. The key should be port.server instead

D. There should be no spaces around the dash

Solution

1. Step 1: Check property syntax

   Properties require key and value separated by an equals sign (=), not a dash (-).

2. Step 2: Validate the key and value

   The key server.port is correct, and 8080 is a valid port number.

3. Final Answer:

   The key and value are separated by a dash instead of equals sign -> Option B

4. Quick Check:

   Use '=' to separate key and value [OK]

Hint: Always use '=' between key and value in properties [OK]

Common Mistakes:

• Using dash instead of equals sign
• Swapping key parts order
• Thinking spaces fix the syntax

5. You want to add a custom property app.title in application.properties and access it in your Spring Boot code. Which of these steps is correct?

hard

A. Add app.title=MyApp in properties and access it with System.getenv("app.title")

B. Add app.title: MyApp in properties and read it with System.getProperty("app.title")

C. Add app.title=MyApp in properties and use @Value("${app.title}") in code

D. Add app.title=MyApp in properties and use @Autowired String app.title in code

Solution

1. Step 1: Add custom property correctly

   Use key=value syntax: app.title=MyApp in application.properties.

2. Step 2: Access property in Spring Boot code

   Use @Value("${app.title}") annotation to inject the property value.

3. Final Answer:

   Add app.title=MyApp in properties and use @Value("${app.title}") in code -> Option C

4. Quick Check:

   Custom property + @Value injection = correct [OK]

Hint: Use @Value("${key}") to inject properties in code [OK]

Common Mistakes:

• Using colon instead of equals in properties
• Trying to get property from environment variables
• Incorrect use of @Autowired for simple values