public class FizzFuzz { @Inject @Named("red") private String service; public static void main(String[] args) { FizzFuzz fizzFuzz = Guice.createInjector(new AbstractModule() { @Override protected void configure() { bindConstant().annotatedWith(Names.named("red")).to("red-service"); } }).getInstance(FizzFuzz.class); System.out.println(fizzFuzz.service); } }
Library library = Library.create(new AbstractModule() { @Override protected void configure() { // recall requireBinding(SomeUserAPI.class) statement we wrote previously, // here we are "implementing" it bind(SomeUserAPI.class).to(SomeUserAPIImpl.class); // other bindings for your exposed interfaces } }); MyAPIService service = library.myAPIService();
public static <T> AbstractModule of(final Class<T> injectedClass, final T value) { return new AbstractModule() { @Override protected void configure() { bind(injectedClass).toInstance(value); } }; }
public static <T> AbstractModule forProxy(final Class<T> proxy) { return new AbstractModule() { @Override protected void configure() { Provider<T> provider = new ConfigProvider<T>(proxy); requestInjection(provider); bind(proxy).toProvider(Providers.guicify(provider)); } }; }
@Before public void createInjector() { this.injector = Guice.createInjector( Modules.override(new YourZABCDModule()).with(new AbstractModule() { @Override public void configure() { bind(B.class).to(FakeB.class); } })); }
public class TestMagic { public static void main(final String... arg) { Guice.createInjector( new AbstractModule() { @Override protected void configure() { bind(String.class).annotatedWith(Names.named("testString")).toInstance("Guice!"); bind(LegacyThing.class).toProvider(new MagicLegacyProvider<>(LegacyThingImp.class, Key.get(String.class, Names.named("testString")))); } }).getInstance(LegacyThing.class); } }
private Injector injector; @Before public void init() throws Exception { injector = Guice.createInjector(new AbstractModule() { @Override protected void configure() { bind(A.class).to(MockedInstanceOfAWithValueFoo.class); } }); }
Injector injector = Guice.createInjector(new JUnitMockBootstrapBinder(), new AbstractModule() { public void configure() { bind(String.class).annotatedWith(Names.named("jsonValue")) .toInstance("someValue"); } });
public class TestBase { protected Injector injector = Guice.createInjector(new AbstractModule() { @Override protected void configure() { bind(HelloService.class); } }); @Before public void setup () { injector.injectMembers(this); } }
// Here we use an anonymous class as the "configuring" module. In real life, you would // probably use a standalone module. Injector injector = Guice.createInjector(new AbstractModule() { @Override protected void configure() { // No cheese please! bindConstant().annotatedWith(Names.named("addCheese")).to(false); bind(PantryModule.class); } }); Module configuredConditionalModule = injector.getInstance(PantryModule.class);
@Test public void test() { SomeOtherClassObject other = ...; // what ever you need to create the Mock Injector injector = Guice.createInjector(new AbstractModule(){ public void configure() { bind(SomeOtherClassObject.class)toInstance(other); } }); SomeClass some = injector.getInstance(SomeClass.class); // guice takes care of the constructor injection some.someMethod(...); }
Injector injector = Guice.createInjector( new AbstractModule() { @Override protected void configure() { bind( MyClass.class ).toInstance( mock(MyClass.class) ); bind( AnotherClass.class ).toInstance( mock(AnotherClass.class) ); } } ); //Create new instance of class that needs injections ThirdClass thirdInstance = injector.getInstance( ThirdClass.class );
Module testModule = Modules.override(new ProductionModule()) .with(new AbstractModule(){ @Override protected void configure() { bind(QueueFactory.class).toInstance(spy(new QueueFactory())); } }); Injector injector = Guice.createInjector(testModule); QueueFactory qFactorySpy = injector.getInstance(QueueFactory.class);
HashSet<AbstractModule> initialAms = new HashSet<AbstractModule>(); AbstractModule short1 = new AbstractModule("short1"); AbstractModule short2 = new AbstractModule("short2"); initialAms.add(short2); initialAms.add(short1); LV lv = new LV(initialAms);
Injector injector = Guice.createInjector(new AbstractModule() { protected void configure() { GuiceConfigurations.bindProperties(binder(), new File("src/test/data"), "conf1.properties"); } });
Injector injector = Guice.createInjector(new AbstractModule() { @Override protected void configure() { bind(SampleDao.class).toInstance(mockDao); } }); addResource(injector.getInstance(SampleResource.class);
@Test public void execute() { Injector injector = Guice.createInjector(new AbstractModule() { @Override protected void configure() { bind(GlobalSettings.class).toProvider(GlobalSettingsProvider.class).in(Singleton.class); } }); GlobalSettings g1 = injector.getInstance(GlobalSettings.class); GlobalSettings g2 = injector.getInstance(GlobalSettings.class); assertThat(g1).isSameAs(g2); }
public class PipelineRunner { @Inject Injector injector; // rarely a good idea, but necessary here public D createD(final String inputForA) { Module module = new AbstractModule() { @Override public void configure() { bindConstant(inputForA).annotatedWith(PipelineInput.class); } }; return injector.createChildInjector(new PipelineModule(), module) .getInstance(D.class); } }
public static void main(String ... params) { Injector injector = Guice.createInjector(new AbstractModule() { @Override protected void configure() { install(new FactoryModuleBuilder().build(IElement1Factory.class)); } }); MetamodelImpl model = injector.getInstance(MetamodelImpl.class); Element element = model.getElement("Initialize-Me"); System.out.println(element); }
@Override public void configure() { install(Modules.override(new DataFabricLevelDBModule()).with(new AbstractModule() { @Override protected void configure() { bind(QueueClientFactory.class).to(LevelDBAndInMemoryQueueClientFactory.class).in(Singleton.class); bind(QueueAdmin.class).to(InMemoryQueueAdmin.class).in(Singleton.class); } })); }