11.2. Use CDI

Procedure 11.1. Enable CDI in JBoss EAP 6

1. Check to see if the CDI subsystem details are commented out of the configuration file.

   A subsystem can be disabled by commenting out the relevant section of the domain.xml or standalone.xml configuration files, or by removing the relevant section altogether.
   To find the CDI subsystem in EAP_HOME/domain/configuration/domain.xml or EAP_HOME/standalone/configuration/standalone.xml, search them for the following string. If it exists, it is located inside the <extensions> section.

   <extension module="org.jboss.as.weld"/>

   The following line must also be present in the profile you are using. Profiles are in individual <profile> elements within the <profiles> section.

   <subsystem xmlns="urn:jboss:domain:weld:1.0"/>

2. Before editing any files, stop JBoss EAP 6.

   JBoss EAP 6 modifies the configuration files during the time it is running, so you must stop the server before you edit the configuration files directly.

3. Edit the configuration file to restore the CDI subsystem.

   If the CDI subsystem was commented out, remove the comments.
   If it was removed entirely, restore it by adding this line to the file in a new line directly above the </extensions> tag:

   <extension module="org.jboss.as.weld"/>

4. You also need to add the following line to the relevant profile in the <profiles> section.

   <subsystem xmlns="urn:jboss:domain:weld:1.0"/>

5. Restart JBoss EAP 6.

   Start JBoss EAP 6 with your updated configuration.

Procedure 11.2. Use legacy beans in CDI applications

1. Package your beans into an archive.

   Package your beans into a JAR or WAR archive.

2. Include a beans.xml file in your archive.

   Place a beans.xml file into your JAR archive's META-INF/ or your WAR archive's WEB-INF/ directory. The file can be empty.

Procedure 11.3. Resolve an Ambiguous Injection with a Qualifier

1. Create a qualifier annotation called @Translating.

   @Qualifier
   @Retention(RUNTIME)
   @Target({TYPE,METHOD,FIELD,PARAMETERS})
   public @interface Translating{}
   

2. Annotate your translating Welcome with the @Translating annotation.

   @Translating
   public class TranslatingWelcome extends Welcome {
       @Inject Translator translator;
       public String buildPhrase(String city) {
           return translator.translate("Welcome to " + city + "!");
       }
       ...
   }
   

3. Request the translating Welcome in your injection.

   You must request a qualified implementation explicitly, similar to the factory method pattern. The ambiguity is resolved at the injection point.

   public class Greeter {
     private Welcome welcome;
     @Inject
     void init(@Translating Welcome welcome) {
       this.welcome = welcome;
     } 
     public void welcomeVisitors() {
       System.out.println(welcome.buildPhrase("San Francisco"));
     }
   }
   

1. Inject an object into any part of a bean with the @Inject annotation.

   To obtain an instance of a class, within your bean, annotate the field with @Inject.

   Example 11.6. Injecting a TextTranslator instance into a TranslateController

   public class TranslateController {
   
      @Inject TextTranslator textTranslator;
      ...
   

2. Use your injected object's methods

   You can use your injected object's methods directly. Assume that TextTranslator has a method translate.

   Example 11.7. Use your injected object's methods

   // in TranslateController class
   
   public void translate() {
   
      translation = textTranslator.translate(inputText); 
   
   }
   

3. Use injection in the constructor of a bean

   You can inject objects into the constructor of a bean, as an alternative to using a factory or service locator to create them.

   Example 11.8. Using injection in the constructor of a bean

   public class TextTranslator {
   
      private SentenceParser sentenceParser;
   
      private Translator sentenceTranslator;
   
       
   
      @Inject
   
      TextTranslator(SentenceParser sentenceParser, Translator sentenceTranslator) {
   
         this.sentenceParser = sentenceParser;
   
         this.sentenceTranslator = sentenceTranslator;
   
      }
   
      // Methods of the TextTranslator class
      ...
   }
   

4. Use the Instance(<T>) interface to get instances programmatically.

   The Instance interface can return an instance of TextTranslator when parameterized with the bean type.

   Example 11.9. Obtaining an instance programmatically

   @Inject Instance<TextTranslator> textTranslatorInstance;
   
   ...
   
   public void translate() {
   
      textTranslatorInstance.get().translate(inputText);
   
   }
   

Procedure 11.4. Manage Bean Lifecycles

1. Annotate the bean with the scope corresponding to your desired scope.

   @RequestScoped
   @Named("greeter")
   public class GreeterBean {
     private Welcome welcome;
     private String city; // getter & setter not shown
     @Inject   void init(Welcome welcome) {
       this.welcome = welcome;
     }
     public void welcomeVisitors() {
       System.out.println(welcome.buildPhrase(city));
     }
   }
   

2. When your bean is used in the JSF view, it holds state.

   <h:form>
     <h:inputText value="#{greeter.city}"/>
     <h:commandButton value="Welcome visitors" action="#{greeter.welcomeVisitors}"/>
   </h:form>

1. Use the @Named annotation to assign a name to a bean.

   @Named("greeter")
   public class GreeterBean {
     private Welcome welcome;
   
     @Inject
     void init (Welcome welcome) {
       this.welcome = welcome;
     }
   
     public void welcomeVisitors() {
       System.out.println(welcome.buildPhrase("San Francisco"));
     }
   }
   

   The bean name itself is optional. If it is omitted, the bean is named after the class name, with the first letter decapitalized. In the example above, the default name would be greeterBean.

2. Use the named bean in a JSF view.

   <h:form>
     <h:commandButton value="Welcome visitors" action="#{greeter.welcomeVisitors}"/>
   </h:form>

Procedure 11.5. Override an Injection

1. Define the alternative.

   @Alternative
   @Translating 
   public class MockTranslatingWelcome extends Welcome {
     public String buildPhrase(string city) {
       return "Bienvenue à " + city + "!");
     }
   }
   

2. Substitute the alternative.

   To activate the substitute implementation, add the fully-qualified class name to your META-INF/beans.xml or WEB-INF/beans.xml file.

   <beans>
     <alternatives>
       <class>com.acme.MockTranslatingWelcome</class>
     </alternatives>
   </beans>

Procedure 11.6. Define and Use Stereotypes

1. Define the stereotype,

   @Secure
   @Transactional
   @RequestScoped
   @Named
   @Stereotype
   @Retention(RUNTIME)
   @Target(TYPE)
   public @interface BusinessComponent {
    ...
   }
   

2. Use the stereotype.

   @BusinessComponent
   public class AccountManager {
     public boolean transfer(Account a, Account b) {
       ...
     }
   }
   

Procedure 11.7. Use interceptors with CDI

1. Define the interceptor binding type.

   @InterceptorBinding
   @Retention(RUNTIME)
   @Target({TYPE, METHOD})
   public @interface Secure {}
   

2. Mark the interceptor implementation.

   @Secure
   @Interceptor
   public class SecurityInterceptor {
     @AroundInvoke
     public Object aroundInvoke(InvocationContext ctx) throws Exception {
       // enforce security ...
       return ctx.proceed();
       }
   }
   

3. Use the interceptor in your business code.

   @Secure
   public class AccountManager {
     public boolean transfer(Account a, Account b) {
       ...
     }
   }
   

4. Enable the interceptor in your deployment, by adding it to META-INF/beans.xml or WEB-INF/beans.xml.

   <beans>
     <interceptors>
       <class>com.acme.SecurityInterceptor</class>
       <class>com.acme.TransactionInterceptor</class>
     </interceptors>
   </beans>

   The interceptors are applied in the order listed.