Properties in Spring Boot 2 Tutorial
Tags: java, springboot, tutorial
Published: 2020-05-05 18:36:38

---
title: Properties in Spring Boot 2 Tutorial
published: true
description: Learn about properties files, environment properties, and command-line properties in Spring Boot 2 and how to use them with the @Value annotation.
tags: java, springboot, tutorial
series: Properties in Spring Boot
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/v8ycz8j98vshyw8ywcfo.jpg
---

# Who this post is for

If you are just getting started with Spring Boot 2, then this post is for you.

As a prerequisite, you have installed Java, Maven, and an IDE like IntelliJ, and you followed along with the [Build A Next-Level RESTful Web Service with Spring Boot 2](https://dev.to/scottshipp/build-a-next-level-restful-web-service-with-spring-boot-20d4) post. You currently have a running RESTful web service.

# Let’s get started

Let’s use the greeting application from the Building a next-level RESTful web service article to add and use a property.

The first thing you will notice is that in the `/src/main/resources` directory of this application, there is an `application.properties` file. This file is empty right now. This file was generated by [Spring Initializr](https://start.spring.io/) when we created the application. Remember that I mentioned that the Spring team recommends starting every Spring Boot application with Spring Initializr.

What is this file? `application.properties` is one of the default “property sources” meaning it is one place that Spring Boot is going to look for properties when the application starts up. Actually, Spring Boot looks for a file named `application.properties` in several places. You can read about that in the [Spring Boot documentation](https://docs.spring.io/spring-boot/docs/2.2.6.RELEASE/reference/html/spring-boot-features.html#boot-features-external-config-placeholders-in-properties).

# Add a property

You can store properties for your Spring Boot 2 applications and services in the `application.properties` file in a key-value format.

Open up `application.properties` and add the line:

```
defaultGreeting=Hello
```

Once that’s done, you can use the `@Value` annotation anywhere within your application to refer to this property. The `@Value` annotation can refer to property variables with placeholders, which use the `${myVariableName}` syntax. You can read more about placeholders in the Spring Boot documentation.

# Use the property

Open `GreetingController.java` (found somewhere in `/src/main/java/`), and let’s now change the template variable from a static variable to a member variable, and annotate it with `@Value("${defaultGreeting}")`. I also changed the variable name from `template` to `greeting`, because “template” isn’t accurate anymore.

The result is this:

```java
import java.util.concurrent.atomic.AtomicLong;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/greeting")
public class GreetingController {
    private final AtomicLong counter = new AtomicLong();

    @Value("${defaultGreeting}")
    private String greeting;

    @GetMapping
    public Greeting greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
        return customizeGreeting(name);
    }

    @PutMapping
    public ResponseEntity<Greeting> update(String greeting) {
        this.greeting = greeting;
        return ResponseEntity.ok(customizeGreeting("World"));
    }

    private Greeting customizeGreeting(String name) {
        return new Greeting(counter.incrementAndGet(), greeting + ", " + name);
    }
}
```

Be sure to build (`mvn package`), run (`java -jar target/yourjar.jar`), and test this before continuing, just like you did before using curl or Postman. Remember that you will send a GET request to http://localhost:8080/greeting.

Also try updating the value of `defaultGreeting` in `application.properties`. You will notice that when you change it while the application is running, nothing happens. You have to stop the application, rebuild it, and rerun it in order for the application to pick up the change.

# Properties from Arguments

You currently have a `defaultGreeting` property in `application.properties` and you know how to change it.

The rebuild and rerun part of changing a property is fine for some things, but it may not quite be what you want.

What if you could set this property any time you start the application, without changing the application.properties file and rebuilding?

Luckily, you can. Currently, you run the application like this:

```
java -jar target/greeting-0.0.1-SNAPSHOT.jar
```

(Note that you may have named your application something else besides “greeting” so that would appear in the jar file name instead.)

You can actually pass properties, as arguments, to that run command. Try this, and see what happens:

```
java -DdefaultGreeting="Hey" -jar target/greeting-0.0.1-SNAPSHOT.jar
```

If you test that, you’ll notice that the default greeting changed to “Hey” as expected.

# Environment variables

One of the main reasons to use properties is so that your application can run on different machines, but be customized in some ways for the machine it’s running on. Maybe you distinguish between a dev or test machine and a production machine. Or maybe the difference is simply about who is running the application.

In this greeting application, what if we could use the username from the environment to set the default person that the greeting is for?

This is actually rather easy with Spring Boot! Assuming you are using BASH shell, you should have a `$USER` environment variable. Open a terminal and try typing echo `$USER` and you should see your username. If you do not have a BASH shell on your machine, go find out how to set an environment variable named `USER` for your OS before proceeding, and set it to your username.

# Update the code to use an environment variable property

So we know that we want to refer to an environment variable named `$USER`. Can you think of how you might change the code to do that? (Hint: using the `@Value` annotation.)

As silly as it sounds, you can directly refer to environment variables in `@Value` annotations in Spring Boot, because it automatically loads them. Environment variables are a default property source that the application populates when it loads up.

So you essentially just add `@Value("${USER}")`. Go ahead and add a member of the class named user that is a String.

Now, you’ll want to make it so that by default the name variable is set to this value. You may think that we can just set the `defaultValue` attribute of the `@RequestParam` to our new user variable, but that won’t be allowed because it requires the use of a constant. So, instead, let’s just remove that. The next thing that we run into is that, by default, query parameters are required, but you can set a `required = false` attribute, so I’m going to do that. Now, I’m going to go ahead and just check if name is `null` when we receive it, and in that case set it to the value of user. My final code looks like this:

```java
@RestController
@RequestMapping("/greeting")
public class GreetingController {
    private final AtomicLong counter = new AtomicLong();

    @Value("${defaultGreeting}")
    private String greeting;

    @Value("${USER}")
    private String user = "World";

    @GetMapping
    public Greeting greeting(@RequestParam(value = "name", required = false) String name) {
        if(name == null) {
            name = user;
        }
        return customizeGreeting(name);
    }

    @PutMapping
    public ResponseEntity<Greeting> update(String greeting) {
        this.greeting = greeting;
        return ResponseEntity.ok(customizeGreeting("World"));
    }

    private Greeting customizeGreeting(String name) {
        return new Greeting(counter.incrementAndGet(), greeting + ", " + name);
    }
}
```

With those changes in place, I rebuild and rerun the application, and now by default the response to my GET request is, “Hello, scottshi” because “scottshi” happens to be the username I chose on this computer. When you run it, you should see your username instead.

# What you learned

In this post, you learned how to provide configuration (properties) to a Spring Boot application via:

* environment variables

* command-line arguments

* application.properties

. . . and consume them with the `@Value` annotation.

In a future post, I will cover more ways to consume properties.

# Where to learn more

If you are ready to learn more, right now, check out the [Spring Boot reference manual](https://docs.spring.io/spring-boot/docs/2.2.6.RELEASE/reference/html/spring-boot-features.html#boot-features-external-config) where you can learn:

* additional default property sources

* the order of evaluation that Spring Boot follows to determine which properties win