Weld 2.4.0.CR1 - 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;

   }

}
import javax.enterprise.inject.Instance;

import javax.inject.Inject;

....

@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 { ... }
import javax.enterprise.inject.Produces;

@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();

}
import javax.enterprise.inject.Produces;

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;

}
import javax.enterprise.inject.Instance;

...

@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://xmlns.jcp.org/xml/ns/javaee"

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

   xsi:schemaLocation="

      http://xmlns.jcp.org/xml/ns/javaee

      http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd">

   <alternatives>

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

   </alternatives>

</beans>

@Inject Instance<PaymentProcessor> paymentProcessorSource;
PaymentProcessor p = paymentProcessorSource.get();
@Inject @Asynchronous Instance<PaymentProcessor> paymentProcessorSource;
import javax.enterprise.inject.Instance;

...

@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);
import org.jboss.weld.inject.WeldInstance;

class Foo {

  @Inject

  WeldInstance<Bar> instance;

  void doWork() {

    try (Handler<Bar> barHandler = instance.getHandler()) {

        barHandler.get().doBusiness();

        // Note that Bar will be automatically destroyed at the end of the try-with-resources statement

    }

    Handler<Bar> barHandler = instance.getHandler()

    barHandler.get().doBusiness();

    // Calls Instance.destroy()

    barHandler.destroy();

  }

}
@ApplicationScoped

class OrderService {

  @Inject

  @Any

  WeldInstance<OrderProcessor> instance;

  void create(Order order) {

    for (Handler<OrderProcessor> handler : instance.handlers()) {

            handler.get().process(order);

            if (Dependent.class.equals(handler.getBean().getScope()) {

                // Destroy only dependent processors

                handler.destroy();

            }

        }

  }

}
class OrderService {

  @Inject

  Instance<OrderProcessor> instance;

  void create(Order order) {

    if (instance.isResolvable()) {

        instance.get().process(order);

    } else {

        // Log a warning or throw an exception

    }

  }

}
Logger log = Logger.getLogger(MyClass.class.getName());
import javax.enterprise.inject.spi.InjectionPoint;

import javax.enterprise.inject.Produces;

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;
import javax.enterprise.inject.Produces;

import javax.enterprise.inject.spi.InjectionPoint;

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;
import javax.enterprise.inject.Produces;

import javax.inject.Inject;

import javax.persistence.PersistenceContextType.EXTENDED;

@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 MyFilter implements Filter {

...

@Override

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)

      throws IOException, ServletException {

        try {

            chain.doFilter(request, response);

        } catch (BusyConversationException e) {

            response.setContentType("text/plain");

            response.getWriter().print("BusyConversationException");

        }

    }

...

<filter-mapping>

      <filter-name>My Filter</filter-name>

      <url-pattern>/*</url-pattern>

   </filter-mapping>

   <filter-mapping>

      <filter-name>CDI Conversation Filter</filter-name>

      <url-pattern>/*</url-pattern>

   </filter-mapping>

<context-param>

   <param-name>org.jboss.weld.context.conversation.lazy</param-name>

   <param-value>true</param-value>

</context-param>

public class Calculator { ... }
@Inject @New Calculator calculator;
@ConversationScoped

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

   @Inject Calculator calculator;

   @Inject @New Calculator newCalculator;

}
$> unzip wildfly-8.0.0.Final.zip
$> mv wildfly-8.*/ wildfly-8
$> export JBOSS_HOME=/path/to/wildfly-8
$> cd examples/jsf/numberguess
$> mvn jboss-as:run
$> mvn verify -Darquillian=wildfly-managed-8
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=wildfly-managed-8
$> chmod 755 glassfish-4.0-unix.sh
$> ./glassfish-4.0-unix.sh
$> cd examples/jsf/numberguess
$> mvn glassfish:create-domain
$> mvn package glassfish:deploy
$> unzip apache-tomcat-7.0.53.zip

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

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

<faces-config version="2.2"

   xmlns="http://xmlns.jcp.org/xml/ns/javaee"

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

   xsi:schemaLocation="

      http://xmlns.jcp.org/xml/ns/javaee

      http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd">

      <name>numberguess</name>

</faces-config>

<!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.guessLower}"/>

               <h:outputText id="Lower" value="Lower!" rendered="#{game.guessHigher}"/>

            </div>

            <div>

               I'm thinking of a number between

               <span id="numberGuess:smallest">#{game.smallest}</span>

               and <span id="numberGuess:biggest">#{game.biggest}</span>.

               You have #{game.remainingGuesses} guesses remaining. 

            </div>

            <div>

               Your guess:

               <h:inputText id="inputGuess" value="#{game.guess}"

                  required="true" size="3" disabled="#{game.guessCorrect}"

                  validator="#{game.validateNumberRange}"/> 

               <h:commandButton id="guessButton" value="Guess" action="#{game.check}"

               disabled="#{game.guessCorrect}"/> 

            </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 static final int MAX_NUMBER = 100;

    java.util.Random getRandom() {

        return random;

    }

    @Produces

    @Random

    int next() {

        //a number between 1 and 100

        return getRandom().nextInt(MAX_NUMBER - 1) + 1;

    }

    @Produces

    @MaxNumber

    int getMaxNumber() {

        return MAX_NUMBER;

    }

}
import javax.enterprise.inject.Instance;

@Named

@SessionScoped

public class Game implements Serializable {

    private static final int DEFAULT_REMAINING_GUESSES = 10;

    private int number;

    private int guess;

    private int smallest;

    private int biggest;

    private int remainingGuesses;

    @Inject

    @MaxNumber

    private int maxNumber;

    @Inject

    @Random

    private Instance<Integer> randomNumber;

    public Game() {

    }

    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;

    }

    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 = DEFAULT_REMAINING_GUESSES;

        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 boolean isGuessHigher() {

        return guess != 0 && guess > number;

    }

    public boolean isGuessLower() {

        return guess != 0 && guess < number;

    }

    public boolean isGuessCorrect() {

        return guess == number;

    }

}

<listener>

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

</listener>

mvn eclipse:configure-workspace -Declipse.workspace=/path/to/your/eclipse/workspace
mvn eclipse:eclipse
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 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;

    }

    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();

        System.out.println("psst! the number is " + this.number);

    }

}
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.";

        }

    }

}
import javax.enterprise.event.Observes;

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() { 

        borderPanel = new javax.swing.JPanel();

        gamePanel = new javax.swing.JPanel();

        inputsPanel = new javax.swing.JPanel();

        buttonPanel = new javax.swing.JPanel();

        guessButton = new javax.swing.JButton();

        ...

        mainLabel.setText(msgGenerator.getChallengeMessage());

        mainMsgPanel.add(mainLabel);

        messageLabel.setText(msgGenerator.getResultMessage());

        mainMsgPanel.add(messageLabel);

        ...

    }

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

        int guess = -1;

        try {

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

        } catch (NumberFormatException nfe) {

            // noop

        }

        game.setGuess(guess);

        game.check();

        refreshUI();

        if (game.isGameWon() || game.isGameLost()) {

            switchButtons();

        }

    }

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

        game.reset();

        refreshUI();

        switchButtons();

    }

    private void switchButtons() {

        CardLayout buttonLyt = (CardLayout) buttonPanel.getLayout();

        buttonLyt.next(buttonPanel);

    }

    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="7"

   xmlns="http://xmlns.jcp.org/xml/ns/javaee"

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

   xsi:schemaLocation="

      http://xmlns.jcp.org/xml/ns/javaee

      http://xmlns.jcp.org/xml/ns/javaee/application_7.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="TranslatorMain">

   <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() {}

}
import javax.enterprise.inject.Produces;

@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://xmlns.jcp.org/xml/ns/javaee"

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

   xsi:schemaLocation="

      http://xmlns.jcp.org/xml/ns/javaee

      http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd">

   <interceptors>

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

   </interceptors>

</beans>

<beans

   xmlns="http://xmlns.jcp.org/xml/ns/javaee"

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

   xsi:schemaLocation="

      http://xmlns.jcp.org/xml/ns/javaee

      http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.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://xmlns.jcp.org/xml/ns/javaee"

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

   xsi:schemaLocation="

      http://xmlns.jcp.org/xml/ns/javaee

      http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd">

   <decorators>

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

   </decorators>

</beans>

@Qualifier

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

@Retention(RUNTIME)

public @interface Updated {}
public void onAnyDocumentEvent(@Observes Document document) { ... }
public void afterDocumentUpdate(@Observes @Updated Document document) { ... }
@Inject @Any Event<Document> documentEvent;

@Inject @Updated Event<Document> anotherDocumentEvent;
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({METHOD, FIELD, PARAMETER, TYPE})

@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) { ... }
import javax.ejb.Singleton;

import javax.enterprise.inject.Produces;

@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;

   }

}
import javax.enterprise.event.Event;

@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);

   }

   ...

}
import javax.ejb.Singleton;

@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 { ... }

<beans>

   <alternatives>

      <stereotype>org.mycompany.testing.Mock</stereotype>

   </alternatives>

</beans>

@Auditable

@Action

@Stereotype

@Target(TYPE)

@Retention(RUNTIME)

public @interface AuditableAction {}
@Named

@RequestScoped

@Stereotype

@Target({TYPE, METHOD, FIELD})

@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://xmlns.jcp.org/xml/ns/javaee"

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

   xsi:schemaLocation="

      http://xmlns.jcp.org/xml/ns/javaee

      http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd">

   <alternatives>

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

   </alternatives>

</beans>

@Inject @LargeTransaction PaymentProcessor paymentProcessor;
@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
import javax.enterprise.inject.Produces;

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 LoginServlet 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) {

      ...

   }

}
import javax.jms.ConnectionFactory;

import javax.jms.Queue;

public class OrderResources {

   @Resource(name="jms/ConnectionFactory")

   private ConnectionFactory connectionFactory;

   @Resource(name="jms/OrderQueue")

   private Queue orderQueue;

   @Produces @Order

   public Connection createOrderConnection() throws JMSException {

    return connectionFactory.createConnection();

   }

   public void closeOrderConnection(@Disposes @Order Connection connection)

         throws JMSException {

      connection.close();

   }

   @Produces @Order

   public Session createOrderSession(@Order Connection connection)

         throws JMSException {

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

   }

   public void closeOrderSession(@Disposes @Order Session session)

         throws JMSException {

      session.close();

   }

   @Produces @Order

   public MessageProducer createOrderMessageProducer(@Order Session session)

         throws JMSException {

      return session.createProducer(orderQueue);

   }

   public void closeOrderMessageProducer(@Disposes @Order MessageProducer producer)

         throws JMSException {

      producer.close();

   }

}
@Inject Order order;

@Inject @Order MessageProducer producer;

@Inject @Order Session orderSession;

public void sendMessage() {

   MapMessage msg = orderSession.createMapMessage();

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

   ...

   producer.send(msg);

}
 import javax.enterprise.inject.spi.Extension;

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

MyBean(MyExtension myExtension) {

   myExtension.doSomething();

}
import javax.enterprise.inject.spi.Extension;

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");

   }

}
import javax.enterprise.inject.spi.Extension;

class MyExtension implements Extension {

   <T> void processAnnotatedType(@Observes @WithAnnotations({Ignore.class}) ProcessAnnotatedType<T> pat) {

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

      if ( pat.getAnnotatedType().isAnnotationPresent(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> InjectionTarget<T> createInjectionTarget(AnnotatedType<T> type);

   public <T> InjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> annotatedType);

   public <X> ProducerFactory<X> getProducerFactory(AnnotatedField<? super X> field, Bean<X> declaringBean);

   public <X> ProducerFactory<X> getProducerFactory(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,

   public <T, X> Bean<T> createBean(BeanAttributes<T> attributes, Class<X> beanClass, ProducerFactory<X> producerFactory);

   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()
import javax.enterprise.inject.spi.CDI;

...

//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 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 interface Bean<T> extends Contextual<T>, BeanAttributes<T> {

   public Class<?> getBeanClass();

   public Set<InjectionPoint> getInjectionPoints();

   public boolean isNullable();

}
Set<Bean<?>> allBeans = beanManager.getBeans(Obect.class, new AnnotationLiteral<Any>() {});
import javax.enterprise.inject.spi.Extension;

import javax.enterprise.event.Observes;

import java.lang.annotation.Annotation;

import java.lang.reflect.Type;

import javax.enterprise.inject.spi.InjectionPoint;

...

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();

            }

        } );

    }

}
import java.lang.reflect.Type;

import javax.enterprise.inject.spi.Extension;

import java.lang.annotation.Annotation;

...

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();

        /* Only wrap AnnotatedTypes for classes with @Named packages */

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

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

            return;

        }

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

            class NamedLiteral extends AnnotationLiteral<Named>

            implements Named {

                @Override

                public String value() {

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

                    String unqualifiedName = "";

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

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

                    }

                    if (unqualifiedName.isEmpty()) {

                        unqualifiedName = Introspector.decapitalize(at.getJavaClass().getSimpleName());

                    }

                    final String qualifiedName;

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

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

                            + '.' + unqualifiedName;

                    }

                    else {

                        qualifiedName = unqualifiedName;

                    }

                    return qualifiedName;

                }

            }

            private final NamedLiteral namedLiteral = new NamedLiteral();

            @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)) {

                    return (T) namedLiteral;

                }

                else {

                    return at.getAnnotation(annType);

                }

            }

            @Override

            public Set<Annotation> getAnnotations() {

                Set<Annotation> original = at.getAnnotations();

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

                boolean hasNamed = false;

                for (Annotation annotation : original) {

                    if (annotation.annotationType().equals(Named.class)) {

                        annotations.add(getAnnotation(Named.class));

                        hasNamed = true;

                    }

                    else {

                        annotations.add(annotation);

                    }

                }

                if (!hasNamed) {

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

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

                        annotations.add(getAnnotation(Named.class));

                    }

                }

                return annotations;

            }

            @Override

            public Type getBaseType() {

                return at.getBaseType();

            }

            @Override

            public Set<Type> getTypeClosure() {

                return at.getTypeClosure();

            }

            @Override

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

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

                    return true;

                }

                return at.isAnnotationPresent(annType);

            }

        };

        pat.setAnnotatedType(wrapped);

    }

}
import javax.enterprise.inject.spi.Extension;

import java.lang.annotation.Annotation;

...

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>() {

         class AlternativeLiteral extends AnnotationLiteral<Alternative> implements Alternative {}

         private final AlternativeLiteral alternativeLiteral = new AlternativeLiteral();

         @Override

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

            return (X) (annType.equals(Alternative.class) ?  alternativeLiteral : type.getAnnotation(annType));

         }

         @Override

         public Set<Annotation> getAnnotations() {

            Set<Annotation> annotations = new HashSet<Annotation>(type.getAnnotations());

            annotations.add(alternativeLiteral);

            return annotations;

         }

         @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 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
import javax.enterprise.event.Observes;

import javax.enterprise.inject.spi.Extension;

import javax.enterprise.inject.spi.InjectionPoint;

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.getJavaClass().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().getDeclaredField(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 AfterTypeDiscovery {

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

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

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

    public void addAnnotatedType(AnnotatedType<?> type, String id);

}
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();

}
import javax.enterprise.context.spi.Context;

public interface AlterableContext extends Context {

    public void destroy(Contextual<?> contextual);

}

<dependency>

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

    <artifactId>weld-servlet-core</artifactId>

    <version>2.4.0.CR1</version>

</dependency>

<dependency>

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

    <artifactId>weld-servlet</artifactId>

    <version>2.4.0.CR1</version>

</dependency>

<listener>

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

</listener>

<context-param>

   <param-name>WELD_CONTEXT_ID_KEY</param-name>

   <param-value>customValue</param-value>

</context-param>

<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>

public class Main {

    public static void main(String[] args) throws ServletException, LifecycleException {

        Tomcat tomcat = new Tomcat();

        Context ctx = tomcat.addContext("/", new File("src/main/resources").getAbsolutePath());

        Tomcat.addServlet(ctx, "hello", HelloWorldServlet.class.getName());

        ctx.addServletMapping("/*", "hello");

        // ctx.addApplicationListener(Listener.class.getName()); 

        tomcat.start();

        tomcat.getServer().await();

    }

    public static class HelloWorldServlet extends HttpServlet {

        @Inject

        private BeanManager manager;

        @Override

        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

            resp.setContentType("text/plain");

            resp.getWriter().append("Hello from " + manager);

        }

    }

}

<?xml version="1.0"?>

<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN" "http://www.eclipse.org/jetty/configure_9_0.dtd">

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

  <Set name="contextPath">/weld-numberguess</Set>

  <Set name="war"><Property name="jetty.webapps" default="."/>/weld-numberguess.war</Set>

  <Call name="prependServerClass">

    <Arg>-org.eclipse.jetty.server.handler.ContextHandler</Arg>

  </Call>

  <Call name="prependServerClass">

    <Arg>-org.eclipse.jetty.servlet.FilterHolder</Arg>

  </Call>

  <Call name="prependServerClass">

    <Arg>-org.eclipse.jetty.servlet.ServletContextHandler</Arg>

  </Call>

  <Call name="prependServerClass">

    <Arg>-org.eclipse.jetty.servlet.ServletHolder</Arg>

  </Call>

</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>

<listener>

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

</listener>

<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>

public class Main {

    public static void main(String[] args) throws Exception {

        Server jetty = new Server(8080);

        WebAppContext context = new WebAppContext();

        context.setContextPath("/");

        context.setResourceBase("src/main/resources");

        jetty.setHandler(context);

        context.addServlet(HelloWorldServlet.class, "/*");

        context.addEventListener(new Listener()); 

        jetty.start();

        jetty.join();

    }

    public static class HelloWorldServlet extends HttpServlet {

        @Inject BeanManager manager;

        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

            resp.setContentType("text/plain");

            resp.getWriter().append("Hello from " + manager);

        }

    }

}
public class Main {

    public static void main(String[] args) throws ServletException {

        DeploymentInfo servletBuilder = Servlets.deployment()

                .setClassLoader(Main.class.getClassLoader())

                .setResourceManager(new ClassPathResourceManager(Main.class.getClassLoader()))

                .setContextPath("/")

                .setDeploymentName("test.war")

                .addServlet(Servlets.servlet("hello", HelloWorldServlet.class).addMapping("/*"))

                .addListener(Servlets.listener(Listener.class)); 

        DeploymentManager manager = Servlets.defaultContainer().addDeployment(servletBuilder);

        manager.deploy();

        HttpHandler servletHandler = manager.start();

        PathHandler path = Handlers.path(Handlers.redirect("/")).addPrefixPath("/", servletHandler);

        Undertow server = Undertow.builder().addHttpListener(8080, "localhost").setHandler(path).build();

        server.start();

    }

    public static class HelloWorldServlet extends HttpServlet {

        @Inject BeanManager manager;

        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

            resp.setContentType("text/plain");

            resp.getWriter().append("Hello from " + manager);

        }

    }

}
@Inject @Parameters List<String> params;
@Inject @Parameters String[] paramsArray;
import javax.inject.Singleton;

@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>
/** A builder used to bootsrap a Weld SE container. */

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 all the containers initialized by a specific builder instance. */

   public void shutdown() {...}

}
/** Represents a Weld SE container. */

public class WeldContainer implements javax.enterprise.inject.Instance<Object>

{

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

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

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

   public BeanManager getBeanManager() {...}

   /** Returns the identifier of the container */

   String getId() {...}

   /** Shuts down the container. */

   public void shutdown() {...}

   /** Returns the running container with the specified identifier or null if no such container exists */

   public static WeldContainer instance(String id) {...}

}
import org.jboss.weld.environment.se.Weld;

public static void main(String[] args) {

   Weld weld = new Weld();

   WeldContainer container = weld.initialize();

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

   container.shutdown();

}
org.jboss.weld.environment.se.Weld;

public static void main(String[] args) {

   Weld weld = new Weld();

   WeldContainer container = weld.initialize();

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

   // When all observer methods are notified the container shuts down

   container.shutdown();

}
org.jboss.weld.environment.se.Weld;

public static void main(String[] args) {

   Weld weld = new Weld();

   try (WeldContainer container = weld.initialize()) {

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

   }

}
Weld weld = new Weld()

    .disableDiscovery()

    .packages(Main.class, Utils.class)

    .interceptors(TransactionalInterceptor.class)

    .property("org.jboss.weld.construction.relaxed", true);

try (WeldContainer container = weld.initialize()) {

    MyBean bean = container.select(MyBean.class).get();

    System.out.println(bean.computeResult());

}
Weld weld = new Weld()

    .disableDiscovery();

weld.containerId("one").beanClasses(MyBean.class).initialize();

weld.containerId("two").beanClasses(OtherBean.class).initialize();

MyBean bean = WeldContainer.instance("one").select(MyBean.class).get();

System.out.println(bean.computeResult());

// Shutdown the first container

WeldContainer.instance("one").shutdown();

// Shutdown all the containers initialized by the builder instance

weld.shutdown();
public class Foo {

  @Inject

  MyRequestScopedBean bean;

  @ActivateRequestScope

  public void executeInRequestContext() {

    bean.ping()

  }

}

<beans>

  <decorators>

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

  </decorator>

</beans>

public class Foo {

  @Inject

  MyThreadScopedBean bean;

  @ActivateThreadScope

  public void executeInThreadContext() {

    bean.ping()

  }

}

<dependency>

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

   <artifactId>weld-se</artifactId>

</dependency>

        try (WeldContainer weld = new Weld().disableDiscovery().beanClasses(Cat.class).initialize()) {

              ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);

              context.addEventListener(new Listener());

              context.setAttribute(Listener.CONTAINER_ATTRIBUTE_NAME, weld);

              Server server = new Server(8080);

              context.setContextPath("/");

              server.setHandler(context);

              context.addServlet(TestServlet.class, "/test");

              server.start();

        }
        Weld weld = new Weld();

        WeldContainer container = weld.initialize();

        Server server = new Server(8080);

        context.setContextPath("/");

        server.setHandler(context);

        context.addServlet(TestServlet.class, "/test");

        context.setAttribute(WeldServletLifecycle.BEAN_MANAGER_ATTRIBUTE_NAME, container.getBeanManager());

        server.start();
        Weld builder = new Weld().disableDiscovery().beanClasses(Cat.class);

        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);

        context.addEventListener(Listener.using(builder));

        Server server = new Server(8080);

        context.setContextPath("/");

        server.setHandler(context);

        context.addServlet(TestServlet.class, "/test");

        server.start();
public class MyExternalConfiguration implements ExternalConfiguration {

    @Override

    public void cleanup() {

    // cleanup code

    }

    @Override

    public Map<String, Object> getConfigurationProperties() {

        Map<String, Object> properties = new HashMap<String, Object>();

        properties.put(ConfigurationKey.CONCURRENT_DEPLOYMENT.get(), false);

        properties.put(ConfigurationKey.PRELOADER_THREAD_POOL_SIZE.get(), 200);

        properties.put(ConfigurationKey.PROXY_DUMP.get(), "/home/weld");

        return properties;

    }

}

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

<beans xmlns="http://xmlns.jcp.org/xml/ns/javaee">

    <scan>

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

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

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

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

            <if-class-not-available name="com.google.GWT"/>

        </exclude>

        <!--

            Exclude types from com.acme.verbose package if the system property verbosity is set to low

            i.e.

              java ... -Dverbosity=low

        -->

        <exclude name="com.acme.verbose.*">

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

        </exclude>

        <!--

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

             property is set

        -->

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

            <if-class-available name="org.apache.wicket.Wicket"/>

            <if-system-property name="viewlayer"/>

        </exclude>

    </scan>

</beans>

<web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee/"

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

xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">

    <context-param>

        <param-name>org.jboss.weld.context.mapping</param-name>

        <param-value>.*\.html</param-value>

    </context-param>

</web-app>

mvn clean test -Dtest=MyWeldSETest -Dorg.jboss.logging.provider=slf4j -Dorg.slf4j.simpleLogger.log.org.jboss.weld=debug

<web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee/"

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

xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">

    <context-param>

        <param-name>org.jboss.weld.development</param-name>

        <param-value>true</param-value>

    </context-param>

</web-app>

java -cp myCoolApp.jar -Dorg.jboss.weld.development=true com.foo.MyMain
org.jboss.weld.environment.se.Weld;

public static void main(String[] args) {

   Weld weld = new Weld().property("org.jboss.weld.development", true);

   try (WeldContainer container = weld.initialize()) {

      ...

   }

}
=====================================
 Weld Development Mode: ENABLED
 ------------------------------------
 Disable this mode in production - it may have negative impact on performance and/or represent a potential security risk
=====================================
   /* 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 activate 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 activate 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));

      }

   }
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 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);

}
import org.jboss.weld.bootstrap.api.Service;

public interface ResourceLoader extends Service {

    public Class<?> classForName(String name);

    public URL getResource(String name);

    public Collection<URL> getResources(String name);

}
public interface ClassFileServices extends BootstrapService {

    ClassFileInfo getClassFileInfo(String className);

}
public interface ClassFileInfo {

    String getClassName();

    String getSuperclassName();

    boolean isAnnotationDeclared(Class<? extends Annotation> annotationType);

    boolean containsAnnotation(Class<? extends Annotation> annotationType);

    int getModifiers();

    boolean hasCdiConstructor();

    boolean isAssignableFrom(Class<?> javaClass);

    boolean isAssignableTo(Class<?> javaClass);

    boolean isVetoed();

    boolean isTopLevelClass();
// 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(instance);

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

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

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

// Get an the Bean object

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

// Create the injection target

InjectionTarget<T> it = beanManager.createInjectionTarget(ejbDescriptor);

// Per instance required, create the creational context

WeldCreationalContext<T> cc = beanManager.createCreationalContext(bean);

// register an AroundConstructCallback if needed

cc.setConstructorInterceptionSuppressed(true);

cc.registerAroundConstructCallback(new AroundConstructCallback<T>() {

    public T aroundConstruct(ConstructionHandle<T> handle, AnnotatedConstructor<T> constructor, Object[] parameters,

            Map<String, Object> data) throws Exception {

        // TODO: invoke @AroundConstruct interceptors

        return handle.proceed(parameters, data);

    }

});

// Produce the instance, performing any constructor injection required

T instance = it.produce(cc);

// 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(instance);

cc.release();

	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). Sets the button’s label based on the game state.
	`replayBtnActionPerformed` simply calls `game.reset()` to start a new game, refreshes the messages in the UI and sets the button’s label based on the game state.

Configuration key	Default value	Description
`org.jboss.weld.bootstrap.concurrentDeployment`	true	If set to false, `ConcurrentDeployer` and `ConcurrentValidator` will not be used.
`org.jboss.weld.bootstrap.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 key	Default value	Description
`org.jboss.weld.executor.threadPoolType`	`FIXED`	The type of the thread pool. Possible values are: `FIXED`, `FIXED_TIMEOUT`, `NONE`, `SINGLE_THREAD`
`org.jboss.weld.executor.threadPoolSize`	`Runtime.getRuntime().availableProcessors()`	The number of threads to be used for bean loading and deployment.
`org.jboss.weld.executor.threadPoolKeepAliveTime`	60 seconds	Passed to the constructor of the ThreadPoolExecutor class, maximum time that excess idle threads will wait for new tasks before terminating.
`org.jboss.weld.executor.threadPoolDebug`	false	If set to true, debug timing information is printed to the standard output.

	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 key	Tool	Default value	Description
`org.jboss.weld.probe.invocationMonitor.excludeType`	Probe	''	A regular expression. If a non-empty string and the base type for an AnnotatedType or a declaring type for an AnnotatedMember matches this pattern the type is excluded from monitoring.
`org.jboss.weld.probe.invocationMonitor.skipJavaBeanProperties`	Probe	true	If set to `true`, the JavaBean accessor methods are not monitored.
`org.jboss.weld.probe.eventMonitor.excludeType`	Probe	''	A regular expression. If a non-empty string and the runtime class of the event object matches this pattern the event is excluded from monitoring.
`org.jboss.weld.probe.eventMonitor.containerLifecycleEvents`	Probe	false	If set to `true` all the container lifecycle events are monitored during bootstrap.
`org.jboss.weld.probe.embedInfoSnippet`	Probe	true	If set to `true` an informative HTML snippet will be added to every HTTP response with Content-Type of value `text/html`.
`org.jboss.weld.probe.jmxSupport`	Probe	false	If set to `true` one or more MBean components may be registered so that it’s possible to use JMX to access the Probe development tool data.

Configuration key	Default value (ms)	Description
`org.jboss.weld.conversation.timeout`	600000	Conversation timeout represent the maximum time during which is the conversation active.
`org.jboss.weld.conversation.concurrentAccessTimeout`	1000	Conversation concurrent access timeout represent the maximum time to wait on the conversation concurrent lock.

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` `@Default`	`RequestContext` `BoundRequestContext`	A request context bound to a manually propagated map, useful for testing or non-Servlet environments
`@RequestScoped`	`@Http` `@Default`	`RequestContext` `HttpRequestContext`	A request context bound to a Servlet request, used for any Servlet based request context
`@RequestScoped`	`@Ejb` `@Default`	`RequestContext` `EjbRequestContext`	A request context bound to a an interceptor’s invocation context, used for EJB invocations outside of Servlet requests
`@ConversationScoped`	`@Bound` `@Default`	`ConversationContext` `BoundConversationContext`	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`	`@Http` `@Default`	`ConversationContext` `HttpConversationContext`	A conversation context bound to a Servlet request, used for any Servlet based conversation context
`@SessionScoped`	`@Bound` `@Default`	`SessionContext` `BoundSessionContext`	A session context bound to a manually propagated map, useful for testing or non-Servlet environments
`@SessionScoped`	`@Http` `@Default`	`SessionContext` `HttpSessionContext`	A session context bound to a Servlet request, used for any Servlet based session context
`@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

Class	Type	Description
`org.jboss.weld.probe.ProbeFilter`	Servlet filter	An integrator is required to register this filter for every web application which should be a subject of inspection. The filter should only be mapped to a single URL pattern of value `/*`.
`org.jboss.weld.probe.ProbeExtension`	CDI extension	An integrator is required to register this extension for every application which should be a subject of inspection.

group id	artifact id	version
org.jboss.logging	jboss-logging	3.1.3.GA
com.google.guava	guava	13.0.1
javax.enterprise	cdi-api	1.1-20130918
javax.annotation	javax.annotation-api	1.2
javax.interceptor	javax.interceptor-api	1.2
org.apache.geronimo.specs	geronimo-el_2.2_spec	1.0.3

Note

Note

Note

Warning

Note

Note

Note

Note

Note

Note