Spring Boot - jak uruchomić Port

Czy możliwy jest również dostęp do portu zarządzania w podobny sposób, np.:

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

    @LocalServerPort
    int randomServerPort;

    @LocalManagementPort
    int randomManagementPort;

Środowisko wiosny przechowuje te informacje dla Ciebie.

@Autowired
Environment environment;

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

Na powierzchni wygląda to identycznie jak wstrzykiwanie pola z adnotacją @Value("${local.server.port}") (lub @LocalServerPort, które jest identyczne), podczas którego błąd automatycznego wiązania jest wyrzucany przy starcie, ponieważ wartość nie jest dostępna, dopóki kontekst nie zostanie w pełni zainicjowany. Różnica polega na tym, że to wywołanie jest domyślnie wykonywane w uruchomionej logice biznesowej, a nie wywoływane podczas uruchamiania aplikacji, a zatem' Lazy-fetch ' portu rozwiązuje problem ok.

Port, który jest używany przez osadzoną instancję Tomcat podczas testów, można uzyskać poprzez wstrzyknięcie lokalnego.serwer.wartość portu jako taka:

// Inject which port we were assigned
@Value("${local.server.port}")
int port;

Po prostu, aby inni, którzy skonfigurowali swoje aplikacje, takie jak moje, skorzystali z tego, przez co przeszedłem...

Żadne z powyższych rozwiązań nie zadziałało na mnie, ponieważ mam katalog ./config tuż pod bazą projektu z 2 plikami:

application.properties
application-dev.properties

W application.properties mam:

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

W application-dev.properties mam:

server_host = localhost
server_port = 8080

To jest tak, kiedy uruchamiam mój fat jar z CLI pliki {[8] } będą odczytywane z katalogu ./config i wszystko jest dobrze.

Cóż, okazuje się, że te pliki właściwości całkowicie nadpisują ustawienie {[10] } w @SpringBootTest W moich specyfikacjach Spocka. Bez względu na to, co próbowałem, nawet z webEnvironment ustawionym na RANDOM_PORT Spring zawsze uruchamiał osadzony kontener Tomcat na porcie 8080 (lub jakąkolwiek wartość ustawiłem w plikach ./config/*.properties).

Jedynym sposobem, w jaki udało mi się to przezwyciężyć, było dodanie wyraźnego properties = "server_port=0" do adnotacji @SpringBootTest W moich specyfikacjach integracji Spocka:

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

Wtedy, i tylko wtedy Wiosna w końcu zaczęła kręcić Tomcat na przypadkowym porcie. IMHO to jest błąd Spring testing framework, ale jestem pewien, że będą mieli własne zdanie na ten temat.

Począwszy od Spring Boot 1.4.0 możesz użyć tego w swoim teście:

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

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

  @LocalServerPort
  int randomPort;

  // ...
}

Żadne z tych rozwiązań nie zadziałało. Podczas konstruowania konfiguracji Swaggera musiałem znać port serwera. Używanie ServerProperties zadziałało dla mnie:

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         
    }
}

Ten przykład wykorzystuje Spring Boot auto configuration i JAX-RS (nie Spring MVC).

Po Spring Boot 2 wiele się zmieniło. Powyższe odpowiedzi działają przed Spring Boot 2. Teraz, jeśli uruchomisz swoją aplikację z argumentami runtime dla portu serwera, wtedy otrzymasz tylko wartość statyczną z @Value("${server.port}"), o której mowa w aplikacji .właściwości pliku. Teraz, aby uzyskać rzeczywisty port, w którym działa serwer, użyj następującej metody:

    @Autowired
    private ServletWebServerApplicationContext server;

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

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

Również, jeśli używasz aplikacji jako klientów Eureka / Discovery z obciążeniem zrównoważonym RestTemplate lub WebClient, powyższa metoda zwróci dokładny numer portu.

Możesz pobrać port serwera z

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();
}
    

Upewnij się, że zaimportowałeś poprawny pakiet

import org.springframework.core.env.Environment;

A następnie użyj obiektu 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"));
    }

/ Align = "left" / Klient zostanie zainicjalizowany, gdy jest to potrzebne, wtedy port powinien być dostępny:

@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;
    }
}