Configure a Spring Boot Web Application

2. The Port Number

In main standalone applications, the main HTTP port defaults to 8080; we can easily configure Boot to use a different port:

1
server.port=8083

And for, YAML-based configuration:

1
2
server:
     port: 8083

We can also programmatically customize the server port:

1
2
3
4
5
6
7
8
9
public class CustomizationBean implements
   WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
  
     @Override
     public void customize(ConfigurableServletWebServerFactory container) {
         container.setPort( 8083 );
     }
}

3. The Context Path

By default, the context path is “/”. If that"s not ideal and you need to change it – to something like /app_name, here"s the quick and simple way to do it via properties:

1
server.servlet.contextPath=/springbootapp

And for YAML-based configuration:

1
2
3
server:
     servlet:
         contextPath:/springbootapp

Finally – the change can be done programmatically as well:

1
2
3
4
5
6
7
8
9
public class CustomizationBean
   implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
  
     @Override
     public void customize(ConfigurableServletWebServerFactorycontainer) {
         container.setContextPath( "/springbootapp" );
     }
}

4. The White Label Error Page

Spring Boot automatically registers a BasicErrorController bean if you don"t specify any custom implementation in the configuration.

However, this default controller can, of course, be configured:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MyCustomErrorController implements ErrorController {
  
     private static final String PATH = "/error" ;
     
     @GetMapping (value=PATH)
     public String error() {
         return "Error haven" ;
     }
 
     @Override
     public String getErrorPath() {
         return PATH;
     }
}

5. Customize The Error Messages

Boot provides /error mappings by default to handle errors in a sensible way.

If you want to configure more specific error pages, there"s good support for a uniform Java DSL to customize error handling:

1
2
3
4
5
6
7
8
9
10
@Component
public class CustomizationBean
   implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
  
     @Override
     public void customize(ConfigurableServletWebServerFactorycontainer) {       
         container.addErrorPages( new ErrorPage(HttpStatus.BAD_REQUEST, "/400" ));
         container.addErrorPages( new ErrorPage( "/errorHaven" ));
     }
}

Here, we specifically handled Bad Request to match the /400 path and all others to match the common path.

And a very simple /errorHaven implementation:

1
2
3
4
@GetMapping ( "/errorHaven" )
String errorHeaven() {
     return "You have reached the haven of errors!!!" ;
}

Output:

1
You have reached the haven of errors!!!

6. Shut Down A Boot Application Programmatically

You can programmatically shut down a Boot app with the help of SpringApplication. This has a static exit() method that takes two arguments: the ApplicationContext and an ExitCodeGenerator:

1
2
3
4
@Autowired
public void shutDown(ExecutorServiceExitCodeGenerator exitCodeGenerator) {
     SpringApplication.exit(applicationContext, exitCodeGenerator);
}

It"s through this utility method that we can shut down the app.

7. Configure the Logging Levels

You can easily tune the logging levels in a Boot application; Starting with version 1.2.0 onwards, you can configure the log level in the main properties file:

1
2
logging.level.org.springframework.web: DEBUG
logging.level.org.hibernate: ERROR

And just as with a standard Spring app – you can activate different logging systems like Logback, log4j, log4j2, etc by adding their customized XML or properties file in the classpath and defining the libraries in the pom.

8. Register a New Servlet

If you"re deploying the application with the help of the embedded server, you can register new Servlets in a Boot application by exposing them as beans from conventional config:

1
2
3
4
@Bean
public HelloWorldServlet helloWorld() {
     return new HelloWorldServlet();
}

Alternatively, you can use a ServletRegistrationBean:

1
2
3
4
5
6
7
8
9
@Bean
public SpringHelloServletRegistrationBean servletRegistrationBean() {
  
     SpringHelloServletRegistrationBean bean = new SpringHelloServletRegistrationBean(
       new SpringHelloWorldServlet(), "/springHelloWorld/*" );
     bean.setLoadOnStartup( 1 );
     bean.addInitParameter( "message" , "SpringHelloWorldServlet special message" );
     return bean;
}

9. Configure Jetty or Undertow in Boot Application

The Spring Boot starters generally use Tomcat as the default embedded server. If that needs to be changed – you can exclude the Tomcat dependency and include Jetty or Undertow instead:

Configuring Jetty

1
2
3
4
5
6
7
8
9
10
11
12
13
14
< dependency >
     < groupId >org.springframework.boot</ groupId >
     < artifactId >spring-boot-starter-web</ artifactId >
     < exclusions >
         < exclusion >
             < groupId >org.springframework.boot</ groupId >
             < artifactId >spring-boot-starter-tomcat</ artifactId >
         </ exclusion >
     </ exclusions >
</ dependency >
< dependency >
     < groupId >org.springframework.boot</ groupId >
     < artifactId >spring-boot-starter-jetty</ artifactId >
</ dependency >
1
2
3
4
5
6
7
8
9
@Bean
public JettyEmbeddedServletContainerFactory  jettyEmbeddedServletContainerFactory() {
     JettyEmbeddedServletContainerFactory jettyContainer =
       new JettyEmbeddedServletContainerFactory();
     
     jettyContainer.setPort( 9000 );
     jettyContainer.setContextPath( "/springbootapp" );
     return jettyContainer;
}

Configuring Undertow

1
2
3
4
5
6
7
8
9
10
11
12
13
14
< dependency >
     < groupId >org.springframework.boot</ groupId >
     < artifactId >spring-boot-starter-web</ artifactId >
     < exclusions >
         < exclusion >
             < groupId >org.springframework.boot</ groupId >
             < artifactId >spring-boot-starter-tomcat</ artifactId >
         </ exclusion >
     </ exclusions >
</ dependency >
< dependency >
     < groupId >org.springframework.boot</ groupId >
     < artifactId >spring-boot-starter-undertow</ artifactId >
</ dependency >
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Bean
public UndertowEmbeddedServletContainerFactory embeddedServletContainerFactory() {
     UndertowEmbeddedServletContainerFactory factory =
       new UndertowEmbeddedServletContainerFactory();
     
     factory.addBuilderCustomizers( new UndertowBuilderCustomizer() {
         @Override
         public void customize(io.undertow.Undertow.Builder builder) {
             builder.addHttpListener( 8080 , "0.0.0.0" );
         }
     });
     
     return factory;
}

10. Conclusion

In this quick article, we went over some of the more interesting and useful Spring Boot configuration options.

There are of course many, many more options to configure and tune a Boot app to your needs in the reference docs – these are just some of the more useful I found.