public interface Registry
Registries are primarily used for inter Handler
communication in request processing.
The Context
object that handlers operate on implements the Registry
interface.
import ratpack.handling.Handler; import ratpack.handling.Context; import ratpack.registry.Registry; import static org.junit.Assert.assertTrue; public class Thing { private final String name public Thing(String name) { this.name = name; } public String getName() { return name; } } public class UpstreamHandler implements Handler { public void handle(Context context) { context.next(Registry.single(new Thing("foo"))); } } public class DownstreamHandler implements Handler { public void handle(Context context) { assertTrue(context instanceof Registry); Thing thing = context.get(Thing.class); context.render(thing.getName()); } } import ratpack.test.handling.HandlingResult; import ratpack.test.handling.RequestFixture; import static ratpack.handling.Handlers.chain; import static ratpack.func.Action.noop; import static org.junit.Assert.assertEquals; Handler chain = chain(new UpstreamHandler(), new DownstreamHandler()); HandlingResult result = RequestFixture.handle(chain, noop()); assertEquals("foo", result.rendered(String.class));
Registry objects are assumed to be thread safe. No external synchronization is performed around registry access. As registry objects may be used across multiple requests, they should be thread safe.
Registries that are created per request however do not need to be thread safe.
Registry objects are returned in the reverse order that they were added (i.e. Last-In-First-Out).
import com.google.common.base.Joiner;
import ratpack.registry.Registry;
import static org.junit.Assert.assertEquals;
public class Example {
public static void main(String... args) throws Exception {
Registry registry = Registry.of(r -> r
.add("Ratpack")
.add("foo")
.add("bar")
);
assertEquals("bar", registry.get(String.class));
String joined = Joiner.on(", ").join(registry.getAll(String.class));
assertEquals("bar, foo, Ratpack", joined);
}
}
While this is strictly the case for the core registry implementations in Ratpack, adapted implementations (e.g. Guice, Spring etc.) may have more nuanced ordering semantics. To the greatest extent possible, registry implementations should strive to honor LIFO ordering.
Modifier and Type | Method and Description |
---|---|
static Registry |
backedBy(RegistryBacking registryBacking)
Creates a new registry instance that is backed by a RegistryBacking implementation.
|
static RegistryBuilder |
builder()
Creates a new
registry builder . |
static Registry |
empty()
Returns an empty registry.
|
default <T,O> Optional<O> |
first(Class<T> type,
Function<? super T,? extends O> function)
A convenience method for
first(TypeToken, Function) . |
default <T,O> Optional<O> |
first(TypeToken<T> type,
Function<? super T,? extends O> function)
Find and transform an item.
|
default <O> O |
get(Class<O> type)
Provides an object of the specified type, or throws an exception if no object of that type is available.
|
default <O> O |
get(TypeToken<O> type)
Provides an object of the specified type, or throws an exception if no object of that type is available.
|
default <O> Iterable<? extends O> |
getAll(Class<O> type)
Returns all of the objects whose declared type is assignment compatible with the given type.
|
<O> Iterable<? extends O> |
getAll(TypeToken<O> type)
Returns all of the objects whose declared type is assignment compatible with the given type.
|
default Registry |
join(Registry child)
Creates a new registry by joining
this registry with the given registry |
default <O> Optional<O> |
maybeGet(Class<O> type)
Does the same thing as
get(Class) , except returns null instead of throwing an exception. |
<O> Optional<O> |
maybeGet(TypeToken<O> type)
Does the same thing as
get(Class) , except returns null instead of throwing an exception. |
static Registry |
of(Action<? super RegistrySpec> action)
Builds a registry from the given action.
|
static <T> Registry |
single(Class<? super T> publicType,
T implementation)
Creates a single entry registry, using
RegistryBuilder.add(Class, Object) . |
static <T> Registry |
single(Class<T> publicType,
Supplier<? extends T> supplier)
Deprecated.
|
static Registry |
single(Object object)
Creates a single entry registry, using
RegistryBuilder.add(Object) . |
static <T> Registry |
singleLazy(Class<T> publicType,
Supplier<? extends T> supplier)
Creates a single lazily created entry registry, using
RegistryBuilder.addLazy(Class, Supplier) . |
default <O> O get(Class<O> type) throws NotInRegistryException
O
- The type of the object to providetype
- The type of the object to provideNotInRegistryException
- If no object of this type can be returneddefault <O> O get(TypeToken<O> type) throws NotInRegistryException
O
- The type of the object to providetype
- The type of the object to provideNotInRegistryException
- If no object of this type can be returneddefault <O> Optional<O> maybeGet(Class<O> type)
get(Class)
, except returns null instead of throwing an exception.O
- The type of the object to providetype
- The type of the object to provide<O> Optional<O> maybeGet(TypeToken<O> type)
get(Class)
, except returns null instead of throwing an exception.O
- The type of the object to providetype
- The type of the object to providedefault <O> Iterable<? extends O> getAll(Class<O> type)
O
- the type of objects to search fortype
- the type of objects to search for<O> Iterable<? extends O> getAll(TypeToken<O> type)
O
- the type of objects to search fortype
- the type of objects to search fordefault <T,O> Optional<O> first(TypeToken<T> type, Function<? super T,? extends O> function) throws Exception
This method will apply the given function to items in the order returned by getAll(TypeToken)
until the function returns a non null value.
The first non null value will be returned by this method immediately (as an optional).
If the function returns a null value for every item, an empty optional is returned.
T
- the type of the object to search forO
- the type of transformed objecttype
- the type of object to search forfunction
- a function to apply to each itemException
- any thrown by the functiondefault <T,O> Optional<O> first(Class<T> type, Function<? super T,? extends O> function) throws Exception
first(TypeToken, Function)
.T
- the type of the object to search forO
- the type of transformed objecttype
- the type of object to search forfunction
- a function to apply to each itemException
- any thrown by the functionfirst(TypeToken, Function)
default Registry join(Registry child)
this
registry with the given registry
The returned registry is effectively the union of the two registries, with the child
registry taking precedence.
This means that child entries are effectively “returned first”.
import ratpack.registry.Registry;
import java.util.List;
import com.google.common.collect.Lists;
import static org.junit.Assert.assertEquals;
public class Example {
public static interface Thing {
String getName();
}
public static class ThingImpl implements Thing {
private final String name;
public ThingImpl(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
public static void main(String[] args) {
Registry child = Registry.builder().add(Thing.class, new ThingImpl("child-1")).add(Thing.class, new ThingImpl("child-2")).build();
Registry parent = Registry.builder().add(Thing.class, new ThingImpl("parent-1")).add(Thing.class, new ThingImpl("parent-2")).build();
Registry joined = parent.join(child);
assertEquals("child-2", joined.get(Thing.class).getName());
List<Thing> all = Lists.newArrayList(joined.getAll(Thing.class));
assertEquals("child-2", all.get(0).getName());
assertEquals("child-1", all.get(1).getName());
assertEquals("parent-2", all.get(2).getName());
assertEquals("parent-1", all.get(3).getName());
}
}
child
- the child registrythis
and the given childstatic Registry empty()
static RegistryBuilder builder()
registry builder
.RegistryBuilder
static Registry of(Action<? super RegistrySpec> action) throws Exception
action
- the action that defines the registryException
- any thrown by the actionstatic Registry backedBy(RegistryBacking registryBacking)
registryBacking
- the implementation that returns instances for the registry@Deprecated static <T> Registry single(Class<T> publicType, Supplier<? extends T> supplier)
singleLazy(Class, Supplier)
singleLazy(Class, Supplier)
.T
- the public type of the entrypublicType
- the public type of the entrysupplier
- the supplier for the objectRegistryBuilder.addLazy(Class, Supplier)
static <T> Registry singleLazy(Class<T> publicType, Supplier<? extends T> supplier)
RegistryBuilder.addLazy(Class, Supplier)
.T
- the public type of the entrypublicType
- the public type of the entrysupplier
- the supplier for the objectRegistryBuilder.addLazy(Class, Supplier)
static Registry single(Object object)
RegistryBuilder.add(Object)
.object
- the entry objectRegistryBuilder.add(java.lang.Object)
static <T> Registry single(Class<? super T> publicType, T implementation)
RegistryBuilder.add(Class, Object)
.T
- the public type of the entrypublicType
- the public type of the entryimplementation
- the entry objectRegistryBuilder.add(Class, Object)