net.sf.mmm.util.component.api

Interface Cdi

public interface Cdi

This interface only exists for documentation purpose!
CDI is a shortcut for Context and Dependency Injection and is a java standard supporting the IoC pattern. The annotations from JSR 250 and JSR 330 are combined to configure component implementations. A CDI framework can understand these standardized annotations and assembles your components performing the dependency injection. We strongly recommend to use spring as IocContainer but there are also other implementations like JBoss Seam, Google Guice (GIN for GWT)/Eclipse SiSu, etc.
Here is an example how everything works together:

 public interface MyComponent {
   void doSomething();
 }

 public interface OtherComponent {
   void doSomethingElse();
 }

 //this annotation declares this as a component that is configured by the IocContainer...
 @Named
 public class MyComponentImpl implements MyComponent {

   private OtherComponent otherComponent;

   // this annotation defines a dependency to OtherComponent. The IocContainer verifies that there is exactly
   // one component available that implements OtherComponent and that gets automatically injected here...
   @Inject
   public void setOtherComponent(OtherComponent otherComponent) {
     this.otherComponent = otherComponent;
   }

   // this annotation defines an initializer method that is called after all dependencies have been injected (e.g.
   // setOtherComponent must have been called before).
   @PostConstruct
   public void initialize() {
     // ... setup the component here ...
   }

   // this annotation defines an destroy method that is called when the application is shut down...
   @PostConstruct
   public void dispose() {
     // ... free resources, release thread-pool, etc. ...
   }

   public void doSomething() {
     // do something and maybe then
     this.otherComponent.doSomethingElse();
   }

 }

 // and finally to complete the example...
 @Named
 public class OtherComponentImpl implements OtherComponent {

   public void doSomethingElse() {
     // here we do something else...
   }

 }
 

Even though there are different variants how to do it, we strongly recommend using public setter injection as it is the best approach for testability, debugging and getting most helpful messages in case of an error. Also we provide AbstractLoggableComponent that you can extend from.

Since:

3.1.0

Author:

Joerg Hohwiller (hohwille at users.sourceforge.net)

Field Summary

Fields

Modifier and Type	Field and Description
static String	CDI_NAME A CDI name is the name of a component for CDI.
static String	GET_INSTANCE We strongly believe in the Ioc pattern and try to avoid the keyword static except for constants (in combination with final).

Field Detail

CDI_NAME

static final String CDI_NAME

A CDI name is the name of a component for CDI.
The regular implementation will be annotated with @Named (MyComponentInterface.CDI_NAME).
If you want to replace this implementation you can do so by defining your own spring-bean with the same bean-id at a higher level (in a spring-XML file directly or indirectly importing the component-scan for the default implementation) or even using the same annotation (if you know what you are doing). Your replacement may or may not extend the default implementation.
NOTE:
This constant is only for documentation purpose. Please never use it in your code.

GET_INSTANCE

static final String GET_INSTANCE

We strongly believe in the Ioc pattern and try to avoid the keyword static except for constants (in combination with final). Books like Design Patterns. Elements of Reusable Object-Oriented Software. introduced various patterns like Singleton (or maybe AbstractFactory) that make use of static access and lead to inflexible and bad design. Instead Ioc is the pattern of choice to get access to singletons or factories. However, the problem is that Java does NOT support Ioc in its core. So for a small and simple application it might be over-complicated to use it.

Therefore we picked a design that is the best compromise between easy access and flexibility:

• We strictly follow the Ioc design which allows extension and customization.
• Additionally we provide static getInstance() methods for convenience.

You have the choice. If you just want to use StringUtil it is fine to use StringUtilImpl.getInstance(). However if you want to make use of many components of this project and decide for Ioc you can get all utilities and other components injected. This gives you the final freedom to replace or extend components without patching our code.
A special case are GWT (Google Web Toolkit) specific utilities, because GWT allows rebinding that we are using to create the singleton instance. You can configure your *.gwt.xml to replace the default implementation with a derived custom class extending the default and overriding methods to add changed behavior.
ATTENTION:
You always have to be aware of what you are actually doing when you are replacing central components. Changing behavior will NOT only have impact on your code using the component but on everybody else in your JVM what is the actual idea of the approach.
NOTE:
This constant is only for documentation purpose. Please never use it in your code.