5 | */
6 | package se.jbee.inject.convert;
7 |
--------------------------------------------------------------------------------
/test.examples/test/java/test/example2/bus/BusModule.java:
--------------------------------------------------------------------------------
1 | package test.example2.bus;
2 |
3 | import se.jbee.inject.binder.BinderModule;
4 |
5 | public class BusModule extends BinderModule {
6 | @Override
7 | protected void declare() {
8 | autobind().in(BusService.class);
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/test.examples/test/java/test/example1/Example1EnvBundle.java:
--------------------------------------------------------------------------------
1 | package test.example1;
2 |
3 | import se.jbee.inject.binder.EnvModule;
4 |
5 | public class Example1EnvBundle extends EnvModule {
6 |
7 | @Override
8 | protected void declare() {
9 | bind(Integer.class).to(13);
10 | }
11 |
12 | }
13 |
--------------------------------------------------------------------------------
/se.jbee.inject.api/main/java/module-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Contains the core API of the library. Most prominently the {@link
3 | * se.jbee.inject.Injector} context abstraction.
4 | */
5 | module se.jbee.inject.api {
6 |
7 | requires transitive se.jbee.lang;
8 |
9 | exports se.jbee.inject;
10 |
11 | }
12 |
--------------------------------------------------------------------------------
/.idea/libraries/lib.xml:
--------------------------------------------------------------------------------
1 |
5 | * In multi-module application this is usually required by each module to bind
6 | * the services provided by the software module.
7 | */
8 | module se.jbee.inject.bind {
9 |
10 | requires transitive se.jbee.lang;
11 | requires transitive se.jbee.inject.api;
12 |
13 | exports se.jbee.inject.bind;
14 | exports se.jbee.inject.binder;
15 | exports se.jbee.inject.binder.spi;
16 | exports se.jbee.inject.config;
17 |
18 | uses se.jbee.inject.bind.Bundle;
19 | uses se.jbee.inject.bind.ModuleWith;
20 | }
21 |
--------------------------------------------------------------------------------
/test.examples/test/java/test/example2/car/CarEnvModule.java:
--------------------------------------------------------------------------------
1 | package test.example2.car;
2 |
3 | import se.jbee.inject.binder.Installs;
4 | import se.jbee.inject.binder.LocalEnvModule;
5 | import se.jbee.inject.config.NamesBy;
6 | import se.jbee.inject.config.ProducesBy;
7 | import se.jbee.lang.Type;
8 | import test.example2.Car;
9 | import test.example2.car.pool.CarPoolEnvModule;
10 |
11 | @Installs(bundles = CarPoolEnvModule.class)
12 | public class CarEnvModule extends LocalEnvModule {
13 |
14 | @Override
15 | protected void declare() {
16 | bind(NamesBy.class).to(NamesBy.DECLARED_NAME);
17 | bind(ProducesBy.class).to(ProducesBy.declaredMethods(false)
18 | .returnTypeAssignableTo(Type.raw(Car.class)));
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/.idea/se.jbee.inject.action.iml:
--------------------------------------------------------------------------------
1 |
2 |
7 | * In multi-module application this module should only be required in the single
8 | * module responsible for bootstrapping the application.
9 | */
10 | module se.jbee.inject.bootstrap {
11 |
12 | requires java.logging;
13 |
14 | requires transitive se.jbee.lang;
15 | requires transitive se.jbee.inject.api;
16 | requires transitive se.jbee.inject.bind;
17 | requires se.jbee.inject.container;
18 |
19 | exports se.jbee.inject.bootstrap;
20 | exports se.jbee.inject.defaults;
21 | exports se.jbee.inject.scope;
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/test.integration/test/java/test/integration/api/TestTarget.java:
--------------------------------------------------------------------------------
1 | package test.integration.api;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import se.jbee.inject.Dependency;
5 | import se.jbee.inject.Target;
6 |
7 | import java.util.List;
8 |
9 | import static org.junit.jupiter.api.Assertions.assertFalse;
10 | import static org.junit.jupiter.api.Assertions.assertTrue;
11 | import static se.jbee.inject.Dependency.dependency;
12 | import static se.jbee.inject.Target.targeting;
13 |
14 | class TestTarget {
15 |
16 | @Test
17 | void thatTargetInstancesNeedsToBeMatchedByDependencies() {
18 | Target target = targeting(List.class);
19 | Dependency
5 | * Each of the interfaces is a {@link java.lang.FunctionalInterface} that based
6 | * on on essential abstract method adds further {@code default} methods that
7 | * operate on the essential method. In most cases they provide an alternative
8 | * parameter list to allow use of different arguments in a convenient way. This
9 | * convenience "layer" can be added to API implementation by implementing the
10 | * interface.
11 | *
12 | * All interfaces have a type parameter for the binder type that is returned by
13 | * all of their methods so that implementations can return their specific binder
14 | * types.
15 | */
16 | package se.jbee.inject.binder.spi;
17 |
--------------------------------------------------------------------------------
/test.examples/test/java/test/ExamplesBundle.java:
--------------------------------------------------------------------------------
1 | package test;
2 |
3 | import se.jbee.inject.bind.Bootstrapper;
4 | import se.jbee.inject.bind.Bundle;
5 | import se.jbee.inject.binder.BundleFor;
6 | import se.jbee.inject.defaults.DefaultFeature;
7 | import test.example1.Example1RootBundle;
8 | import test.example2.Example2Bundle;
9 |
10 | public class ExamplesBundle extends BundleFor
7 | * It is in some sense a source value that can be turned into one or more
8 | * bindings during the binding process.
9 | *
10 | * The reason this is defined in the core is simply that some of the core types
11 | * should implement it. Otherwise this would be found in the binding module.
12 | *
13 | * @since 8.1
14 | */
15 | public interface Descriptor {
16 |
17 | /* just a marker */
18 |
19 |
20 | final class BridgeDescriptor implements Descriptor {
21 |
22 | public final Class type;
23 |
24 | public BridgeDescriptor(Class type) {
25 | this.type = type;
26 | }
27 | }
28 |
29 | final class ArrayDescriptor implements Descriptor {
30 | public final Hint[] elements;
31 |
32 | public ArrayDescriptor(Hint[] elements) {
33 | this.elements = elements;
34 | }
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/se.jbee.inject.api/main/java/se/jbee/inject/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Contains all essential concepts and types of the library. The user facing API
3 | * is the {@link se.jbee.inject.Injector}.
4 | *
5 | *
7 | * The root package with it essential types does not depend on any of its
8 | * sub-packages, the sub-packages depend on the root.
9 | *
13 | * To initialise objects created in the {@link se.jbee.inject.Injector} bind a
14 | * {@link se.jbee.inject.Lift} for the {@link se.jbee.lang.Type} of
15 | * objects it should initialise. This is mostly equivalent to a
16 | *
8 | * The {@link se.jbee.inject.bootstrap.Bootstrap#DEFAULT_ENV} is a default
9 | * implementation of {@link se.jbee.inject.Env} in form of a map. More complex
10 | * setup can be done by bootstrapping the {@link se.jbee.inject.Env} itself from
11 | * a root {@link se.jbee.inject.bind.Bundle} and convert the resulting {@link
12 | * se.jbee.inject.Injector} to an {@link se.jbee.inject.Env} using {@link
13 | * se.jbee.inject.Injector#asEnv()}. Most often such a setup will use {@link
14 | * se.jbee.inject.Env#with(se.jbee.inject.Name, Type,
15 | * java.lang.Object)} to add properties to the resulting environment that are
16 | * only available at runtime like command line arguments.
17 | *
4 | * {@link se.jbee.inject.action.Action}s are abstractions for vanilla Java
5 | * methods which are identified by their parameter and return type pair.
6 | *
7 | * Callers can inject them as {@link se.jbee.inject.action.Action} without
8 | * becoming dependent on the provider of the underlying implementation. This
9 | * allows a very loosely coupled highly modularised application composed out of
10 | * modules that do not need to know each other. The contract between the
11 | * application module are the data types of parameter and return types.
12 | *
13 | * {@link se.jbee.inject.action.Action}s can also be used do emulate method
14 | * interception without bytecode manipulation. All calls to {@link
15 | * se.jbee.inject.action.Action}s are executed using the {@link
16 | * se.jbee.inject.action.ActionExecutor}. Any custom interception can be implemented
17 | * by providing a custom {@link se.jbee.inject.action.ActionExecutor} implementation.
18 | */
19 | package se.jbee.inject.action;
20 |
--------------------------------------------------------------------------------
/se.jbee.inject.bind/main/java/se/jbee/inject/binder/spi/ConfiguringInstanceLocalBinder.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject.binder.spi;
2 |
3 | import se.jbee.inject.Instance;
4 | import se.jbee.inject.config.Config;
5 |
6 | /**
7 | * Makes a configuration binding. Any configuration is local to a target {@link
8 | * Instance}.
9 | *
10 | * @since 8.1
11 | *
12 | * @param return type of the binder step following a {@code configure} step
13 | */
14 | @FunctionalInterface
15 | public interface ConfiguringInstanceLocalBinder> extends
16 | InstanceLocalBinder {
17 |
18 | /**
19 | * Root for container "global" configuration.
20 | *
21 | * @since 8.1
22 | */
23 | default B configure() {
24 | return injectingInto(Config.class);
25 | }
26 |
27 | /**
28 | * Root for target type specific configuration.
29 | *
30 | * @since 8.1
31 | */
32 | default B configure(Class ns) {
33 | return configure().within(ns);
34 | }
35 |
36 | /**
37 | * Root for {@link Instance} specific configuration.
38 | *
39 | * @since 8.1
40 | */
41 | default B configure(Instance ns) {
42 | return configure().within(ns);
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/se.jbee.inject.bind/main/java/se/jbee/inject/binder/spi/ReferenceBinder.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject.binder.spi;
2 |
3 | import se.jbee.inject.Instance;
4 | import se.jbee.inject.Name;
5 | import se.jbee.lang.Type;
6 |
7 | import static se.jbee.inject.Instance.instance;
8 | import static se.jbee.inject.Name.named;
9 | import static se.jbee.lang.Type.raw;
10 |
11 | /**
12 | * Bind a resource to a forward referenced {@link Instance}.
13 | *
14 | * This is practically publishing the referenced {@link Instance} as the bound
15 | * "API" resource.
16 | *
17 | * @param
5 | * The methods to call are identified using {@connect} feature which is based on
6 | * {@link se.jbee.inject.Lift}s.
7 | *
8 | * The {@link se.jbee.inject.schedule.Scheduled} annotation can be used to mark
9 | * methods that should be called and define their {@link
10 | * se.jbee.inject.schedule.Schedule}.
11 | *
12 | * Annotated methods can have parameters which are injected. The idea is to
13 | * reverse the code dependencies. Instead of making all classes dependent on the
14 | * code that runs the scheduling the desired schedule is declared in a
15 | * declarative way. This allows to switch the executing code without modifying
16 | * any of the classes that have the need for scheduled tasks. Also all
17 | * dependencies that are only needed to run the task body can be made parameters
18 | * of the scheduled method reducing the need for fields that are otherwise not
19 | * used in the class.
20 | *
21 | * Users can add custom ways to derive a {@link se.jbee.inject.schedule.Schedule}
22 | * by registering a named {@link se.jbee.inject.schedule.Schedule.ScheduleFactory}.
23 | */
24 | package se.jbee.inject.schedule;
25 |
--------------------------------------------------------------------------------
/se.jbee.inject.bind/main/java/se/jbee/inject/binder/spi/PackageLocalBinder.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject.binder.spi;
2 |
3 | import se.jbee.inject.Packages;
4 |
5 | import static se.jbee.inject.Packages.*;
6 |
7 | /**
8 | * Make a binding local to a specific package. This means the binding only
9 | * applies for an injection if the injected bean class is defined within the
10 | * packages declared.
11 | *
12 | * @since 8.1
13 | *
14 | * @param return type of the binder step following a {@code in} step
15 | */
16 | @FunctionalInterface
17 | public interface PackageLocalBinder {
18 |
19 | /**
20 | * Make all bindings made with the returned binder local to the provided set
21 | * of {@link Packages}.
22 | *
23 | * @param packages a set of {@link Packages} all following binding should
24 | * apply to
25 | * @return next step in fluent API
26 | */
27 | B in(Packages packages);
28 |
29 | /**
30 | * @see #in(Packages)
31 | */
32 | default B inPackageAndSubPackagesOf(Class type) {
33 | return in(packageAndSubPackagesOf(type));
34 | }
35 |
36 | /**
37 | * @see #in(Packages)
38 | */
39 | default B inPackageOf(Class type) {
40 | return in(packageOf(type));
41 | }
42 |
43 | /**
44 | * @see #in(Packages)
45 | */
46 | default B inSubPackagesOf(Class type) {
47 | return in(subPackagesOf(type));
48 | }
49 |
50 | }
51 |
--------------------------------------------------------------------------------
/test.integration/test/java/test/integration/bind/TestExampleDecoratorBinds.java:
--------------------------------------------------------------------------------
1 | package test.integration.bind;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import se.jbee.inject.Injector;
5 | import se.jbee.inject.binder.BinderModule;
6 | import se.jbee.inject.bootstrap.Bootstrap;
7 |
8 | import static org.junit.jupiter.api.Assertions.assertEquals;
9 |
10 | /**
11 | * Test the fix for issue #61, falsely detection of dependency cycle when using
12 | * the decorator pattern.
13 | */
14 | class TestExampleDecoratorBinds {
15 |
16 | interface Foo {
17 | // the used abstraction
18 | }
19 |
20 | public static class Decorator implements Foo {
21 |
22 | final Foo decorated;
23 |
24 | public Decorator(Foo decorated) {
25 | this.decorated = decorated;
26 | }
27 |
28 | }
29 |
30 | public static class Bar implements Foo {
31 | // a special Foo for the Decorator
32 | }
33 |
34 | static class TestExampleDecoratorBindsModule extends BinderModule {
35 |
36 | @Override
37 | protected void declare() {
38 | bind(Foo.class).to(Decorator.class);
39 | injectingInto(Decorator.class).bind(Foo.class).to(Bar.class);
40 | }
41 | }
42 |
43 | @Test
44 | void decoratorPatternCanBeUsed() {
45 | Injector injector = Bootstrap.injector(TestExampleDecoratorBindsModule.class);
46 | assertEquals(Decorator.class, injector.resolve(Foo.class).getClass());
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/test.integration/test/java/test/integration/api/TestResource.java:
--------------------------------------------------------------------------------
1 | package test.integration.api;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import se.jbee.inject.*;
5 | import se.jbee.lang.Type;
6 |
7 | import java.io.Serializable;
8 | import java.util.ArrayList;
9 | import java.util.Arrays;
10 | import java.util.Collections;
11 | import java.util.List;
12 |
13 | import static java.util.stream.Collectors.toList;
14 | import static org.junit.jupiter.api.Assertions.assertEquals;
15 | import static se.jbee.lang.Type.raw;
16 |
17 | class TestResource {
18 |
19 | @Test
20 | void naturalOrderIsFromMostQualifiedToLeastQualified() {
21 | List
14 | * Therefore it is for example used to bootstrap the initial {@link Env}.
15 | *
16 | * By default this API binds all bindings as {@link se.jbee.inject.DeclarationType#DEFAULT}.
17 | *
18 | * @since 8.1
19 | */
20 | public abstract class SimpleModule extends SimpleBinder
21 | implements Bundle, Module {
22 |
23 | private Boolean declaring;
24 |
25 | protected SimpleModule() {
26 | super(Bind.UNINITIALIZED.per(Scope.container));
27 | }
28 |
29 | protected abstract void declare();
30 |
31 | @Override
32 | public final void bootstrap(Bootstrapper bootstrap) {
33 | bootstrap.install(this);
34 | }
35 |
36 | @Override
37 | public final void declare(Bindings bindings, Env env) {
38 | InconsistentBinding.nonnullThrowsReentranceException(declaring);
39 | configure(bind -> bind
40 | .into(env, bindings)
41 | .with(source(getClass()))
42 | .asDefault());
43 | declaring = true;
44 | declare();
45 | }
46 |
47 | }
48 |
--------------------------------------------------------------------------------
/se.jbee.inject.event/main/java/se/jbee/inject/event/EventTrigger.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject.event;
2 |
3 | import se.jbee.lang.Type;
4 |
5 | import java.util.function.Consumer;
6 |
7 | /**
8 | * An {@link EventTrigger} is an independent source of a particular type of
9 | * event.
10 | *
11 | * When an event type has known receivers the corresponding {@link EventTrigger}
12 | * is resolved and {@link #activate(Consumer)} is called passing in a callback
13 | * to the dispatch which should be used by the trigger in case it wants to
14 | * trigger an event of its type in the future.
15 | *
16 | * @param
3 | * This package contains the default implementation for the {@link
4 | * se.jbee.inject.Injector} context. It is created from a list of {@link
5 | * se.jbee.inject.ResourceDescriptor}s. Once a context is created the list of
6 | * {@link se.jbee.inject.Resource}s it contains it immutable. This means the
7 | * type of things it knows how to resolve is fixed.
8 | *
12 | * Many of the "basic" features of the {@link se.jbee.inject.Injector} are actually
13 | * defined in user space in form of {@code se.jbee.inject.bind.Module}s that make
14 | * bindings to produce {@link se.jbee.inject.ResourceDescriptor}s.
15 | *
16 | * For example {@link se.jbee.inject.Scope}s are usual {@link
17 | * se.jbee.inject.Resource}s that are bound to their implementations by default
18 | * by the {@code se.jbee.inject.defaults.DefaultScopes} module.
19 | *
23 | * The {@link se.jbee.inject.container.Container} implementation is independent
24 | * of the {@code se.jbee.inject.bind.Binding} based fluent API. Its bindings
25 | * extends the {@link se.jbee.inject.ResourceDescriptor} type that is the basis
26 | * of creating the actual container implementation.
27 | *
13 | * This basic implementation does not have any particular guarantees of fairness
14 | * in the presence of a changing list due to dynamic connects and disconnects.
15 | */
16 | public final class RoundRobinDispatch
9 | * One way to access a field only visible within their declaring classes package
10 | * is to bind a local version of {@link Get}:
11 | *
15 | * Alternatively the implementation of {@link Get} could use {@link
16 | * java.lang.reflect.AccessibleObject#setAccessible(boolean)} which with java
17 | * module system will require to open the module accordingly.
18 | */
19 | @FunctionalInterface
20 | public interface Get {
21 |
22 | /**
23 | * An implementation of this method should basically just call {@link
24 | * Field#get(Object)}.
25 | *
26 | * To work around visibility limitations the implementation of this method
27 | * can be defined and bound in the package of the called {@link Field}.
28 | *
29 | * Alternatively an implementation could for example use {@link
30 | * java.lang.reflect.AccessibleObject#setAccessible(boolean)} to make the
31 | * {@link Field} accessible before accessing it.
32 | *
33 | * The implementation could also do an entirely different thing as long as
34 | * the result is equivalent to accessing the provided {@link Field} of the
35 | * provided instance.
36 | *
37 | * @see Field#get(Object)
38 | */
39 | Object call(Field target, Object instance) throws Exception;
40 | }
41 |
--------------------------------------------------------------------------------
/se.jbee.inject.api/main/java/se/jbee/inject/Injection.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2012-2019, Jan Bernitt
3 | *
4 | * Licensed under the Apache License, Version 2.0, http://www.apache.org/licenses/LICENSE-2.0
5 | */
6 | package se.jbee.inject;
7 |
8 | import java.io.Serializable;
9 |
10 | /**
11 | * Describes a "stack-frame" or "layer" within the injection process.
12 | *
13 | * For example, when resolving instance A which causes resolving instance B the
14 | * resolution or injection of A becomes the first frame, the injection of B the
15 | * second and so forth.
16 | */
17 | public final class Injection implements Serializable {
18 |
19 | public final Instance dependency;
20 | public final Locator target;
21 | public final ScopeLifeCycle lifeCycle;
22 |
23 | public Injection(Instance dependency, Locator target,
24 | ScopeLifeCycle lifeCycle) {
25 | this.dependency = dependency;
26 | this.target = target;
27 | this.lifeCycle = lifeCycle;
28 | }
29 |
30 | @Override
31 | public boolean equals(Object obj) {
32 | return obj instanceof Injection && equalTo((Injection) obj);
33 | }
34 |
35 | @Override
36 | public int hashCode() {
37 | return dependency.hashCode() ^ target.hashCode();
38 | }
39 |
40 | public boolean equalTo(Injection other) {
41 | return this == other || dependency.equalTo(other.dependency)
42 | && target.equalTo(other.target);
43 | }
44 |
45 | @Override
46 | public String toString() {
47 | return dependency + " from " + target;
48 | }
49 |
50 | public Injection ignoredScoping() {
51 | return new Injection(dependency, target, ScopeLifeCycle.ignore);
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/se.jbee.inject.bind/main/java/se/jbee/inject/bind/BindingType.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2012-2019, Jan Bernitt
3 | *
4 | * Licensed under the Apache License, Version 2.0, http://www.apache.org/licenses/LICENSE-2.0
5 | */
6 | package se.jbee.inject.bind;
7 |
8 | import se.jbee.inject.Supplier;
9 |
10 | /**
11 | * What is supplying instances for a {@link Binding}?
12 | *
13 | * As we cannot look into the implementation of a {@link Supplier} this type
14 | * groups ways to supply instances.
15 | */
16 | public enum BindingType {
17 |
18 | /**
19 | * The binding expresses a need, it is unclear if another binding can fulfil
20 | * it.
21 | */
22 | REQUIRED,
23 |
24 | /**
25 | * The binding is a forward reference to a sub-type (implementation type) or
26 | * to a virtual or generic instance factory like one for lists or other type
27 | * parameterised "bridges".
28 | */
29 | REFERENCE,
30 |
31 | /**
32 | * The instances are supplied from a {@link Supplier} that has been defined
33 | * before expansion. This might be user defined or hard-wired one within the
34 | * binder API.
35 | */
36 | PREDEFINED,
37 |
38 | /**
39 | * The instances are supplied by constructing new ones using a constructor.
40 | */
41 | CONSTRUCTOR,
42 |
43 | /**
44 | * The instances are supplied using a factory method.
45 | */
46 | METHOD,
47 |
48 | /**
49 | * The instance is supplied from a field. Field is read each time supply
50 | * occurs.
51 | */
52 | FIELD,
53 |
54 | /**
55 | * The binding is an incomplete value that should be expanded into a
56 | * complete {@link Binding}.
57 | */
58 | VALUE,
59 | }
60 |
--------------------------------------------------------------------------------
/se.jbee.inject.api/main/java/se/jbee/inject/Converter.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject;
2 |
3 | import se.jbee.lang.Type;
4 |
5 | /**
6 | * General abstraction for value type conversion.
7 | *
8 | * @author Jan Bernitt
9 | *
10 | * @param type of the input value
11 | * @param type of the output value (converted value)
12 | */
13 | @FunctionalInterface
14 | public interface Converter
3 | * This package contains {@link se.jbee.inject.bind.Bundle} implementations
4 | * which allow to pick up application level {@link se.jbee.inject.bind.Bundle}s
5 | * using java's {@link java.util.ServiceLoader} mechanism.
6 | *
10 | * To pick up {@link se.jbee.inject.bind.Bundle}s defined via {@link
11 | * java.util.ServiceLoader} as part of the {@link se.jbee.inject.Injector}
12 | * context install the {@link se.jbee.inject.binder.ServiceLoaderBundles} bundle
13 | * in one of your application's {@link se.jbee.inject.bind.Bundle}s when
14 | * creating the {@link se.jbee.inject.Injector} context.
15 | *
19 | * To pick up {@link se.jbee.inject.bind.Bundle}s defined via {@link
20 | * java.util.ServiceLoader} as part of the {@link se.jbee.inject.Env} context
21 | * install the {@link se.jbee.inject.binder.ServiceLoaderEnvBundles} bundle in
22 | * one of your application's environment {@link se.jbee.inject.bind.Bundle}s
23 | * when creating the {@link se.jbee.inject.Env} context.
24 | *
28 | * To pick up {@link se.jbee.inject.bind.ModuleWith} defining the effects of an
29 | * particular {@link java.lang.annotation.Annotation} install the {@link
30 | * se.jbee.inject.binder.ServiceLoaderAnnotations} {@link
31 | * se.jbee.inject.bind.Module} as part of the {@link se.jbee.inject.Env}
32 | * context.
33 | *
9 | * One way to call methods only visible within their declaring classes package
10 | * is to bind a local version of {@link Invoke}:
11 | *
15 | * Alternatively the implementation of {@link Invoke} could use {@link
16 | * java.lang.reflect.AccessibleObject#setAccessible(boolean)} which with java
17 | * module system will require to open the module accordingly.
18 | */
19 | @FunctionalInterface
20 | public interface Invoke {
21 |
22 | /**
23 | * An implementation of this method should basically just call {@link
24 | * Method#invoke(Object, Object...)}.
25 | *
26 | * To work around visibility limitations the implementation of this method
27 | * can be defined and bound in the package of the called {@link Method}.
28 | *
29 | * Alternatively an implementation could for example use {@link
30 | * java.lang.reflect.AccessibleObject#setAccessible(boolean)} to make the
31 | * {@link Method} accessible before calling it.
32 | *
33 | * The implementation could also do an entirely different thing as long as
34 | * the result is equivalent to calling the provided {@link Method} with the
35 | * provided arguments.
36 | *
37 | * @see Method#invoke(Object, Object...)
38 | */
39 | Object call(Method target, Object instance, Object[] args) throws Exception;
40 | }
41 |
--------------------------------------------------------------------------------
/se.jbee.lang/main/java/se/jbee/lang/Qualifying.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2012-2019, Jan Bernitt
3 | *
4 | * Licensed under the Apache License, Version 2.0, http://www.apache.org/licenses/LICENSE-2.0
5 | */
6 | package se.jbee.lang;
7 |
8 | /**
9 | * When determining what resource is used to inject a dependency
10 | * everything is sorted starting with the most {@link Qualifying}. The most
11 | * qualified match is injected.
12 | *
13 | * @author Jan Bernitt (jan@jbee.se)
14 | *
15 | * @param
9 | * One way to make local classes constructable using reflection is to bind a
10 | * local version of {@link New}.
11 | *
15 | * Alternatively the implementation of {@link New} could use {@link
16 | * java.lang.reflect.AccessibleObject#setAccessible(boolean)} which with java
17 | * module system will require to open the module accordingly.
18 | */
19 | @FunctionalInterface
20 | public interface New {
21 |
22 | /**
23 | * An implementation of this method should basically just call {@link
24 | * Constructor#newInstance(Object...)}.
25 | *
26 | * To work around visibility limitations the implementation of this method
27 | * can be defined and bound in the package of the called {@link
28 | * Constructor}.
29 | *
30 | * Alternatively an implementation could for example use {@link
31 | * java.lang.reflect.AccessibleObject#setAccessible(boolean)} to make the
32 | * {@link Constructor} accessible before calling it.
33 | *
34 | * The implementation could also do an entirely different thing as long as
35 | * the result is equivalent to calling the provided {@link Constructor} with
36 | * the provided arguments.
37 | *
38 | * @see Constructor#newInstance(Object...)
39 | */
40 |
3 | * This package contains tests that use the fluent {@link
4 | * se.jbee.inject.binder.Binder} API to setup a test scenario.
5 | *
6 | * This means almost all of them bootstrap an {@link se.jbee.inject.Injector}
7 | * context for that test scenario and verify the behaviour of the resulting
8 | * {@link se.jbee.inject.Injector}. Supposedly this is best described as
9 | * component tests. They test all involved parts from the user facing fluent API
10 | * to declare the test scenario to the inner workings of the {@link
11 | * se.jbee.inject.Injector} to verify the correct behaviour.
12 | *
14 | * The tests are grouped in 4 groups:
15 | *
19 | * Use the name pattern {@code TestBasic*}. They show-case the basics of the
20 | * fluent API and their effects in small self-contained scenarios focussing on a
21 | * single concept or type of binding. They are also meant as a beginners guide
22 | * to learn the fundamentals of the library.
23 | *
27 | * Use the name pattern {@code TestExample*}. They show-case how to solve a
28 | * particular problem in mostly small self-contained examples. They are also
29 | * meant as a reference or template that can be analysed and adopted to the
30 | * users problem.
31 | *
35 | * Use the name pattern {@code TestFeature*}. They are meant to verify the
36 | * correct behaviour of a single feature. As such they can be used as a
37 | * reference for that particular feature.
38 | *
3 | * Contains the default implementations of common {@link se.jbee.inject.Scope}s.
4 | * In the library a scope implementation is a managed container instance.
5 | *
9 | * The {@link se.jbee.inject.defaults.DefaultScopes} {@link
10 | * se.jbee.inject.bind.Module} is used to define the common {@link
11 | * se.jbee.inject.Scope} implementations.
12 | *
10 | * Different implementations have different strategies to select the {@link
11 | * ActionSite} to use for each particular call and how to handle different types
12 | * of errors.
13 | *
14 | * @param key input value type (parameter type of the {@link Action})
15 | * @param output value type (return type of the {@link Action})
16 | * @see RoundRobinDispatch
17 | * @see MulticastDispatch
18 | * @since 8.1
19 | */
20 | @FunctionalInterface
21 | public interface ActionDispatch
14 | * For example a {@link Method}, {@link Constructor} or {@link Field} but also
15 | * any form of user defined source.
16 | *
17 | * @since 8.1
18 | */
19 | @FunctionalInterface
20 | public interface Annotated {
21 |
22 | /**
23 | * @return the underlying source for annotations
24 | */
25 | AnnotatedElement element();
26 |
27 | @FunctionalInterface
28 | interface Enhancer extends UnaryOperator
19 | * This is also meant as a template to learn how to implement a similar feature
20 | * for another logging framework. Just have a look at how the {@link
21 | * BinderModule} implementing the {@link DefaultFeature#LOGGER} toggle is
22 | * implemented.
23 | */
24 | class TestBasicLoggerBinds {
25 |
26 | @Installs(features = DefaultFeature.class, by = DefaultFeatures.class)
27 | @DefaultFeatures(DefaultFeature.LOGGER)
28 | private static class TestBasicLoggerBindsModule extends BinderModule {
29 |
30 | @Override
31 | protected void declare() {
32 | construct(Foo.class);
33 | }
34 |
35 | }
36 |
37 | public static class Foo {
38 |
39 | final Logger logger;
40 |
41 | @SuppressWarnings("unused")
42 | public Foo(Logger logger) {
43 | this.logger = logger;
44 | }
45 | }
46 |
47 | @Test
48 | void eachClassGetsTheLoggerWithItsCanonicalNameInjected() {
49 | Injector context = Bootstrap.injector(TestBasicLoggerBindsModule.class);
50 | Foo foo = context.resolve(Foo.class);
51 | assertSame(Logger.getLogger(Foo.class.getCanonicalName()), foo.logger);
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/se.jbee.inject.convert/main/java/se/jbee/inject/convert/Converts.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject.convert;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Repeatable;
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.Target;
7 |
8 | import static java.lang.annotation.ElementType.*;
9 | import static java.lang.annotation.RetentionPolicy.RUNTIME;
10 |
11 | /**
12 | * Is added to {@link se.jbee.inject.Converter}s to add additional input value
13 | * transformation chains to extend the possible input types of a particular
14 | * {@link se.jbee.inject.Converter}.
15 | */
16 | @Documented
17 | @Repeatable(ConvertsMultiple.class)
18 | @Retention(RUNTIME)
19 | @Target({ TYPE, METHOD, CONSTRUCTOR, FIELD })
20 | public @interface Converts {
21 |
22 | /**
23 | * @return A conversion sequence, for example {@code A, B, C} means a value
24 | * of type {@code A} is first converted to {@code B} and from {@code B} to
25 | * {@code C}. The final type (here {@code C}) should be the input type of
26 | * the {@link se.jbee.inject.Converter} this annotation is attached to.
27 | *
28 | * By adding such additional conversion a {@link se.jbee.inject.Converter}
29 | * with an input of {@code C} then can also be have inputs of type {@code A}
30 | * or {@code B} as we know how to get from those to the required input type
31 | * {@code C}.
32 | */
33 | String[] value();
34 |
35 | /**
36 | * @return The set of {@link Class} to import so that their {@link
37 | * Class#getSimpleName()} can be used in the conversion sequence given by
38 | * {@link #value()}. Alternativly (or in addition) the {@link Imports}
39 | * annotation can be used to provide the full {@link Class} references for
40 | * simple class names.
41 | */
42 | Class[] imports() default {};
43 | }
44 |
--------------------------------------------------------------------------------
/test.integration/test/java/test/integration/bind/TestBasicScopedBinds.java:
--------------------------------------------------------------------------------
1 | package test.integration.bind;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import se.jbee.inject.Injector;
5 | import se.jbee.inject.Scope;
6 | import se.jbee.inject.UnresolvableDependency.UnstableDependency;
7 | import se.jbee.inject.binder.BinderModule;
8 | import se.jbee.inject.bootstrap.Bootstrap;
9 |
10 | import static org.junit.jupiter.api.Assertions.assertEquals;
11 | import static org.junit.jupiter.api.Assertions.assertThrows;
12 |
13 | /**
14 | * Very simple demo of the {@link se.jbee.inject.ScopeLifeCycle}s that help to
15 | * detect scoping errors, such as trying to inject an instance in {@link
16 | * Scope#injection} into another one in {@link Scope#application}.
17 | */
18 | class TestBasicScopedBinds {
19 |
20 | private static class Foo {
21 |
22 | @SuppressWarnings("unused")
23 | Foo(Bar bar) {
24 | // it is just about the instances
25 | }
26 | }
27 |
28 | private static class Bar {
29 | // just to demo
30 | }
31 |
32 | private static class TestBasicScopedBindsModule extends BinderModule {
33 |
34 | @Override
35 | protected void declare() {
36 | per(Scope.application).construct(Foo.class);
37 | per(Scope.injection).construct(Bar.class);
38 | }
39 | }
40 |
41 | private final Injector context = Bootstrap.injector(
42 | TestBasicScopedBindsModule.class);
43 |
44 | @Test
45 | void injectingAnInjectionScopedInstanceIntoAppScopedInstanceThrowsAnException() {
46 | Exception ex = assertThrows(UnstableDependency.class, () -> context.resolve(Foo.class));
47 | assertEquals("Unstable dependency injection\n"
48 | + "\t of: test.integration.bind.TestBasicScopedBinds.Bar scoped injection\n"
49 | + "\tinto: test.integration.bind.TestBasicScopedBinds.Foo scoped application",
50 | ex.getMessage());
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/se.jbee.inject.bind/main/java/se/jbee/inject/binder/spi/InstanceLocalBinder.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject.binder.spi;
2 |
3 | import se.jbee.inject.Instance;
4 | import se.jbee.inject.Name;
5 | import se.jbee.lang.Type;
6 |
7 | import static se.jbee.inject.Instance.defaultInstanceOf;
8 | import static se.jbee.inject.Name.named;
9 | import static se.jbee.lang.Type.raw;
10 |
11 | /**
12 | * Make a binding local to the injected {@link Instance}.
13 | *
14 | * Usually this is used to specify what parameter to use when injecting the
15 | * target instance.
16 | *
17 | * @since 8.1
18 | *
19 | * @param return type of the binder step following a {@code injectingInto}
20 | * step
21 | */
22 | @FunctionalInterface
23 | public interface InstanceLocalBinder {
24 |
25 | /**
26 | * Makes all bindings made with the returned binder local to the injection
27 | * of the provided {@link Instance}, in other words when dependencies of
28 | * that {@link Instance} are resolved.
29 | *
30 | * @param target the injected {@link Instance}
31 | * @return next step in fluent API
32 | */
33 | B injectingInto(Instance target);
34 |
35 | /**
36 | * @see #injectingInto(Instance)
37 | */
38 | default B injectingInto(String name, Class type) {
39 | return injectingInto(named(name), raw(type));
40 | }
41 |
42 | /**
43 | * @see #injectingInto(Instance)
44 | */
45 | default B injectingInto(Name name, Type type) {
46 | return injectingInto(Instance.instance(name, type));
47 | }
48 |
49 | /**
50 | * @see #injectingInto(Instance)
51 | */
52 | default B injectingInto(Type target) {
53 | return injectingInto(defaultInstanceOf(target));
54 | }
55 |
56 | /**
57 | * @see #injectingInto(Instance)
58 | */
59 | default B injectingInto(Class target) {
60 | return injectingInto(raw(target));
61 | }
62 |
63 | }
64 |
--------------------------------------------------------------------------------
/se.jbee.inject.api/main/java/se/jbee/inject/InconsistentDeclaration.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2012-2019, Jan Bernitt
3 | *
4 | * Licensed under the Apache License, Version 2.0, http://www.apache.org/licenses/LICENSE-2.0
5 | */
6 | package se.jbee.inject;
7 |
8 | import java.lang.annotation.Annotation;
9 |
10 | /**
11 | * If there is a statically resolvable problem with a binding ({@link Locator}
12 | * in the context of a container) this exception is thrown during bootstrapping.
13 | * It is never thrown after the bootstrapping step has finished (a
14 | * {@link Injector} was created successfully).
15 | *
16 | * @see UnresolvableDependency
17 | */
18 | public class InconsistentDeclaration extends RuntimeException {
19 |
20 | public InconsistentDeclaration(Exception cause) {
21 | super(cause);
22 | }
23 |
24 | public InconsistentDeclaration(String msg, Exception cause) {
25 | super(msg, cause);
26 | }
27 |
28 | public InconsistentDeclaration(String msg) {
29 | super(msg);
30 | }
31 |
32 | // Text should answer: What is the problem with the binding or in the binding process?
33 |
34 | public static InconsistentDeclaration notConstructable(Class impl) {
35 | return new InconsistentDeclaration(
36 | "Attempt to bind a non-constructable type: " + impl);
37 | }
38 |
39 | public static InconsistentDeclaration incomprehensibleHint(
40 | Hint hint) {
41 | return new InconsistentDeclaration(
42 | "Attempt to give a parameter hint that does not fit the target: "
43 | + hint);
44 | }
45 |
46 | public static InconsistentDeclaration annotationLacksProperty(
47 | Class property, Class type) {
48 | return new InconsistentDeclaration("Attempt to use an annotation "
49 | + type.getSimpleName() + " that lacks a expected property of type: "
50 | + property.getSimpleName());
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
1 | __.__
2 | ______ __ _________ ____ |__|__| ____
3 | \____ \| | \_ __ \_/ __ \ | | |/ \
4 | | |_> > | /| | \/\ ___/ | | | | \
5 | | __/|____/ |__| \___ >\__| |__|___| /
6 | |__| \/\______| \/
7 |
8 | Build with Java 22+, usable with Java 11+
9 |
10 | Docs http://jbee.github.io/purejin/
11 | Feedback http://github.com/jbee/purejin/issues
12 | Contribute http://github.com/jbee/purejin/pulls
13 | CI https://github.com/jbee/purejin/actions
14 | Releases https://github.com/jbee/purejin/releases
15 | --------------------------------------------------------------------------
16 |
17 | Build https://github.com/sormuras/bach
18 |
19 | - Install JDK 22 (or higher) on your machine
20 | - Clone project sources with submodules
21 | - Execute `java @build`
22 |
23 | --------------------------------------------------------------------------
24 |
25 | License http://www.apache.org/licenses/LICENSE-2.0
26 |
27 | Copyright (c) 2012-2024 Jan Bernitt
28 |
29 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
30 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
33 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
34 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
37 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
39 | THE POSSIBILITY OF SUCH DAMAGE.
40 |
--------------------------------------------------------------------------------
/test.integration/test/java/test/integration/bind/TestExampleInterfaceDecouplingBinds.java:
--------------------------------------------------------------------------------
1 | package test.integration.bind;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import se.jbee.inject.Injector;
5 | import se.jbee.inject.binder.BinderModule;
6 | import se.jbee.inject.bootstrap.Bootstrap;
7 |
8 | import static org.junit.jupiter.api.Assertions.assertNotSame;
9 | import static se.jbee.inject.Name.named;
10 |
11 | /**
12 | * This illustrates how to use different named instances for the same interface
13 | * that are all implemented by the same class without having them linked to the
14 | * same instance.
15 | */
16 | class TestExampleInterfaceDecouplingBinds {
17 |
18 | interface Decoupling {
19 |
20 | }
21 |
22 | public static class DefaultImpl implements Decoupling {
23 |
24 | }
25 |
26 | static class TestExampleInterfaceDecouplingBindsModule extends BinderModule {
27 |
28 | @Override
29 | protected void declare() {
30 | bind(named("a"), Decoupling.class).toConstructor(DefaultImpl.class);
31 | bind(named("b"), Decoupling.class).toConstructor(DefaultImpl.class);
32 | bind(named("c"), Decoupling.class).toConstructor(DefaultImpl.class);
33 | bind(named("d"), Decoupling.class).toConstructor(DefaultImpl.class);
34 | }
35 | }
36 |
37 | @Test
38 | void instancesAreAllDifferentButUseTheSameInterface() {
39 | Injector injector = Bootstrap.injector(
40 | TestExampleInterfaceDecouplingBindsModule.class);
41 | Decoupling a = injector.resolve("a", Decoupling.class);
42 | Decoupling b = injector.resolve("b", Decoupling.class);
43 | Decoupling c = injector.resolve("c", Decoupling.class);
44 | Decoupling d = injector.resolve("d", Decoupling.class);
45 |
46 | assertNotSame(a, b);
47 | assertNotSame(a, c);
48 | assertNotSame(a, d);
49 | assertNotSame(b, c);
50 | assertNotSame(b, d);
51 | assertNotSame(c, d);
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/test.integration/test/java/test/integration/bind/TestFeaturePackageLocalClassesBinds.java:
--------------------------------------------------------------------------------
1 | package test.integration.bind;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import se.jbee.inject.Injector;
5 | import se.jbee.inject.binder.BinderModule;
6 | import se.jbee.inject.bootstrap.Bootstrap;
7 | import se.jbee.inject.config.New;
8 |
9 | import java.lang.reflect.Constructor;
10 |
11 | import static org.junit.jupiter.api.Assertions.assertNotNull;
12 |
13 | /**
14 | * Shows the simply but awesome feature of allowing default and package visible
15 | * managed instances created from constructors using reflection without using
16 | * deep reflection ({@link java.lang.reflect.AccessibleObject#setAccessible(boolean)})
17 | * if adding the following binding to one of the {@link
18 | * se.jbee.inject.bind.Module}s in the same package:
19 | *
20 | *
24 | * The lambda that is created this way is only used within the package and as it
25 | * is defined in the package will have access to all classes visible in the
26 | * package.
27 | */
28 | class TestFeaturePackageLocalClassesBinds {
29 |
30 | private static class TestFeaturePackageLocalClassesBindsModule extends
31 | BinderModule {
32 |
33 | @Override
34 | protected void declare() {
35 | locally().bind(New.class).to(Constructor::newInstance);
36 | construct(DefaultVisibleBean.class);
37 | }
38 | }
39 |
40 | static class DefaultVisibleBean {
41 |
42 | DefaultVisibleBean() {
43 | // default visible constructor
44 | }
45 | }
46 |
47 | private final Injector context = Bootstrap.injector(
48 | TestFeaturePackageLocalClassesBindsModule.class);
49 |
50 | @Test
51 | void localNewBindAllowsCreatingDefaultVisibleBeans() {
52 | assertNotNull(context.resolve(DefaultVisibleBean.class));
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
1 | # This workflow builds a modular Java project with Bach.java
2 | # For more information see:
3 | # - https://help.github.com/en/actions/language-and-framework-guides/github-actions-for-java
4 | # - https://github.com/sormuras/bach
5 |
6 | name: 'CI'
7 |
8 | on:
9 | push:
10 | branches: [ master ]
11 | pull_request:
12 | branches: [ master ]
13 |
14 | env:
15 | PROJECT_VERSION: '11-ea'
16 |
17 | jobs:
18 | build:
19 | name: "Build (JDK-${{ matrix.java }}, ${{ matrix.os }})"
20 | strategy:
21 | fail-fast: false
22 | matrix:
23 | os: [ ubuntu-latest ]
24 | java: [ 22 ]
25 | language: [ 'java' ]
26 | runs-on: ${{ matrix.os }}
27 | steps:
28 | - name: 'Check out sources'
29 | uses: actions/checkout@v4
30 | with:
31 | submodules: recursive
32 | - name: 'Set up JDK'
33 | uses: oracle-actions/setup-java@v1
34 | with:
35 | release: ${{ matrix.java }}
36 | - name: 'Set up version'
37 | run: |
38 | SHA7=$(echo "${{ github.sha }}" | cut -c1-7)
39 | VERSION=${PROJECT_VERSION}+${SHA7}
40 | echo "VERSION=${VERSION}" >> ${GITHUB_ENV}
41 | - name: 'Build with Bach'
42 | run: java --show-version -D--project-version=${VERSION} @build
43 | - name: 'Generate API documentation'
44 | run: java -D--project-version=${VERSION} .bach/src/Document.java
45 | - name: 'Report test summary'
46 | if: always()
47 | uses: test-summary/action@v2
48 | with:
49 | paths: .bach/out/test-reports/**/TEST-*.xml
50 | - name: 'Upload build artifact'
51 | uses: actions/upload-artifact@v4
52 | with:
53 | name: ${{ github.event.repository.name }}-build-${{ env.VERSION }}
54 | path: |
55 | .bach/out/main/modules
56 |
--------------------------------------------------------------------------------
/test.integration/test/java/test/integration/example1/TestServiceLoaderBootstrapBinds.java:
--------------------------------------------------------------------------------
1 | package test.integration.example1;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import se.jbee.inject.Env;
5 | import se.jbee.inject.Injector;
6 | import se.jbee.inject.bind.Bundle;
7 | import se.jbee.inject.binder.ServiceLoaderBundles;
8 | import se.jbee.inject.binder.ServiceLoaderEnvBundles;
9 | import test.Example;
10 |
11 | import java.util.ServiceLoader;
12 |
13 | import static org.junit.jupiter.api.Assertions.assertEquals;
14 | import static org.junit.jupiter.api.Assertions.assertNotNull;
15 |
16 | /**
17 | * This test demonstrates how the {@link java.util.ServiceLoader} concept is
18 | * used to define one or more root {@link Bundle} {@link Class}es as
19 | *
17 | * By default it is assumed that the converters are defined as fields or methods
18 | * within the class extending the {@link ConverterModule}.
19 | *
20 | * Alternatively this base class can be used by overriding {@link #declare()}
21 | * and calling {@link #autobindConverters()} with other target types.
22 | *
23 | * Last but not least this can just act as a manual on how to bind converters
24 | * using {@link #autobind()} or other manual binds.
25 | *
26 | * @since 8.1
27 | */
28 | public abstract class ConverterModule extends BinderModule {
29 |
30 | @SuppressWarnings("rawtypes")
31 | private static final Type
15 | * A {@link Supplier} is the main "backend" (internal) abstraction to generate
16 | * or yield instances of the type supplied by the {@link Supplier}. Their
17 | * user-facing "frontend" counterpart is the {@link se.jbee.inject.Generator}.
18 | *
19 | * While {@link Supplier}s stay inaccessible for the user of the {@link
20 | * Injector} context the {@link se.jbee.inject.Generator}s that act as an facade
21 | * for their internal {@link Supplier} can be resolved by users like any other
22 | * dependency.
23 | *
24 | * @see TestFeatureResolveResourceBinds
25 | */
26 | class TestBasicSupplierBinds {
27 |
28 | public static class TestBasicSupplierBindsModule extends BinderModule
29 | implements Supplier
17 | * Hence, {@link Installs} should only be used on leaf classes that are not
18 | * subject to further inheritance. To install a {@link se.jbee.inject.bind.Bundle}
19 | * as a "side-effect" of a {@link se.jbee.inject.bind.Module} use the {@link
20 | * BinderModule#BinderModule(Class)} constructor.
21 | */
22 | class TestFeatureInstallsAnnotationBinds {
23 |
24 | @Installs(bundles = A.class)
25 | abstract static class RootModule extends BinderModule {
26 |
27 | }
28 |
29 | @Installs(bundles = B.class)
30 | abstract static class NodeModule extends RootModule {
31 |
32 | }
33 |
34 | static class LeafModule extends NodeModule {
35 |
36 | @Override
37 | protected void declare() {
38 | multibind(String.class).to("C");
39 | }
40 | }
41 |
42 | static class A extends BinderModule {
43 |
44 | @Override
45 | protected void declare() {
46 | multibind(String.class).to("A");
47 | }
48 | }
49 |
50 | static class B extends BinderModule {
51 |
52 | @Override
53 | protected void declare() {
54 | multibind(String.class).to("B");
55 | }
56 | }
57 |
58 | private final Injector context = Bootstrap.injector(LeafModule.class);
59 |
60 | @Test
61 | void installsOnSupertypesAreOverridden() {
62 | assertEqualsIgnoreOrder(new String[] { "B", "C" },
63 | context.resolve(String[].class));
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/se.jbee.inject.bind/main/java/se/jbee/inject/bind/ModuleWith.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2012-2019, Jan Bernitt
3 | *
4 | * Licensed under the Apache License, Version 2.0, http://www.apache.org/licenses/LICENSE-2.0
5 | */
6 | package se.jbee.inject.bind;
7 |
8 | import se.jbee.inject.Env;
9 | import se.jbee.inject.Name;
10 | import se.jbee.lang.Type;
11 |
12 | import java.lang.annotation.Annotation;
13 | import java.lang.reflect.Method;
14 |
15 | import static se.jbee.lang.Type.raw;
16 |
17 | /**
18 | * A {@link ModuleWith} is an extension to a usual {@link Module} that depends
19 | * on *one* of the values that have been set in the {@link Env}. The property is
20 | * resolved by type.
21 | *
22 | * {@link ModuleWith} are also used to apply the effects of custom
23 | * {@link Annotation}s. In that case the property passed is the annotated
24 | * {@link Class}.
25 | *
26 | * @see Module
27 | *
28 | * @param
19 | * Annotate a {@code se.jbee.inject.bind.ModuleWith} implementation that should
20 | * load via {@link ServiceLoader} to implement the effects of an type level
21 | * {@link Annotation} and have {@link Extends#value()} point to the
22 | * {@link Annotation} type that triggers the implementation
23 | * {@code se.jbee.inject.bind.ModuleWith}. If the provided {@link Class} is not
24 | * an {@link Annotation} type the module is ignored.
25 | *
29 | * Annotate a {@code se.jbee.inject.bind.Bundle} implementation that should load
30 | * via {@link ServiceLoader} have {@link Extends#value()} be {@link Env}
31 | * {@link Class} to add the bundle to those that should be loaded as part of the
32 | * {@link Env} instead of the {@link Injector} context. To add
33 | * {@code se.jbee.inject.bind.Bundle}s to the {@link Injector} context don't
34 | * annotate them with {@link Extends} or use {@link Injector} {@link Class} as
35 | * {@link Extends#value()}.
36 | *
37 | *
38 | * @since 8.1
39 | */
40 | @Inherited
41 | @Documented
42 | @Retention(RUNTIME)
43 | @Target(TYPE)
44 | public @interface Extends {
45 |
46 | /**
47 | * @return refers to a type in the context of the annotated extension. The
48 | * semantic depends on the annotated type. See class level
49 | * documentation for details.
50 | */
51 | Class value();
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/se.jbee.inject.bind/main/java/se/jbee/inject/binder/spi/ParentLocalBinder.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject.binder.spi;
2 |
3 | import se.jbee.inject.Instance;
4 | import se.jbee.inject.Name;
5 | import se.jbee.lang.Type;
6 |
7 | import static se.jbee.inject.Instance.anyOf;
8 | import static se.jbee.inject.Instance.instance;
9 | import static se.jbee.inject.Name.named;
10 | import static se.jbee.lang.Type.raw;
11 |
12 | /**
13 | * Make a binding local to the parent {@link Instance} of the currently injected
14 | * bean.
15 | *
16 | * Multiple calls to {@link #within(Instance)} (and its variants) can be used
17 | * to make the binding to a parent hierarchy.
18 | *
19 | * @since 8.1
20 | *
21 | * @param return type of the binder step following a {@code within} step
22 | */
23 | @FunctionalInterface
24 | public interface ParentLocalBinder {
25 |
26 | /**
27 | * Makes all bindings made with the returned binder local to the provided
28 | * parent instance.
29 | *
30 | * @param parent the parent {@link Instance} to match
31 | * @return next step in fluent API
32 | */
33 | B within(Instance parent);
34 |
35 | /**
36 | * @see #within(Instance)
37 | */
38 | default B within(String name, Class parent) {
39 | return within(instance(named(name), raw(parent)));
40 | }
41 |
42 | /**
43 | * @see #within(Instance)
44 | */
45 | default B within(Name name, Type parent) {
46 | return within(instance(name, parent));
47 | }
48 |
49 | /**
50 | * Makes all bindings made with the returned binder local to any parent
51 | * having the provided type.
52 | *
53 | * @param parent the type of parent instances to match
54 | * @return next step in fluent API
55 | */
56 | default B within(Class parent) {
57 | return within(raw(parent));
58 | }
59 |
60 | /**
61 | * Makes all bindings made with the returned binder local to any parent
62 | * having the provided type.
63 | *
64 | * @param parent the type of parent instances to match
65 | * @return next step in fluent API
66 | */
67 | default B within(Type parent) {
68 | return within(anyOf(parent));
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/se.jbee.inject.bootstrap/main/java/se/jbee/inject/defaults/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Contains {@link se.jbee.inject.bind.Bundle}s and {@link
3 | * se.jbee.inject.bind.Module}s that declare the {@link
4 | * se.jbee.inject.defaults.DefaultFeature}s of the library that are build in top of
5 | * the general container mechanism itself.
6 | *
7 | *
9 | * This also includes default implementations for {@link
10 | * se.jbee.inject.bind.ValueBinder}s (see {@link se.jbee.inject.defaults.DefaultValueBinders})
11 | * and the {@link se.jbee.inject.Supplier} implementations they use (see {@link
12 | * se.jbee.inject.binder.Supply}) as well as source value types expended by the
13 | * default {@link se.jbee.inject.bind.ValueBinder}s:
14 | *
21 | * The base classes mentioned in usage section all install the
22 | * {@link se.jbee.inject.defaults.DefaultsBundle} which binds defaults for
23 | * {@link se.jbee.inject.Scope}s, {@link se.jbee.inject.AnnotatedWith} and
24 | * {@link se.jbee.inject.config.Extension}. As always this can be uninstalled or
25 | * overridden using explicit binds.
26 | *
30 | * The {@link se.jbee.inject.defaults.AnnotatedWithModule} provides the default
31 | * implementation of the {@link se.jbee.inject.AnnotatedWith} utility type.
32 | *
34 | * The {@link se.jbee.inject.defaults.ExtensionModule} provides the default
35 | * implementation for {@link se.jbee.inject.config.Extension} concept.
36 | *
38 | * The {@link se.jbee.inject.defaults.DefaultFeature} basic adapters that extend
39 | * the range of types available based on other bound instances.
40 | * {@link se.jbee.inject.defaults.DefaultFeature#ENV} and
41 | * {@link se.jbee.inject.defaults.DefaultFeature#SUB_CONTEXT} are installed by
42 | * default.
43 | *
20 | * There is nothing special about this interface except that the {@link
21 | * SchedulerModule} connects it to the {@link Scheduled} annotation so
22 | * instances of implementing classes get connected via {@link
23 | * se.jbee.inject.Lift}.
24 | */
25 | interface Aware {}
26 |
27 | /**
28 | * @return The {@link TimeUnit} used for the {@link #every()} and {@link #starting()} property.
29 | */
30 | TimeUnit unit() default TimeUnit.SECONDS;
31 |
32 | /**
33 | * @return length of the scheduled interval in millis, seconds, minutes (depending on {@link #unit()})
34 | */
35 | int every() default 1;
36 |
37 | /**
38 | * @return
39 | */
40 | int starting() default -1;
41 |
42 | /**
43 | * @return name of the {@link se.jbee.inject.config.Config} property in case
44 | * the time is not given directly by {@link #every()} and {@link #unit()}.
45 | *
46 | * The annotated type is used as context for the {@link
47 | * se.jbee.inject.config.Config}.
48 | *
49 | * If this property is defined the time defined by {@link #every()} and
50 | * {@link #unit()} acts as a default or fallback in case the configuration
51 | * is not defined.
52 | */
53 | String by() default "";
54 |
55 | /**
56 | * @return maximum number of consecutive execution failures after which
57 | * scheduling is cancelled. If zero or negative execution is never
58 | * cancelled.
59 | */
60 | int maxFails() default 1;
61 | }
62 |
--------------------------------------------------------------------------------
/test.integration/test/java/test/integration/bind/TestBasicMultiInstallBinds.java:
--------------------------------------------------------------------------------
1 | package test.integration.bind;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import se.jbee.inject.Injector;
5 | import se.jbee.inject.binder.BinderModule;
6 | import se.jbee.inject.binder.BootstrapperBundle;
7 | import se.jbee.inject.bootstrap.Bootstrap;
8 |
9 | import static org.junit.jupiter.api.Assertions.assertEquals;
10 |
11 | /**
12 | * A very small example showing that stateless {@link se.jbee.inject.bind.Module}
13 | * classes can be installed multiple times using different actual instances
14 | * without causing errors because of duplicate (clashing) bindings.
15 | *
16 | * This is because they are recognised as stateless and only the first install
17 | * does have an effect. Further installs are ignored.
18 | *
19 | * The situation would be different if the installed {@link
20 | * se.jbee.inject.bind.Module} has state. In such case is must be assumed that
21 | * this is intentional reuse of the same code to create different bindings based
22 | * on the internal state. Such {@link se.jbee.inject.bind.Module} are all
23 | * installed. Should these lead to clashing bindings this causes the
24 | * bootstrapping to fail with an exception.
25 | */
26 | class TestBasicMultiInstallBinds {
27 |
28 | private static class TwiceInstalledModule extends BinderModule {
29 |
30 | @Override
31 | protected void declare() {
32 | bind(Integer.class).to(42);
33 | }
34 |
35 | }
36 |
37 | private static class TestMultiInstallBundle extends BootstrapperBundle {
38 |
39 | @Override
40 | protected void bootstrap() {
41 | installDefaults();
42 | install(new TwiceInstalledModule());
43 | install(new TwiceInstalledModule());
44 | }
45 | }
46 |
47 | /**
48 | * A stateless module that just has one initial state (or no state) can be
49 | * installed multiple times without causing an error.
50 | */
51 | @Test
52 | void statelessModulesCanBeInstalledTwice() {
53 | Injector injector = Bootstrap.injector(TestMultiInstallBundle.class);
54 | assertEquals(42, injector.resolve(Integer.class).intValue());
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/se.jbee.inject.contract/main/java/se/jbee/inject/contract/Event.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2012-2019, Jan Bernitt
3 | *
4 | * Licensed under the Apache License, Version 2.0, http://www.apache.org/licenses/LICENSE-2.0
5 | */
6 | package se.jbee.inject.contract;
7 |
8 | import se.jbee.lang.Type;
9 |
10 | import java.lang.reflect.Method;
11 | import java.util.function.BinaryOperator;
12 |
13 | import static java.lang.System.currentTimeMillis;
14 |
15 | /**
16 | * The message describing the handler interface method invocation as data.
17 | *
18 | * @since 8.1
19 | *
20 | * @param
18 | * This build upon that the default {@link Scope} is {@link Scope#auto} which is
19 | * a "virtual" scope indicating that {@link ScopesBy} should be used to
20 | * determine the used {@link Scope}. Should a binding explicitly set a {@link
21 | * Scope} using {@link se.jbee.inject.binder.Binder.RootBinder#per(Name)} this
22 | * still is honoured and the custom {@link ScopesBy} strategy is not used for
23 | * such a binding.
24 | */
25 | class TestExampleAnnotatedScopeBinds {
26 |
27 | private static class TestExampleAnnotatedScopeBindsModule extends BinderModule {
28 |
29 | @Override
30 | public Env configure(Env env) {
31 | return env.with(ScopesBy.class, //
32 | ScopesBy.annotatedWith(Scoped.class, Scoped::value));
33 | }
34 |
35 | @Override
36 | protected void declare() {
37 | bind(InjectionScoped.class).toConstructor();
38 | }
39 | }
40 |
41 | @Scoped("injection")
42 | public static final class InjectionScoped {
43 |
44 | }
45 |
46 | private final Injector injector = Bootstrap.injector(
47 | TestExampleAnnotatedScopeBindsModule.class);
48 |
49 | @Test
50 | void annotatedScopeIsUsed() {
51 | assertNotSame(injector.resolve(InjectionScoped.class),
52 | injector.resolve(InjectionScoped.class));
53 | Resourceenums as the options to chose from.
11 | *
12 | * @author Jan Bernitt (jan@jbee.se)
13 | *
14 | * @param null is it doesn't represent any special feature (so
22 | * it will be install in any case).
23 | */
24 | T featureOf(Class bundleOrModule);
25 | }
26 |
--------------------------------------------------------------------------------
/se.jbee.inject.bind/main/java/se/jbee/inject/bind/Module.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2012-2019, Jan Bernitt
3 | *
4 | * Licensed under the Apache License, Version 2.0, http://www.apache.org/licenses/LICENSE-2.0
5 | */
6 | package se.jbee.inject.bind;
7 |
8 | import se.jbee.inject.Env;
9 |
10 | /**
11 | * {@link Bindings} are defined with {@link Module}s while {@link Bundle}s are
12 | * used to group multiple {@link Module}s and {@link Bundle}s what allows to
13 | * build graphs of {@link Bundle}s with {@link Module}s as leaves.
14 | *
15 | * @see Bundle
16 | * @see ModuleWith
17 | */
18 | @FunctionalInterface
19 | public interface Module {
20 |
21 | /**
22 | * @param bindings use to declare made bound within this {@link Module}.
23 | * @param env the {@link Env} used during the bootstrapping of the
24 | * {@link Module}
25 | */
26 | void declare(Bindings bindings, Env env);
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/.idea/se.jbee.inject.iml:
--------------------------------------------------------------------------------
1 |
2 | Registering Handlers
6 | * Any vanilla java interface can be registered as an event handler using {@link
7 | * se.jbee.inject.contract.ContractModule#handle(java.lang.Class)}.
8 | *
9 | * Sending Events
10 | * The event handler interface is injected into the calling managed instance and
11 | * the handler method is called.
12 | *
13 | * Receiving Events
14 | * Any bound and created instance that implements a registered event handler
15 | * interface will asynchronously receive any message send. Either make sure the
16 | * instance is injected during bootstrapping of the application or bind the
17 | * instance in an {@link se.jbee.inject.ScopeLifeCycle#eager()} scope.
18 | */
19 | package se.jbee.inject.contract;
20 |
--------------------------------------------------------------------------------
/se.jbee.inject.bootstrap/main/java/se/jbee/inject/scope/ThreadScope.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject.scope;
2 |
3 | import se.jbee.inject.*;
4 |
5 | /**
6 | * Asks the {@link Provider} once per thread per {@link Resource} which is
7 | * understand commonly as a usual 'per-thread' singleton.
8 | */
9 | public final class ThreadScope implements Scope {
10 |
11 | private final ThreadLocalCode organisation
6 | * Initialising Objects Created In Context
12 | * javax.annotation.PostConstruct annotation just that the effect
17 | * is not given by an annotated method but by the provided {@link
18 | * se.jbee.inject.Lift} function. This can equally be applied to the
19 | * {@link se.jbee.inject.Injector} itself to wrap it. The bootstrapping will
20 | * return the outermost wrapper.
21 | * Custom Environments
7 | * {@link se.jbee.inject.Injector} Features
11 | * A Note on Independence
22 | *
12 | * locally().bind(Get.class).to(Field::get);
13 | *
14 | * Extending the Injector Context
9 | * Extending the Env Context
18 | * Adding Custom Type Level Annotation Definitions
27 | *
12 | * locally().bind(Invoke.class).to(Method::invoke);
13 | *
14 | *
12 | * locally().bind(New.class).to(Constructor::newInstance);
13 | *
14 | * Basics
18 | * Examples
26 | * Features
34 | * Defaults
8 | * Provided Scopes
15 | *
16 | *
34 | */
35 | package se.jbee.inject.scope;
36 |
--------------------------------------------------------------------------------
/se.jbee.inject.action/main/java/se/jbee/inject/action/ActionDispatch.java:
--------------------------------------------------------------------------------
1 | package se.jbee.inject.action;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * An {@link ActionDispatch} implements the algorithm that is used to
7 | * select and call one or more {@link ActionSite} to produce the {@link Action}
8 | * output.
9 | *
21 | * locally().bind(New.class).to(Constructor::newInstance);
22 | *
23 | * /META-INF/services/se.jbee.inject.bootstrap.Bundle files in jar
20 | * files to assemble the context of an modular application.
21 | *
22 | * This example is based on the /lib/example.jar which contains
23 | * very basic example of one {@link Bundle} installing one {@link Module} which
24 | * is binding an int and {@link String} value. These example files can be found
25 | * in src/example.
26 | *
27 | * The {@link ServiceLoader} as a source is hooked in explicitly by installing
28 | * the {@link ServiceLoaderEnvBundles} when bootstrapping an {@link Env} and the
29 | * {@link ServiceLoaderBundles} when bootstrapping an {@link Injector}. This
30 | * gives same control as always for this feature as well.
31 | */
32 | class TestServiceLoaderBootstrapBinds {
33 |
34 | @Test
35 | void serviceLoaderCanBeUsedToDeclareModuleRoots() {
36 | Injector context = Example.EXAMPLE_1.injector();
37 | assertNotNull(context);
38 | assertEquals(13, context.resolve(int.class).intValue());
39 | assertEquals("test.example1.Example1Module",
40 | context.resolve(String.class));
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/test.integration/test/java/test/integration/bind/TestFeatureLiftWithGenericsBinds.java:
--------------------------------------------------------------------------------
1 | package test.integration.bind;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import se.jbee.inject.Injector;
5 | import se.jbee.inject.binder.BinderModule;
6 | import se.jbee.inject.bootstrap.Bootstrap;
7 |
8 | import java.util.ArrayList;
9 | import java.util.HashSet;
10 |
11 | import static java.util.Arrays.asList;
12 | import static java.util.Collections.singletonList;
13 | import static org.junit.jupiter.api.Assertions.assertEquals;
14 | import static se.jbee.lang.Cast.listTypeOf;
15 |
16 | class TestFeatureLiftWithGenericsBinds {
17 |
18 | public static class StringList extends ArrayListUsages
16 | *
17 | * Providing Annotation Templet via ServiceLoader
18 | * Providing Bundles via ServiceLoader
28 | * Defaults
8 | *
16 | *
20 | * Utilities
29 | *