org.springframework.boot.autoconfigure.web.ServerProperties Java Examples

public H2DbProperties(
        @Autowired(required = false) ConfigurableEnvironment environment,
        @Autowired(required = false) ServerProperties serverProperties) {
    String applicationName = "application";
    Integer port = 0;
    if (Objects.nonNull(environment)) {
        applicationName = environment.getProperty("spring.application.name");
    }
    if (Objects.nonNull(serverProperties)) {
        port = serverProperties.getPort();
    }
    this.filePath = System.getProperty("user.dir") +
            File.separator +
            ".txlcn" +
            File.separator +
            (StringUtils.hasText(applicationName) ? applicationName : "application") +
            "-" + port;
}
 

public RequestForwarder(
        ServerProperties serverProperties,
        FaradayProperties faradayProperties,
        HttpClientProvider httpClientProvider,
        MappingsProvider mappingsProvider,
        LoadBalancer loadBalancer,
        Optional<MeterRegistry> meterRegistry,
        ProxyingTraceInterceptor traceInterceptor,
        PostForwardResponseInterceptor postForwardResponseInterceptor
) {
    this.serverProperties = serverProperties;
    this.faradayProperties = faradayProperties;
    this.httpClientProvider = httpClientProvider;
    this.mappingsProvider = mappingsProvider;
    this.loadBalancer = loadBalancer;
    this.meterRegistry = meterRegistry;
    this.traceInterceptor = traceInterceptor;
    this.postForwardResponseInterceptor = postForwardResponseInterceptor;
}
 

@Test
public void testShouldReturnEndpointsWithoutContextPath() {
  WebEndpointProperties webEndpointProperties = new WebEndpointProperties();
  ServerProperties properties = new ServerProperties();
  properties.getServlet().setContextPath("foo");

  EndpointsSupplier<ExposableWebEndpoint> endpointsSupplier = () -> {
    ExposableWebEndpoint infoEndpoint = createEndpoint("info");
    ExposableWebEndpoint healthEndpoint = createEndpoint("health");

    return Arrays.asList(infoEndpoint, healthEndpoint);
  };

  Optional<Pattern> pattern = new SkipPatternAutoConfiguration.ActuatorSkipPatternProviderConfig()
      .skipPatternForActuatorEndpointsSamePort(webEndpointProperties, endpointsSupplier)
      .pattern();

  then(pattern).isNotEmpty();
  then(pattern.get().pattern())
      .isEqualTo("/actuator/(info|info/.*|health|health/.*)");
}
 

@Autowired
public LightminClientProperties(final ManagementServerProperties managementServerProperties,
                                final ServerProperties serverProperties,
                                @Value("${spring.batch.lightmin.application-name:null}") final String name,
                                @Value("${endpoints.health.id:health}") final String healthEndpointId,
                                final WebEndpointProperties webEndpointProperties,
                                final Environment environment) {
    if (name == null || "null".equals(name)) {
        this.name = environment.getProperty("spring.application.name", "spring-boot-application");
    } else {
        this.name = name;
    }
    this.healthEndpointId = healthEndpointId;
    this.managementServerProperties = managementServerProperties;
    this.serverProperties = serverProperties;
    this.webEndpointProperties = webEndpointProperties;
}
 

@SuppressWarnings("ConstantConditions")
public BackstopperSpringboot2ContainerErrorController(
    @NotNull ProjectApiErrors projectApiErrors,
    @NotNull UnhandledServletContainerErrorHelper unhandledServletContainerErrorHelper,
    @NotNull ServerProperties serverProperties
) {
    if (projectApiErrors == null) {
        throw new NullPointerException("ProjectApiErrors cannot be null.");
    }

    if (unhandledServletContainerErrorHelper == null) {
        throw new NullPointerException("UnhandledServletContainerErrorHelper cannot be null.");
    }

    if (serverProperties == null) {
        throw new NullPointerException("ServerProperties cannot be null.");
    }

    this.projectApiErrors = projectApiErrors;
    this.unhandledServletContainerErrorHelper = unhandledServletContainerErrorHelper;
    this.errorPath = serverProperties.getError().getPath();
}
 

@Bean
@Lazy(false)
@ConditionalOnMissingBean
public ApplicationFactory applicationFactory(InstanceProperties instance, ManagementServerProperties management,
		ServerProperties server, ServletContext servletContext, PathMappedEndpoints pathMappedEndpoints,
		WebEndpointProperties webEndpoint, ObjectProvider<List<MetadataContributor>> metadataContributors,
		DispatcherServletPath dispatcherServletPath) {
	return new ServletApplicationFactory(instance, management, server, servletContext, pathMappedEndpoints,
			webEndpoint,
			new CompositeMetadataContributor(metadataContributors.getIfAvailable(Collections::emptyList)),
			dispatcherServletPath);
}
 

public MappingsProvider(
        ServerProperties serverProperties,
        FaradayProperties faradayProperties,
        MappingsValidator mappingsValidator,
        HttpClientProvider httpClientProvider
) {
    this.serverProperties = serverProperties;
    this.faradayProperties = faradayProperties;
    this.mappingsValidator = mappingsValidator;
    this.httpClientProvider = httpClientProvider;
}
 

DefaultEndpointLocator(Registration registration, ServerProperties serverProperties,
		Environment environment, ZipkinProperties zipkinProperties,
		InetUtils inetUtils) {
	this.registration = registration;
	this.serverProperties = serverProperties;
	this.environment = environment;
	this.zipkinProperties = zipkinProperties;
	this.firstNonLoopbackAddress = findFirstNonLoopbackAddress(inetUtils);
}
 

@Test
public void portDefaultsTo8080() throws UnknownHostException {
	DefaultEndpointLocator locator = new DefaultEndpointLocator(null,
			new ServerProperties(), this.environment, new ZipkinProperties(),
			localAddress(ADDRESS1234));

	assertThat(locator.local().port()).isEqualTo(8080);
}
 

@Test
public void portDefaultsToLocalhost() throws UnknownHostException {
	DefaultEndpointLocator locator = new DefaultEndpointLocator(null,
			new ServerProperties(), this.environment, new ZipkinProperties(),
			localAddress(ADDRESS1234));

	assertThat(locator.local().ipv4()).isEqualTo("1.2.3.4");
}
 

public DefaultErrorController(ErrorAttributes errorAttributes, ServerProperties properties) {
    super(errorAttributes == null ? new DefaultErrorAttributes() : errorAttributes);
    if (properties == null) {
        errorProperties = new ErrorProperties();
        errorProperties.setPath("/error");
    } else {
        this.errorProperties = properties.getError();
    }
}
 

public FwGatewayErrorConfigure(ServerProperties serverProperties,
                                 ResourceProperties resourceProperties,
                                 ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                 ServerCodecConfigurer serverCodecConfigurer,
                                 ApplicationContext applicationContext) {
    this.serverProperties = serverProperties;
    this.applicationContext = applicationContext;
    this.resourceProperties = resourceProperties;
    this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
    this.serverCodecConfigurer = serverCodecConfigurer;
}
 

/**
 * 路由加载器
 *
 * @return
 */
@Bean
public JdbcRouteLocator jdbcRouteLocator(ZuulProperties zuulProperties, ServerProperties serverProperties, JdbcTemplate jdbcTemplate, ApplicationEventPublisher publisher) {
    jdbcRouteLocator = new JdbcRouteLocator(serverProperties.getServlet().getContextPath(), zuulProperties, jdbcTemplate, publisher);
    log.info("JdbcRouteLocator:{}", jdbcRouteLocator);
    return jdbcRouteLocator;
}
 

public ErrorHandlerConfiguration(ServerProperties serverProperties,
								 ResourceProperties resourceProperties,
								 ObjectProvider<List<ViewResolver>> viewResolversProvider,
								 ServerCodecConfigurer serverCodecConfigurer,
								 ApplicationContext applicationContext) {
	this.serverProperties = serverProperties;
	this.applicationContext = applicationContext;
	this.resourceProperties = resourceProperties;
	this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
	this.serverCodecConfigurer = serverCodecConfigurer;
}
 

public CustomErrorWebFluxAutoConfiguration(ServerProperties serverProperties,
                                           ResourceProperties resourceProperties,
                                           ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                           ServerCodecConfigurer serverCodecConfigurer,
                                           ApplicationContext applicationContext) {
    this.serverProperties = serverProperties;
    this.applicationContext = applicationContext;
    this.resourceProperties = resourceProperties;
    this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
    this.serverCodecConfigurer = serverCodecConfigurer;
}
 

public ErrorHandlerConfig(ServerProperties serverProperties,
                                 ResourceProperties resourceProperties,
                                 ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                 ServerCodecConfigurer serverCodecConfigurer,
                                 ApplicationContext applicationContext) {
    this.serverProperties = serverProperties;
    this.applicationContext = applicationContext;
    this.resourceProperties = resourceProperties;
    this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
    this.serverCodecConfigurer = serverCodecConfigurer;
}
 

@Bean
@Lazy(false)
@ConditionalOnMissingBean
public ApplicationFactory applicationFactory(InstanceProperties instance, ManagementServerProperties management,
		ServerProperties server, PathMappedEndpoints pathMappedEndpoints, WebEndpointProperties webEndpoint,
		ObjectProvider<List<MetadataContributor>> metadataContributors) {
	return new DefaultApplicationFactory(instance, management, server, pathMappedEndpoints, webEndpoint,
			new CompositeMetadataContributor(metadataContributors.getIfAvailable(Collections::emptyList)));
}
 

public ExceptionAutoConfiguration(ServerProperties serverProperties,
                                  ResourceProperties resourceProperties,
                                  ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                  ServerCodecConfigurer serverCodecConfigurer,
                                  ApplicationContext applicationContext) {
    this.serverProperties = serverProperties;
    this.applicationContext = applicationContext;
    this.resourceProperties = resourceProperties;
    this.viewResolvers = viewResolversProvider
            .getIfAvailable(() -> Collections.emptyList());
    this.serverCodecConfigurer = serverCodecConfigurer;
}
 

public DynamicRouteConfiguration(Registration registration, DiscoveryClient discovery,
                                 ZuulProperties zuulProperties, ServerProperties server, RedisTemplate redisTemplate) {
    this.registration = registration;
    this.discovery = discovery;
    this.zuulProperties = zuulProperties;
    this.server = server;
    this.redisTemplate = redisTemplate;
}
 

/**
 * Registers a custom {@link ErrorController} to change the default error handling approach.
 *
 * @param errorAttributes    Will be used to enrich error responses.
 * @param serverProperties   Will be used to access error related configurations.
 * @param errorViewResolvers All possible view resolvers to render the whitelabel error page.
 * @return The custom error controller instance.
 */
@Bean
@ConditionalOnBean(WebErrorHandlers.class)
@ConditionalOnMissingBean(ErrorController.class)
public BasicErrorController customErrorController(ErrorAttributes errorAttributes,
                                             ServerProperties serverProperties,
                                             ObjectProvider<ErrorViewResolver> errorViewResolvers) {
    List<ErrorViewResolver> resolvers = errorViewResolvers.orderedStream().collect(toList());
    return new CustomServletErrorController(errorAttributes, serverProperties.getError(), resolvers);
}
 

@Test
public void testExtractorsCount() {
	ConfigurableApplicationContext context = new SpringApplicationBuilder(
			BusConfig.class, EnvironmentMonitorAutoConfiguration.class,
			ServletWebServerFactoryAutoConfiguration.class, ServerProperties.class,
			PropertyPlaceholderAutoConfiguration.class).properties("server.port=-1")
					.run();
	PropertyPathEndpoint endpoint = context.getBean(PropertyPathEndpoint.class);
	assertThat(((Collection<?>) ReflectionTestUtils.getField(
			ReflectionTestUtils.getField(endpoint, "extractor"), "extractors"))
					.size()).isEqualTo(7);
	context.close();
}
 

public CloudFoundryApplicationFactory(InstanceProperties instance, ManagementServerProperties management,
		ServerProperties server, PathMappedEndpoints pathMappedEndpoints, WebEndpointProperties webEndpoint,
		MetadataContributor metadataContributor, CloudFoundryApplicationProperties cfApplicationProperties) {
	super(instance, management, server, pathMappedEndpoints, webEndpoint, metadataContributor);
	this.cfApplicationProperties = cfApplicationProperties;
	this.instance = instance;
}
 

@Bean
ApplicationListener<ApplicationReadyEvent> onApplicationReadyEventListener(ServerProperties serverProperties,
		KeycloakServerProperties keycloakServerProperties) {

	return (evt) -> {

		Integer port = serverProperties.getPort();
		String keycloakContextPath = keycloakServerProperties.getContextPath();

		LOG.info("Embedded Keycloak started: http://localhost:{}{} to use keycloak", port, keycloakContextPath);
	};
}
 

@Bean
ApplicationListener<ApplicationReadyEvent> onApplicationReadyEventListener(ServerProperties serverProperties, KeycloakServerProperties keycloakServerProperties) {

    return (evt) -> {

        Integer port = serverProperties.getPort();
        String keycloakContextPath = keycloakServerProperties.getContextPath();

        LOG.info("Embedded Keycloak started: http://localhost:{}{} to use keycloak", port, keycloakContextPath);
    };
}
 

public ExceptionAutoConfiguration(ServerProperties serverProperties,
                                  ResourceProperties resourceProperties,
                                  ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                  ServerCodecConfigurer serverCodecConfigurer,
                                  ApplicationContext applicationContext) {
    this.serverProperties = serverProperties;
    this.applicationContext = applicationContext;
    this.resourceProperties = resourceProperties;
    this.viewResolvers = viewResolversProvider
            .getIfAvailable(() -> Collections.emptyList());
    this.serverCodecConfigurer = serverCodecConfigurer;
}
 

@Bean
ApplicationListener<ApplicationReadyEvent> onApplicationReadyEventListener(ServerProperties serverProperties,
		KeycloakServerProperties keycloakServerProperties) {

	return (evt) -> {

		Integer port = serverProperties.getPort();
		String keycloakContextPath = keycloakServerProperties.getContextPath();

		LOG.info("Embedded Keycloak started: http://localhost:{}{} to use keycloak", port, keycloakContextPath);
	};
}
 

@Test
public void should_return_empty_when_no_endpoints() {
	EndpointsSupplier<ExposableWebEndpoint> endpointsSupplier = Collections::emptyList;
	Optional<Pattern> pattern = new SkipPatternConfiguration.ActuatorSkipPatternProviderConfig()
			.skipPatternForActuatorEndpointsSamePort(new ServerProperties(),
					new WebEndpointProperties(), endpointsSupplier)
			.skipPattern();

	then(pattern).isEmpty();
}
 

@Autowired
public SampleController(ServerProperties serverProps, Environment environment) {
    this.serverPort = serverProps.getPort();
    String userIdHeaderKeysFromEnv = environment.getProperty("wingtips.user-id-header-keys");
    this.userIdHeaderKeys = (userIdHeaderKeysFromEnv == null)
                            ? null
                            : Arrays.asList(userIdHeaderKeysFromEnv.split(","));
}
 

@Test
public void testCanAddCustomPropertyPathNotificationExtractor() {
	ConfigurableApplicationContext context = new SpringApplicationBuilder(
			BusConfig.class, CustomPropertyPathNotificationExtractorConfig.class,
			EnvironmentMonitorAutoConfiguration.class,
			ServletWebServerFactoryAutoConfiguration.class, ServerProperties.class,
			PropertyPlaceholderAutoConfiguration.class).properties("server.port=-1")
					.run();
	PropertyPathEndpoint endpoint = context.getBean(PropertyPathEndpoint.class);
	assertThat(((Collection<?>) ReflectionTestUtils.getField(
			ReflectionTestUtils.getField(endpoint, "extractor"), "extractors"))
					.size()).isEqualTo(8);
	context.close();
}
 

@Before
public void beforeMethod() {
    projectApiErrorsMock = mock(ProjectApiErrors.class);
    unhandledContainerErrorHelperMock = mock(UnhandledServletContainerErrorHelper.class);
    servletRequestMock = mock(ServletRequest.class);
    serverPropertiesMock = mock(ServerProperties.class);
    errorPropertiesMock = mock(ErrorProperties.class);
    errorPath = UUID.randomUUID().toString();

    doReturn(errorPropertiesMock).when(serverPropertiesMock).getError();
    doReturn(errorPath).when(errorPropertiesMock).getPath();
}