Weld - CDI Reference Implementation

Java EE component environment resources · contexts

public class SentenceParser {

   public List<String> parse(String text) { ... }

}
@Stateless

public class SentenceTranslator implements Translator {

   public String translate(String sentence) { ... }

}
@Local

public interface Translator {

   public String translate(String sentence);

}
public class TextTranslator {

   private SentenceParser sentenceParser;

   private Translator sentenceTranslator;

   @Inject

   TextTranslator(SentenceParser sentenceParser, Translator sentenceTranslator) {

      this.sentenceParser = sentenceParser;

      this.sentenceTranslator = sentenceTranslator;

   }

   public String translate(String text) {

      StringBuilder sb = new StringBuilder();

      for (String sentence: sentenceParser.parse(text)) {

          sb.append(sentenceTranslator.translate(sentence));

      }

      return sb.toString();

   }

}
@Named @RequestScoped

public class TranslateController {

   @Inject TextTranslator textTranslator;

   private String inputText;

   private String translation;

   // JSF action method, perhaps

   public void translate() {

      translation = textTranslator.translate(inputText); 

   }

   public String getInputText() {

      return inputText;

   }

   public void setInputText(String text) {

      this.inputText = text;

   }

   public String getTranslation() {

      return translation;

   }

}
@Inject Instance<TextTranslator> textTranslatorInstance;

...

public void translate() {

   textTranslatorInstance.get().translate(inputText);

}
public class BookShop 

      extends Business 

      implements Shop<Book> {

   ...

}
@Stateful

public class BookShopBean 

      extends Business 

      implements BookShop, Auditable {

   ...

}
@Typed(Shop.class)

public class BookShop 

      extends Business 

      implements Shop<Book> {

   ...

}
@Qualifier

@Target({TYPE, METHOD, PARAMETER, FIELD})

@Retention(RUNTIME)

public @interface CreditCard {}
@Inject @CreditCard PaymentProcessor paymentProcessor
@CreditCard

public class CreditCardPaymentProcessor 

    implements PaymentProcessor { ... }
public @SessionScoped

class ShoppingCart implements Serializable { ... }
public @SessionScoped @Named("cart")

class ShoppingCart implements Serializable { ... }

<h:dataTable value="#{cart.lineItems}" var="item">

   ...

</h:dataTable>

public @SessionScoped @Named

class ShoppingCart implements Serializable { ... }
public @Alternative

class MockPaymentProcessor extends PaymentProcessorImpl { ... }
@InterceptorBinding

@Inherited

@Target( { TYPE, METHOD })

@Retention(RUNTIME)

public @interface Transactional {}
public @Transactional @Interceptor

class TransactionInterceptor { ... }
public @SessionScoped @Transactional

class ShoppingCart implements Serializable { ... }
@ApplicationScoped

public class RandomNumberGenerator {

   private java.util.Random random = new java.util.Random(System.currentTimeMillis());

   @Produces @Named @Random int getRandomNumber() {

      return random.nextInt(100);

   }

}
@Inject @Random int randomNumber;
<p>Your raffle number is #{randomNumber}.</p>
@Produces Set<Roles> getRoles(User user) {

   return user.getRoles();

}
public class Shop {

   @Produces PaymentProcessor paymentProcessor = ....;

   @Produces @Catalog List<Product> products = ....;

}
@Named @RequestScoped

public class Credentials {

    private String username;

    private String password;

    @NotNull @Length(min=3, max=25)

    public String getUsername() { return username; }

    public void setUsername(String username) { this.username = username; }

    @NotNull @Length(min=6, max=20)

    public String getPassword() { return password; }

    public void setPassword(String password) { this.password = password; }

}
<h:form>

   <h:panelGrid columns="2" rendered="#{!login.loggedIn}">

      <f:validateBean>

         <h:outputLabel for="username">Username:</h:outputLabel>

         <h:inputText id="username" value="#{credentials.username}"/>

         <h:outputLabel for="password">Password:</h:outputLabel>

         <h:inputSecret id="password" value="#{credentials.password}"/>

      </f:validateBean>

   </h:panelGrid>

   <h:commandButton value="Login" action="#{login.login}" rendered="#{!login.loggedIn}"/>

   <h:commandButton value="Logout" action="#{login.logout}" rendered="#{login.loggedIn}"/>

</h:form>
@Entity

public class User {

   private @NotNull @Length(min=3, max=25) @Id String username;

   private @NotNull @Length(min=6, max=20) String password;

   public String getUsername() { return username; }

   public void setUsername(String username) { this.username = username; }

   public String setPassword(String password) { this.password = password; }

}
@SessionScoped @Named

public class Login implements Serializable {

   @Inject Credentials credentials;

   @Inject @UserDatabase EntityManager userDatabase;

   private User user;

   public void login() {

      List<User> results = userDatabase.createQuery(

         "select u from User u where u.username = :username and u.password = :password")

         .setParameter("username", credentials.getUsername())

         .setParameter("password", credentials.getPassword())

         .getResultList();

      if (!results.isEmpty()) {

         user = results.get(0);

      }

      else {

         // perhaps add code here to report a failed login

      }

   }

   public void logout() {

      user = null;

   }

   public boolean isLoggedIn() {

      return user != null;

   }

   @Produces @LoggedIn User getCurrentUser() {

      return user;

   }

}
@Qualifier

@Retention(RUNTIME)

@Target({TYPE, METHOD, PARAMETER, FIELD})

public @interface LoggedIn {}
@Qualifier

@Retention(RUNTIME)

@Target({METHOD, PARAMETER, FIELD})

public @interface UserDatabase {}
class UserDatabaseProducer {

   @Produces @UserDatabase @PersistenceContext 

   static EntityManager userDatabase;

}
public class DocumentEditor {

   @Inject Document document;

   @Inject @LoggedIn User currentUser;

   @Inject @DocumentDatabase EntityManager docDatabase;

   public void save() {

      document.setCreatedBy(currentUser);

      docDatabase.persist(document);

   }

}

<h:panelGroup rendered="#{login.loggedIn}">

   signed in as #{currentUser.username}

</h:panelGroup>

public class Checkout {

   private final ShoppingCart cart;

   @Inject

   public Checkout(ShoppingCart cart) {

      this.cart = cart;

   }

}
public class Checkout {

   private ShoppingCart cart;

   @Inject

   void setShoppingCart(ShoppingCart cart) {

      this.cart = cart;

   }

}
public class Checkout {

   private @Inject ShoppingCart cart;

}
@Produces Checkout createCheckout(ShoppingCart cart) {

    return new Checkout(cart);

}
@Synchronous

public class SynchronousPaymentProcessor implements PaymentProcessor {

   public void process(Payment payment) { ... }

}
@Asynchronous

public class AsynchronousPaymentProcessor implements PaymentProcessor {

   public void process(Payment payment) { ... }

}
@Qualifier

@Retention(RUNTIME)

@Target({TYPE, METHOD, FIELD, PARAMETER})

public @interface Synchronous {}
@Qualifier

@Retention(RUNTIME)

@Target({TYPE, METHOD, FIELD, PARAMETER})

public @interface Asynchronous {}
@Inject @Synchronous PaymentProcessor syncPaymentProcessor;

@Inject @Asynchronous PaymentProcessor asyncPaymentProcessor;
@Inject

public void setPaymentProcessors(@Synchronous PaymentProcessor syncPaymentProcessor, 

                                 @Asynchronous PaymentProcessor asyncPaymentProcessor) {

   this.syncPaymentProcessor = syncPaymentProcessor;

   this.asyncPaymentProcessor = asyncPaymentProcessor;

}
@Inject

public Checkout(@Synchronous PaymentProcessor syncPaymentProcessor, 

                @Asynchronous PaymentProcessor asyncPaymentProcessor) {

   this.syncPaymentProcessor = syncPaymentProcessor;

   this.asyncPaymentProcessor = asyncPaymentProcessor;

}
@Produces

PaymentProcessor getPaymentProcessor(@Synchronous PaymentProcessor syncPaymentProcessor,

                                     @Asynchronous PaymentProcessor asyncPaymentProcessor) {

   return isSynchronous() ? syncPaymentProcessor : asyncPaymentProcessor;

}
@Inject

void initServices(@Any Instance<Service> services) { 

   for (Service service: services) {

      service.init();

   }

}
@Qualifier

@Retention(RUNTIME)

@Target({METHOD, FIELD, PARAMETER, TYPE})

public @interface PayBy {

   PaymentMethod value();

}
private @Inject @PayBy(CHECK) PaymentProcessor checkPayment;
@Qualifier

@Retention(RUNTIME)

@Target({METHOD, FIELD, PARAMETER, TYPE})

public @interface PayBy {

   PaymentMethod value();

   @Nonbinding String comment() default "";

}
@Inject @Synchronous @Reliable PaymentProcessor syncPaymentProcessor;
@Synchronous @Reliable

public class SynchronousReliablePaymentProcessor implements PaymentProcessor {

   public void process(Payment payment) { ... }

}
@Alternative @Synchronous @Asynchronous

public class MockPaymentProcessor implements PaymentProcessor {

   public void process(Payment payment) { ... }

}

<beans

   xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/javaee

      http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">

   <alternatives>

         <class>org.mycompany.mock.MockPaymentProcessor</class>

   </alternatives>

</beans>

@Inject Instance<PaymentProcessor> paymentProcessorSource;
PaymentProcessor p = paymentProcessorSource.get();
@Inject @Asynchronous Instance<PaymentProcessor> paymentProcessorSource;
@Inject @Any Instance<PaymentProcessor> paymentProcessorSource;
class AsynchronousQualifier

extends AnnotationLiteral<Asynchronous> implements Asynchronous {}
PaymentProcessor p = paymentProcessorSource

   .select(new AnnotationLiteral<Asynchronous>() {});
Annotation qualifier = synchronously ?
      new SynchronousQualifier() : new AsynchronousQualifier();
PaymentProcessor p = anyPaymentProcessor.select(qualifier).get().process(payment);
Logger log = Logger.getLogger(MyClass.class.getName());
class LogFactory {

   @Produces Logger createLogger(InjectionPoint injectionPoint) { 

      return Logger.getLogger(injectionPoint.getMember().getDeclaringClass().getName()); 

   }

}
@Inject Logger log;
@Qualifier

@Retention(RUNTIME)

@Target({TYPE, METHOD, FIELD, PARAMETER})

public @interface HttpParam {

   @Nonbinding public String value();

}
@HttpParam("username") @Inject String username;

@HttpParam("password") @Inject String password;
class HttpParams

   @Produces @HttpParam("")

   String getParamValue(InjectionPoint ip) {

      ServletRequest request = (ServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();

      return request.getParameter(ip.getAnnotated().getAnnotation(HttpParam.class).value());

   }

}
public interface InjectionPoint {

   public Type getType();

   public Set<Annotation> getQualifiers();

   public Bean<?> getBean();

   public Member getMember();

   public Annotated getAnnotated();

   public boolean isDelegate();

   public boolean isTransient();

}
@ScopeType

@Retention(RUNTIME)

@Target({TYPE, METHOD})

public @interface ClusterScoped {}
@ClusterScoped

public class SecondLevelCache { ... }
@Inject Conversation conversation;
@ConversationScoped @Stateful

public class OrderBuilder {

   private Order order;

   private @Inject Conversation conversation;

   private @PersistenceContext(type = EXTENDED) EntityManager em;

   @Produces public Order getOrder() {

      return order;

   }

   public Order createOrder() {

      order = new Order();

      conversation.begin();

      return order;

   }

   public void addLineItem(Product product, int quantity) {

      order.add(new LineItem(product, quantity));

   }

   public void saveOrder(Order order) {

      em.persist(order);

      conversation.end();

   }

   @Remove

   public void destroy() {}

}

<a href="/addProduct.jsp?cid=#{javax.enterprise.context.conversation.id}">Add Product</a>

<h:link outcome="/addProduct.xhtml" value="Add Product">

   <f:param name="cid" value="#{javax.enterprise.context.conversation.id}"/>

</h:link>

conversation.setTimeout(timeoutInMillis);
public class Calculator { ... }
@Inject @New Calculator calculator;
@ConversationScoped

public class Calculator { ... }
public class PaymentCalc {

   @Inject Calculator calculator;

   @Inject @New Calculator newCalculator;

}
$> unzip jboss-as-7.1.1.Final.zip
$> mv jboss-as-7.*/ jboss-as-7
$> export JBOSS_HOME=/path/to/jboss-as-7
$> cd examples/jsf/numberguess
$> mvn jboss-as:run
$> mvn verify -Darquillian=jbossas-managed-7
Tests run: 2, Failures: 0, Errors: 0, Skipped: 0
$> cd examples/jsf/translator/ear
$> mvn jboss-as:run
$> cd examples/jsf/translator/ftest
$> mvn verify -Darquillian=jbossas-managed-7
$> chmod 755 glassfish-v3-unix.sh
$> ./glassfish-v3-unix.sh
$> cd examples/jsf/numberguess
$> mvn glassfish:create-domain
$> mvn package glassfish:deploy
$> unzip apache-tomcat-6.0.18.zip

<user username="admin" password="" roles="manager"/>

$> cd /path/to/apache-tomcat-6
$> ./bin/start.sh
$> cd c:\path\to\apache-tomcat-6\bin
$> start
$> cd examples/jsf/numberguess
$> mvn compile war:exploded tomcat:exploded -Ptomcat
$> mvn tomcat:redeploy -Ptomcat
$> mvn war:inplace tomcat:run -Ptomcat
$> mvn compile war:inplace -Ptomcat
$> mvn verify -Darquillian=tomcat-embedded-6 -Ptomcat
$> cd examples/jsf/numberguess
$> mvn war:inplace jetty:run -Pjetty
$> mvn compile war:inplace -Pjetty
$> mvn clean eclipse:clean eclipse:eclipse -Pjetty-ide
$> mvn war:inplace -Pjetty-ide

<faces-config version="2.0"

   xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/javaee

      http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd">

</faces-config>

<web-app version="2.5"
   xmlns="http://java.sun.com/xml/ns/javaee"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="
      http://java.sun.com/xml/ns/javaee
      http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

   <display-name>weld-jsf-numberguess-war</display-name>
   <description>Weld JSF numberguess example (war)</description>

   <servlet>
      <servlet-name>Faces Servlet</servlet-name>
      <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>Faces Servlet</servlet-name>
      <url-pattern>*.jsf</url-pattern>
   </servlet-mapping>

   <context-param>
      <param-name>javax.faces.DEFAULT_SUFFIX</param-name>
      <param-value>.xhtml</param-value>
   </context-param>

   <session-config>
      <session-timeout>10</session-timeout>
   </session-config>

</web-app>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
   xmlns:ui="http://java.sun.com/jsf/facelets"
   xmlns:h="http://java.sun.com/jsf/html"
   xmlns:f="http://java.sun.com/jsf/core">

   <ui:composition template="/template.xhtml">
      <ui:define name="content">
         <h1>Guess a number...</h1>
         <h:form id="numberGuess">
            <div style="color: red">
               <h:messages id="messages" globalOnly="false"/>
               <h:outputText id="Higher" value="Higher!"
                  rendered="#{game.number gt game.guess and game.guess ne 0}"/>
               <h:outputText id="Lower" value="Lower!"
                  rendered="#{game.number lt game.guess and game.guess ne 0}"/>
            </div>

            <div>
               I'm thinking of a number between #{game.smallest} and #{game.biggest}.
               You have #{game.remainingGuesses} guesses remaining.
            </div>

            <div>
               Your guess: 
               <h:inputText id="inputGuess" value="#{game.guess}"
                  size="3" required="true" disabled="#{game.number eq game.guess}"
                  validator="#{game.validateNumberRange}"/>
               <h:commandButton id="guessButton" value="Guess" 
                  action="#{game.check}" disabled="#{game.number eq game.guess}"/>
            </div>
            <div>
              <h:commandButton id="restartButton" value="Reset" action="#{game.reset}" immediate="true"/>
            </div>
         </h:form>
      </ui:define>
   </ui:composition>
</html>
@Qualifier

@Target( { TYPE, METHOD, PARAMETER, FIELD })

@Retention(RUNTIME)

public @interface Random {}
@Qualifier

@Target( { TYPE, METHOD, PARAMETER, FIELD })

@Retention(RUNTIME)

public @interface MaxNumber {}

@ApplicationScoped

public class Generator implements Serializable {

   private java.util.Random random = new java.util.Random(System.currentTimeMillis());

   private int maxNumber = 100;

   java.util.Random getRandom() {

      return random;

   }

   @Produces @Random int next() { 

      return getRandom().nextInt(maxNumber); 

   }

   @Produces @MaxNumber int getMaxNumber() {

      return maxNumber;

   }

}
@Named

@SessionScoped

public class Game implements Serializable {

   private int number;

   private int guess;

   private int smallest;

   private int biggest;

   private int remainingGuesses;

   @Inject @MaxNumber private int maxNumber;

   @Inject @Random Instance<Integer> randomNumber;

   public Game() {}

   public void check() {

      if (guess > number) {

         biggest = guess - 1;

      }

      else if (guess < number) {

         smallest = guess + 1;

      }

      else if (guess == number) {

         FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Correct!"));

      }

      remainingGuesses--;

   }

   @PostConstruct

   public void reset() {

      this.smallest = 0;

      this.guess = 0;

      this.remainingGuesses = 10;

      this.biggest = maxNumber;

      this.number = randomNumber.get();

   }

   public void validateNumberRange(FacesContext context,  UIComponent toValidate, Object value) {

      if (remainingGuesses <= 0) {

         FacesMessage message = new FacesMessage("No guesses left!");

         context.addMessage(toValidate.getClientId(context), message);

         ((UIInput) toValidate).setValid(false);

         return;

      }

      int input = (Integer) value;

      if (input < smallest || input > biggest) {

         ((UIInput) toValidate).setValid(false);

         FacesMessage message = new FacesMessage("Invalid guess");

         context.addMessage(toValidate.getClientId(context), message);

      }

   }

   public int getNumber() {

      return number;

   }

   public int getGuess() {

      return guess;

   }

   public void setGuess(int guess) {

      this.guess = guess;

   }

   public int getSmallest() {

      return smallest;

   }

   public int getBiggest() {

      return biggest;

   }

   public int getRemainingGuesses() {

      return remainingGuesses;

   }

}

<listener>

   <listener-class>org.jboss.weld.environment.servlet.Listener</listener-class>

</listener>

mvn -Drun
@ApplicationScoped

public class Game

{

   public static final int MAX_NUM_GUESSES = 10;

   private Integer number;

   private int guess = 0;

   private int smallest = 0;

   @Inject

   @MaxNumber

   private int maxNumber;

   private int biggest;

   private int remainingGuesses = MAX_NUM_GUESSES;

   private boolean validNumberRange = true;

   @Inject

   Generator rndGenerator;

   public Game()

   {

   }

   ...

   public boolean isValidNumberRange()

   {

      return validNumberRange;

   }

   public boolean isGameWon()

   {

      return guess == number;

   }

   public boolean isGameLost()

   {

      return guess != number && remainingGuesses <= 0;

   }

   public boolean check()

   {

      boolean result = false;

      if (checkNewNumberRangeIsValid())

      {

         if (guess > number)

         {

            biggest = guess - 1;

         }

         if (guess < number)

         {

            smallest = guess + 1;

         }

         if (guess == number)

         {

            result = true;

         }

         remainingGuesses--;

      }

      return result;

   }

   private boolean checkNewNumberRangeIsValid()

   {

      return validNumberRange = ((guess >= smallest) && (guess <= biggest));

   }

   @PostConstruct

   public void reset()

   {

      this.smallest = 0;

      this.guess = 0;

      this.remainingGuesses = 10;

      this.biggest = maxNumber;

      this.number = rndGenerator.next();

   }

}
public class MessageGenerator

{

   @Inject

   private Game game;

   public String getChallengeMessage()

   {

      StringBuilder challengeMsg = new StringBuilder("I'm thinking of a number between ");

      challengeMsg.append(game.getSmallest());

      challengeMsg.append(" and ");

      challengeMsg.append(game.getBiggest());

      challengeMsg.append(". Can you guess what it is?");

      return challengeMsg.toString();

   }

   public String getResultMessage()

   {

      if (game.isGameWon())

      {

         return "You guessed it! The number was " + game.getNumber();

      }

      else if (game.isGameLost())

      {

         return "You are fail! The number was " + game.getNumber();

      }

      else if (!game.isValidNumberRange())

      {

         return "Invalid number range!";

      }

      else if (game.getRemainingGuesses() == Game.MAX_NUM_GUESSES)

      {

         return "What is your first guess?";

      }

      else

      {

         String direction = null;

         if (game.getGuess() < game.getNumber())

         {

            direction = "Higher";

         }

         else

         {

            direction = "Lower";

         }

         return direction + "! You have " + game.getRemainingGuesses() + " guesses left.";

      }

   }

}
public class NumberGuessFrame extends javax.swing.JFrame

{

   @Inject

   private Game game;

   @Inject

   private MessageGenerator msgGenerator;

   public void start(@Observes ContainerInitialized event)

   {

      java.awt.EventQueue.invokeLater(new Runnable()

      {

         public void run()

         {

            initComponents();

            setVisible(true);

         }

      });

   }

   private void initComponents()

   {

      buttonPanel = new javax.swing.JPanel();

      mainMsgPanel = new javax.swing.JPanel();

      mainLabel = new javax.swing.JLabel();

      messageLabel = new javax.swing.JLabel();

      guessText = new javax.swing.JTextField();

      ...

      mainLabel.setText(msgGenerator.getChallengeMessage());

      mainMsgPanel.add(mainLabel);

      messageLabel.setText(msgGenerator.getResultMessage());

      mainMsgPanel.add(messageLabel);

      ...

   }

   private void guessButtonActionPerformed( java.awt.event.ActionEvent evt )

   {

      int guess =  Integer.parseInt(guessText.getText());

      game.setGuess( guess );

      game.check();

      refreshUI();

   }

   private void replayBtnActionPerformed(java.awt.event.ActionEvent evt)

   {

      game.reset();

      refreshUI();

   }

   private void refreshUI() {

      mainLabel.setText( msgGenerator.getChallengeMessage() );

      messageLabel.setText( msgGenerator.getResultMessage() );

      guessText.setText( "" );

      guessesLeftBar.setValue( game.getRemainingGuesses() );

      guessText.requestFocus();

   }

   // swing components

   private javax.swing.JPanel borderPanel;

   ...

   private javax.swing.JButton replayBtn;

}

<plugin>

   <groupId>org.apache.maven.plugins</groupId>

   <artifactId>maven-ear-plugin</artifactId>

   <configuration>

      <modules>

         <webModule>

            <groupId>org.jboss.weld.examples.jsf.translator</groupId>

            <artifactId>weld-jsf-translator-war</artifactId>

            <contextRoot>/weld-translator</contextRoot>

         </webModule>

      </modules>

   </configuration>

</plugin>

<application version="5"

   xmlns="http://java.sun.com/xml/ns/javaee" 

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/javaee

      http://java.sun.com/xml/ns/javaee/application_5.xsd">

  <display-name>weld-jsf-translator-ear</display-name>

  <description>The Weld JSF translator example (ear)</description>

  <module>

    <web>

      <web-uri>weld-translator.war</web-uri>

      <context-root>/weld-translator</context-root>

    </web>

  </module>

  <module>

    <ejb>weld-translator.jar</ejb>

  </module>

</application>

<h:form id="translator">

   <table>

      <tr align="center" style="font-weight: bold">

         <td>

            Your text

         </td>

         <td>

            Translation

         </td>

      </tr>

      <tr>

         <td>

            <h:inputTextarea id="text" value="#{translator.text}" required="true" rows="5" cols="80"/>

         </td>

         <td>

            <h:outputText value="#{translator.translatedText}"/>

         </td>

      </tr>

   </table>

   <div>

      <h:commandButton id="button" value="Translate" action="#{translator.translate}"/>

   </div>

</h:form>

public class TextTranslator implements Serializable { 

   private SentenceParser sentenceParser; 

   @EJB private Translator translator; 

   @Inject public TextTranslator(SentenceParser sentenceParser) { 

      this.sentenceParser = sentenceParser; 

   }

   public String translate(String text) { 

      StringBuilder sb = new StringBuilder(); 

      for (String sentence: sentenceParser.parse(text)) { 

         sb.append(translator.translate(sentence)).append(". "); 

      } 

      return sb.toString().trim(); 

   }

}
@Stateless

public class SentenceTranslator implements Translator { 

   public String translate(String sentence) { 

      return "Lorem ipsum dolor sit amet"; 

   }

}
@Stateful

@RequestScoped

@Named("translator")

public class TranslatorControllerBean implements TranslatorController {

   @Inject private TextTranslator translator;

   private String inputText;

   private String translatedText;

   public void translate() {

      translatedText = translator.translate(inputText);

   }

   public String getText() {

      return inputText;

   }

   public void setText(String text) {

      this.inputText = text;

   }

   public String getTranslatedText() {

      return translatedText;

   }

   @Remove public void remove() {}

}
@SessionScoped

public class Preferences implements Serializable {

   private PaymentStrategyType paymentStrategy;

   ...

   @Produces @Preferred 

   public PaymentStrategy getPaymentStrategy() {

       switch (paymentStrategy) {

           case CREDIT_CARD: return new CreditCardPaymentStrategy();

           case CHECK: return new CheckPaymentStrategy();

           case PAYPAL: return new PayPalPaymentStrategy();

           default: return null;

       } 

   }

}
@Inject @Preferred PaymentStrategy paymentStrategy;
@Produces @Preferred @SessionScoped

public PaymentStrategy getPaymentStrategy() {

   ...

}
@Produces @Preferred @SessionScoped

public PaymentStrategy getPaymentStrategy(CreditCardPaymentStrategy ccps,

                                          CheckPaymentStrategy cps,

                                          PayPalPaymentStrategy ppps) {

   switch (paymentStrategy) {

      case CREDIT_CARD: return ccps;

      case CHEQUE: return cps;

      case PAYPAL: return ppps;

      default: return null;

   } 

}
@Produces @Preferred @SessionScoped

public PaymentStrategy getPaymentStrategy(@New CreditCardPaymentStrategy ccps,

                                          @New CheckPaymentStrategy cps,

                                          @New PayPalPaymentStrategy ppps) {

   switch (paymentStrategy) {

      case CREDIT_CARD: return ccps;

      case CHEQUE: return cps;

      case PAYPAL: return ppps;

      default: return null;

   } 

}
@Produces @RequestScoped Connection connect(User user) {

   return createConnection(user.getId(), user.getPassword());

}
void close(@Disposes Connection connection) {

   connection.close();

}
public class TransactionInterceptor {

   @AroundInvoke 

   public Object manageTransaction(InvocationContext ctx) throws Exception { ... }

}
public class DependencyInjectionInterceptor {

   @PostConstruct 

   public void injectDependencies(InvocationContext ctx) { ... }

}
public class TimeoutInterceptor {

   @AroundTimeout 

   public Object manageTransaction(InvocationContext ctx) throws Exception { ... }

}
@InterceptorBinding

@Target({METHOD, TYPE})

@Retention(RUNTIME)

public @interface Transactional {}
@Transactional

public class ShoppingCart { ... }
public class ShoppingCart {

   @Transactional public void checkout() { ... }

}
@Transactional @Interceptor

public class TransactionInterceptor {

   @AroundInvoke 

   public Object manageTransaction(InvocationContext ctx) throws Exception { ... }

}
@Transactional @Interceptor

public class TransactionInterceptor {

    @Resource UserTransaction transaction;

    @AroundInvoke 

    public Object manageTransaction(InvocationContext ctx) throws Exception { ... }

}

<beans

   xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/javaee

      http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">

   <interceptors>

      <class>org.mycompany.myapp.TransactionInterceptor</class>

   </interceptors>

</beans>

<beans

   xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/javaee

      http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">

   <interceptors>

      <class>org.mycompany.myapp.SecurityInterceptor</class>

      <class>org.mycompany.myapp.TransactionInterceptor</class>

   </interceptors>

</beans>

@InterceptorBinding

@Target({METHOD, TYPE})

@Retention(RUNTIME)

public @interface Transactional {

   boolean requiresNew() default false;

}
@Transactional(requiresNew = true) @Interceptor

public class RequiresNewTransactionInterceptor {

   @AroundInvoke 

   public Object manageTransaction(InvocationContext ctx) throws Exception { ... }

}
@Transactional(requiresNew = true)

public class ShoppingCart { ... }
@InterceptorBinding

@Target({METHOD, TYPE})

@Retention(RUNTIME)

public @interface Secure {

   @Nonbinding String[] rolesAllowed() default {};

}
@Secure(rolesAllowed="admin") @Transactional

public class ShoppingCart { ... }
@Transactional @Secure @Interceptor

public class TransactionalSecureInterceptor { ... }
public class ShoppingCart {

   @Transactional @Secure public void checkout() { ... }

}
@Secure

public class ShoppingCart {

   @Transactional public void checkout() { ... }

}
@Transactional

public class ShoppingCart {

   @Secure public void checkout() { ... }

}
@Transactional @Secure

public class ShoppingCart {

   public void checkout() { ... }

}
public @interface Action extends Transactional, Secure { ... }
@Transactional @Secure

@InterceptorBinding

@Target(TYPE)

@Retention(RUNTIME)

public @interface Action { ... }
@Interceptors({TransactionInterceptor.class, SecurityInterceptor.class})

public class ShoppingCart {

   public void checkout() { ... }

}
public interface Account {

   public BigDecimal getBalance();

   public User getOwner();

   public void withdraw(BigDecimal amount);

   public void deposit(BigDecimal amount);

}
@Decorator

public abstract class LargeTransactionDecorator

      implements Account {

   ...

}
@Decorator

public abstract class LargeTransactionDecorator

      implements Account {

   @Inject @Delegate @Any Account account;

   @PersistenceContext EntityManager em;

   public void withdraw(BigDecimal amount) {

      ...

   }

   public void deposit(BigDecimal amount);

      ...

   }

}
@Decorator

public abstract class LargeTransactionDecorator

      implements Account {

   @Inject @Delegate @Any Account account;

   ...

}
@Inject @Delegate @Any Account account;
@Inject @Delegate @Foreign Account account;
@Decorator

public abstract class LargeTransactionDecorator

      implements Account {

   @Inject @Delegate @Any Account account;

   @PersistenceContext EntityManager em;

   public void withdraw(BigDecimal amount) {

      account.withdraw(amount);

      if ( amount.compareTo(LARGE_AMOUNT)>0 ) {

         em.persist( new LoggedWithdrawl(amount) );

      }

   }

   public void deposit(BigDecimal amount);

      account.deposit(amount);

      if ( amount.compareTo(LARGE_AMOUNT)>0 ) {

         em.persist( new LoggedDeposit(amount) );

      }

   }

}

<beans

   xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/javaee

      http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">

   <decorators>

         <class>org.mycompany.myapp.LargeTransactionDecorator</class>

   </decorators>

</beans>

@Qualifier

@Target({FIELD, PARAMETER})

@Retention(RUNTIME)

public @interface Updated {}
public void onAnyDocumentEvent(@Observes Document document) { ... }
public void afterDocumentUpdate(@Observes @Updated Document document) { ... }
public void afterDocumentUpdate(@Observes @Updated Document document, User user) { ... }
@Inject @Any Event<Document> documentEvent;
documentEvent.fire(document);
@Inject @Updated Event<Document> documentUpdatedEvent;
documentEvent.select(new AnnotationLiteral<Updated>(){}).fire(document);
public void refreshOnDocumentUpdate(@Observes(receive = IF_EXISTS) @Updated Document d) { ... }
@Qualifier

@Target({PARAMETER, FIELD})

@Retention(RUNTIME)

public @interface Role {

   RoleType value();

}
public void adminLoggedIn(@Observes @Role(ADMIN) LoggedIn event) { ... }
@Inject @Role(ADMIN) Event<LoggedIn> loggedInEvent;
abstract class RoleBinding 

   extends AnnotationLiteral<Role> 

   implements Role {}
documentEvent.select(new RoleBinding() {

   public void value() { return user.getRole(); }

}).fire(document);
@Inject @Blog Event<Document> blogEvent;

...

if (document.isBlog()) blogEvent.select(new AnnotationLiteral<Updated>(){}).fire(document);
public void afterBlogUpdate(@Observes @Updated @Blog Document document) { ... }
public void afterDocumentUpdate(@Observes @Updated Document document) { ... }
public void onAnyBlogEvent(@Observes @Blog Document document) { ... }
public void onAnyDocumentEvent(@Observes Document document) { ... }}}
public void afterPersonalBlogUpdate(@Observes @Updated @Personal @Blog Document document) { ... }
public void refreshCategoryTree(@Observes(during = AFTER_SUCCESS) CategoryUpdateEvent event) { ... }
@ApplicationScoped @Singleton

public class Catalog {

   @PersistenceContext EntityManager em;

   List<Product> products;

   @Produces @Catalog 

   List<Product> getCatalog() {

      if (products==null) {

         products = em.createQuery("select p from Product p where p.deleted = false")

            .getResultList();

      }

      return products;

   }

}
@Stateless

public class ProductManager {

   @PersistenceContext EntityManager em;

   @Inject @Any Event<Product> productEvent;

   public void delete(Product product) {

      em.delete(product);

      productEvent.select(new AnnotationLiteral<Deleted>(){}).fire(product);

   }

   public void persist(Product product) {

      em.persist(product);

      productEvent.select(new AnnotationLiteral<Created>(){}).fire(product);

   }

   ...

}
@ApplicationScoped @Singleton

public class Catalog {

   ...

   void addProduct(@Observes(during = AFTER_SUCCESS) @Created Product product) {

      products.add(product);

   }

   void removeProduct(@Observes(during = AFTER_SUCCESS) @Deleted Product product) {

      products.remove(product);

   }

}
@Stereotype

@Retention(RUNTIME)

@Target(TYPE)

...

public @interface Action {}
@Action 

public class LoginAction { ... }
@RequestScoped

@Stereotype

@Retention(RUNTIME)

@Target(TYPE)

public @interface Action {}
@Dependent @Action 

public class DependentScopedLoginAction { ... }
@RequestScoped

@Transactional(requiresNew=true)

@Secure

@Stereotype

@Retention(RUNTIME)

@Target(TYPE)

public @interface Action {}
@RequestScoped

@Transactional(requiresNew=true)

@Secure

@Named

@Stereotype

@Retention(RUNTIME)

@Target(TYPE)

public @interface Action {}
@Alternative

@Stereotype

@Retention(RUNTIME)

@Target(TYPE)

public @interface Mock {}
@Mock

public class MockLoginAction extends LoginAction { ... }
@Auditable

@Action

@Stereotype

@Target(TYPE)

@Retention(RUNTIME)

public @interface AuditableAction {}
@Named 

@RequestScoped 

@Stereotype 

@Target({TYPE, METHOD}) 

@Retention(RUNTIME) 

public @interface Model {}
public class DefaultPaymentProcessor 

      implements PaymentProcessor {

   ...

}
public @Alternative

class StagingPaymentProcessor 

      implements PaymentProcessor {

   ...

}
public @Alternative

class StagingPaymentProcessor 

      extends DefaultPaymentProcessor {

   ...

}
@Alternative

@Stereotype

@Retention(RUNTIME)

@Target(TYPE)

public @interface Staging {}
@Staging

public class StagingPaymentProcessor 

      implements PaymentProcessor {

   ...

}

<beans

   xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/javaee

      http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">

   <alternatives>

         <stereotype>org.mycompany.myapp.Staging</stereotype>

   </alternatives>

</beans>

@Inject @LargeTransaction PaymentProcessor paymentProcessor;
@Alternative @Specializes

public class MockCreditCardPaymentProcessor 

      extends CreditCardPaymentProcessor {

   ...

}
@Produces @WebServiceRef(lookup="java:app/service/Catalog")

Catalog catalog;
@Produces @Resource(lookup="java:global/env/jdbc/CustomerDatasource") 

@CustomerDatabase Datasource customerDatabase;
@Produces @PersistenceContext(unitName="CustomerDatabase")

@CustomerDatabase EntityManager customerDatabasePersistenceContext;
@Produces @PersistenceUnit(unitName="CustomerDatabase") 

@CustomerDatabase EntityManagerFactory customerDatabasePersistenceUnit;
@Produces @EJB(ejbLink="../their.jar#PaymentService") 

PaymentService paymentService;
@Inject Catalog catalog;
@Inject @CustomerDatabase Datasource customerDatabase;
@Inject @CustomerDatabase EntityManager customerDatabaseEntityManager;
@Inject @CustomerDatabase EntityManagerFactory customerDatabaseEntityManagerFactory;
@Inject PaymentService paymentService;
@Inject @CustomerDatabase EntityManager
@PersistenceContext(unitName="CustomerDatabase") EntityManager
class FacesContextProducer {

   @Produces @RequestScoped FacesContext getFacesContext() {

      return FacesContext.getCurrentInstance();

   }

}
@Transactional @Interceptor

public class TransactionInterceptor {

   @Resource UserTransaction transaction;

   @AroundInvoke public Object manageTransaction(InvocationContext ctx) throws Exception { ... }

}
@SessionScoped

public class Login implements Serializable {

   @Inject Credentials credentials;

   @PersistenceContext EntityManager userDatabase;

    ...

}
public class Login extends HttpServlet {

   @Inject Credentials credentials;

   @Inject Login login;

   @Override

   public void service(HttpServletRequest request, HttpServletResponse response)

      throws ServletException, IOException {

      credentials.setUsername(request.getParameter("username")):

      credentials.setPassword(request.getParameter("password")):

      login.login();

      if ( login.isLoggedIn() ) {

         response.sendRedirect("/home.jsp");

      }

      else {

         response.sendRedirect("/loginError.jsp");

      }

   }

}
@Transactional @MessageDriven

public class ProcessOrder implements MessageListener {

   @Inject Inventory inventory;

   @PersistenceContext EntityManager em;

   public void onMessage(Message message) {

      ...

   }

}
public class OrderResources {

   @Resource(name="jms/ConnectionFactory")

   private ConnectionFactory connectionFactory;

   @Resource(name="jms/OrderQueue")

   private Queue orderQueue;

   @Produces @OrderConnection

   public Connection createOrderConnection() throws JMSException {

    return connectionFactory.createConnection();

   }

   public void closeOrderConnection(@Disposes @OrderConnection Connection connection)

         throws JMSException {

      connection.close();

   }

   @Produces @OrderSession

   public Session createOrderSession(@OrderConnection Connection connection)

         throws JMSException {

      return connection.createSession(true, Session.AUTO_ACKNOWLEDGE);

   }

   public void closeOrderSession(@Disposes @OrderSession Session session)

         throws JMSException {

      session.close();

   }

   @Produces @OrderMessageProducer

   public MessageProducer createOrderMessageProducer(@OrderSession Session session)

         throws JMSException {

      return session.createProducer(orderQueue);

   }

   public void closeOrderMessageProducer(@Disposes @OrderMessageProducer MessageProducer producer)

         throws JMSException {

      producer.close();

   }

}
@Inject Order order;

@Inject @OrderMessageProducer MessageProducer producer;

@Inject @OrderSession QueueSession orderSession;

public void sendMessage() {

   MapMessage msg = orderSession.createMapMessage();

   msg.setLong("orderId", order.getId());

   ...

   producer.send(msg);

}
class MyExtension implements Extension { ... }
org.mydomain.extension.MyExtension
@Inject 

MyBean(MyExtension myExtension) {

   myExtension.doSomething();

}
class MyExtension implements Extension {

   void beforeBeanDiscovery(@Observes BeforeBeanDiscovery bbd) {

      Logger.global.debug("beginning the scanning process");

   }

   <T> void processAnnotatedType(@Observes ProcessAnnotatedType<T> pat) {

      Logger.global.debug("scanning type: " + pat.getAnnotatedType().getJavaClass().getName());

   } 

   void afterBeanDiscovery(@Observes AfterBeanDiscovery abd) {

      Logger.global.debug("finished the scanning process");

   }

}
class MyExtension implements Extension {

   <T> void processAnnotatedType(@Observes ProcessAnnotatedType<T> pat) {

      //tell the container to ignore the type if it is annotated @Ignore

      if ( pat.getAnnotatedType().isAnnotionPresent(Ignore.class) ) pat.veto();   

   } 

}
<T> void processAnnotatedType(@Observes ProcessAnnotatedType<T> pat, BeanManager beanManager) { ... }
public interface BeanManager {

   public Object getReference(Bean<?> bean, Type beanType, CreationalContext<?> ctx);

   public Object getInjectableReference(InjectionPoint ij, CreationalContext<?> ctx);

   public <T> CreationalContext<T> createCreationalContext(Contextual<T> contextual);

   public Set<Bean<?>> getBeans(Type beanType, Annotation... qualifiers);

   public Set<Bean<?>> getBeans(String name);

   public Bean<?> getPassivationCapableBean(String id);

   public <X> Bean<? extends X> resolve(Set<Bean<? extends X>> beans);

   public void validate(InjectionPoint injectionPoint);

   public void fireEvent(Object event, Annotation... qualifiers);

   public <T> Set<ObserverMethod<? super T>> resolveObserverMethods(T event, Annotation... qualifiers);

   public List<Decorator<?>> resolveDecorators(Set<Type> types, Annotation... qualifiers);

   public List<Interceptor<?>> resolveInterceptors(InterceptionType type, Annotation... interceptorBindings);

   public boolean isScope(Class<? extends Annotation> annotationType);

   public boolean isNormalScope(Class<? extends Annotation> annotationType);

   public boolean isPassivatingScope(Class<? extends Annotation> annotationType);

   public boolean isQualifier(Class<? extends Annotation> annotationType);

   public boolean isInterceptorBinding(Class<? extends Annotation> annotationType);

   public boolean isStereotype(Class<? extends Annotation> annotationType);

   public Set<Annotation> getInterceptorBindingDefinition(Class<? extends Annotation> bindingType);

   public Set<Annotation> getStereotypeDefinition(Class<? extends Annotation> stereotype);

   public boolean areQualifiersEquivalent(Annotation qualifier1, Annotation qualifier2);

   public boolean areInterceptorBindingsEquivalent(Annotation interceptorBinding1, Annotation interceptorBinding2);

   public int getQualifierHashCode(Annotation qualifier);

   public int getInterceptorBindingHashCode(Annotation interceptorBinding);

   public Context getContext(Class<? extends Annotation> scopeType);

   public ELResolver getELResolver();

   public ExpressionFactory wrapExpressionFactory(ExpressionFactory expressionFactory);

   public <T> AnnotatedType<T> createAnnotatedType(Class<T> type);

   public <T> AnnotatedType<T> getAnnotatedType(Class<T> type, String id);

   public <T> Iterable<AnnotatedType<T>> getAnnotatedTypes(Class<T> type);

   public <T> InjectionTarget<T> createInjectionTarget(AnnotatedType<T> type);

   public <X> Producer<?> createProducer(AnnotatedField<? super X> field, Bean<X> declaringBean);

   public <X> Producer<?> createProducer(AnnotatedMethod<? super X> method, Bean<X> declaringBean);

   public <T> BeanAttributes<T> createBeanAttributes(AnnotatedType<T> type);

   public BeanAttributes<?> createBeanAttributes(AnnotatedMember<?> type);

   public <T> Bean<T> createBean(BeanAttributes<T> attributes, Class<T> beanClass, InjectionTarget<T> injectionTarget);

   public <T> Bean<T> createBean(BeanAttributes<T> attributes, Class<?> beanClass, Producer<T> producer);

   public InjectionPoint createInjectionPoint(AnnotatedField<?> field);

   public InjectionPoint createInjectionPoint(AnnotatedParameter<?> parameter);

   public <T extends Extension> T getExtension(Class<T> extensionClass);

}
@Inject BeanManager beanManager;
CDI.current().getBeanManager()
BeanManager manager = CDI.current().getBeanManager();
CDI.select(Foo.class).get()
//get the BeanManager

BeanManager beanManager = CDI.current().getBeanManager();

//CDI uses an AnnotatedType object to read the annotations of a class

AnnotatedType<SomeFrameworkComponent> type = beanManager.createAnnotatedType(SomeFrameworkComponent.class);

//The extension uses an InjectionTarget to delegate instantiation, dependency injection 

//and lifecycle callbacks to the CDI container

InjectionTarget<SomeFrameworkComponent> it = beanManager.createInjectionTarget(type);

//each instance needs its own CDI CreationalContext

CreationalContext ctx = beanManager.createCreationalContext(null);

//instantiate the framework component and inject its dependencies

SomeFrameworkComponent instance = it.produce(ctx);  //call the constructor

it.inject(instance, ctx);  //call initializer methods and perform field injection

it.postConstruct(instance);  //call the @PostConstruct method

...

//destroy the framework component instance and clean up dependent objects

it.preDestroy(instance);  //call the @PreDestroy method

it.dispose(instance);  //it is now safe to discard the instance

ctx.release();  //clean up dependent objects

public interface Bean<T> extends Contextual<T> {

   public Set<Type> getTypes();

   public Set<Annotation> getQualifiers();

   public Class<? extends Annotation> getScope();

   public String getName();

   public Set<Class<? extends Annotation>> getStereotypes();

   public Class<?> getBeanClass();

   public boolean isAlternative();

   public boolean isNullable();

   public Set<InjectionPoint> getInjectionPoints();

}
Set<Bean<?>> allBeans = beanManager.getBeans(Obect.class, new AnnotationLiteral<Any>() {});
public class SecurityManagerExtension implements Extension {

    void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager bm) {

        //use this to read annotations of the class

        AnnotatedType<SecurityManager> at = bm.createAnnotatedType(SecurityManager.class); 

        //use this to instantiate the class and inject dependencies

        final InjectionTarget<SecurityManager> it = bm.createInjectionTarget(at); 

        abd.addBean( new Bean<SecurityManager>() {

            @Override

            public Class<?> getBeanClass() {

                return SecurityManager.class;

            }

            @Override

            public Set<InjectionPoint> getInjectionPoints() {

                return it.getInjectionPoints();

            }

            @Override

            public String getName() {

                return "securityManager";

            }

            @Override

            public Set<Annotation> getQualifiers() {

                Set<Annotation> qualifiers = new HashSet<Annotation>();

                qualifiers.add( new AnnotationLiteral<Default>() {} );

                qualifiers.add( new AnnotationLiteral<Any>() {} );

                return qualifiers;

            }

            @Override

            public Class<? extends Annotation> getScope() {

                return ApplicationScoped.class;

            }

            @Override

            public Set<Class<? extends Annotation>> getStereotypes() {

                return Collections.emptySet();

            }

            @Override

            public Set<Type> getTypes() {

                Set<Type> types = new HashSet<Type>();

                types.add(SecurityManager.class);

                types.add(Object.class);

                return types;

            }

            @Override

            public boolean isAlternative() {

                return false;

            }

            @Override

            public boolean isNullable() {

                return false;

            }

            @Override

            public SecurityManager create(CreationalContext<SecurityManager> ctx) {

                SecurityManager instance = it.produce(ctx);

                it.inject(instance, ctx);

                it.postConstruct(instance);

                return instance;

            }

            @Override

            public void destroy(SecurityManager instance, 

                                CreationalContext<SecurityManager> ctx) {

                it.preDestroy(instance);

                it.dispose(instance);

                ctx.release();

            }

        } );

    }

}
public class QualifiedNameExtension implements Extension {

    <X> void processAnnotatedType(@Observes ProcessAnnotatedType<X> pat) {

        //wrap this to override the annotations of the class

        final AnnotatedType<X> at = pat.getAnnotatedType();

        AnnotatedType<X> wrapped = new AnnotatedType<X>() {

            @Override

            public Set<AnnotatedConstructor<X>> getConstructors() {

                return at.getConstructors();

            }

            @Override

            public Set<AnnotatedField<? super X>> getFields() {

                return at.getFields();

            }

            @Override

            public Class<X> getJavaClass() {

                return at.getJavaClass();

            }

            @Override

            public Set<AnnotatedMethod<? super X>> getMethods() {

                return at.getMethods();

            }

            @Override

            public <T extends Annotation> T getAnnotation(final Class<T> annType) {

                if ( Named.class.equals(annType) ) {

                    class NamedLiteral 

                            extends AnnotationLiteral<Named> 

                            implements Named {

                        @Override

                        public String value() {

                            Package pkg = at.getClass().getPackage();

                            String unqualifiedName = at.getAnnotation(Named.class).value();

                            final String qualifiedName;

                            if ( pkg.isAnnotationPresent(Named.class) ) {

                                qualifiedName = pkg.getAnnotation(Named.class).value() 

                                      + '.' + unqualifiedName;

                            }

                            else {

                                qualifiedName = unqualifiedName;

                            }

                            return qualifiedName;

                        }

                    }

                    return (T) new NamedLiteral();

                }

                else {

                    return at.getAnnotation(annType);

                }

            }

            @Override

            public Set<Annotation> getAnnotations() {

                return at.getAnnotations();

            }

            @Override

            public Type getBaseType() {

                return at.getBaseType();

            }

            @Override

            public Set<Type> getTypeClosure() {

                return at.getTypeClosure();

            }

            @Override

            public boolean isAnnotationPresent(Class<? extends Annotation> annType) {

                return at.isAnnotationPresent(annType);

            }

        };

        pat.setAnnotatedType(wrapped);

    }

}
class ServiceAlternativeExtension implements Extension {

   <T extends Service> void processAnnotatedType(@Observes ProcessAnnotatedType<T> pat) {

      final AnnotatedType<T> type = pat.getAnnotatedType();

      //if the class implements Service, make it an @Alternative

      AnnotatedType<T> wrapped = new AnnotatedType<T>() {

         @Override

         public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {

            return annotationType.equals(Alternative.class) ? 

               true : type.isAnnotationPresent(annotationType);

         }

         //remaining methods of AnnotatedType

         ...

      }

      pat.setAnnotatedType(wrapped);

   } 

}
public interface BeanAttributes<T> {

public Set<Type> getTypes();

public Set<Annotation> getQualifiers();

public Class<? extends Annotation> getScope();

public String getName();

public Set<Class<? extends Annotation>> getStereotypes();

public boolean isAlternative();

public boolean isNullable();
public interface ProcessBeanAttributes<T> {

    public Annotated getAnnotated();

    public BeanAttributes<T> getBeanAttributes();

    public void setBeanAttributes(BeanAttributes<T> beanAttributes);

    public void addDefinitionError(Throwable t);

    public void veto();
public <T> BeanAttributes<T> createBeanAttributes(AnnotatedType<T> type);

public BeanAttributes<?> createBeanAttributes(AnnotatedMember<?> type);
firstName=Gavin
lastName=King
public class ConfigExtension implements Extension {

    <X> void processInjectionTarget(@Observes ProcessInjectionTarget<X> pit) {

        //wrap this to intercept the component lifecycle

        final InjectionTarget<X> it = pit.getInjectionTarget();

        final Map<Field, Object> configuredValues = new HashMap<Field, Object>();

        //use this to read annotations of the class and its members

        AnnotatedType<X> at = pit.getAnnotatedType();

        //read the properties file

        String propsFileName = at.getClass().getSimpleName() + ".properties";

        InputStream stream = at.getJavaClass().getResourceAsStream(propsFileName);

        if (stream!=null) {

            try {

                Properties props = new Properties();

                props.load(stream);

                for (Map.Entry<Object, Object> property : props.entrySet()) {

                    String fieldName = property.getKey().toString();

                    Object value = property.getValue();

                    try {

                        Field field = at.getJavaClass().getField(fieldName);

                        field.setAccessible(true);

                        if ( field.getType().isAssignableFrom( value.getClass() ) ) {

                            configuredValues.put(field, value);

                        }

                        else {

                            //TODO: do type conversion automatically

                            pit.addDefinitionError( new InjectionException(

                                   "field is not of type String: " + field ) );

                        }

                    }

                    catch (NoSuchFieldException nsfe) {

                        pit.addDefinitionError(nsfe);

                    }

                    finally {

                        stream.close();

                    }

                }

            }

            catch (IOException ioe) {

                pit.addDefinitionError(ioe);

            }

        }

        InjectionTarget<X> wrapped = new InjectionTarget<X>() {

            @Override

            public void inject(X instance, CreationalContext<X> ctx) {

                it.inject(instance, ctx);

                //set the values onto the new instance of the component

                for (Map.Entry<Field, Object> configuredValue: configuredValues.entrySet()) {

                    try {

                        configuredValue.getKey().set(instance, configuredValue.getValue());

                    }

                    catch (Exception e) {

                        throw new InjectionException(e);

                    }

                }

            }

            @Override

            public void postConstruct(X instance) {

                it.postConstruct(instance);

            }

            @Override

            public void preDestroy(X instance) {

                it.dispose(instance);

            }

            @Override

            public void dispose(X instance) {

                it.dispose(instance);

            }

            @Override

            public Set<InjectionPoint> getInjectionPoints() {

                return it.getInjectionPoints();

            }

            @Override

            public X produce(CreationalContext<X> ctx) {

                return it.produce(ctx);

            }

        };

        pit.setInjectionTarget(wrapped);

    }

}
public interface ProcessInjectionPoint<T, X> {

    public InjectionPoint getInjectionPoint();

    public void setInjectionPoint(InjectionPoint injectionPoint);

    public void addDefinitionError(Throwable t);

}
public interface ProcessModule {

    public List<Class<?>> getAlternatives();

    public List<Class<?>> getInterceptors();

    public List<Class<?>> getDecorators();

    public InputStream getBeansXml();

}
public interface Context {

   public Class<? extends Annotation> getScope();

   public <T> T get(Contextual<T> contextual, CreationalContext<T> creationalContext);

   public <T> T get(Contextual<T> contextual);

   boolean isActive();

}
public interface AlterableContext extends Context {

    public void destroy(Contextual<?> contextual);

}

<listener>

   <listener-class>org.jboss.weld.environment.servlet.Listener</listener-class>

</listener>

<Context>

   <Resource name="BeanManager" 

      auth="Container"

      type="javax.enterprise.inject.spi.BeanManager"

      factory="org.jboss.weld.resources.ManagerObjectFactory"/>

</Context>

<resource-env-ref>

   <resource-env-ref-name>BeanManager</resource-env-ref-name>

   <resource-env-ref-type>

      javax.enterprise.inject.spi.BeanManager

   </resource-env-ref-type>

</resource-env-ref>

<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN"

   "http://jetty.mortbay.org/configure.dtd">

<Configure id="webAppCtx" class="org.mortbay.jetty.webapp.WebAppContext">

   <New id="BeanManager" class="org.mortbay.jetty.plus.naming.Resource">

      <Arg><Ref id="webAppCtx"/></Arg> 

      <Arg>BeanManager</Arg>

      <Arg>

         <New class="javax.naming.Reference">

            <Arg>javax.enterprise.inject.spi.BeanManager</Arg> 

            <Arg>org.jboss.weld.resources.ManagerObjectFactory</Arg>

            <Arg/>

         </New>

      </Arg>

   </New>

</Configure>

<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN"

   "http://www.eclipse.org/jetty/configure.dtd">

<Configure id="webAppCtx" class="org.eclipse.jetty.webapp.WebAppContext">

    <New id="BeanManager" class="org.eclipse.jetty.plus.jndi.Resource">

        <Arg> <Ref id="webAppCtx"/> </Arg>

        <Arg>BeanManager</Arg>

        <Arg>

            <New class="javax.naming.Reference">

                <Arg>javax.enterprise.inject.spi.BeanManager</Arg>

                <Arg>org.jboss.weld.resources.ManagerObjectFactory</Arg>

                <Arg/>

            </New>

        </Arg>

    </New>

</Configure> 

<resource-env-ref>

   <resource-env-ref-name>BeanManager</resource-env-ref-name>

   <resource-env-ref-type>

      javax.enterprise.inject.spi.BeanManager

   </resource-env-ref-type>

</resource-env-ref>

<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN"

   "http://jetty.mortbay.org/configure.dtd">

<Configure id="webAppCtx" class="org.mortbay.jetty.webapp.WebAppContext">

   <Call class="org.jboss.weld.environment.jetty.WeldServletHandler" name="process">

      <Arg><Ref id="webAppCtx"/></Arg>

   </Call>

</Configure>

@Inject @Parameters List<String> params;
@Inject @Parameters String[] paramsArray;
@Singleton

public class HelloWorld

{

   public void printHello(@Observes ContainerInitialized event, @Parameters List<String> parameters) {

       System.out.println("Hello " + parameters.get(0));

   }

}

java org.jboss.weld.environment.se.StartMain <args>
public class Weld

{

   /** Boots Weld and creates and returns a WeldContainer instance, through which

    * beans and events can be accesed. */

   public WeldContainer initialize() {...}

   /** Convenience method for shutting down the container. */

   public void shutdown() {...}

}
public class WeldContainer

{

   /** Provides access to all beans within the application. */

   public Instance<Object> instance() {...}

   /** Provides access to all events within the application. */

   public Event<Object> event() {...}

   /** Provides direct access to the BeanManager. */

   public BeanManager getBeanManager() {...}

}
public static void main(String[] args) {

   Weld weld = new Weld();

   WeldContainer container = weld.initialize();

   container.instance().select(MyApplicationBean.class).get();

   weld.shutdown();

}
public static void main(String[] args) {

   Weld weld = new Weld();

   WeldContainer container = weld.initialize();

   container.event().select(MyEvent.class).fire( new MyEvent() );

   weld.shutdown();

}

<beans>

  <decorators>

     <class>org.jboss.weld.environment.se.threading.RunnableDecorator</class>

  </decorator>

</beans>

<dependency>

   <groupId>org.jboss.weld.se</groupId>

   <artifactId>weld-se</artifactId>

</dependency>

   /* Inject the BoundRequestContext. */

   /* Alternatively, you could look this up from the BeanManager */ 

   @Inject BoundRequestContext requestContext;

   ...

   /* Start the request, providing a data store which will last the lifetime of the request */

   public void startRequest(Map<String, Object> requestDataStore) {

      // Associate the store with the context and acticate the context

      requestContext.associate(requestDataStore);

      requestContext.activate();

   }

   /* End the request, providing the same data store as was used to start the request */

   public void endRequest(Map<String, Object> requestDataStore) {

      try {

         /* Invalidate the request (all bean instances will be scheduled for destruction) */

         requestContext.invalidate();

         /* Deactivate the request, causing all bean instances to be destroyed (as the context is invalid) */

         requestContext.deactivate();

      } finally {

         /* Ensure that whatever happens we dissociate to prevent any memory leaks */

         requestContext.dissociate(requestDataStore);

      }

   }
   @Inject BoundConversationContext conversationContext;

   ...

   /* Start a transient conversation */

   /* Provide a data store which will last the lifetime of the request */

   /* and one that will last the lifetime of the session */

   public void startTransientConversation(Map<String, Object> requestDataStore, 

                                          Map<String, Object> sessionDataStore) {

      resumeOrStartConversation(requestDataStore, sessionDataStore, null);

   }

   /* Start a transient conversation (if cid is null) or resume a non-transient */

   /* conversation. Provide a data store which will last the lifetime of the request */

   /* and one that will last the lifetime of the session */      

   public void resumeOrStartConversation(Map<String, Object> requestDataStore, 

                                         Map<String, Object> sessionDataStore, 

                                         String cid) {

      /* Associate the stores with the context and acticate the context */

      * BoundRequest just wraps the two datastores */

      conversationContext.associate(new MutableBoundRequest(requestDataStore, sessionDataStore));

      // Pass the cid in

      conversationContext.activate(cid);

   }

   /* End the conversations, providing the same data store as was used to start */

   /* the request. Any transient conversations will be destroyed, any newly-promoted */

   /* conversations will be placed into the session */

   public void endOrPassivateConversation(Map<String, Object> requestDataStore, 

                                          Map<String, Object> sessionDataStore) {

      try {

         /* Invalidate the conversation (all transient conversations will be scheduled for destruction) */

         conversationContext.invalidate();

         /* Deactivate the conversation, causing all transient conversations to be destroyed */

         conversationContext.deactivate();

      } finally {

        /* Ensure that whatever happens we dissociate to prevent memory leaks*/

         conversationContext.dissociate(new MutableBoundRequest(requestDataStore, sessionDataStore));

      }

   }

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://java.sun.com/xml/ns/javaee" 

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

       xmlns:weld="http://jboss.org/schema/weld/beans" 

       xsi:schemaLocation="

          http://java.sun.com/xml/ns/javaee http://docs.jboss.org/cdi/beans_1_0.xsd

          http://jboss.org/schema/weld/beans http://jboss.org/schema/weld/beans_1_1.xsd">

    <weld:scan>

        <!-- Don't deploy the classes for the swing app! -->

        <weld:exclude name="com.acme.swing.**" />

        <!-- Don't include GWT support if GWT is not installed -->

        <weld:exclude name="com.acme.gwt.**">

            <weld:if-class-available name="!com.google.GWT"/>

        </weld:exclude>

        <!--

            Exclude classes which end in Blether if the system property verbosity is set to low

            i.e.

              java ... -Dverbosity=low            

        -->        

        <weld:exclude pattern="^(.*)Blether$">

            <weld:if-system-property name="verbosity" value="low"/>

        </weld:exclude>

       <!--

             Don't include JSF support if Wicket classes are present, and the viewlayer system

             property is not set

        -->

        <weld:exclude name="com.acme.jsf.**">

            <weld:if-class-available name="org.apahce.wicket.Wicket"/>

            <weld:if-system-property name="!viewlayer"/>

        </weld:exclude>

    </weld:scan>

</beans>

public interface Service {

   public void cleanup();

}
public interface BootstrapService extends Service {

    void cleanupAfterBoot();

}
public interface ResourceReferenceFactory<T> {

    ResourceReference<T> createResource();

}
public interface ResourceReference<T> {

    T getInstance();

    void release();

}
public interface BeanStore {

    <T> ContextualInstance<T> get(String id);

    void clear();

    Collection<String> getContextualIds();

    <T> void put(String id, ContextualInstance<T> contextualInstance);

}
public interface Bootstrap {

    public Bootstrap startContainer(Environment environment, Deployment deployment);

    public Bootstrap startInitialization();

    public Bootstrap deployBeans();

    public Bootstrap validateBeans();

    public Bootstrap endInitialization();

    public void shutdown();

    public WeldManager getManager(BeanDeploymentArchive beanDeploymentArchive);

    public BeansXml parse(URL url);

    public BeansXml parse(Iterable<URL> urls);

    public BeansXml parse(Iterable<URL> urls, boolean removeDuplicates);

    public Iterable<Metadata<Extension>> loadExtensions(ClassLoader classLoader);

}
public interface ResourceLoader extends Service {

    public Class<?> classForName(String name);

    public URL getResource(String name);

    public Collection<URL> getResources(String name);

}
public interface AnnotationDiscovery extends Service {

    boolean containsAnnotation(Class<?> javaClass, Class<? extends Annotation> annotation);

}
public interface ExtendedAnnotationDiscovery extends AnnotationDiscovery {

    Set<String> getAnnotationsAnnotatedWith(Class<? extends Annotation> annotation);

}
// Fire ProcessInjectionTarget, returning the InjectionTarget

// to use

InjectionTarget it = weldBeanManager.fireProcessInjectionTarget(clazz);

// Per instance required, create the creational context

CreationalContext<?> cc = beanManager.createCreationalContext(null);

// Produce the instance, performing any constructor injection required

Object instance = it.produce();

// Perform injection and call initializers

it.inject(instance, cc);

// Call the post-construct callback

it.postConstruct(instance);

// Call the pre-destroy callback

it.preDestroy(instance);

// Clean up the instance

it.dispose();

cc.release();
// Obtain the EjbDescriptor for the EJB

// You may choose to use this utility method to get the descriptor

EjbDescriptor<?> ejbDescriptor = beanManager.getEjbDescriptor(ejbName);

// Get an the Bean object

Bean<?> bean = beanManager.getBean(ejbDescriptor);

// Create the injection target

InjectionTarget it = deploymentBeanManager.createInjectionTarget(ejbDescriptor);

// Per instance required, create the creational context

CreationalContext<?> cc = deploymentBeanManager.createCreationalContext(bean);

// Perform injection and call initializers

it.inject(instance, cc);

// You may choose to have CDI call the post construct and pre destroy

// lifecycle callbacks

// Call the post-construct callback

it.postConstruct(instance);

// Call the pre-destroy callback

it.preDestroy(instance);

// Clean up the instance

it.dispose();

cc.release();

	Enable and initialize the JSF servlet
	Configure requests for URLs ending in `.jsf` to be handled by JSF
	Tell JSF that we will be giving our JSF views (Facelets templates) an extension of `.xhtml`
	Configure a session timeout of 10 minutes

	Facelets is the built-in templating language for JSF. Here we are wrapping our page in a template which defines the layout.
	There are a number of messages which can be sent to the user, "Higher!", "Lower!" and "Correct!"
	As the user guesses, the range of numbers they can guess gets smaller - this sentence changes to make sure they know the number range of a valid guess.
	This input field is bound to a bean property using a value expression.
	A validator binding is used to make sure the user doesn't accidentally input a number outside of the range in which they can guess - if the validator wasn't here, the user might use up a guess on an out of bounds number.
	And, of course, there must be a way for the user to send their guess to the server. Here we bind to an action method on the bean.

	The bean is application scoped rather than session scoped, since an instance of a Swing application typically represents a single 'session'.
	Notice that the bean is not named, since it doesn't need to be accessed via EL.
	In Java SE there is no JSF `FacesContext` to which messages can be added. Instead the `Game` class provides additional information about the state of the current game including: If the game has been won or lost If the most recent guess was invalid This allows the Swing UI to query the state of the game, which it does indirectly via a class called `MessageGenerator`, in order to determine the appropriate messages to display to the user during the game.
	Since there is no dedicated validation phase, validation of user input is performed during the `check()` method.
	The `reset()` method makes a call to the injected `rndGenerator` in order to get the random number at the start of each game. Note that it can't use `Instance.get()` like the JSF example does because there will not be any active contexts like there are during a JSF request.

	The injected instance of the game (logic and state).
	The injected message generator for UI messages.
	This application is started in the prescribed Weld SE way, by observing the `ContainerInitialized` event.
	This method initializes all of the Swing components. Note the use of the `msgGenerator` here.
	`guessButtonActionPerformed` is called when the 'Guess' button is clicked, and it does the following: Gets the guess entered by the user and sets it as the current guess in the `Game` Calls `game.check()` to validate and perform one 'turn' of the game Calls `refreshUI`. If there were validation errors with the input, this will have been captured during `game.check()` and as such will be reflected in the messages returned by `MessageGenerator` and subsequently presented to the user. If there are no validation errors then the user will be told to guess again (higher or lower) or that the game has ended either in a win (correct guess) or a loss (ran out of guesses).
	`replayBtnActionPerformed` simply calls `game.reset()` to start a new game and refreshes the messages in the UI.

Scope	Qualifiers	Context	Notes
`@Dependent`	`@Default`	`DependentContext`	The dependent context is unbound and unmanaged
`@RequestScoped`	`@Unbound`	`RequestContext`	An unbound request context, useful for testing
`@RequestScoped`	`@Bound`	`RequestContext`	A request context bound to a manually propagated map, useful for testing or non-Servlet environments
`@RequestScoped`	`@Default`	`BoundRequestContext`
`@RequestScoped`	`@Http`	`RequestContext`	A request context bound to a Servlet request, used for any Servlet based request context
`@RequestScoped`	`@Default`	`HttpRequestContext`
`@RequestScoped`	`@Ejb`	`RequestContext`	A request context bound to a an interceptor's invocation context, used for EJB invocations outside of Servlet requests
`@RequestScoped`	`@Default`	`EjbRequestContext`
`@ConversationScoped`	`@Bound`	`ConversationContext`	A conversation context bound to two manually propagated maps (one which represents the request and one which represents the session), useful for testing or non-Servlet environments
`@ConversationScoped`	`@Default`	`BoundConversationContext`
`@ConversationScoped`	`@Http`	`ConversationContext`	A conversation context bound to a Servlet request, used for any Servlet based conversation context
`@ConversationScoped`	`@Default`	`HttpConversationContext`
`@SessionScoped`	`@Bound`	`SessionContext`	A session context bound to a manually propagated map, useful for testing or non-Servlet environments
`@SessionScoped`	`@Default`	`BoundSessionContext`
`@SessionScoped`	`@Http`	`SessionContext`	A session context bound to a Servlet request, used for any Servlet based session context
`@SessionScoped`	`@Default`	`HttpSessionContext`
`@ApplicationScoped`	`@Default`	`ApplicationContext`	An application context backed by an application scoped singleton, it is unmanaged and unbound but does offer an option to destroy all entries
`@SingletonScoped`	`@Default`	`SingletonContext`	A singleton context backed by an application scoped singleton, it is unmanaged and unbound but does offer an option to destroy all entries

	The instance of `Game` for the application is injected here.
	The `Game`'s state is interrogated to determine the appropriate challenge message ...
	... and again to determine whether to congratulate, console or encourage the user to continue.

Configuration option	Default value	Description
`concurrentDeployment`	true	If set to false, `ConcurrentDeployer` and `ConcurrentValidator` will not be used.
`preloaderThreadPoolSize`	`Math.max(1, Runtime.getRuntime().availableProcessors() - 1)`	Weld is capable of resolving observer methods for container lifecycle events in advance while bean deployer threads are blocked waiting for I/O operations (such as classloading). This process is called preloading and leads to better CPU utilization and faster application startup time. This configuration option specifies the number of threads used for preloading. If set to 0, preloading is disabled.

Configuration option	Default value	Description
`debug`	false	If set to true, debug timing information is printed to the standard output.
`threadPoolSize`	`Runtime.getRuntime().availableProcessors()`	The number of threads to be used for bean loading and deployment.
`threadPoolType`	`FIXED`	The type of the thread pool. Possible values are: `FIXED`, `FIXED_TIMEOUT`, `NONE`, `SINGLE_THREAD`

Note

Note

Note

Warning

Note

Note

Note

Note

Note