This guide describes how to use Spring Session to transparently leverage a relational database to back a web application’s HttpSession
with Java Configuration.
Note
|
You can find the completed guide in the httpsession-jdbc sample application. |
Before you use Spring Session, you must update your dependencies. If you use Maven, you must add the following dependencies:
<dependencies>
<!-- ... -->
<dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-jdbc</artifactId>
<version>{spring-session-version}</version>
<type>pom</type>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>{spring-core-version}</version>
</dependency>
</dependencies>
After adding the required dependencies, we can create our Spring configuration.
The Spring configuration is responsible for creating a Servlet Filter that replaces the HttpSession
implementation with an implementation backed by Spring Session.
To do so, add the following Spring Configuration:
link:{samples-dir}spring-session-sample-javaconfig-jdbc/src/main/java/sample/Config.java[role=include]
-
The
@EnableJdbcHttpSession
annotation creates a Spring Bean with the name ofspringSessionRepositoryFilter
. That bean implementsFilter
. The filter is in charge of replacing theHttpSession
implementation to be backed by Spring Session. In this instance, Spring Session is backed by a relational database. -
We create a
dataSource
that connects Spring Session to an embedded instance of an H2 database. We configure the H2 database to create database tables by using the SQL script that is included in Spring Session. -
We create a
transactionManager
that manages transactions for previously configureddataSource
.
For additional information on how to configure data access related concerns, see the {docs-url}/spring/docs/{spring-core-version}/reference/html/data-access.html[Spring Framework Reference Documentation].
Our Spring Configuration created a Spring bean named springSessionRepositoryFilter
that implements Filter
.
The springSessionRepositoryFilter
bean is responsible for replacing the HttpSession
with a custom implementation that is backed by Spring Session.
In order for our Filter
to do its magic, Spring needs to load our Config
class.
Last, we need to ensure that our Servlet Container (that is, Tomcat) uses our springSessionRepositoryFilter
for every request.
Fortunately, Spring Session provides a utility class named AbstractHttpSessionApplicationInitializer
to make both of these steps easy.
The following example shows how to do so:
link:{samples-dir}spring-session-sample-javaconfig-jdbc/src/main/java/sample/Initializer.java[role=include]
Note
|
The name of our class (Initializer) does not matter.
What is important is that we extend AbstractHttpSessionApplicationInitializer .
|
-
The first step is to extend
AbstractHttpSessionApplicationInitializer
. Doing so ensures that the Spring bean namedspringSessionRepositoryFilter
is registered with our Servlet Container for every request. -
AbstractHttpSessionApplicationInitializer
also provides a mechanism to ensure Spring loads ourConfig
.
Spring Session provides the @SpringSessionDataSource
qualifier, allowing you to explicitly declare which DataSource
bean should be injected in JdbcIndexedSessionRepository
.
This is particularly useful in scenarios with multiple DataSource
beans present in the application context.
The following example shows how to do so:
@EnableJdbcHttpSession
public class Config {
@Bean
@SpringSessionDataSource // (1)
public EmbeddedDatabase firstDataSource() {
return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.H2).addScript("org/springframework/session/jdbc/schema-h2.sql").build();
}
@Bean
public HikariDataSource secondDataSource() {
// ...
}
}
-
This qualifier declares that firstDataSource is to be used by Spring Session.
This section describes how to work with the httpsession-jdbc
Sample Application.
You can run the sample by obtaining the {download-url}[source code] and invoking the following command:
$ ./gradlew :spring-session-sample-javaconfig-jdbc:tomcatRun
You should now be able to access the application at http://localhost:8080/
Now you can try using the application. To do so, fill out the form with the following information:
-
Attribute Name: username
-
Attribute Value: rob
Now click the Set Attribute button. You should now see the values displayed in the table.
We interact with the standard HttpSession
in the SessionServlet
shown in the following listing:
link:{samples-dir}spring-session-sample-javaconfig-jdbc/src/main/java/sample/SessionServlet.java[role=include]
Instead of using Tomcat’s HttpSession
, we persist the values in H2 database.
Spring Session creates a cookie named SESSION
in your browser.
That cookie contains the ID of your session.
You can view the cookies (with Chrome or Firefox).
If you like, you can remove the session by using the H2 web console available at: http://localhost:8080/h2-console/ (use jdbc:h2:mem:testdb
for JDBC URL).
Now you can visit the application at http://localhost:8080/ and see that the attribute we added is no longer displayed.