I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE COURSE

1. Overview

Spring Session has the simple goal of free up session management from the limitations of the HTTP session stored in the server.

The solution makes it easy to share session data between services in the cloud without being tied to a single container (i.e. Tomcat). Additionally, it supports multiple sessions in the same browser and sending sessions in a header.

In this article, we’ll use Spring Session to manage authentication information in a web app. While Spring Session can persist data using JDBC, Gemfire, or MongoDB, we will use Redis.

For an introduction to Redis check out this article.

2. A Simple Project

Let’s first create a simple Spring Boot project to use as a base for our session examples later on:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.0.RELEASE</version>
    <relativePath/>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Our application runs with Spring Boot and the parent pom provides versions for each entry. The latest version of each dependency can be found here: spring-boot-starter-security, spring-boot-starter-web, spring-boot-starter-test.

Let’s also add some configuration properties for our Redis server in application.properties:

spring.redis.host=localhost
spring.redis.port=6379

3. Spring Boot Configuration

First, let’s demonstrate configuring Spring Session with Boot.

Note: You do not need to complete sections 3 And 4. Just pick one depending on whether or not you are using Spring Boot to configure Spring Session.

3.1. Dependencies

Add these dependencies to our project:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session</artifactId>
</dependency>

We are using the boot parent pom to set the versions here, so these are guaranteed to work with our other dependencies. The latest version of each dependency can be found here: spring-boot-starter-data-redis, spring-session.

3.2. Spring Session Configuration

Now let’s add a configuration class for Spring Session:

@Configuration
@EnableRedisHttpSession
public class SessionConfig extends AbstractHttpSessionApplicationInitializer {
}

4. Standard Spring Config (no Boot)

Let’s also have a look at the integrating and configuring spring-session without Spring Boot – just with plain Spring.

4.1. Dependencies

First, if we’re adding spring-session to a standard Spring project, we’ll need to explicitly define:

<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session</artifactId>
    <version>1.2.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.5.0.RELEASE</version>
</dependency>

The latest versions of the these modules can be found here: spring-session, spring-data-redis

4.2. Spring Session Configuration

Now let’s add a configuration class for Spring Session:

@Configuration
@EnableRedisHttpSession
public class SessionConfig extends AbstractHttpSessionApplicationInitializer {
    @Bean
    public JedisConnectionFactory connectionFactory() {
        return new JedisConnectionFactory();
    }
}

As you can see the differences are minimal – we just have to now define our JedisConnectionFactory bean explicitly – Boot does it for us.

In both types @EnableRedisHttpSession and the extension of AbstractHttpSessionApplicationInitializer will create and wire up a filter in front of all our security infrastructure to look for active sessions and populate the security context from values stored in Redis.

Let’s now complete this application with a controller and the security config.

5. Application Configuration

Navigate to our main application file and add a controller:

@RestController
public class SessionController {
    @RequestMapping("/")
    public String helloAdmin() {
        return "hello admin";
    }
}

This will give us an endpoint to test.

Next, add our security configuration class:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth
          .inMemoryAuthentication()
          .withUser("admin").password("password").roles("ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
          .httpBasic().and()
          .authorizeRequests()
          .antMatchers("/").hasRole("ADMIN")
          .anyRequest().authenticated();
    }
}

This protects our endpoints with basic authentication and sets up a user to test with.

6. Test

Finally, let’s test everything out – we’ll define a simple test here that’s going to allow us to do 2 things:

  • consume the live web application
  • talk to Redis

Let’s first set things up:

public class SessionControllerTest {

    private Jedis jedis;
    private TestRestTemplate testRestTemplate;
    private TestRestTemplate testRestTemplateWithAuth;
    private String testUrl = "http://localhost:8080/";

    @Before
    public void clearRedisData() {
        testRestTemplate = new TestRestTemplate();
        testRestTemplateWithAuth = new TestRestTemplate("admin", "password", null);

        jedis = new Jedis("localhost", 6379);
        jedis.flushAll();
    }
}

Notice how we’re setting up both of these clients – the HTTP client and the Redis one. Of course, at this point the server (and Redis) should be up and running – so that we can communicate with them via these tests.

Let’s begin by testing that Redis is empty:

@Test
public void testRedisIsEmpty() {
    Set<String> result = jedis.keys("*");
    assertEquals(0, result.size());
}

Now test that our security returns a 401 for unauthenticated requests:

@Test
public void testUnauthenticatedCantAccess() {
    ResponseEntity<String> result = testRestTemplate.getForEntity(testUrl, String.class);
    assertEquals(HttpStatus.UNAUTHORIZED, result.getStatusCode());
}

Next, we test that Spring Session is managing our authentication token:

@Test
public void testRedisControlsSession() {
    ResponseEntity<String> result = testRestTemplateWithAuth.getForEntity(testUrl, String.class);
    assertEquals("hello admin", result.getBody()); //login worked

    Set<String> redisResult = jedis.keys("*");
    assertTrue(redisResult.size() > 0); //redis is populated with session data

    String sessionCookie = result.getHeaders().get("Set-Cookie").get(0).split(";")[0];
    HttpHeaders headers = new HttpHeaders();
    headers.add("Cookie", sessionCookie);
    HttpEntity<String> httpEntity = new HttpEntity<>(headers);

    result = testRestTemplate.exchange(testUrl, HttpMethod.GET, httpEntity, String.class);
    assertEquals("hello admin", result.getBody()); //access with session works worked

    jedis.flushAll(); //clear all keys in redis

    result = testRestTemplate.exchange(testUrl, HttpMethod.GET, httpEntity, String.class);
    assertEquals(HttpStatus.UNAUTHORIZED, result.getStatusCode());
    //access denied after sessions are removed in redis
}

First, our test confirms that our request was successful using the admin authentication credentials.

Then we extract the session value from the response headers and use it as our authentication in our second request. We validate that, and then clear all the data in Redis.

Finally, we make another request using the session cookie and confirm that we are logged out. This confirms that Spring Session is managing our sessions.

7. Conclusion

Spring Session is a powerful tool for managing HTTP sessions. With our session storage simplified to a configuration class and a few Maven dependencies, we can now wire up multiple applications to the same Redis instance and share authentication information.

As always you can find the source code over on Github.

I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE LESSONS

newest oldest most voted
Notify of
ottoman91
Guest
ottoman91

hi. i am using spring on a micro finance core banking solution (Apache fineract). I have installed redis on my ubuntu 14.04 machine. however, when I set the spring.redis.host and spring.redis.port properties in my src/main/resources/application.properties file, every time i run either ./gradlew clean tomcatRunWar or ./gradle build, the application.properties file gets reset to only showing spring.profiles.default=basicauth, and the redis configurations are not displayed. Any pointers on how I can diagnose this issue? Thanks.

Grzegorz Piwowarek
Guest
Grzegorz Piwowarek

Well, check the Gradle build file. It’s super weird and this is the first time I am hearing about something like this

Eugen Paraschiv
Guest

I’m afraid I haven’t seen that either. I’d try to simplify the build down to the bare essentials until it’s no longer happening to see where the problem is coming from. If you take a disciplined approach, you should be able to narrow it down to the root cause (you probably have already – I’m a bit late here).

ottoman91
Guest
ottoman91

so i did figure it out. basically there were two other gradle files that were being called from within the build.gradle file depending on which environment was chosen, so the probelm was solved. however, still havent been able to configure redis with spring session, like there is no error, but i can still access concurrent browser sessions from two different browser instances ( form mozilla and google chrome). also tried to set this through basic spring security configuration, but even that did not work out.