Transient bindings

By default every instance obtained using ActiveJ Inject is singleton. This means that instances are cached when retrieved the first time and then reused on future Injector#getInstance calls. This behavior is different from a default behaviour of a majority of other dependency injection frameworks.

However, there are situations when you do not want to cache an instance, but rather you want to create a new instance each time. For that you can use "transient" binding. Such bindings are special because instances retrieved using "transient" bindings are not cached. Such instances are recreated each time when being retrieved.

note

Transient bindings are not transitive. If you have a non-transient binding A that depends on an instance provided via a transient binding B, a binding A is not itself transient. It will use a cached instance of a transient binding.

Defining transient bindings

There are multiple ways to define a transient binding.

We can use asTransient() method from the ModuleBuilder DSL and mark a binding as transient like this:

bind(double.class).to(Math::random).asTransient();

Or, alternatively we can use @Transient annotation to annotate methods already annotated with @Provides annotation:

@Providesdouble random() {    return Math.random();}

When you retrieve an instance of double from the injector you will get a new random number each time.

Transient binding example

Let's look at another example. Imagine that our application needs to know a current time. Therefore, we cannot cache an instance of an Instant. So, we should create a binding for an Instant as transient.

Let's define a module that defines a binding for an instance of current Instant (notice the @Transient annotation):

static class CurrentTimeModule extends AbstractModule {  @Provides  @Transient  Instant currentInstant() {    return Instant.now();  }}

Now let's retrieve two instances of an Instant from the injector waiting for a second between each retrieval:

Injector injector = Injector.of(new CurrentTimeModule());
System.out.println(injector.getInstance(Instant.class));Thread.sleep(1000);System.out.println(injector.getInstance(Instant.class));

If we run the example we will see that retrieved instances of Instant differ by approximately 1 second.

You can find a full example on Github