116

我有一个 spring boot 应用程序（使用嵌入式 tomcat 7），我已经设置server.port = 0了我的application.properties所以我可以有一个随机端口。服务器启动并在端口上运行后，我需要能够获取所选的端口。

我不能使用@Value("$server.port")，因为它是零。这是一条看似简单的信息，为什么我不能从我的 java 代码中访问它呢？我怎样才能访问它？

4

12 回答 12

109

是否也可以通过类似的方式访问管理端口，例如：

  @SpringBootTest(classes = {Application.class}, webEnvironment = WebEnvironment.RANDOM_PORT)
  public class MyTest {

    @LocalServerPort
    int randomServerPort;

    @LocalManagementPort
    int randomManagementPort;
于 2016-08-11T11:15:55.743 回答
89

Spring 的 Environment 为您保存这些信息。

@Autowired
Environment environment;

String port = environment.getProperty("local.server.port");

从表面上看，这看起来与注入带注释的字段@Value("${local.server.port}")（或@LocalServerPort相同）相同，因此在启动时会引发自动装配失败，因为在上下文完全初始化之前该值不可用。此处的不同之处在于，此调用是在运行时业务逻辑中隐式进行的，而不是在应用程序启动时调用，因此端口的“延迟获取”可以解决。

于 2016-04-03T21:02:24.180 回答
26

感谢@Dirk Lachowski 为我指明了正确的方向。该解决方案并不像我希望的那样优雅，但我得到了它的工作。阅读 spring 文档，我可以监听 EmbeddedServletContainerInitializedEvent 并在服务器启动并运行后获取端口。这是它的样子 -

import org.springframework.boot.context.embedded.EmbeddedServletContainerInitializedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;




    @Component
    public class MyListener implements ApplicationListener<EmbeddedServletContainerInitializedEvent> {

      @Override
      public void onApplicationEvent(final EmbeddedServletContainerInitializedEvent event) {
          int thePort = event.getEmbeddedServletContainer().getPort();
      }
    }
于 2015-05-18T21:20:44.150 回答
17

您可以通过注入 local.server.port 值来获取嵌入式 Tomcat 实例在测试期间使用的端口，如下所示：

// Inject which port we were assigned
@Value("${local.server.port}")
int port;
于 2015-07-06T20:12:51.580 回答
17

就像其他像我一样配置了他们的应用程序的人从我所经历的事情中受益......

上述解决方案都不适合我，因为我的./config项目库下有一个目录，其中包含 2 个文件：

application.properties
application-dev.properties

在application.properties我有：

spring.profiles.active = dev  # set my default profile to 'dev'

在application-dev.properties我有：

server_host = localhost
server_port = 8080

所以当我从 CLI 运行我的 fat jar 时，*.properties文件将从./config目录中读取，一切都很好。

好吧，事实证明这些属性文件完全覆盖了我的 Spock 规范中的webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT设置 。@SpringBootTest无论我尝试什么，即使webEnvironment设置为RANDOM_PORTSpring 总是会在端口 8080（或我在./config/*.properties文件中设置的任何值）上启动嵌入式 Tomcat 容器。

我能够克服这个问题的唯一properties = "server_port=0"方法是在我的 Spock 集成规范中添加一个显式的@SpringBootTest注释：

@SpringBootTest (webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, properties = "server_port=0")

然后，直到那时，Spring 才终于开始在一个随机端口上启动 Tomcat。恕我直言，这是一个 Spring 测试框架错误，但我相信他们对此会有自己的看法。

希望这对某人有所帮助。

于 2017-05-03T00:36:50.203 回答
12

从 Spring Boot 1.4.0 开始，您可以在测试中使用它：

import org.springframework.boot.context.embedded.LocalServerPort;

@SpringBootTest(classes = {Application.class}, webEnvironment = WebEnvironment.RANDOM_PORT)
public class MyTest {

  @LocalServerPort
  int randomPort;

  // ...
}
于 2016-08-05T21:17:48.683 回答
7

这些解决方案都不适合我。在构建 Swagger 配置 bean 时，我需要知道服务器端口。使用ServerProperties对我有用：

import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.ws.rs.ApplicationPath;

import io.swagger.jaxrs.config.BeanConfig;
import io.swagger.jaxrs.listing.ApiListingResource;
import io.swagger.jaxrs.listing.SwaggerSerializers;

import org.glassfish.jersey.server.ResourceConfig;
import org.springframework.stereotype.Component;

@Component
@ApplicationPath("api")
public class JerseyConfig extends ResourceConfig 
{
    @Inject
    private org.springframework.boot.autoconfigure.web.ServerProperties serverProperties;

    public JerseyConfig() 
    {
        property(org.glassfish.jersey.server.ServerProperties.BV_SEND_ERROR_IN_RESPONSE, true);
    }

    @PostConstruct
    protected void postConstruct()
    {
        // register application endpoints
        registerAndConfigureSwaggerUi();
    }

    private void registerAndConfigureSwaggerUi()
    {
        register(ApiListingResource.class);
        register(SwaggerSerializers.class);

        final BeanConfig config = new BeanConfig();
        // set other properties
        config.setHost("localhost:" + serverProperties.getPort()); // gets server.port from application.properties file         
    }
}

此示例使用 Spring Boot 自动配置和 JAX-RS（不是 Spring MVC）。

于 2016-04-06T20:35:40.840 回答
6

在 Spring Boot 2 之后，发生了很多变化。上面给出的答案在 Spring Boot 2 之前有效。现在，如果您使用服务器端口的运行时参数运行应用程序，那么您将只能获得application.properties文件@Value("${server.port}")中提到的静态值。现在要获取服务器运行的实际端口，请使用以下方法：

    @Autowired
    private ServletWebServerApplicationContext server;

    @GetMapping("/server-port")
    public String serverPort() {

        return "" + server.getWebServer().getPort();
    }

此外，如果您将您的应用程序用作负载平衡RestTemplate或的 Eureka/Discovery 客户端WebClient，则上述方法将返回确切的端口号。

于 2020-08-19T12:30:03.413 回答
0

您可以从

HttpServletRequest

@Autowired
private HttpServletRequest request;

@GetMapping(value = "/port")
public Object getServerPort() {
   System.out.println("I am from " + request.getServerPort());
   return "I am from  " + request.getServerPort();
}
于 2020-10-15T17:39:44.450 回答
0

我在 Spring 2.5.5 并使用 Junit 4.13.2，这是我的解决方案：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.test.context.junit4.SpringRunner;

// tell Java the environment your testcase running is in Spring, 
// which will enable the auto configuration such as value injection
@RunWith(SpringRunner.class)
@SpringBootTest(
    class = Application.class, 
    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class SimpleWebTest {

    @LocalServerPort
    private int randomPort;

    @Test
    public void test() {
        // use randomPort ...
        System.out.println(randomPort);
    }

}
于 2021-10-16T13:14:46.067 回答
-1

我用一种代理bean解决了它。客户端在需要时被初始化，到那时端口应该可用：

@Component
public class GraphQLClient {

    private ApolloClient apolloClient;
    private final Environment environment;

    public GraphQLClient(Environment environment) {
        this.environment = environment;
    }

    public ApolloClient getApolloClient() {
        if (apolloClient == null) {
            String port = environment.getProperty("local.server.port");
            initApolloClient(port);
        }
        return apolloClient;
    }

    public synchronized void initApolloClient(String port) {
        this.apolloClient = ApolloClient.builder()
                .serverUrl("http://localhost:" + port + "/graphql")
                .build();
    }

    public <D extends Operation.Data, T, V extends Operation.Variables> GraphQLCallback<T> graphql(Operation<D, T, V> operation) {
        GraphQLCallback<T> graphQLCallback = new GraphQLCallback<>();
        if (operation instanceof Query) {
            Query<D, T, V> query = (Query<D, T, V>) operation;
            getApolloClient()
                    .query(query)
                    .enqueue(graphQLCallback);
        } else {
            Mutation<D, T, V> mutation = (Mutation<D, T, V>) operation;
            getApolloClient()
                    .mutate(mutation)
                    .enqueue(graphQLCallback);

        }
        return graphQLCallback;
    }
}
于 2020-10-25T18:37:11.400 回答
-1

请确保您已导入正确的包

import org.springframework.core.env.Environment;

然后使用 Environment 对象

@Autowired
private Environment env;    // Environment Object containts the port number

 @GetMapping("/status")
  public String status()
    {
   return "it is runing on"+(env.getProperty("local.server.port"));
    }
于 2020-01-21T21:13:19.863 回答