Field Detail

• LOCAL_MEMORY_SESSION_CACHE_BINDING_NAME

  public static final String LOCAL_MEMORY_SESSION_CACHE_BINDING_NAME

  The name of the binding for the Cache implementation that backs the in memory session store.

  See Also:

  memoryStore(Consumer), Constant Field Values

• LOCAL_MEMORY_SESSION_CACHE_BINDING_KEY

  public static final com.google.inject.Key<com.google.common.cache.Cache<io.netty.util.AsciiString,​io.netty.buffer.ByteBuf>> LOCAL_MEMORY_SESSION_CACHE_BINDING_KEY

  The key of the binding for the Cache implementation that backs the in memory session store.

  See Also:

  memoryStore(Consumer)

Constructor Detail

• SessionModule

  public SessionModule()

Method Detail

• memoryStore

  public static Action<com.google.inject.Binder> memoryStore​(Consumer<? super com.google.common.cache.CacheBuilder<io.netty.util.AsciiString,​io.netty.buffer.ByteBuf>> config)

  A builder for an alternative cache for the default in memory store.

  This method is intended to be used with the BindingsSpec.binder(Action) method.

  
   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)))
       );
     }
   }
   

  Parameters:

  config - the cache configuration

  Returns:

  an action that binds the cache

  See Also:

  memoryStore(Binder, Consumer)

• memoryStore

  public static void memoryStore​(com.google.inject.Binder binder,
                                 Consumer<? super com.google.common.cache.CacheBuilder<io.netty.util.AsciiString,​io.netty.buffer.ByteBuf>> config)

  A builder for an alternative cache for the default in memory store.

  This method can be used from within a custom Module.

  
   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 LOCAL_MEMORY_SESSION_CACHE_BINDING_KEY key. It also implicitly registers a RemovalListener, that releases the byte buffers as they are discarded.

  Parameters:

  binder - the guice binder

  config - the cache configuration

• allowTypes

  public static void allowTypes​(com.google.inject.Binder binder,
                                Class<?>... types)

  Registers the given types as being session safe.

  This method is only effectual if the implementation of SessionTypeFilter provided by this module is not overridden.

  
   import com.google.inject.AbstractModule;
   import ratpack.session.Session;
   import ratpack.session.SessionModule;
   import ratpack.guice.Guice;
   import ratpack.test.embed.EmbeddedApp;
  
   import java.io.Serializable;
  
   import static org.junit.jupiter.api.Assertions.assertEquals;
  
   public class Example {
  
     static class AllowedType implements Serializable {
     }
  
     static class NonAllowedType implements Serializable {
     }
  
     static class NonAllowedTypeContainer implements Serializable {
       NonAllowedType nonAllowedType = new NonAllowedType();
     }
  
     public static class MySessionTypesModule extends AbstractModule {
       protected void configure() {
         SessionModule.allowTypes(binder(),
           AllowedType.class,
           NonAllowedTypeContainer.class
         );
       }
     }
  
     public static void main(String... args) throws Exception {
       EmbeddedApp.of(a -> a
         .registry(Guice.registry(b -> b
           .module(SessionModule.class)
           .module(MySessionTypesModule.class)
         ))
         .handlers(c -> c
           .get("set/allowed", ctx ->
             ctx.get(Session.class)
               .set(new AllowedType())
               .then(() -> ctx.render("ok"))
           )
           .get("set/nonAllowed", ctx ->
             ctx.get(Session.class)
               .set(new NonAllowedType())
               .onError(e -> ctx.render(e.toString()))
               .then(() -> ctx.render("ok"))
           )
           .get("set/nonAllowedContainer", ctx ->
             ctx.get(Session.class)
               .set(new NonAllowedTypeContainer())
               .onError(e -> ctx.render(e.toString()))
               .then(() -> ctx.render("ok"))
           )
         )
       ).test(http -> {
         // Works, only references allowed types
         String response1 = http.getText("set/allowed");
         assertEquals("ok", response1);
  
         // Doesn't work, tries to set not allowed type
         String response2 = http.getText("set/nonAllowed");
         assertEquals("ratpack.session.NonAllowedSessionTypeException: Type Example$NonAllowedType is not an allowed session type. Register a SessionTypeFilterPlugin allowing it. See SessionModule.allowTypes().", response2);
  
         // Doesn't work, allowed type references not allowed type
         String response3 = http.getText("set/nonAllowedContainer");
         assertEquals("ratpack.session.NonAllowedSessionTypeException: Type Example$NonAllowedType is not an allowed session type. Register a SessionTypeFilterPlugin allowing it. See SessionModule.allowTypes().", response3);
       });
     }
   }
   

  While the above example only shows type checking being applied on writing to the session, the same checking is applied when reading from the session.

  Parameters:

  binder - the binder

  types - the types to allow to be used in a session

  Since:

  1.9

• bindSessionTypeFilterPlugin

  public static com.google.inject.binder.LinkedBindingBuilder<SessionTypeFilterPlugin> bindSessionTypeFilterPlugin​(com.google.inject.Binder binder)

  Creates a multi-binding binder for a SessionTypeFilterPlugin.

  Parameters:

  binder - the binder

  Returns:

  a binding builder for a SessionTypeFilterPlugin

• configure

  protected void configure()

  Overrides:

  configure in class com.google.inject.AbstractModule