In the Spring-Boot documentation, there is a section that describe how to enable multiple connectors for tomcat (http://docs.spring.io/spring-boot/docs/1.1.7.RELEASE/reference/htmlsingle/#howto-enable-multiple-connectors-in-tomcat).
But is there a way to simply add connectors to the existing one (the web and the management connectors)? And to bind them to some mvc controllers? What I want to do is to create some web services that are accessible on a different ports.
You could use a child application for each service, with each child configured to use a separate port by setting its server.port property. Any components that you want to be isolated should go in one of the children. Any components that you want to share should go in the parent.
Here's an example of this approach. There are two child applications, one listening on port 8080 and one listening on port 8081. Each contains a controller which is mapped to /one and /two respectively.
package com.example;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
public class Application {
public static void main(String[] args) {
SpringApplicationBuilder parentBuilder
= new SpringApplicationBuilder(ApplicationConfiguration.class);
parentBuilder.child(ServiceOneConfiguration.class)
.properties("server.port:8080").run(args);
parentBuilder.child(ServiceTwoConfiguration.class)
.properties("server.port:8081").run(args);
}
@Configuration
static class ApplicationConfiguration {
@Bean
public MySharedService sharedService() {
return new MySharedService();
}
}
@Configuration
@EnableAutoConfiguration
static class ServiceOneConfiguration {
@Bean
public ControllerOne controller(MySharedService service) {
return new ControllerOne(service);
}
}
@Configuration
@EnableAutoConfiguration
static class ServiceTwoConfiguration {
@Bean
public ControllerTwo controller(MySharedService service) {
return new ControllerTwo(service);
}
}
@RequestMapping("/one")
static class ControllerOne {
private final MySharedService service;
public ControllerOne(MySharedService service) {
this.service = service;
}
@RequestMapping
@ResponseBody
public String getMessage() {
return "ControllerOne says \"" + this.service.getMessage() + "\"";
}
}
@RequestMapping("/two")
static class ControllerTwo {
private final MySharedService service;
public ControllerTwo(MySharedService service) {
this.service = service;
}
@RequestMapping
@ResponseBody
public String getMessage() {
return "ControllerTwo says \"" + this.service.getMessage() + "\"";
}
}
static class MySharedService {
public String getMessage() {
return "Hello";
}
}
}
server.port, management.port and management.context-path properties (the last two to access Actuator endpoints) could be set to make the embedded container to listen on different ports.
In case it would be desirable to listen on ports other than server.port and management.port:
@Configuration
public class EmbeddedTomcatConfiguration {
@Value("${server.additionalPorts}")
private String additionalPorts;
@Bean
public EmbeddedServletContainerFactory servletContainer() {
TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory();
Connector[] additionalConnectors = this.additionalConnector();
if (additionalConnectors != null && additionalConnectors.length > 0) {
tomcat.addAdditionalTomcatConnectors(additionalConnectors);
}
return tomcat;
}
private Connector[] additionalConnector() {
if (StringUtils.isBlank(this.additionalPorts)) {
return null;
}
String[] ports = this.additionalPorts.split(",");
List<Connector> result = new ArrayList<>();
for (String port : ports) {
Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
connector.setScheme("http");
connector.setPort(Integer.valueOf(port));
result.add(connector);
}
return result.toArray(new Connector[] {});
}
}
application.yml
server:
port: ${appPort:8800}
additionalPorts: 8881,8882
Application.java
@SpringBootApplication
@ComponentScan(...)
@Import(EmbeddedTomcatConfiguration.class)
public Application {
public static void main(String[] args) {
SpringApplication.run(Application .class, args);
}
}
In http://tech.asimio.net/2016/12/15/Configuring-Tomcat-to-Listen-on-Multiple-ports-using-Spring-Boot.html I covered how to make Embedded Tomcat to listen on a different port and configured JavaMelody to exclusively access it through that new port.
