* This module provides the general session API (see {@link Session}), and a default {@link SessionStore} implementation that stores session data in local memory. * *
* It is expected that most applications will provide alternative bindings for the {@link SessionStore} type, overriding the default. * This allows arbitrary stores to be used to persist session data. *
* The default, in memory, implementation stores the data in a {@link Cache}{@code <}{@link AsciiString}, {@link ByteBuf}{@code >}. * This cache instance is provided by this module and defaults to storing a maximum of 1000 entries, discarding least recently used. * The {@link #memoryStore} methods are provided to conveniently construct alternative cache configurations, if necessary. *
* Objects must be serialized to be stored in the session. * The get/set methods {@link SessionData} allow supplying a {@link SessionSerializer} to be used for the specific value. * For variants of the get/set methods where a serializer is not provided, the implementation of {@link SessionSerializer} bound with Guice will be used. * The default implementation provided by this module uses Java's in built serialization mechanism. * Users of this module may choose to override this binding with an alternative serialization strategy. *
* However, other Ratpack extensions may require session storage any rely on Java serialization. * For this reason, there is also always a {@link JavaSessionSerializer} implementation available that is guaranteed to be able to serialize any {@link Serializable} * object (that conforms to the {@link Serializable} contract. * Users of this module may also choose to override this binding with another implementation (e.g. one based on Kryo), * but this implementation must be able to serialize any object implementing {@link Serializable}. * * It is also often desirable to provide alternative implementations for {@link SessionSerializer} and {@link JavaSessionSerializer}. * The default binding for both types is an implementation that uses out-of-the-box Java serialization (which is neither fast nor efficient). * *
{@code
* import ratpack.guice.Guice;
* import ratpack.path.PathTokens;
* import ratpack.session.Session;
* import ratpack.session.SessionModule;
* import ratpack.test.embed.EmbeddedApp;
*
* import static org.junit.Assert.assertEquals;
*
* public class Example {
* public static void main(String... args) throws Exception {
* EmbeddedApp.of(a -> a
* .registry(Guice.registry(b -> b
* .module(SessionModule.class)
* ))
* .handlers(c -> c
* .get("set/:name/:value", ctx ->
* ctx.get(Session.class).getData().then(sessionData -> {
* PathTokens pathTokens = ctx.getPathTokens();
* sessionData.set(pathTokens.get("name"), pathTokens.get("value"));
* ctx.render("ok");
* })
* )
* .get("get/:name", ctx -> {
* ctx.get(Session.class).getData()
* .map(d -> d.require(ctx.getPathTokens().get("name")))
* .then(ctx::render);
* })
* )
* ).test(httpClient -> {
* assertEquals("ok", httpClient.getText("set/foo/bar"));
* assertEquals("bar", httpClient.getText("get/foo"));
*
* assertEquals("ok", httpClient.getText("set/foo/baz"));
* assertEquals("baz", httpClient.getText("get/foo"));
* });
* }
* }
* }
*/
public class SessionModule extends ConfigurableModule* This method is intended to be used with the {@link BindingsSpec#binder(Action)} method. *
{@code
* import ratpack.guice.Guice;
* import ratpack.session.SessionModule;
*
* public class Example {
* public static void main(String... args) {
* Guice.registry(b -> b
* .binder(SessionModule.memoryStore(c -> c.maximumSize(100)))
* );
* }
* }
* }
*
* @param config the cache configuration
* @return an action that binds the cache
* @see #memoryStore(Binder, Consumer)
*/
public static Action* This method can be used from within a custom {@link Module}. *
{@code
* import com.google.inject.AbstractModule;
* import ratpack.session.SessionModule;
*
* public class CustomSessionModule extends AbstractModule {
* protected void configure() {
* SessionModule.memoryStore(binder(), c -> c.maximumSize(100));
* }
* }
* }
* }
* This method binds the built cache with the {@link #LOCAL_MEMORY_SESSION_CACHE_BINDING_KEY} key.
* It also implicitly registers a {@link RemovalListener}, that releases the byte buffers as they are discarded.
*
* @param binder the guice binder
* @param config the cache configuration
*/
public static void memoryStore(Binder binder, Consumer> config) {
binder.bind(LOCAL_MEMORY_SESSION_CACHE_BINDING_KEY).toProvider(() -> {
CacheBuilder