Spring Boot auto-configuration provides automatic configuration to your Spring application based on the modules and associated library dependencies of those modules that you have added. For instance, if you have added the embedded in-memory database H2 in your classpath, you are not required to manually configure any bean related to the database such as DataSource, JdbcTemplate, and so on. Spring Boot provides your H2 database with auto-configuration after adding dependency on the H2 database in your application's classpath.

Spring Boot provides the magic of autoconfiguration by extensive use of pre-written @Configuration classes for each module of Spring Framework. But these auto-configurations are activated based on:

• The contents of the classpath of your Spring application
• Properties you have set in the application
• Beans already defined...

Spring Boot offers you full control over auto-configuration. You can control what Spring Boot does. There are several options for customizing Spring Boot configuration. They are as follows:

• You can customize by setting some of Spring Boot's properties in the properties or YAML files
• Also, you can define certain beans yourself so Spring Boot won't use the default
• You can disable some autoconfiguration explicitly
• Change dependencies

Let's see these four points in detail, and how to use them to customize Spring Boot auto-configuration in your Spring application.

Spring Boot allows you to customize your application configurations and you can use...

Spring Boot offers you more than 1,000 properties for fine-tuning. Spring Boot documentation (https://docs.spring.io/spring-boot/docs/2.0.2.RELEASE/reference/htmlsingle/#common-application-properties) gives an exhaustive list of these properties. You can use these properties to adjust the settings of your Spring application. You can specify these properties via environment variables, Java system properties, JNDI, command line arguments, or property files. But Spring Boot has an order of overriding these properties in case you define same properties on all of them. Let's see the order of evaluation of the properties in the next section.

Spring Boot allows you to create your own customized configuration of application properties with beans. You can register these beans as properties with Spring Boot by using the @ConfigurationProperties annotation, and after this, you can set these properties by using either the application.properties or application.yml file.

Spring Boot provides alternative ways of working with properties that allow you to strongly type safe beans and validate the configuration of your application. Let's see the use of the @ConfigurationProperties annotation for a dedicated container bean:

• This @ConfigurationProperties annotation will hold the externalized properties
• It avoids repeating the prefix
• Data members automatically set from corresponding properties

Let's see the following example:

 @Component 
@ConfigurationProperties(prefix=...

Logging is very important in each application to debug and analyze the application's bugs during runtime. If you are working with the old-fashioned Spring Framework, then you have to configure the logging framework explicitly in your application. But Spring Boot provides support for several logging frameworks and also allows you to customize and fine-tune logging in to your Spring application. Spring Boot includes, by default:

• SLF4J: Logging facade
• Logback: SLF4J implementation

But as a best practice, stick to default logging in your application and use the SLF4J abstraction in the application code. Spring Boot also supports other logging frameworks such as Java Util Logging, Log4J, and Log4J2. You can use another logging frameworks by just adding a dependency, as follows:

<dependency> 
   <groupId>org.springframework.boot</groupId...

In a Spring Boot application, the SpringApplication class automatically supports YAML as an alternative to properties. YAML isn't a markup language. It is an alternative to .properties files and it allows you to define properties in the hierarchical configuration. The Java parser for YAML is called SnakeYAML. It must be in the classpath, but it is automatically added to the classpath by spring-boot-starters.

Spring Boot supports YAML for properties as an alternative to properties files. YAML is convenient for hierarchical configuration data. Spring Boot properties are organized in groups, for example, server, database, and so on.

Let's see the following properties...

Every application has a chance of encountering an error, even if it is an extremely robust application. So, designing custom error pages is important for any enterprise application. Spring Boot applications provide a default error page. You can see one in the following screenshot:

But if you want to use a custom error page for a given status code, you can add a file to the /error folder. You can create a custom error page by using static HTML, FreeMarker, Velocity, Thymeleaf, JSP, and so on. The name of the file should be the exact status code or a series mask.

Let's see the following image to map 404 to a static HTML file; your folder structure would be as follows:

As you can see, I have added a custom 404 error page (static error page 404.html) under the /resource/public/error directory; see the following output from the error page...