Können Sie es jetzt kaum erwarten Ihr erstes Web Bean zu schreiben? Oder sind Sie etwas skeptisch und fragen sich, welche Hürden Ihnen bei der Web Beans Spezifikation bevorstehen? Die gute Nachricht ist, dass Sie wahrscheinlich schon hunderte, wenn nicht tausende von Web Beans geschrieben haben. Vielleicht erinnern Sie sich nicht einmal an das erste Web Bean, das Sie je geschrieben haben.

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;

    

    @Initializer

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

    }

    

}

@Initializer

public setTextTranslator(TextTranslator textTranslator) {

    this.textTranslator = textTranslator;

}

TextTranslator tt = manager.getInstanceByType(TextTranslator.class);

@CreditCard PaymentProcessor paymentProcessor

@CreditCard

public class CreditCardPaymentProcessor 

    implements PaymentProcessor { ... }

@Mock

public class MockSentenceTranslator implements Translator {

    public String translate(String sentence) {

        return "Lorem ipsum dolor sit amet";

    }

}

@SessionScoped

public class ShoppingCart { ... }

@SessionScoped @Named("cart")

public class ShoppingCart { ... }

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

@SessionScoped @Named

public class ShoppingCart { ... }

@SessionScoped 

@Interceptors(TransactionInterceptor.class)

public class ShoppingCart { ... }

@SessionScoped @Transactional

public class ShoppingCart { ... }

@Stateful @SessionScoped

public class ShoppingCart {


    ...

    

    @Remove

    public void destroy() {}


}

@ApplicationScoped

public class Generator {


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

    

    @Produces @Random int next() {

        return random.nextInt(100);

    }


}

@Random int randomNumber

@Produces @RequestScoped Connection connect(User user) {

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

}

void close(@Disposes Connection connection) {

    connection.close();

}

Illustrieren wir diese Ideen an einem vollständigen Beispiel. Wir werden einen Benutzer Login/Logout für eine JSF verwendende Anwendung implementieren. Zunächst definieren wir ein Web Bean das den während des Logins eingegebenen Benutzernamen und das Passwort verwahrt:

@Named @RequestScoped

public class Credentials {

        

    private String username;

    private String password;

    

    public String getUsername() { return username; }

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

    

    public String getPassword() { return password; }

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

    

}

Dieses Web Bean ist an den Login-Prompt in folgendem JSF-Formular gebunden:

<h:form>

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

        <h:outputLabel for="username"

>Username:</h:outputLabel>

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

        <h:outputLabel for="password"

>Password:</h:outputLabel>

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

    </h:panelGrid>

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

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

</h:form

>

Die eigentliche Arbeit wird durch ein Session-begrenztes Web Bean übernommen, dass Informationen zum aktuell eingeloggten Benutzer verwahrt und anderen Web Beans die User-Entity offenlegt:

@SessionScoped @Named

public class Login {


    @Current Credentials credentials;

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

        }

        

    }

    

    public void logout() {

        user = null;

    }

    

    public boolean isLoggedIn() {

       return user!=null;

    }

    

    @Produces @LoggedIn User getCurrentUser() {

        return user;

    }


}

Natürlich handelt es sich bei @LoggedIn um eine "Binding"-Annotation:

@Retention(RUNTIME)

@Target({TYPE, METHOD, FIELD})

@BindingType

public @interface LoggedIn {}

Jetzt kann jedes andere Web Bean den aktuellen Benutzer auf leichte Weise einspeisen:

public class DocumentEditor {


    @Current Document document;

    @LoggedIn User currentUser;

    @PersistenceContext EntityManager docDatabase;

    

    public void save() {

        document.setCreatedBy(currentUser);

        docDatabase.persist(document);

    }

    

}

Wir hoffen, dass Ihnen dieses Beispiel einen Vorgeschmack auf das Web Bean Programmiermodell gegeben hat. Im nächsten Kapitel sehen wir uns die Web Beans Dependency-Einspeisung näher an.

Die Web Beans Referenzimplementierung wird unter das Seam Projekt entwickelt. Sie können die aktuellste Entwickler-Release von Web Beans von der Downloads Seite herunterladen.

Die Web Beans RI kommt mit zwei deploybaren Beispielanwendungen: webbeans-numberguess, ein war-Beispiel, das nur einfache Beans enthält und webbeans-translator, ein ear-Beispiel, dasEnterprise Beans enthält. Um Beispiele auszuführen benötigen Sie folgendes:

Currently, the Web Beans RI only runs on JBoss Application Server 5. You'll need to download JBoss AS 5.0.1.GA from jboss.org, and unzip it. For example:

$ cd /Applications
$ unzip ~/jboss-5.0.1.GA.zip

Anschließend laden Sie die Web Beans RI unter seamframework.org herunter und entzippen diese. Zum Beispiel

$ cd ~/
$ unzip ~/webbeans-$VERSION.zip

Als nächstes müssen wir Web Beans mitteilen, wo JBoss sich befindet. Editieren Sie jboss-as/build.properties und setzen Sie die jboss.home-Property. Zum Beispiel:

jboss.home=/Applications/jboss-5.0.1.GA

To install Web Beans, you'll need Ant 1.7.0 installed, and the ANT_HOME environment variable set. For example:

$ unzip apache-ant-1.7.0.zip
$ export ANT_HOME=~/apache-ant-1.7.0

Then, you can install the update. The update script will use Maven to download Web Beans automatically.

$ cd webbeans-$VERSION/jboss-as
$ ant update

Jetzt können Sie Ihr erstes Beispiel deployen!

Um das numberguess Beispiel zu deployen:

$ cd examples/numberguess
ant deploy

JBoss AS starten:

$ /Application/jboss-5.0.0.GA/bin/run.sh

Deployen Sie die Anwendung und genießen Sie stundenlangen Spaß unter http://localhost:8080/webbeans-numberguess!

Die Web Beans RI enthält ein zweites einfaches Beispiel, das Ihren Text ins Lateinische übersetzt. Beim numberguess Beispiel handelt es sich um ein war-Beispiel und es verwendet nur einfache Beans; das translator-Beispiel ist ein ear-Beispiel, das in einem EJB-Modul verpackte Enterprise Beans enthält . Um dies auszuprobieren:

$ cd examples/translator
ant deploy

Warten Sie, bis die Anwendung deployt ist und besuchen Sie http://localhost:8080/webbeans-translator!

3.1. Das numberguess-Beispiel

In der numberguess-Anwendung haben Sie 10 Versuche, eine Zahl zwischen 1 und 100 zu erraten. Nach jedem Versuch wird Ihnen mitgeteilt, ob Sie zu hoch oder zu niedrig liegen.

Das numberguess-Beispiel besteht aus einer Reihe von Web Beans, Konfigurationsdateien und Facelet JSF-Seiten, die als eine war verpackt sind. Fangen wir mit den Konfigurationsdateien an.

Alle Konfigurationsdateien für dieses Beispiel befinden sich in WEB-INF/, das in WebContent im Quell-Baum gespeichert ist. Zunächst haben wir faces-config.xml, in dem wir JSF anweisen, Facelets zu verwenden:

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

<faces-config version="1.2"

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

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

              xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">

    

    <application>

        <view-handler

>com.sun.facelets.FaceletViewHandler</view-handler>

    </application>



</faces-config

>

Es existiert eine leere web-beans.xml-Datei, die diese Anwendung als Web Beans Applikation kennzeichnet.

Und schließlich gibt es noch web.xml:

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

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

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

   <servlet-mapping>
      <servlet-name
>Faces Servlet</servlet-name>
      <url-pattern
>*.jsf</url-pattern>
   </servlet-mapping>
              
   <context-param>
      <param-name
>javax.faces.DEFAULT_SUFFIX</param-name>
      <param-value
>.xhtml</param-value>
   </context-param>

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

</web-app
>

	Enable and load the JSF servlet
	Configure requests to .jsf pages to be handled by JSF
	Tell JSF that we will be giving our source files (facelets) an extension of .jsf
	Configure a session timeout of 10 minutes

Anmerkung

Whilst this demo is a JSF demo, you can use the Web Beans RI with any Servlet based web framework.

Let's take a look at the Facelet view:

<!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"
    xmlns:s="http://jboss.com/products/seam/taglib">

  <ui:composition template="template.xhtml">
    <ui:define name="content">
       <h1
>Guess a number...</h1>
       <h:form id="NumberGuessMain">
          <div style="color: red">
             <h:messages id="messages" globalOnly="false"/>
             <h:outputText id="Higher" value="Higher!" rendered="#{game.number gt game.guess and game.guess ne 0}"/>
             <h:outputText id="Lower" value="Lower!" rendered="#{game.number lt game.guess and game.guess ne 0}"/>
          </div>
   
          <div>
             I'm thinking of a number between #{game.smallest} and #{game.biggest}.
             You have #{game.remainingGuesses} guesses.
          </div>
     
          <div>
             Your guess: 
             <h:inputText id="inputGuess" 
                          value="#{game.guess}" 
                          required="true" 
                          size="3" 
                          disabled="#{game.number eq game.guess}">
                <f:validateLongRange maximum="#{game.biggest}" 
                                     minimum="#{game.smallest}"/>
             </h:inputText>
            <h:commandButton id="GuessButton"  
                             value="Guess" 
                             action="#{game.check}" 
                             disabled="#{game.number eq game.guess}"/>
          </div>
          <div>
            <h:commandButton id="RestartButton" value="Reset" action="#{game.reset}" immediate="true" />
          </div>
       </h:form>
    </ui:define>
  </ui:composition>
</html
>

	Facelets is a templating language for JSF, here we are wrapping our page in a template which defines the header.
	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 sentance changes to make sure they know what range to guess in.
	This input field is bound to a Web Bean, using the value expression.
	A range validator 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 range 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 Web Bean.

Das Beispiel besteht aus 4 Klassen, wobei die ersten beiden Binding-Typen sind. Zunächst gibt es den @Random Binding-Typ, der zur Einspeisung einer zufälligen Zahl dient:

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

@Retention(RUNTIME)

@Documented

@BindingType

public @interface Random {}

Es gibt außerdem den @MaxNumber Binding-Typ, der zur Einspeisung der maximalen Zahl, die eingespeist werden kann, verwendet wird:

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

@Retention(RUNTIME)

@Documented

@BindingType

public @interface MaxNumber {}

Die Generator-Klasse ist verantwortlich für die Erstellung der zufälligen Zahl via einer Producer-Methode. Sie legt auch die mögliche Maximalzahl via einer maximum Producer-Methode offen:

@ApplicationScoped

public class Generator {

   

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

   

   private int maxNumber = 100;

   

   java.util.Random getRandom()

   {

      return random;

   }

   

   @Produces @Random int next() { 

      return getRandom().nextInt(maxNumber); 

   }

   

   @Produces @MaxNumber int getMaxNumber()

   {

      return maxNumber;

   }


}

Sie werden feststellen, dass der Generator anwendungsbegrenzt ist; daher erhalten wir nicht jedes Mal ein anderes Zufallsergebnis.

Das letzte Web Bean in der Anwendung ist das sessionbegrenzte Game.

Sie werden bemerken, dass wir die @Named-Annotation verwendet haben, damit wir das Bean durch EL in der JSF-Seite verwenden können. Zu guter Letzt haben wir Konstruktor-Einspeisung zur Initialisierung des Spiels mit Zufallszahl verwendet. Und natürlich müssen wir dem Spieler mitteilen, wenn er gewonnen hat, daher bieten wir Feedback mittels einer FacesMessage.

package org.jboss.webbeans.examples.numberguess;



import javax.annotation.PostConstruct;

import javax.faces.application.FacesMessage;

import javax.faces.context.FacesContext;

import javax.webbeans.AnnotationLiteral;

import javax.webbeans.Current;

import javax.webbeans.Initializer;

import javax.webbeans.Named;

import javax.webbeans.SessionScoped;

import javax.webbeans.manager.Manager;


@Named

@SessionScoped

public class Game

{

   private int number;

   

   private int guess;

   private int smallest;

   private int biggest;

   private int remainingGuesses;

   

   @Current Manager manager;

   

   public Game()

   {

   }

   

   @Initializer

   Game(@MaxNumber int maxNumber)

   {      

      this.biggest = maxNumber;

   }


   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 String check()

   {

      if (guess

>number)

      {

         biggest = guess - 1;

      }

      if (guess<number)

      {

         smallest = guess + 1;

      }

      if (guess == number)

      {

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

      }

      remainingGuesses--;

      return null;

   }

   

   @PostConstruct

   public void reset()

   {

      this.smallest = 0;

      this.guess = 0;

      this.remainingGuesses = 10;

      this.number = manager.getInstanceByType(Integer.class, new AnnotationLiteral<Random

>(){});

   }

   

}

<plugin>

   <groupId

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

   <artifactId

>maven-ear-plugin</artifactId>

   <configuration>

      <modules>

         <webModule>

            <groupId

>org.jboss.webbeans.examples.translator</groupId>

            <artifactId

>webbeans-translator-war</artifactId>

            <contextRoot

>/webbeans-translator</contextRoot>

         </webModule>

      </modules>

   </configuration>

</plugin

>

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

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

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

             xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/application_5.xsd"

             version="5">

  <display-name

>webbeans-translator-ear</display-name>

  <description

>Ear Example for the reference implementation of JSR 299: Web Beans</description>

  

  <module>

    <web>

      <web-uri

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

      <context-root

>/webbeans-translator</context-root>

    </web>

  </module>

  <module>

    <ejb

>webbeans-translator.jar</ejb>

  </module>

</application

>

<h:form id="NumberGuessMain">

            

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

   private SentenceParser sentenceParser; 

   private Translator sentenceTranslator; 

   

   @Initializer

   TextTranslator(SentenceParser sentenceParser, Translator sentenceTranslator) 

   { 

      this.sentenceParser = sentenceParser; 

      this.sentenceTranslator = sentenceTranslator;

@Stateful

@RequestScoped

@Named("translator")

public class TranslatorControllerBean implements TranslatorController

{

   

   @Current TextTranslator translator;

   @Remove

   public void remove()

   {

      

   }

That concludes our short tour of the Web Beans examples. For more on Web Beans , or to help out, please visit http://www.seamframework.org/WebBeans/Development.

Wir brauche Unterstützung auf allen Gebieten - Fehlerbehebung, Schreiben neuer Features, Schreiben neuer Beispiele und bei der Übersetzung dieses Referenzhandbuchs.

Web Beans unterstützt drei primäre Mechanismen für "Dependency"-Einspeisung:

Konstruktorparameter-Einspeisung:

public class Checkout {

        

    private final ShoppingCart cart;

    

    @Initializer

    public Checkout(ShoppingCart cart) {

        this.cart = cart;

    }


}

Initializer-Methode Parameter-Einspeisung:

public class Checkout {

        

    private ShoppingCart cart;


    @Initializer 

    void setShoppingCart(ShoppingCart cart) {

        this.cart = cart;

    }

    

}

Und direkte Feldeinspeisung:

public class Checkout {


    private @Current ShoppingCart cart;

    

}

Dependency-Einspeisung findet stets bei der ersten Instantiierung der Web Bean Instanz statt.

Die Einspeisung von Konstruktorparametern wird für EJB-Beans nicht unterstützt, da das EJB durch den EJB-Container und nicht den Web Bean Manager instantiiert wird.

Parameter von Konstruktoren und Initialisierermethoden müssen nicht explizit annotiert werden, wenn der standardmäßige Binding-Typ @Current gilt.Eingespeiste Felder jedoch müssen einen Binding-Typ festlegen, selbst wenn der standardmäßige Binding-Typ gilt. Legt das Feld keinen standardmäßige Binding-Typ fest, so wird es nicht eingespeist.

Producer-Methoden unterstützen Parametereinspeisung ebenfalls:

@Produces Checkout createCheckout(ShoppingCart cart) {

    return new Checkout(cart);

}

Observer-Methoden (auf die wir in Kapitel 9, Ereignisse näher eingehen), "Disposal"-Methoden und "Destructor"-Methoden unterstützen allesamt die Parametereinspeisung.

Die Web Beans Spezifikation definiert eine Prozedur namens typesicherer Auflösungsalgorithmus (sog. typesafe resolution algorithm), den der Web Bean Manager bei der Identifizierung des an einem Einspeisungspunkt einzuspeisenden Web Beans folgt. Dieser Algorithmus sieht auf den ersten Blick recht komplex aus, ist es aber nach kurzer Eingewöhnung nicht. Typensichere Auflösung wird zum Initialisierungszeitpunkt des Systems durchgeführt, was bedeutet, dass der Manager den Benutzer sofort darüber informiert, falls die Abhängigkeiten eines Web Beans nicht erfüllt werden können - dies erfolgt durch Meldung von UnsatisfiedDependencyException oder AmbiguousDependencyException.

Der Zweck dieses Algorithmus ist es, mehreren Web Beans die Einspeisung desselben API-Typs zu gestatten und entweder:

Schauen wir uns jetzt näher an, wie der Web Beans Manager ein einzuspeisendes Web Bean bestimmt.

@PayByCheque

public class ChequePaymentProcessor implements PaymentProcessor {

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

}

@PayByCreditCard

public class CreditCardPaymentProcessor implements PaymentProcessor {

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

}

@Retention(RUNTIME)

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

@BindingType

public @interface PayByCheque {}

@Retention(RUNTIME)

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

@BindingType

public @interface PayByCreditCard {}

@PayByCheque PaymentProcessor chequePaymentProcessor;

@PayByCreditCard PaymentProcessor creditCardPaymentProcessor;

@Initializer

public void setPaymentProcessors(@PayByCheque PaymentProcessor chequePaymentProcessor, 

                                 @PayByCreditCard PaymentProcessor creditCardPaymentProcessor) {

   this.chequePaymentProcessor = chequePaymentProcessor;

   this.creditCardPaymentProcessor = creditCardPaymentProcessor;

}

@Initializer

public Checkout(@PayByCheque PaymentProcessor chequePaymentProcessor, 

                @PayByCreditCard PaymentProcessor creditCardPaymentProcessor) {

   this.chequePaymentProcessor = chequePaymentProcessor;

   this.creditCardPaymentProcessor = creditCardPaymentProcessor;

}

@Retention(RUNTIME)

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

@BindingType

public @interface PayBy {

    PaymentType value();

}

@PayBy(CHEQUE) PaymentProcessor chequePaymentProcessor;

@PayBy(CREDIT_CARD) PaymentProcessor creditCardPaymentProcessor;

@Asynchronous @PayByCheque PaymentProcessor paymentProcessor

@Produces 

@Asynchronous @PayByCheque 

PaymentProcessor createAsyncPaymentProcessor(@PayByCheque PaymentProcessor processor) {

    return new AsynchronousPaymentProcessor(processor);

}

@Retention(RUNTIME)

  @Target({TYPE, METHOD})

  @DeploymentType

  public @interface Mock {}

public class ExternalPaymentProcessor {

        

    public void process(Payment p) {

        ...

    }

    

}

@Mock 

public class MockPaymentProcessor implements PaymentProcessor {


    @Override

    public void process(Payment p) {

        p.setSuccessful(true);

    }


}

<WebBeans>

    <Deploy>

        <Standard/>

        <Production/>

        <test:Mock/>

    </Deploy>

</WebBeans

>

@Current PaymentProcessor paymentProcessor

@Current Manager manager;

PaymentProcessor p = manager.getInstanceByType(PaymentProcessor.class);

PaymentProcessor p = manager.getInstanceByType(PaymentProcessor.class, 

                                               new AnnotationLiteral<CreditCard

>(){});

abstract class CreditCardBinding 

    extends AnnotationLiteral<CreditCard

> 

    implements CreditCard {}

PaymentProcessor p = manager.getInstanceByType(PaymentProcessor.class, 

                                               new CreditCardBinding() { 

                                                   public void value() { return paymentType; } 

                                               } );

Logger log = Logger.getLogger(MyClass.class.getName());

class LogFactory {


   @Produces Logger createLogger(InjectionPoint injectionPoint) { 

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

   }


}

@Current Logger log;

@BindingType

@Retention(RUNTIME)

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

public @interface HttpParam {

   @NonBinding public String value();

}

@HttpParam("username") String username;

@HttpParam("password") String password;

class HttpParams


   @Produces @HttpParam("")

   String getParamValue(ServletRequest request, InjectionPoint ip) {

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

   }


}

public interface InjectionPoint { 

   public Object getInstance(); 

   public Bean<?> getBean(); 

   public Member getMember(): 

   public <T extends Annotation

> T getAnnotation(Class<T

> annotation); 

   public Set<T extends Annotation

> getAnnotations(); 

}

Bis jetzt haben wir ein paar Beispiele von Geltungsbereichtyp-Annotationen gesehen. Der Geltungsbereich eines Web Beans bestimmt den Lebenszyklus der Instanzen des Web Beans. Der Geltungsbereich bestimmt auch, welche Clients sich auf welche Instanzen des Web Beans beziehen. Gemäß der Web Beans Spezifikation bestimmt ein Geltungsbereich:

Wenn wir etwa ein session-begrenztes Web Bean CurrentUser haben, so sehen alle Web Beans, die im Kontext derselben HttpSession aufgerufen werden, dieselbe Instanz von CurrentUser. Diese Instanz wird automatisch erstellt, wenn CurrentUser erstmals in dieser Session benötigt wird und automatisch gelöscht, wenn die Session endet.

@Retention(RUNTIME)

@Target({TYPE, METHOD})

@ScopeType

public @interface ClusterScoped {}

@ClusterScoped

public class SecondLevelCache { ... }

@Current Conversation Konversation;

@ConversationScoped @Stateful

public class OrderBuilder {


    private Order order;

    private @Current 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=#{conversation.id}"
>Add Product</a
>

conversation.setTimeout(timeoutInMillis);

public class Calculator { ... }

@New Calculator calculator;

@ConversationScoped

public class Calculator { ... }

public class PaymentCalc {


    @Current Calculator calculator;

    @New Calculator newCalculator;


}

Producer-Methoden gestatten es uns, bestimmte Beschränkungen zu umgehen, die auftreten, wenn der Web Bean Manager statt die Anwendung für die Instantiierung von Objekten verantwortlich ist. Sie sind auch die einfachste Art der Integration von Objekten in die Web Beans Umgebung, die keine Web Beans sind. (In Kapitel 12, Definition von Web Beans unter Verwendung von XML lernen wir eine zweite Weise kennen.)

Gemäß der Spezifikation:

Producer-Methoden lassen uns zum Beispiel:

Insbesondere lassen uns Producer-Methoden Runtime-Polymorphie mit Web Beans verwenden. Wie wir bereits gesehen haben sind Deployment-Typen eine leistungsfähige Lösung zum Problem der Polymorphie zum Zeitpunkt des Deployment. Aber nachdem das System deployt ist, wird die Web Bean Implementierung behoben. Eine Producer-Methode besitzt keine solche Einschränkung:

@SessionScoped

public class Preferences {

    

    private PaymentStrategyType paymentStrategy;

    

    ...

    

    @Produces @Preferred 

    public PaymentStrategy getPaymentStrategy() {

        switch (paymentStrategy) {

            case CREDIT_CARD: return new CreditCardPaymentStrategy();

            case CHEQUE: return new ChequePaymentStrategy();

            case PAYPAL: return new PayPalPaymentStrategy();

            default: return null;

        } 

    }

    

}

Überlegen Sie einen Einspeisungspunkt:

@Preferred PaymentStrategy paymentStrat;

Dieser Einspeisungspunkt besitzt denselben Typ und diesselben Binding-Annotationen wie die Producer-Methode, so dass er unter Verwendung der üblichen Web Beans Einspeisungsregeln zur Producer-Methode auflöst. Die Producer-Methode wird vom Web Bean Manager aufgerufen um eine Instanz zu erhalten, um diesen Einspeisungspunkt zu bedienen.

@Produces @Preferred @SessionScoped

public PaymentStrategy getPaymentStrategy() {

    ...

}

@Produces @Preferred @SessionScoped

public PaymentStrategy getPaymentStrategy(CreditCardPaymentStrategy ccps,

                                          ChequePaymentStrategy 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 ChequePaymentStrategy cps,

                                          @New PayPalPaymentStrategy ppps) {

    switch (paymentStrategy) {

        case CREDIT_CARD: return ccps;

        case CHEQUE: return cps;

        case PAYPAL: return ppps;

        default: return null;

    } 

}