ConfigureaSpringBootWebApplication
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
@Component
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
@Component
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.
以上是 ConfigureaSpringBootWebApplication 的全部内容， 来源链接： utcz.com/z/513027.html
