AOP Alliance is a set of interfaces that multiple frameworks implement (see AOP Alliance Motivations), including both Guice and Spring. AOP Alliance was chosen for Guice because it has a high capability and a simple API. The Guice wiki has an AOP guide.
You should not be using the Injector directly. Rather pass in the Provider<FooClass> instead. Also, you should be injecting the provider in the places where you use FooClass. private final Provider<FooClass> provider; @Inject public ClassWhereFooIsUsed(Provider<FooClass> provider) { this.provider = provider; } …. somewhere else FooClass f = provider.get(); // This is lazy
For any complex Guice project, you should add tests to make sure that the modules can be used to create your classes. In your example, if B were a type that Guice couldn’t figure out how to create, then Guice won’t be able to create A. If A wasn’t needed to start the server but … Read more
I have always felt that constructor injection to final fields is a best practice. It minimizes mutable state and makes the class easier to understand by making the class’s formal dependencies explicit. public class MyClass { private final MyDependency dependency; @Inject public MyClass(MyDependency dependency) { this.dependency = dependency; } }
I can only speak from experience with Guice, but here’s my take. The short of it is that annotation-based configuration greatly reduces the amount you have to write to wire an application together and makes it easier to change what depends on what… often without even having to touch the configuration files themselves. It does … Read more
Guice 3.0 is now available on central. You’ll need the following to depend on it. <dependency> <groupId>com.google.inject</groupId> <artifactId>guice</artifactId> <version>3.0</version> </dependency> Sadly, they haven’t uploaded source jars, and the class files have been compiled with Java 6. This may be a show-stopper for you…
If your database change infrequently, you could use the data source that comes with the database’s JDBC driver and isolate the calls to the 3rd party library in a provider (My example uses the one provided by the H2 dataabse, but all JDBC providers should have one). If you change to a different implementation of … Read more
Guice’s wiki has a documentation about this use case. Basically, this is what you should do: // Declare that the provider of DefaultSettings is a singleton bind(DefaultSettings.class).in(Singleton.class); // Bind the providers of the interfaces FirstSettings and SecondSettings // to the provider of DefaultSettings (which is a singleton as defined above) bind(FirstSettings.class).to(DefaultSettings.class); bind(SecondSettings.class).to(DefaultSettings.class); There is no … Read more
Overall approach The simplest way to have dependency injection with Apache Sling, and the one used throughout the codebase, is to use the maven-scr-plugin . You can annotate your java classes and then at build time invoke the SCR plugin, either as a Maven plugin, or as an Ant task. For instance, to register a … Read more
What you want for this is Multibindings. Specifically, you want to bind a Set<Action> (not a List, but a Set is probably what you really want anyway) like this: Multibinder<Action> actionBinder = Multibinder.newSetBinder(binder(), Action.class); actionBinder.addBinding().to(FooAction.class); actionBinder.addBinding().to(BarAction.class); Then you can @Inject the Set<Action> anywhere.