Spring Session - HttpSession with GemFire Client/Server (Quick Start)

<dependencies>
        <!-- ... -->

        <dependency>
                <groupId>org.springframework.session</groupId>
                <artifactId>spring-session-data-gemfire</artifactId>
                <version>1.2.1.RELEASE</version>
                <type>pom</type>
        </dependency>
        <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>4.2.5.RELEASE</version>
        </dependency>
</dependencies>

@EnableGemFireHttpSession(maxInactiveIntervalInSeconds = 30) (1)
public class ClientConfig {

        static final long DEFAULT_WAIT_DURATION = TimeUnit.SECONDS.toMillis(20);
        static final long DEFAULT_WAIT_INTERVAL = 500L;

        static final CountDownLatch latch = new CountDownLatch(1);

        static {
                System.setProperty("gemfire.log-level", logLevel());

                ClientMembership.registerClientMembershipListener(
                        new ClientMembershipListenerAdapter() {
                                public void memberJoined(ClientMembershipEvent event) {
                                        if (!event.isClient()) {
                                                latch.countDown();
                                        }
                                }
                        });
        }

        private static String logLevel() {
                return System.getProperty("sample.httpsession.gemfire.log-level", "warning");
        }

        @Bean
        static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
                return new PropertySourcesPlaceholderConfigurer();
        }

        @Bean
        Properties gemfireProperties() { (2)
                return new Properties();
        }

        @Bean
        ClientCacheFactoryBean gemfireCache() { (4)
                ClientCacheFactoryBean clientCacheFactory = new ClientCacheFactoryBean();

                clientCacheFactory.setClose(true);
                clientCacheFactory.setProperties(gemfireProperties());

                return clientCacheFactory;
        }

        @Bean
        PoolFactoryBean gemfirePool((3)
                        @Value("${spring.session.data.gemfire.port:" + ServerConfig.SERVER_PORT + "}") int port) {

                PoolFactoryBean poolFactory = new PoolFactoryBean();

                poolFactory.setFreeConnectionTimeout(5000); // 5 seconds
                poolFactory.setKeepAlive(false);
                poolFactory.setMaxConnections(ServerConfig.MAX_CONNECTIONS);
                poolFactory.setPingInterval(TimeUnit.SECONDS.toMillis(5));
                poolFactory.setReadTimeout(2000); // 2 seconds
                poolFactory.setRetryAttempts(2);
                poolFactory.setSubscriptionEnabled(true);
                poolFactory.setThreadLocalConnections(false);

                poolFactory.setServers(Collections.singletonList(
                        new ConnectionEndpoint(ServerConfig.SERVER_HOSTNAME, port)));

                return poolFactory;
        }

        @Bean
        BeanPostProcessor gemfireCacheServerReadyBeanPostProcessor((5)
                        @Value("${spring.session.data.gemfire.port:" + ServerConfig.SERVER_PORT + "}") final int port) {

                return new BeanPostProcessor() {

                        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
                                if (bean instanceof PoolFactoryBean || bean instanceof Pool) {
                                        Assert.isTrue(waitForCacheServerToStart(ServerConfig.SERVER_HOSTNAME, port),
                                                String.format("GemFire Server failed to start [hostname: %1$s, port: %2$d]",
                                                        ServerConfig.SERVER_HOSTNAME, port));
                                }

                                return bean;
                        }

                        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
                                if (bean instanceof PoolFactoryBean || bean instanceof Pool) {
                                        try {
                                                latch.await(DEFAULT_WAIT_DURATION, TimeUnit.MILLISECONDS);
                                        }
                                        catch (InterruptedException e) {
                                                Thread.currentThread().interrupt();
                                        }
                                }

                                return bean;
                        }
                };
        }

public class Initializer extends AbstractHttpSessionApplicationInitializer { (1)

        public Initializer() {
                super(ClientConfig.class); (2)
        }
}