Java StandardServletEnvironment类代码示例

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
private ConditionOutcome isWebApplication(ConditionContext context,
		AnnotatedTypeMetadata metadata, boolean required) {
	ConditionMessage.Builder message = ConditionMessage.forCondition(
			ConditionalOnWebApplication.class, required ? "(required)" : "");
	if (!ClassUtils.isPresent(WEB_CONTEXT_CLASS, context.getClassLoader())) {
		return ConditionOutcome
				.noMatch(message.didNotFind("web application classes").atAll());
	}
	if (context.getBeanFactory() != null) {
		String[] scopes = context.getBeanFactory().getRegisteredScopeNames();
		if (ObjectUtils.containsElement(scopes, "session")) {
			return ConditionOutcome.match(message.foundExactly("'session' scope"));
		}
	}
	if (context.getEnvironment() instanceof StandardServletEnvironment) {
		return ConditionOutcome
				.match(message.foundExactly("StandardServletEnvironment"));
	}
	if (context.getResourceLoader() instanceof WebApplicationContext) {
		return ConditionOutcome.match(message.foundExactly("WebApplicationContext"));
	}
	return ConditionOutcome.noMatch(message.because("not a web application"));
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
@Test
public void environmentOperations() {
	DispatcherServlet servlet = new DispatcherServlet();
	ConfigurableEnvironment defaultEnv = servlet.getEnvironment();
	assertThat(defaultEnv, notNullValue());
	ConfigurableEnvironment env1 = new StandardServletEnvironment();
	servlet.setEnvironment(env1); // should succeed
	assertThat(servlet.getEnvironment(), sameInstance(env1));
	try {
		servlet.setEnvironment(new DummyEnvironment());
		fail("expected IllegalArgumentException for non-configurable Environment");
	}
	catch (IllegalArgumentException ex) {
	}
	class CustomServletEnvironment extends StandardServletEnvironment { }
	@SuppressWarnings("serial")
	DispatcherServlet custom = new DispatcherServlet() {
		@Override
		protected ConfigurableWebEnvironment createEnvironment() {
			return new CustomServletEnvironment();
		}
	};
	assertThat(custom.getEnvironment(), instanceOf(CustomServletEnvironment.class));
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
@Test
public void webEnvironmentSwitchedOffInListener() throws Exception {
	TestSpringApplication application = new TestSpringApplication(
			ExampleConfig.class);
	application.addListeners(
			new ApplicationListener<ApplicationEnvironmentPreparedEvent>() {

				@Override
				public void onApplicationEvent(
						ApplicationEnvironmentPreparedEvent event) {
					assertThat(event.getEnvironment())
							.isInstanceOf(StandardServletEnvironment.class);
					TestPropertySourceUtils.addInlinedPropertiesToEnvironment(
							event.getEnvironment(), "foo=bar");
					event.getSpringApplication().setWebEnvironment(false);
				}

			});
	this.context = application.run();
	assertThat(this.context.getEnvironment())
			.isNotInstanceOf(StandardServletEnvironment.class);
	assertThat(this.context.getEnvironment().getProperty("foo"));
	assertThat(this.context.getEnvironment().getPropertySources().iterator().next()
			.getName()).isEqualTo(
					TestPropertySourceUtils.INLINED_PROPERTIES_PROPERTY_SOURCE_NAME);
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
private ConditionOutcome isWebApplication(ConditionContext context,
		AnnotatedTypeMetadata metadata) {

	if (!ClassUtils.isPresent(WEB_CONTEXT_CLASS, context.getClassLoader())) {
		return ConditionOutcome.noMatch("web application classes not found");
	}

	if (context.getBeanFactory() != null) {
		String[] scopes = context.getBeanFactory().getRegisteredScopeNames();
		if (ObjectUtils.containsElement(scopes, "session")) {
			return ConditionOutcome.match("found web application 'session' scope");
		}
	}

	if (context.getEnvironment() instanceof StandardServletEnvironment) {
		return ConditionOutcome
				.match("found web application StandardServletEnvironment");
	}

	if (context.getResourceLoader() instanceof WebApplicationContext) {
		return ConditionOutcome.match("found web application WebApplicationContext");
	}

	return ConditionOutcome.noMatch("not a web application");
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
@Override
public void postProcessBeanFactory(final ConfigurableListableBeanFactory beanFactory) throws BeansException {
    super.postProcessBeanFactory(beanFactory);

    final StandardServletEnvironment propertySources =
            (StandardServletEnvironment) super.getAppliedPropertySources().get(ENVIRONMENT_PROPERTIES).getSource();

    propertySources.getPropertySources().forEach(propertySource -> {
        if (propertySource.getSource() instanceof Map) {
            // it will print systemProperties, systemEnvironment, application.properties and other overrides of
            // application.properties
            log.trace("#######" + propertySource.getName() + "#######");


            //noinspection unchecked
            ((Map) propertySource.getSource()).forEach((key, value) -> log.trace(key+"="+value));
        }
    });
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
@Test
public void webEnvironmentSwitchedOffInListener() throws Exception {
	TestSpringApplication application = new TestSpringApplication(
			ExampleConfig.class);
	application.addListeners(
			new ApplicationListener<ApplicationEnvironmentPreparedEvent>() {

				@Override
				public void onApplicationEvent(
						ApplicationEnvironmentPreparedEvent event) {
					assertTrue(event
							.getEnvironment() instanceof StandardServletEnvironment);
					EnvironmentTestUtils.addEnvironment(event.getEnvironment(),
							"foo=bar");
					event.getSpringApplication().setWebEnvironment(false);
				}

			});
	this.context = application.run();
	assertFalse(this.context.getEnvironment() instanceof StandardServletEnvironment);
	assertEquals("bar", this.context.getEnvironment().getProperty("foo"));
	assertEquals("test", this.context.getEnvironment().getPropertySources().iterator()
			.next().getName());
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
/**
 * this test is an integration test (use of a spring context)
 * 
 * It begins with a Jndi instanciation and then try to load a spring context depending on jndi properties.
 * 
 * The goal of this test is to validate that we can read jndi encoded properties from spring
 */
@Test
public void process_properties_should_decode_all_encrypted_props() throws Exception {
	//Jndi setup
	//Set fictive jndi properties (some of them are encoded)
       SimpleNamingContextBuilder.emptyActivatedContextBuilder();
       InitialContext initialContext = new InitialContext();
       initialContext.bind("jndi.prop1", "ENC(VLCeFXg9nPrx7Bmsbcb0h3v5ivRinKQ4)");
       initialContext.bind("jndi.prop2", "testjndiValue2");

       //when
	ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:/com/francetelecom/clara/cloud/commons/jasypt/jndiPropsDecoding.xml"){
		@Override
		protected ConfigurableEnvironment createEnvironment() {
			return new StandardServletEnvironment();
		}
	};
	
	//Then
	TestBean bean = context.getBean(TestBean.class);
	assertEquals("testjndivalue",bean.getSampleProp1());
	assertEquals("testjndiValue2",bean.getSampleProp2());
	assertEquals("testlocalvalue",bean.getSampleProp3());
	assertEquals("testlocalvalue2",bean.getSampleProp4());
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
public void testEnvironmentOperations() {
	DispatcherServlet servlet = new DispatcherServlet();
	ConfigurableEnvironment defaultEnv = servlet.getEnvironment();
	assertThat(defaultEnv, notNullValue());
	ConfigurableEnvironment env1 = new StandardServletEnvironment();
	servlet.setEnvironment(env1); // should succeed
	assertThat(servlet.getEnvironment(), sameInstance(env1));
	try {
		servlet.setEnvironment(new DummyEnvironment());
		fail("expected IllegalArgumentException for non-configurable Environment");
	}
	catch (IllegalArgumentException ex) {
	}
	class CustomServletEnvironment extends StandardServletEnvironment { }
	@SuppressWarnings("serial")
	DispatcherServlet custom = new DispatcherServlet() {
		@Override
		protected ConfigurableWebEnvironment createEnvironment() {
			return new CustomServletEnvironment();
		}
	};
	assertThat(custom.getEnvironment(), instanceOf(CustomServletEnvironment.class));
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
@Override
// TODO throw corresponding exceptions, not just Exception instances.
protected BrokerService createBroker(ServletContext sc) throws Exception {
	// Initialize Web environment to make Spring resolve external
	// properties.
	StandardServletEnvironment standardServletEnvironment = new ReversePropertySourcesStandardServletEnvironment();
	WebApplicationContextUtils.initServletPropertySources(standardServletEnvironment.getPropertySources(), sc);

	URI configURI = new URI(standardServletEnvironment.getProperty(BROKER_URI_PROP));

	LOG.info("Loading message broker from: " + configURI);
	return BrokerFactory.createBroker(configURI);
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
@Test
public void customizePropertySources() {
	MutablePropertySources propertySources = new MutablePropertySources();
	ReversePropertySourcesStandardServletEnvironment env = new ReversePropertySourcesStandardServletEnvironment();
	env.customizePropertySources(propertySources);
	
	String[] sourceNames = { StandardServletEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,
			StandardServletEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME,
			StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME,
			StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME };
	List<String> result = new ArrayList<>();
	propertySources.forEach(a -> result.add(a.getName()));
	Assert.assertArrayEquals(sourceNames, result.toArray());
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
@Test
public void registerServletParamPropertySources_GenericWebApplicationContext() {
	MockServletContext servletContext = new MockServletContext();
	servletContext.addInitParameter("pCommon", "pCommonContextValue");
	servletContext.addInitParameter("pContext1", "pContext1Value");

	GenericWebApplicationContext ctx = new GenericWebApplicationContext();
	ctx.setServletContext(servletContext);
	ctx.refresh();

	ConfigurableEnvironment environment = ctx.getEnvironment();
	assertThat(environment, instanceOf(StandardServletEnvironment.class));
	MutablePropertySources propertySources = environment.getPropertySources();
	assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME), is(true));

	// ServletContext params are available
	assertThat(environment.getProperty("pCommon"), is("pCommonContextValue"));
	assertThat(environment.getProperty("pContext1"), is("pContext1Value"));

	// Servlet* PropertySources have precedence over System* PropertySources
	assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)),
			lessThan(propertySources.precedenceOf(PropertySource.named(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME))));

	// Replace system properties with a mock property source for convenience
	MockPropertySource mockSystemProperties = new MockPropertySource(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME);
	mockSystemProperties.setProperty("pCommon", "pCommonSysPropsValue");
	mockSystemProperties.setProperty("pSysProps1", "pSysProps1Value");
	propertySources.replace(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, mockSystemProperties);

	// assert that servletcontext init params resolve with higher precedence than sysprops
	assertThat(environment.getProperty("pCommon"), is("pCommonContextValue"));
	assertThat(environment.getProperty("pSysProps1"), is("pSysProps1Value"));
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
private String findPropertySource(MutablePropertySources sources) {
	if (ClassUtils.isPresent(SERVLET_ENVIRONMENT_CLASS, null) && sources
			.contains(StandardServletEnvironment.JNDI_PROPERTY_SOURCE_NAME)) {
		return StandardServletEnvironment.JNDI_PROPERTY_SOURCE_NAME;

	}
	return StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME;
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
private ConfigurableEnvironment getOrCreateEnvironment() {
	if (this.environment != null) {
		return this.environment;
	}
	if (this.webEnvironment) {
		return new StandardServletEnvironment();
	}
	return new StandardEnvironment();
}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
private ConfigurableEnvironment getOrCreateEnvironment() {
	if (this.environment != null) {
		return this.environment;
	}
	if (this.webEnvironment) {
		return new StandardServletEnvironment();
	}
	return new StandardEnvironment();

}
 

import org.springframework.web.context.support.StandardServletEnvironment; //导入依赖的package包/类
@Before
public void setUp() {
	prodEnv = new StandardEnvironment();
	prodEnv.setActiveProfiles(PROD_ENV_NAME);

	devEnv = new StandardEnvironment();
	devEnv.setActiveProfiles(DEV_ENV_NAME);

	prodWebEnv = new StandardServletEnvironment();
	prodWebEnv.setActiveProfiles(PROD_ENV_NAME);
}