I am currently writing some framework code that provides a blueprint for services within our platform so that service implementors can focus on the service specific logic rather than the boilerplate integration code. Dependency injection is done via guice.
The blueprint has 2 types of logical component;
Each logic component depends on the integration component.
The integration component depends on all the logic components.
Since this is framework code, the framework is not aware of any of the concrete details so it is not possible to statically declare the dependencies and form the dependency graph. I would like to avoid making service implementors do this because it means they are repeating themselves (just declaring that they have n business logic modules means they have this circular dependency).
My question is what approaches can I take to make this work without making service implementors write that boilerplate code?
Note that multibindings are not available here as, for various reasons outside the scope of this question, each business logic component must be a PrivateModule.
A contrived example to illustrate where
This example can be made to work by changing
@Provides @Exposed @Named("result")
public String go(Container in) {
return in.format();
}
to
@Provides @Exposed @Named("result")
public String go(@Named("a") Container in, @Named("b") Container in2, @Named("c") Container in3) {
return in.format();
}
ie by actually creating a circular dependency.
import com.google.inject.Exposed;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.PrivateModule;
import com.google.inject.Provides;
import com.google.inject.Singleton;
import com.google.inject.name.Named;
import com.google.inject.name.Names;
import java.util.ArrayList;
import java.util.List;
public class GuiceCircularDependencyTest {
public static void main(String[] args) {
Injector in = Guice.createInjector(new Owner());
String result = in.getInstance(Key.get(String.class, Names.named("result")));
System.out.println("Result is: " + result);
}
public static class Owner extends PrivateModule {
@Override
protected void configure() {
bind(Container.class).in(Singleton.class);
install(new Integration());
install(new ModuleA());
install(new ModuleB());
install(new ModuleC());
expose(String.class).annotatedWith(Names.named("result"));
}
}
public static class ModuleA extends PrivateModule {
@Override
protected void configure() {
}
@Provides @Exposed @Named("a")
public Container go(Container in, Wrapper prefix) {
in.add(prefix + "A");
return in;
}
}
public static class ModuleB extends PrivateModule {
@Override
protected void configure() {
}
@Provides @Exposed @Named("b")
public Container go(Container in, Wrapper prefix) {
in.add(prefix + "B");
return in;
}
}
public static class ModuleC extends PrivateModule {
@Override
protected void configure() {
}
@Provides @Exposed @Named("c")
public Container go(Container in, Wrapper prefix) {
in.add(prefix + "C");
return in;
}
}
public static class Integration extends PrivateModule {
@Override
protected void configure() {
bind(Wrapper.class).toInstance(new Wrapper("Module"));
expose(Wrapper.class);
}
@Provides @Exposed @Named("result")
public String go(Container in) {
return in.format();
}
}
public static class Container {
private List<String> strings = new ArrayList<>();
public void add(String string) {
strings.add(string);
}
public String format() {
return strings.toString();
}
}
public static class Wrapper {
private final String prefix;
public Wrapper(String prefix) {
this.prefix = prefix;
}
@Override
public String toString() {
return prefix;
}
}
}
One workaround, that allows a Multibinder
to be shared across private modules, is to wrap the PrivateModule
in an AbstractModule
implementation that simply installs the PrivateModule
and binds the exposed key to the Multibinder
import com.google.inject.AbstractModule;
import com.google.inject.Exposed;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.PrivateModule;
import com.google.inject.Provides;
import com.google.inject.multibindings.Multibinder;
import com.google.inject.name.Named;
import com.google.inject.name.Names;
import java.util.Set;
public class GuiceCircularDependencyTest {
public static void main(String[] args) {
Injector in = Guice.createInjector(new Owner());
String result = in.getInstance(Key.get(String.class, Names.named("result")));
System.out.println("Result is: " + result);
}
public static class Owner extends PrivateModule {
@Override
protected void configure() {
Multibinder<String> multi = Multibinder.newSetBinder(binder(), String.class);
install(new Integration());
install(new ModuleWrapper<>(new ModuleA(), multi));
install(new ModuleWrapper<>(new ModuleB(), multi));
install(new ModuleWrapper<>(new ModuleC(), multi));
expose(String.class).annotatedWith(Names.named("result"));
}
}
public static class ModuleWrapper<T> extends AbstractModule {
private final WrappablePrivateModule<T> inner;
private final Multibinder<T> multi;
public ModuleWrapper(WrappablePrivateModule<T> inner,
Multibinder<T> multi) {
this.inner = inner;
this.multi = multi;
}
@Override
protected void configure() {
install(inner);
multi.addBinding().to(inner.getExposedKey());
}
}
public static abstract class WrappablePrivateModule<T> extends PrivateModule {
@Override
protected void configure() {
}
public abstract Key<T> getExposedKey();
}
public static class ModuleA extends WrappablePrivateModule<String> {
private static final String SUFFIX = "A";
@Override
public Key<String> getExposedKey() {
return Key.get(String.class, Names.named(SUFFIX));
}
@Provides @Exposed @Named(SUFFIX)
public String expose(Wrapper prefix) {
return prefix + SUFFIX;
}
}
public static class ModuleB extends WrappablePrivateModule<String> {
private static final String SUFFIX = "B";
@Override
public Key<String> getExposedKey() {
return Key.get(String.class, Names.named(SUFFIX));
}
@Provides @Exposed @Named(SUFFIX)
public String expose(Wrapper prefix) {
return prefix + SUFFIX;
}
}
public static class ModuleC extends WrappablePrivateModule<String> {
private static final String SUFFIX = "C";
@Override
public Key<String> getExposedKey() {
return Key.get(String.class, Names.named(SUFFIX));
}
@Provides @Exposed @Named(SUFFIX)
public String expose(Wrapper prefix) {
return prefix + SUFFIX;
}
}
public static class Integration extends PrivateModule {
@Override
protected void configure() {
bind(Wrapper.class).toInstance(new Wrapper("Module"));
expose(Wrapper.class);
}
@Provides @Exposed @Named("result")
public String go(Set<String> in) {
return in.toString();
}
}
public static class Wrapper {
private final String prefix;
public Wrapper(String prefix) {
this.prefix = prefix;
}
@Override
public String toString() {
return prefix;
}
}
}
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.