Disabling a Specific Auto-Configuration

Recall that Chapter 2 covered the @SpringBootApplication annotation a bit. This annotation is equivalent to the @Configuration, @ComponentScan, and @EnableAutoConfiguration annotations. You can disable a specific auto-configuration by adding the @EnableAutoConfiguration annotation to your class with the exclude parameter. Listing 3-3 shows an example.

Listing 3-3. app.groovy

                    import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration                                  

@RestController
@EnableAutoConfiguration(exclude=[ActiveMQAutoConfiguration.class])
class WebApp{

    @RequestMapping("/")
          String greetings(){
               "Spring Boot Rocks"
          }
}                

Listing 3-3 shows the @EnableAutoConfiguration annotation with the exclude parameter. This parameter receives an array of auto-configuration classes. If you run this again with the following command:

$ spring run app.groovy --debug
...
Exclusions:
-----------

   org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration
...

You will see the exclusion of the ActiveMQAutoConfiguration class. This is a very useful technique for Groovy scripts, when you want Spring Boot to skip certain and unnecessary auto-configurations. You might wonder why you would want to exclude a configuration. Well, sometimes you will have dependencies that work in two different types of applications—web and non-web for example—and you want to use the jackson-core library that handles JSON objects to create a non-web app. This library can work in web or non-web apps, but the auto-configuration will guess that, based on this dependency, your application is a web app. In that case, you can exclude the web auto-configuration from happening. This is one example of many where you might use the auto-configuration exclusion.

Listing 3-4 shows this exclusion on a Java Spring Boot app.

Listing 3-4. DemoApplication.java—Spring Boot snippet

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration;

@SpringBootApplication(exclude={ActiveMQAutoConfiguration.class,DataSourceAutoConfiguration.class})
public class DemoApplication {

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

Listing 3-4 shows you a Java version. In this example the main class is declaring only the @SpringBootApplication annotation, and within this annotation you can exclude the auto-configuration classes. Listing 3-4 shows two classes being excluded—the ActiveMQAutoConfigurationand DataSourceAutoConfigurationclasses. Why is @EnableAutoConfiguration annotation not being used? Remember that the @SpringBootApplication annotation inherits @EnableAutoConfiguration, @Configuration, and @ComponentScan, which is why you can use the exclude parameter within the @SpringBootApplication.

If you run a Maven or Gradle project (using the example in Listing 3-4) with the debug option, you will see output like this:

$ spring run DemoApplication.java --debug
...
Exclusions:
-----------

   org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration
   org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
...

SpringApplication Class

You can have a more advanced configuration using the Spring application, because you can create an instance out of it and do a lot more. See Listing 3-10.

Listing 3-10. Version 2 of src/main/java/com/apress/spring/SpringBootSimpleApplication.java

package com.apress.spring;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootSimpleApplication {

        public static void main(String[] args) {

                SpringApplication app = new SpringApplication(SpringBootSimpleApplication.class);  
                //add more features here.
                        app.run(args);
        }
}

Custom Banner

Every time you run your application, you can see a banner being displayed at the beginning of the application. That banner can be customized in different ways. Listing 3-11 shows how to implement the org.springframework.boot.Banner interface.

Listing 3-11. Version 3 of src/main/java/com/apress/spring/SpringBootSimpleApplication.java

package com.apress.spring;

import java.io.PrintStream;

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;

@SpringBootApplication
public class SpringBootSimpleApplication {

    public static void main(String[] args) {

        SpringApplication app = new SpringApplication(SpringBootSimpleApplication.class);
        app.setBanner(new Banner() {
                @Override
                public void printBanner(Environment environment, Class<?> sourceClass, PrintStream out) {
                        out.print("

	This is my own banner!

".toUpperCase());                        
                }
        });
               app.run(args);
    }
}

When you run the application, you will see something like this:

$ ./mvnw spring-boot:run

        THIS IS MY OWN BANNER!                

INFO[main] c.a.spring.SpringBootSimpleApplication   : Starting SpringBootSimpleApplication on liukang.local with PID 75712 (/Books/pro-spring-boot/spring-boot-simple-java/target/classes started by felipeg in /Books/pro-spring-boot/spring-boot-simple-java)
...
...
INFO[main] c.a.spring.SpringBootSimpleApplication   : Started SpringBootSimpleApplication in 0.789 seconds (JVM running for 4.295)
INFO[Th-1] s.c.a.AnnotationConfigApplicationContext : Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@203f6b5: startup date [Thu Feb 25 19:00:34 MST 2016]; root of context hierarchy
INFO[Th-1] o.s.j.e.a.AnnotationMBeanExporter        : Unregistering JMX-exposed beans on shutdown

You can also create your own ASCII banner and display it. There is a very cool site that creates ASCII art from text ( http://patorjk.com ). See Figure 3-2.

Figure 3-2. http://​patorjk.​com—text to ASCII art generator

Figure 3-2 shows you the http://patorjk.com site. You can click the “Text to ASCII Art Generator” link. Once you are there, add the text “Pro Spring Boot” in the text field (or whatever you want). Then click Test All to see all the different ASCII art. See Figure 3-3.

Figure 3-3. ASCII art

Figure 3-3 shows you all the ASCII art (around 314 different drawings). Select your favorite and click the button Select Text. Copy it (Ctrl+C Windows/Cmd+C Mac) and then create a file named banner.txt in the src/main/resources/ directory. See Figure 3-4.

Figure 3-4. The content of src/main/resource/banner.txt

You can run your application again using this command:

$ ./mvnw spring-boot:run

You will see the ASCII art you added to the banner.txt file. If you run your app using Listing 3-11 (where you are setting the banner), it will override it and use the banner.txt file that is in your classpath. That’s the default.

By default, Spring Boot will look for the banner.txt in the classpath. But you can change its location. Create another banner.txt file (or copy the one you have already) in the src/main/resources/META-INF/ directory. Then you can run the application by passing a -D parameter. Execute the following command:

$ ./mvnw spring-boot:run -Dbanner.location=classpath:/META-INF/banner.txt

This command is using the -D flag to pass the banner.location property that is pointing to the new classpath location: /META-INF/banner.txt. You can declare this property in the src/main/resources/application.properties file, as follows:

banner.location=classpath:/META-INF/banner.txt

And run it like this:

$ ./mvnw spring-boot:run

You have several options for the setting up the banner.txt file. You can remove completely the banner. You can define it in src/main/resources/applications.property like this:

spring.main.banner-mode=off

This command has precedence over the default banner.txt located at the classpath:banner.txt location. You can also do this programmatically. See Listing 3-12.

Listing 3-12. Version 4 of src/main/java/com/apress/spring/SpringBootSimpleApplication.java

package com.apress.spring;

import org.springframework.boot.Banner.Mode;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootSimpleApplication {

        public static void main(String[] args) {
                SpringApplication app = new SpringApplication(SpringBootSimpleApplication.class);
                  app.setBannerMode(Mode.OFF);                
                  app.run(args);
        }
}                                                              

SpringApplicationBuilder

The SpringApplicationBuilder class provides a fluent API and is a builder for the SpringApplication and ApplicationContext instances. It also provides hierarchy support. Everything that I showed you so far (with the SpringApplication) can be set with this builder. This is another way to configure your Spring Boot application. You use the other approach or maybe you are more comfortable with the fluent API where you can have more readable code. See Listing 3-13.

Listing 3-13. Version 5 of src/main/java/com/apress/spring/SpringBootSimpleApplication.java

package com.apress.spring;

import org.springframework.boot.Banner;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;

@SpringBootApplication
public class SpringBootSimpleApplication {

        public static void main(String[] args) {

                new SpringApplicationBuilder()
                .bannerMode(Banner.Mode.OFF)
                .sources(SpringBootSimpleApplication.class)
                .run(args);

        }
}

Listing 3-13 shows you the SpringApplicationBuilder fluent API. Next, let’s consider more examples.

You can have a hierarchy when you’re creating a Spring app (If you want to know more about application context in Spring, I recommend you read the Apress book called “Pro Spring 4^th Edition”) and you can create this with the SpringApplicationBuilder.

new SpringApplicationBuilder(SpringBootSimpleApplication.class)
          .child(MyConfig.class)
          .run(args);

If you have a web configuration, make sure it’s being declared as a child. All the web configuration must depend on a main Spring context, which is why it needs to be declared as a child. Also parent and children must share the same org.springframework.core.Environment interface (this represents the environment in which the current application is running and is related to profiles and properties declarations).

You can log the info at startup or not; by default, this is set to true:

new SpringApplicationBuilder(SpringBootSimpleApplication.class)
        .logStartupInfo(false)
        .run(args);

You can activate profiles:

new SpringApplicationBuilder(SpringBootSimpleApplication.class)
          .profiles("prod","cloud")
          .run(args);

You’ll learn more about profiles later, so you can make sense of the line above.

You can attach listeners for some of the ApplicationEvent events:

Logger log = LoggerFactory.getLogger(SpringBootSimpleApplication.class);
new SpringApplicationBuilder(SpringBootSimpleApplication.class)
          .listeners(new ApplicationListener<ApplicationEvent>() {

                @Override
                 public void onApplicationEvent(ApplicationEvent event) {
                         log.info("#### > " + event.getClass().getCanonicalName());
                 }

          })
          .run(args);

When you run your application, you should see at least the following output:

...
#### > org.springframework.boot.context.event.ApplicationPreparedEvent
...
#### > org.springframework.context.event.ContextRefreshedEvent
#### > org.springframework.boot.context.event.ApplicationReadyEvent
...
#### > org.springframework.context.event.ContextClosedEvent
...

Then your application can add the necessary logic to handle those events. In addition, you can have these events: ApplicationStartedEvent (sent at the start), ApplicationEnvironmentPreparedEvent (sent when the environment is known), ApplicationPreparedEvent (sent after the bean definitions), ApplicationReadyEvent (sent when the application is ready), ApplicationFailedEvent (sent in case of exception during the startup), and the other I showed you in the output (related to the Spring container). All these events can be useful when you want to set up your application (database, check up for some services, etc.) before it runs, or if your application fails during a start (ApplicationFailedEvent), because you’ll probably want to send a notification somewhere.

You can remove any web environment auto-configuration. Remember that Spring Boot will try to guess what kind of app you are running based on the classpath, and for a web app, the algorithm is very simple. Imagine that you are using some libraries that actually can run without a web environment and your app is not a web app; however, Spring Boot tries to configure it as such:

new SpringApplicationBuilder(SpringBootSimpleApplication.class)
        .web(false)
        .run(args);

The previous section showed you how to you use @EnableAutoConfiguration and its parameter exclude, by passing the auto-configuration classes that you don’t want to be checked on. The above code is where you set the web(false) and it’s the same idea as the exclude parameter. As you can see, you have many options for configuring Spring Boot .

Application Arguments

Spring Boot allows you to get the arguments passed to the application. When you have this:

                  SpringApplication.run(SpringBootSimpleApplication.class, args);                              

You can access the args in your beans. See Listing 3-14.

Listing 3-14. Version 10 of src/main/java/com/apress/spring/SpringBootSimpleApplication.java

package com.apress.spring;

import java.io.IOException;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Component;

@SpringBootApplication
public class SpringBootSimpleApplication {

        public static void main(String[] args) throws IOException {
                SpringApplication.run(SpringBootSimpleApplication.class, args);
        }
}

@Component
class MyComponent {

        private static final Logger log = LoggerFactory.getLogger(MyComponent.class);

        @Autowired
        public MyComponent(ApplicationArguments args) {
               boolean enable = args.containsOption("enable");
                if(enable)
                        log.info("## > You are enable!");

                List<String> _args = args.getNonOptionArgs();
                        log.info("## > extra args ...");
                if(!_args.isEmpty())
                        _args.forEach(file -> log.info(file));
         }
}

When you execute args.containsOption("enable"), it will expect the argument as --<arg>, so in Listing 3-14 it will be expecting --enable. The getNonOptionArgs will take other arguments. To test it, you can execute the following command:

$ ./mvnw spring-boot:run -Drun.arguments="--enable"

You should see the text: ## > You are enable. Also you can run it like this :

$ ./mvnw spring-boot:run -Drun.arguments="arg1,arg2"

$ ./mvnw package

$ java -jar target/spring-boot-simple-0.0.1-SNAPSHOT.jar

$ java -jar target/spring-boot-simple-0.0.1-SNAPSHOT.jar --enable arg1 arg2

ApplicationRunner and CommandLineRunner

Spring Boot allows you to execute code before your application starts. Spring Boot has the ApplicationRunner and the CommandLineRunner interfaces that expose the run methods. See Listing 3-15.

Listing 3-15. Version 11 of src/main/java/com/apress/spring/SpringBootSimpleApplication.java

package com.apress.spring;

import java.io.IOException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class SpringBootSimpleApplication implements CommandLineRunner, ApplicationRunner{
        private static final Logger log = LoggerFactory.getLogger(SpringBootSimpleApplication.class);

        public static void main(String[] args) throws IOException {

                SpringApplication.run(SpringBootSimpleApplication.class, args);

        }

        @Bean
        String info(){
                return "Just a simple String bean";
        }

        @Autowired
        String info;

        @Override
        public void run(ApplicationArguments args) throws Exception {              
                log.info("## > ApplicationRunner Implementation...");
                log.info("Accessing the Info bean: " + info);
                args.getNonOptionArgs().forEach(file -> log.info(file));
        }              
        @Override                              
        public void run(String... args) throws Exception {              
                log.info("## > CommandLineRunner Implementation...");
                log.info("Accessing the Info bean: " + info);
                for(String arg:args)
                        log.info(arg);                                                        
        }              
}

Listing 3-15 shows you the CommandLineRunner and ApplicationRunner interfaces and their implementations. CommandLineRunner exposes the public void(String... args) method and ApplicationRunner exposes the public void run(ApplicationArguments args) method. These are practically the same. It’s not necessary to implement both at the same time; if you want to have more control over the arguments, implement the ApplicationRunner interface. You can run Listing 3-15 with the following command:

$ ./mvnw spring-boot:run -Drun.arguments="arg1,arg2"

You should see the the logs for the info bean and the printout of the arguments passed. Listing 3-16 shows another way to use the CommandLineRunner interface.

Listing 3-16. Version 12 of src/main/java/com/apress/spring/SpringBootSimpleApplication.java

package com.apress.spring;

import java.io.IOException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class SpringBootSimpleApplication {      
        private static final Logger log = LoggerFactory.getLogger(SpringBootSimpleApplication.class);

        public static void main(String[] args) throws IOException {

                SpringApplication.run(SpringBootSimpleApplication.class, args);

        }

        @Bean
        String info(){
                return "Just a simple String bean";
        }

        @Autowired
        String info;

        @Bean              
        CommandLineRunner myMethod(){              
                return args -> {              
                        log.info("## > CommandLineRunner Implementation...");              
                        log.info("Accessing the Info bean: " + info);              
                        for(String arg:args)              
                                log.info(arg);              
                };              
        }              
}

Listing 3-16 shows a method that’s annotated with the @Bean annotation returning a CommandLineRunner implementation. This example uses the Java 8 syntax (lambda) to do the return. You can add as many methods that return a CommandLineRunner as you want. If you want to execute these in certain order, you can use the @Order annotation. If you want to run Listing 3-16 just execute the same command as before:

$ ./mvnw spring-boot:run -Drun.arguments="arg1,arg2"

Configuration Properties Examples

Let’s create a simple project that will help you understand the application configuration:

$ spring init -g=com.apres.spring -a=spring-boot-config --package=com.apress.spring -name=spring-boot-config -x

This command will create a simple Maven Java project. Before continuing with the project, you must know that Spring Boot uses an order if you want to override your application configuration properties:

• Command-line arguments

• SPRING_APPLICATION_JSON

• JNDI (java:comp/env)

• System.getProperties()

• OS environment variables

• RandomValuePropertySource (random.*)

• Profile-specific (application-{profile}.jar) outside of the package JAR

• Profile-specific (application-{profile}.jar) inside of the package JAR

• Application properties (application.properties) outside of the package JAR

• Application properties (application.properties) inside of the package JAR

• @PropertySource

• SpringApplication.setDefaultProperties

As you can see, that’s the order for overriding the application properties. I’ll clarify a little on the “outside” and “inside” package JAR. This means that if you have a JAR library dependency that has an application.properties (or YAML file) in it and it’s being used in your application, then your application with its own application.properties file will have precedence over the application.properties that is in the JAR library.

Let’s start with some examples.

package com.apress.spring;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class SpringBootConfigApplication {

        private static Logger log = LoggerFactory.getLogger(SpringBootConfigApplication.class);

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

        @Value("${server.ip}")                
        String serverIp;                

        @Bean
        CommandLineRunner values(){
                return args -> {
                        log.info(" > The Server IP is: " + serverIp);
                };
        }

}

$ ./mvnw spring-boot:run -Dserver.ip=192.168.12.1

$ ./mvnw package -DskipTests=true
$ java -jar target/spring-boot-config-0.0.1-SNAPSHOT.jar --server.ip=192.168.12.1

.   ____          _            __ _ _
 /\ / ___'_ __ _ _(_)_ __  __ _    
( ( )\___ | '_ | '_| | '_ / _` |    
 \/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.3.3.RELEASE)

INFO 97094 -[m] c.a.spring.SpringBootConfigApplication   : Starting SpringBootConfigApplication v0.0.1-SNAPSHOT on liukang.local with PID 97094
INFO 97094 -[m] c.a.spring.SpringBootConfigApplication   : No active profile set, falling back to default profiles: default
INFO 97094 -[m] s.c.a.AnnotationConfigApplicationContext : Refreshing startup date [Sat Feb 27 10:44:24 MST 2016]; root of context hierarchy
INFO 97094 -[m] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
INFO 97094 -[m] c.a.spring.SpringBootConfigApplication   :  > The Server IP is: 192.168.12.1                    
INFO 97094 -[m] c.a.spring.SpringBootConfigApplication   : Started SpringBootConfigApplication in 1.624 seconds (JVM running for 2.255)
INFO 97094 -[t] s.c.a.AnnotationConfigApplicationContext : Closing startup date [Sat Feb 27 10:44:24 MST 2016]; root of context hierarchy
INFO 97094 -[t] o.s.j.e.a.AnnotationMBeanExporter        : Unregistering JMX-exposed beans on shutdown

server.ip=192.168.23.4

$ ./mvnw spring-boot:run

$ ./mvnw package
$ java -jar target/spring-boot-config-0.0.1-SNAPSHOT.jar

$ ./mvnw spring-boot:run -Dspring.application.json='{"server":{"ip":"192.168.145.78"}}'

$ java -jar target/spring-boot-config-0.0.1-SNAPSHOT.jar --spring.application.json='{"server":{"ip":"192.168.145.78"}}'

$ SPRING_APPLICATION_JSON='{"server":{"ip":"192.168.145.78"}}' java -jar target/spring-boot-config-0.0.1-SNAPSHOT.jar

$ SERVER_IP=192.168.150.46 ./mvnw spring-boot:run

$ SERVER_IP=192.168.150.46 java -jar target/spring-boot-config-0.0.1-SNAPSHOT.jar

$./mvnw spring-boot:run -Dspring.config.name=mycfg

$ ./mvnw package -DskipTests=true
$ java -jar target/spring-boot-config-0.0.1-SNAPSHOT.jar --spring.config.name=mycfg

$ SPRING_CONFIG_NAME=mycfg java -jar target/spring-boot-config-0.0.1-SNAPSHOT.jar

$ ./mvnw spring-boot:run -Dspring.config.name=mycfg -Dspring.config.location=file:app/

$ java -jar target/spring-boot-config-0.0.1-SNAPSHOT.jar --spring.config.location=file:app/ --spring.config.name=mycfg

$ mkdir -p src/main/resources/META-INF/conf
$ cp config/mycfg.properties src/main/resources/META-INF/conf/
$ ./mvnw clean spring-boot:run -Dspring.config.name=mycfg -Dspring.config.location=classpath:META-INF/conf/

$ ./mvnw clean spring-boot:run -Dspring.profiles.active=prod

  .   ____          _            __ _ _
 /\ / ___'_ __ _ _(_)_ __  __ _    
( ( )\___ | '_ | '_| | '_ / _` |    
 \/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.3.3.RELEASE)

INFO 2242 -[m] ...ConfigApplication    : Starting SpringBootConfigApplication on liukang.local with PID 2242
INFO 2242 -[m] ...ConfigApplication    : The following profiles are active: prod                
INFO 2242 -[m] ...gApplicationContext    : Refreshing AnnotationConfigApplicationContext@696a03a3y
INFO 2242 -[m] ...BeanExporter         : Registering beans for JMX exposure on startup
INFO 2242 -[m] ...ConfigApplication    : > The Server IP is: http://my-remote.server.com                
INFO 2242 -[m] ...ConfigApplication    : Started SpringBootConfigApplication in 1.586 seconds
INFO 2242 -[ t] ...gApplicationContext : Closing @696a03a3
INFO 2242 -[ t] ...BeanExporter        : Unregistering JMX-exposed beans on shutdown

Custom Properties Prefix

Spring Boot allows you to write and use your own custom property prefix for your properties. The only thing you need to do is annotate with the @ConfigurationProperties annotation a Java class that will have setters and getters as their properties.

If you are using the STS IDE, I recommend including a dependency in your pom.xml. This dependency will create a code insight and it will trigger the editor’s code completion for the properties. So add the next dependency in your pom.xml:

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
</dependency>

This dependency will allow you to process your custom properties and have a code completion. Now, let’s see the example. Modify your src/main/resource/application.properties file to look like Listing 3-19.

Listing 3-19. src/main/resources/application.properties

server.ip=192.168.3.5

myapp.server-ip=192.168.34.56
myapp.name=My Config App
myapp.description=This is an example

Listing 3-19 shows you the application.properties file. What is new is the second block, where the custom properties with myapp as the prefix are defined. Next, open your main app class and edit it to look like Listing 3-20.

Listing 3-20. Version2 of src/main/java/com/apress/spring/SpringBootConfigApplication.java

package com.apress.spring;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@SpringBootApplication                                                
public class SpringBootConfigApplication {

        private static Logger log = LoggerFactory.getLogger(SpringBootConfigApplication.class);

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

        @Value("${myapp.server-ip}")              
        String serverIp;

        @Autowired              
        MyAppProperties props;              

        @Bean
        CommandLineRunner values(){
                return args -> {
                        log.info(" > The Server IP is: " + serverIp);
                        log.info(" > App Name: " + props.getName());
                        log.info(" > App Info: " + props.getDescription());
                };
        }
                                                                                      
        @Component              
        @ConfigurationProperties(prefix="myapp")              
        public static class MyAppProperties {              
                private String name;              
                private String description;              
                private String serverIp;              

                public String getName() {              
                        return name;              
                }              
                public void setName(String name) {              
                        this.name = name;              
                }              
                public String getDescription() {              
                        return description;              
                }              
                public void setDescription(String description) {              
                        this.description = description;              
                }              
                public String getServerIp() {              
                        return serverIp;              
                }              
                public void setServerIp(String serverIp) {              
                        this.serverIp = serverIp;              
                }              
        }              

}

Listing 3-20 shows you the main app class. Let’s examine it:

• @Value("${myapp.server-ip}"). The annotation now has a myapp.server-ip, which means that the value will be equal to 192.168.34.56.

• @Autowired MyAppProperties props. This is creating an instance of the MyAppProperties type.

• @Component @ConfigurationProperties(prefix="myapp"). The @ConfigurationProperties annotation tells Spring Boot that the class will be used for all the properties defined in the application.properties file that has the myapp prefix. Meaning that it will recognized when you have myapp.serverIp (or myapp.server-ip), myapp.name, and myapp.description. The @Component annotation is used to make sure that the class is picked up as a bean.

The Spring Boot uses relaxed rules to bind environment properties to the @ConfigurationProperties beans, so you don’t have any collision names.

Now if you run your app, you should see all your myapp properties:

$ ./mvnw clean spring-boot:run
...
> The Server IP is: 192.168.34.56
> App Name: My Config App
> App Info: This is an example
...

As you can see, you have plenty of options for using your application configuration properties. You haven’t seen any YAML examples though, and if you want to use the YAML syntax, refer to the Spring Boot documentation for examples.