This document discusses dependency injection and context in Java EE applications. It begins by demonstrating how to explicitly set dependencies through constructors or factories without dependency injection. It then shows how dependency injection frameworks like JSR-330 and JSR-299/CDI can provide type-safe dependency injection through annotations to simplify construction and testing. The rest of the document provides more details on the capabilities and specifications of JSR-330 and JSR-299, including their support for contexts, events, qualifiers, and extensions.

1. Context &
Dependency Injection
A Cocktail of Guice and Seam, the
missing ingredients for Java EE 6
Werner Keil
21/04/2011

2. Without Dependency Injection
Explicit Constructor
class Stopwatch {
final TimeSource timeSource;
Stopwatch () {
timeSource = new AtomicClock(...);
}
void start() { ... }
long stop() { ... }
}
www.catmedia.us 2

3. Without Dependency Injection
Using a Factory
class Stopwatch {
final TimeSource timeSource;
Stopwatch () {
timeSource =
DefaultTimeSource.getInstance();
}
void start() { ... }
long stop() { ... }
} Somewhat like in java.util.Calendar
www.catmedia.us 3

4. Without Dependency Injection
Mock Data
void testStopwatch() {
TimeSource original = DTS.getInstance();
DefaultTimeSource.setInstance(new
MockTimeSource());
try {
Stopwatch sw = new Stopwatch();
...
} finally {
DTS.setInstance(original);
}
}
www.catmedia.us 4

5. With Dependency Injection
@Inject
class Stopwatch {
final TimeSource timeSource;
@Inject Stopwatch(TimeSource timeSource)
{
this.timeSource = TimeSource;
}
void start() { ... }
long stop() { ... }
}
www.catmedia.us 5

6. JSR-330
Definition
 @Inject
 Identifies injectable constructors, methods, and fields .
This works for both static and non-static elements.
 @Qualifier
 Identifies qualifier annotations to declare binding types of
your API
 @Named
 A name (string) based qualifier
 Others may be declared application - or domain-specific
www.catmedia.us 6

7. JSR-330
Implementation
 @Provider
 Provides instances of an (injectable) type. Allows
 Retrieving multiple instances.
 Lazy or optional retrieval of an instance.
 Breaking circular dependencies.
 Abstracting scope
 @Singleton
 Identifies a type that the injector only instantiates once.
 See the well-known Design Pattern
www.catmedia.us 7

8. DEMO
www.catmedia.us 8

9. JSR-330
Configuration
1. Minimal but usable API: A small API surface seems
more important than making it as convenient as
possible for clients. There are only two methods in
the proposed API that could be considered
convenience, added because they seemed to pull
their weight
 InjectionConfigurer.inject and InjectionSpec.inject(Object)
2. Builder-style API: so-called "fluent APIs“
• Open to other styles.
www.catmedia.us 9

10. JSR-330
Configuration (2)
3. Abstract classes instead of interfaces: 2 main types
 (InjectionConfigurer and InjectionSpec) are abstract classes
instead of interfaces.
 This allows new methods to be added later in a binary-
compatible way.
4. Separate configuration API
• The API does not specify how an instance of
InjectionConfigurer is obtained.
• Otherwise we have to standardize the injector API
itself, something outside of the stated scope of JSR-330.
www.catmedia.us 10

11. JSR-330
Configuration (3)
5. Names are different from Guice's configuration API:
This is mostly
 to keep this separate from existing configuration APIs,
but also so
 that new concepts (like "Binding") don't have to be
defined.
www.catmedia.us 11

12. More about JSR-330, see
http://code.google.com/p/atinject
or
http://jcp.org/en/jsr/summary?id=330
www.catmedia.us 12

13. Formerly known as WebBeans…
www.catmedia.us 13

14. JSR-299
Services
 The lifecycle and interactions of stateful components
bound to well-defined lifecycle contexts, where the
set of contexts is extensible
 A sophisticated, type safe dependency injection
mechanism, including a facility for choosing between
various components that implement the same Java
interface at deployment time
 An event notification model
www.catmedia.us 14

15. JSR-299
Services (2)
 Integration with the Unified Expression Language (EL),
allowing any component to be used directly within a
JSF or JSP page
 The ability to decorate injected components
 A web conversation context in addition to the three
standard web contexts defined by the Java Servlets
specification
 An SPI allowing portable extensions to integrate
cleanly with the Java EE environment
www.catmedia.us 15

16. • Sophisticated,
• Type Safe,
• Dependency
Injection,…
www.catmedia.us 16

17. IN MEMORIAM
Pietro Ferrero Jr.
11 September 1963 – 18 April 2011
www.catmedia.us 17

18. JSR-299
Bean Attributes
 A (nonempty) set of bean types
 A (nonempty) set of bindings
 A scope
 A deployment type
 Optionally, a bean EL name
 A set of interceptor bindings
 A bean implementation
www.catmedia.us 18

19. JSR-299
Context
• A custom implementation of Context may be
associated with a scope type by calling
BeanManager.addContext().
public void addContext(Context context);
www.catmedia.us 19

20. JSR-299
Context (2)
• BeanManager.getContext() retrieves an active context
object associated with the a given scope:
public Context getContext(Class<? extends
Annotation> scopeType);
→ Context used in a broader meaning than some other
parts of Java (Enterprise)
www.catmedia.us 20

21. JSR-299
Restricted Instantiation
@SessionScoped
public class PaymentStrategyProducer {
private PaymentStrategyType
paymentStrategyType;
public void setPaymentStrategyType(
PaymentStrategyType type) {
paymentStrategyType = type;
}
www.catmedia.us 21

22. JSR-299
Restricted Instantiation (2)
@Produces PaymentStrategy
getPaymentStrategy(@CreditCard
PaymentStrategy creditCard,
@Cheque PaymentStrategy cheque,
@Online PaymentStrategy online) {
switch (paymentStrategyType) {
case CREDIT_CARD: return creditCard;
case CHEQUE: return cheque;
[…]
www.catmedia.us 22

23. JSR-299
Restricted Instantiation (3)
[…]
case ONLINE: return online;
default: throw new
IllegalStateException();
}
}
}
www.catmedia.us 23

24. JSR-299
Event Observer
• Then the following observer method will always be
notified of the event:
• public void afterLogin(@Observes
LoggedInEvent event) { ... }
• Whereas this observer method may or may not be
notified, depending upon the value of user.getRole():
• public void afterAdminLogin(@Observes
@Role("admin") LoggedInEvent event) { ... }
www.catmedia.us 24

25. JSR-299
Event Binding
• As elsewhere, binding types may have annotation
members:
@BindingType
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface Role {
String value();
}
www.catmedia.us 25

26. JSR-299
Event Binding (2)
 Actually @Role could extend @Named from JSR-330
 JSRs here potentially not consequently streamlined…?
www.catmedia.us 26

27. JSR-299
Portable Extensions
public interface Bean<T>
extends Contextual<T> {
public Set<Type> getTypes();
public Set<Annotation>
getBindings();
public Class<? extends Annotation>
getScopeType();
www.catmedia.us 27

28. JSR-299
Portable Extensions (2)
public Class<? extends Annotation>
getDeploymentType();
public String getName();
public Class<?> getBeanClass();
public boolean isNullable();
public Set<InjectionPoint>
getInjectionPoints();
}
www.catmedia.us 28

29. DEMO
www.catmedia.us 31

30. More about JSR-299, see
http://www.seamframework.org/
JCP
http://jcp.org/en/jsr/summary?id=299
or
http://www.developermarch.com/devel
opersummit/sessions.html#session66
(cancelled ;-/)
www.catmedia.us 32

31. Further Reading
• Java.net
http://www.java.net/
• Java™ EE Patterns and Best Practices
http://kenai.com/projects/javaee-patterns /
www.catmedia.us 33

32. Thank you!
Contact & Questions
jcp@catmedia.us
Twitter
@wernerkeil
www.catmedia.us 34