Welcome to JavaPolis 2007!
The Guice Philosophy
Design in the Small (at the class level)
@Inject is the new "new"
Avoid Injector.getInstance()
Prefer constructor injection
Use method injection in parent classes
Inject members when you don't control creation
Use static member injection judiciously
Minimize accessibility
Designing Modular Applications
Use Guice to bootstrap your application
Use modules to break compile time dependencies
Use modules to hide implementations
Binding annotations can go in the API
Enforce separation at compile time
Use ServiceLoader to dynamically load Modules
Utilize stages
Hide bindings with package-private annotations
Configuring Guice
Avoid heavy lifting in modules
Avoid binding toInstance()
Use eager singletons for startup logic
Pass exceptions to Binder.addError()
DRY--use AbstractModule
Depending upon Providers
Delay instantiation with providers
Prefer getProvider() to getInstance()
Inject Provider instead of Injector
Coming soon: Prefer Binder.getProvider()
Rolling tour own providers
Remove unnecessary indirection with a provider
Limit the scope of providers
Coming soon: Provider Methods
Provider methods vs. XML
Coming soon: Mix automatic and manual injection
Gang of 4 Reloaded
Singleton: No longer an anti-pattern
Replace factories with injection
The builder pattern
The command pattern vs. method interception
The Game of Lifecycles
Manage lifecycles with scopes
Use scope annotations when possible
Consider thread safety in scopes
Testing
Don't use Guice in unit tests
Use interfaces for unit testing
Swap modules in integration tests
Inject proxies
GEE (Guice Enterprise Edition)
Depend on repositories, not entities
Prefer injection to JNDI
Uses Guice's servlet scopes
Reuse Spring beans
Avoid HTTP Session Scope
External Configuration
Let Guice convert values
Use properties files for configuration
Use enums types in configuration
Extending Guice
Strategies
Fine tune the source of bindings
Implement toString()
Case Study
XML
Put simply, Guice alleviates the need for factories and the use of new in your Java code. Think of Guice's @Inject as the new new. You will still need to write factories in some cases, but your code will not depend directly on them. Your code will be easier to change, unit test and reuse in other contexts.
Guice embraces Java's type safe nature, especially when it comes to features introduced in Java 5 such as generics and annotations. You might think of Guice as filling in missing features for core Java. Ideally, the language itself would provide most of the same features, but until such a language comes along, we have Guice.
Guice helps you design better APIs, and the Guice API itself sets a good example. Guice is not a kitchen sink. We justify each feature with at least three use cases. When in doubt, we leave it out. We build general functionality which enables you to extend Guice rather than adding every feature to the core framework.
Guice aims to make development and debugging easier and faster, not harder and slower. In that vein, Guice steers clear of surprises and magic. You should be able to understand code with or without tools, though tools can make things even easier. When errors do occur, Guice goes the extra mile to generate helpful messages.
Bob Lee is a Google software engineer in Mountain View, CA. "I code, I write, and I speak. I make babies (one so far). I take pictures." He's the founder of the Guice framework and involved with the Java Web Beans specification (JSR-299).
