adaptive spring applications with profiles and more

© 2013 SpringOne 2GX. All rights reserved. Do not distribute without permission.

Adaptive Spring Applications with Profiles and More

by Josh Long and Kevin Nilson

Friday, September 20, 13

Developer Advocateinterested in big data, the open web, cloud and all things Spring

2

About Josh Long

@[email protected]


mailto:[email protected]


KEVIN NILSON

About Kevin Nilson

• Chromecast Developer Advocate -‐ Google• Java Champion• 3 Time JavaOne Rock Star• Co-‐Author of Web 2.0 Fundamentals• Leader Silicon Valley Java User Group• Leader Silicon Valley JavaScript Meetup• Leader Silicon Valley Google Developer Group• Taught 7 Course @ College of San Mateo, CIS


WELCOME

Welcome


ADAPTING THE SYSTEM AT CONFIGURATION TIME

Adapting Beans at Construction Time


TAILORING BEAN CONSTRUCTION

manages the life cycle of beans in the ApplicationContext

<bean init-method="init" class="some.Bean" destroy-method="destroy"> ... </bean>

package some;

public class Bean { public void init(){ } public void destroy(){ }}




package some;

public class Bean {

@PostConstruct public void init(){ }

@PreDestroy public void destroy(){ }

}




package some;

public class Bean implements InitializingBean, DisposableBean {

public void afterPropertiesSet(){ }

public void dispose(){ }

}




Spring uses the no-arg constructor of your bean to create it.




Historically: we’ve used FactoryBeans to mix things up

public class CronTriggerFactoryBean implements FactoryBean<CronTrigger> { ...

public CronTrigger getObject(){ ... }}



@PropertySource("/config.properties")@Configurationpublic class ServiceConfiguration {

@Bean public DataSource postgres(Environment e) { // ... }

@Bean public CustomerService customerService(DataSource ds) { return new CustomerService(ds); }}

but with Java configuration, you don’t need the indirection anymore..



If you think about it... factory methods are everywhere!

(They’re even a pattern!)javax.inject.Provider<DataSource> dataSourceProvider

o.sf.beans.FactoryBean<DataSource> dataSourceFactoryBean

java.util.concurrent.Callable<DataSource> dataSourceCallable ...?and what about..



factory methods are going to be awesome with Java 8

Provider<DataSource> dataSourceProvider = ()->{ // ...};



The Environment and Profiles


ASKING QUESTIONS OF THE ENVIRONMENT...

the environment in which an application runs isn’t always certain...



the Spring Environment abstraction helps.

am I?where

@Inject Environment env;

String whereAmI = env.getProperty(“user.dir”);



the Spring Environment abstraction helps.

@Inject Environment env;

String whoAreYou = env.getProperty(“database.url”);

are who

you?


BUILDING ADAPTIVE APPLICATIONS IS HARD

Demousing the Environment



Values may come from anywhere.

You can add your own PropertySource implementations, too.ApplicationContext context = ...ConfigurableEnvironment environment = (ConfigurableEnvironment) context.getEnvironment();

Map<String, Object> map = new HashMap<String, Object>();map.put(“value1”, “url”);

MapPropertySource mapPropertySource = new MapPropertySource( "dbConfig", map);

environment.getPropertySources().addFirst( mapPropertySource );



for convenience, just use the @PropertySource annotation

@PropertySource("/config.properties")@Configurationpublic class ServiceConfiguration {



then you can use the Environment in your Java configuration...

@PropertySource("/config.properties")@Configurationpublic class ServiceConfiguration { @Bean public DataSource database(Environment env) { try { String user = env.getProperty(“db.user”), pw = env.getProperty(“db.password”), url = env.getProperty(“db.url”); Class<? extends Driver> driverClass = env.getPropertyAsClass( “db.driverClass”, Driver.class);



Demousing @PropertySource


PROFILES

Multiple ImplementationsAllow you to provide one implementation for production and other versions that may not really work...


PROFILES

Mocking for TestingMock anything that is non-predictive slow

Testing Edge conditions what-if scenarios


PROFILES

Mocking for ProductivityServices are not always available

Services are often slow

Start the front-end when you start the back-end


PROFILES

@Servicepublic class VideoSearchYoutube implements VideoSearch { public List<String> lookupVideo(String searchTerm) throws Exception{ ... return results;

@Servicepublic class VideoSearchMock implements VideoSearch { public List<String> lookupVideo(String searchTerm) throws Exception{ ... return results;


PROFILES

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [savetheenvironment.embedded.video.VideoSearch] is defined: expected single matching bean but found 2: videoSearchMock,videoSearchYouTube



no more external .xml contexts!


PROBLEM WITH ANNOTATIONS

@Profile(“VideoYoutube”)@Servicepublic class VideoSearchYoutube implements VideoSearch { public List<String> lookupVideo(String searchTerm) throws Exception{ ... return results;

@Profile(“VideoMock”)@Servicepublic class VideoSearchMock implements VideoSearch { public List<String> lookupVideo(String searchTerm) throws Exception{ ... return results;



you can also use profiles in your unit tests.

@ContextConfiguration(classes = {ServiceConfiguration.class})@ActiveProfiles(“mock”)@RunWith(SpringJUnit4ClassRunner.class)public class VideoSearchTest {

@Inject private VideoSearch videoSearch;

@Test public void testVideoSearch() throws Exception { assertEquals( 2, videoSearch.lookupVideo("Kevin Nilson").size()); }

..


ADAPTIVE SPRING

Demousing @Profile



profiles tag groups of beans into sets

dev cloud qa

dataSource

txManager

mongo

dataSource

txManager

mongo

dataSource

txManager

mongo



the Environment also offers access to “profiles.”

profiles let you tag groups of beans, and enable them selectively.



It’s easy to tag a bean with a profile in Java configuration

@Configuration @Profile(“dev”)class LocalConfiguration { }

@Configuration @Profile(“production”) class ProductionConfiguration { }



It’s easy to tag a bean with a profile on a bean-by-bean basis

@Component@Profile(“dev”)class InMemoryCustomerRepository implements CustomerRepository { // ...}

@Component@Profile(“production”) class JdbcCustomerRepository implements CustomerRepository { // ...}



You specify a profile on the ApplicationContext’s Environment

ApplicationContext ac = ..

Environment env = ac.getEnvironment();env.setActiveProfiles( production ? “production” : “dev” );

ac.register(ServiceConfiguration.class);ac.refresh();



You specify a profile with a system environment variable

-Dspring.profiles.active=dev,qa



You specify a profile with a init-param or context-param in web.xml

<servlet> <servlet-name>spring</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>spring.profiles.active</param-name> <param-value>qa,dev</param-value> </init-param></servlet>


http://web.xml

http://web.xml

http://web.servlet.DispatcherServlet



You specify a profile in code in a Servlet (web.xml) environment with an ApplicationContextInitializer:

public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

public void initialize(ConfigurableApplicationContext applicationContext) {

String p = (Math.random() > .5 ? "production" : "qa"); applicationContext.getEnvironment().setActiveProfile(p); } }


http://web.xml

http://web.xml


Then simply register it with the DispatcherServlet.

It’ll be invoked before any beans are read and configured.

<servlet> <servlet-name>spring</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextInitializerClasses</param-name> <param-value> app.MyApplicationContextInitializer </param-value> </init-param></servlet>





it’s even simpler with Servlet 3 environments:

class CrmAbstractDispatcherServletInitializer extends AbstractDispatcherServletInitializer {

@Override protected WebApplicationContext createServletApplicationContext() { boolean production = // value is presumably obtained externally AnnotationConfigWebApplicationContext ac = .. ac.getEnvironment().setActiveProfiles( production ? "production" : "dev" ); ac.register(WebMvcConfiguration.class); ac.refresh(); return ac; }

@Override protected String[] getServletMappings() { return new String[]{"/*"}; }

@Override protected WebApplicationContext createRootApplicationContext() { return null; }}Friday, September 20, 13


You specify a profile for Spring Boot applications in the application.properties file

$>cat src/main/resources/application.properties

# Spring Boot will read this filespring.profiles.active=dev,qa



Some profiles are special (in certain contexts).

default is activated... by default.

Cloud Foundry activates the cloud profile if it’s available.

(we’re all special in certain contexts!)



Demousing EC2 Tags to Configure Profiles

http://tinyurl.com/adaptive-spring-boot




REST DESIGN WITH SPRING

An example of using profiles in EC2

Specific Instanceec2-describe-tags --filter "resource-id=i-6e8be600 --filter "key=profile"

Current Instance profile=$(ec2-describe-tags --filter "resource-id=$(ec2-metadata -i | cut -d ' ' -f2)" --filter "key=profile" | cut -f5)

Start Jettyjava -Dprofile=$profile -jar start.jar

java -Dspring.profiles.active=bacon -jar start.jar



The wide world of @Conditional in Spring 4



@Profile are specializations of an annotation called @Conditional.

Sort of.



@Conditional lets you conditionally create beans.

They delegate to Condition instances.

Supports graceful, resilient systems.



Spring Boot uses @Conditional to great effect.

Provides a healthy suite of Condition implementations like DatabaseCondition, OnBeanCondition, OnClassCondition, and OnWebApplicationCondition.

You can write your own, too.



Demolooking at existing Conditions,writing your own Condition



Refreshing beans with ApplicationContext child contexts



ApplicationContext’s are hierarchical. They nest.

You see this effect when you setup the typical Spring MVC architecture:

ContextLoaderListener

DispatcherServletDispatcherServlet

DispatcherServlet



You can programmatically parent an ApplicationContext, created isolated access to the parent.

You can also isolate and destroy just parts of an ApplicationContext hierarchy, too.



Demo“reloading” beans, pt. 1



better decoupling with ApplicationEvents



the Spring ApplicationContext supports a service bus of sorts.

You may publish and receive messages from one component to another using ApplicationEvents.



Refreshing beans with proxies



Another approach to refreshing a bean:

1. Use bean proxies to isolate reference holders from the swap.

2. Use ApplicationEvent to trigger the refresh of the bean.

3. Let the client provide the factory method.



Refreshing beans with the JMX (and proxies)



Spring provides the @EnableMBeanExport configuration to easily expose beans through JMX.

@ManagedResourcepublic class JmxDataSourceConfigurationEndpoint implements ApplicationContextAware {

private DataSource dataSource; private ConfigurableEnvironment environment; private ApplicationContext applicationContext;

@ManagedOperation public void updateDataSource(String user, String pw, String url) {

Map<String, Object> map = ... MapPropertySource propertySource = ...

// install the new configuration values environment.getPropertySources().addFirst(propertySource);

// publish the event that our proxies will listen for applicationContext.publishEvent(

new RefreshEvent( this.dataSource)); }}


REST DESIGN WITH SPRING

Any

Questions?@starbuxman | [email protected] | http://slideshare.net/joshlong

@javaclimber | [email protected] | http://www.javaclimber.com




http://slideshare.net/joshlong

http://slideshare.net/joshlong

http://www.javaclimber.com

http://www.javaclimber.com

adaptive spring applications with profiles and more

Technology

building adaptive

tailoring

life cycle

applicationcontext

java configuration

propertysource

map

mappropertysource