{"id":608,"date":"2011-10-24T17:43:00","date_gmt":"2011-10-24T14:43:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/java-ee6-cdi-named-components-and-qualifiers.html"},"modified":"2012-11-01T22:22:44","modified_gmt":"2012-11-01T20:22:44","slug":"java-ee6-cdi-named-components-and","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/10\/java-ee6-cdi-named-components-and.html","title":{"rendered":"Java EE6 CDI, Named Components and Qualifiers"},"content":{"rendered":"
One of the biggest promises java EE6 made, was to ease the use of dependency injection. They did, using CDI<\/a>. CDI, which stands for Contexts and Dependency Injection for Java EE, offers a base set to apply dependency injection in your enterprise application.<\/p>\n

Before CDI, EJB 3 also introduced dependency injection, but this was a bit basic. You could inject an EJB (statefull or stateless) into another EJB or Servlet (if you container supported this). Offcourse not every application needs EJB\u2019s, that is why CDI is gaining so much popularity.<\/p>\n

To start, I have made this example. There is a Payment interface, and 2 implementations. A cash payment and a visa payment.<\/p>\n

I want to be able to choose witch type of payment I inject, still using the same interface:<\/p>\n

public interface Payment {\r\n    void pay(BigDecimal amount);\r\n}\r\n<\/pre>\n
Here are the 2 implementations:<\/p>\n
public class CashPaymentImpl implements Payment {\r\n \r\n    private static final Logger LOGGER = Logger.getLogger(CashPaymentImpl.class.toString());\r\n \r\n    @Override\r\n    public void pay(BigDecimal amount) {\r\n        LOGGER.log(Level.INFO, \"payed {0} cash\", amount.toString());\r\n    }\r\n}\r\n<\/pre>\n
public class VisaPaymentImpl implements Payment {\r\n \r\n    private static final Logger LOGGER = Logger.getLogger(VisaPaymentImpl.class.toString());\r\n \r\n    @Override\r\n    public void pay(BigDecimal amount) {\r\n        LOGGER.log(Level.INFO, \"payed {0} with visa\", amount.toString());\r\n    }\r\n}\r\n<\/pre>\n
To inject the interface we use the @Inject<\/a> annotation. The annotation does basically what it says. It injects a component, that is available in your application.<\/p>\n
@Inject private Payment payment;\r\n<\/pre>\n
Off course, you saw this coming from a mile away, this won\u2019t work. The container has 2 implementations of our Payment interface, so he does not know which one to inject.
 
<\/div> <\/div><\/p>\n
Unsatisfied dependencies for type [Payment] with qualifiers [@Default] at injection point [[field] @Inject private be.styledideas.blog.qualifier.web.PaymentBackingAction.payment]<\/span><\/p>\n
So we need some sort of qualifier to point out what implementation we want. CDI offers the @Named<\/a> Annotation, allowing you to give a name to an implementation.<\/p>\n
@Named(\"cash\")\r\npublic class CashPaymentImpl implements Payment {\r\n \r\n    private static final Logger LOGGER = Logger.getLogger(CashPaymentImpl.class.toString());\r\n \r\n    @Override\r\n    public void pay(BigDecimal amount) {\r\n        LOGGER.log(Level.INFO, \"payed {0} cash\", amount.toString());\r\n    }\r\n}\r\n<\/pre>\n
@Named(\"visa\")\r\npublic class VisaPaymentImpl implements Payment {\r\n \r\n    private static final Logger LOGGER = Logger.getLogger(VisaPaymentImpl.class.toString());\r\n \r\n    @Override\r\n    public void pay(BigDecimal amount) {\r\n        LOGGER.log(Level.INFO, \"payed {0} with visa\", amount.toString());\r\n    }\r\n}\r\n<\/pre>\n
When we now change our injection code, we can specify which implementation we need.<\/p>\n
@Inject private @Named(\"visa\") Payment payment;\r\n<\/pre>\n
This works, but the flexibility is limited. When we want to rename our @Named parameter, we have to change it on everyplace where it is used. There is also no refactoring support.<\/p>\n
There is a beter alternative using Custom made annotations using the @Qualifier annotation. Let us change the code a little bit.<\/p>\n
First of all, we create new Annotation types.<\/p>\n
@java.lang.annotation.Documented\r\n@java.lang.annotation.Retention(RetentionPolicy.RUNTIME)\r\n@javax.inject.Qualifier\r\npublic @interface CashPayment {\r\n}\r\n<\/pre>\n
@java.lang.annotation.Documented\r\n@java.lang.annotation.Retention(RetentionPolicy.RUNTIME)\r\n@javax.inject.Qualifier\r\npublic @interface VisaPayment {\r\n}\r\n<\/pre>\n
The @Qualifier<\/a> annotation that is added to the annotation, makes this annotation discoverable by the container. We can now simply add these annotations to our implementations.<\/p>\n
@CashPayment\r\npublic class CashPaymentImpl implements Payment {\r\n \r\n    private static final Logger LOGGER = Logger.getLogger(CashPaymentImpl.class.toString());\r\n \r\n    @Override\r\n    public void pay(BigDecimal amount) {\r\n        LOGGER.log(Level.INFO, \"payed {0} cash\", amount.toString());\r\n    }\r\n}\r\n<\/pre>\n
@VisaPayment\r\npublic class VisaPaymentImpl implements Payment {\r\n \r\n    private static final Logger LOGGER = Logger.getLogger(VisaPaymentImpl.class.toString());\r\n \r\n    @Override\r\n    public void pay(BigDecimal amount) {\r\n        LOGGER.log(Level.INFO, \"payed {0} with visa\", amount.toString());\r\n    }\r\n}\r\n<\/pre>\n
The only thing we now need to do, is change our injection code to<\/p>\n
@Inject private @VisaPayment Payment payment;\r\n<\/pre>\n
When we now change something to our qualifier, we have nice compiler and refactoring support. This also adds extra flexibilty for API<\/a> or Domain-specific language<\/a> design. <\/p>\n
Reference: <\/i><\/strong>Java EE6 CDI, Named Components and Qualifiers<\/a>from our JCG partner<\/a> Jelle Victoor<\/a> at Styled Ideas Blog<\/a>.<\/p>\n
Related Articles :<\/i><\/strong><\/div>\n