Entonces, ¿está preparado para empezar a escribir su primer Web Bean? O quizás está escéptico, preguntándose por qué tipos de arcos le hará ¡saltar la especificación de Web Beans! La buena noticia es que probablemente ya ha escrito y utilizado cientos, quizás miles de Web Beans. Podría no recordar incluso el primer Web Bean que escribió.

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

}

Ilustremos estas ideas con un ejemplo. Vamos a implementar inicio/cierre de sesión de usuario para una aplicación que utiliza JSF. Primero, definiremos un Web Bean para mantener el nombre de usuario y contraseña escritos durante el inicio de sesión:

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

    

}

Este Web Bean está vinculado al intérprete de comandos de inicio de sesión en el siguiente formulario JSF:

<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

>

El trabajo real está hecho por una sesión de ámbito Web Bean que mantiene información acerca del usuario actualmente conectado y expone la entidad del Usuario a otras Web Beans:

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

    }


}

Obviamente, @LoggedIn es una anotación de enlace:

@Retention(RUNTIME)

@Target({TYPE, METHOD, FIELD})

@BindingType

public @interface LoggedIn {}

Ahora, cualquier otro Web Bean puede fácilmente inyectar al usuario actual:

public class DocumentEditor {


    @Current Document document;

    @LoggedIn User currentUser;

    @PersistenceContext EntityManager docDatabase;

    

    public void save() {

        document.setCreatedBy(currentUser);

        docDatabase.persist(document);

    }

    

}

Esperamos que este ejemplo de una idea del modelo de programación de Web Bean. En el próximo capítulo, estudiaremos más a fondo la inyección de dependencia de Web Beans.

La implementación de referencia (IR) de Web Beans se desarrolla en the Seam project. La última versión de Web Beans se puede descargar desde the downloads page.

La IR de Web Beans viene con dos ejemplos de aplicaciones de despliegue: webbeans-numberguess, un ejemplo WAR, que contiene sólo beans sencillos y un ejemplo EAR webbeans-translator que contiene beans empresariales. Para ejecutar los ejemplos necesitará lo siguiente:

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

Luego, descargue la IR de Web Beans desde seamframework.org, y descomprímalo. Por ejemplo:

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

Después necesitaremos decirle a Web Beans en dónde está localizado JBoss. Editar jboss-as/build.properties y establecer la propiedad jboss.home. Por ejemplo:

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

Ahora, ¡está listo para desplegar su primer ejemplo!

Para desplegar el ejemplo numberguess:

$ cd examples/numberguess
ant deploy

Start JBoss AS:

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

Espere que despliegue la aplicación, y diviértase en http://localhost:8080/webbeans-numberguess!

La IR de Web Beans incluye un segundo ejemplo que traducirá su texto en Latín. El ejemplo numberguess es un ejemplo WAR, y sólo utiliza beans sencillos; el ejemplo de traductor es un ejemplo EAR e incluye beans empresariales, empaquetados en un módulo EJB. Para probar:

$ cd examples/translator
ant deploy

Espere a que despliegue la aplicación, y ¡visite http://localhost:8080/webbeans-translator!

3.1. El ejemplo numberguess

En la aplicación numberguess se le dan 10 intentos para adivinar un número entre 1 y 100. Después de cada intento, se le dirá si es mayor o menor a su número.

El ejemplo de numberguess consta de una cantidad de Web Beans, archivos de configuración y páginas Facelet JSF, empaquetadas como WAR. Empecemos con los archivos de configuración.

Todos los archivos de configuración para este ejemplo están localizados en WEB-INF/, el cual está almacenado en WebContent en el árbol fuente. Primero, tenemos faces-config.xml, en donde le pedimos a JSF que utilice Facelets:

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

>

Hay un archivo web-beans.xml vacío, el cual marca esta aplicación como una aplicación de Web Beans.

Por último, está 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
>ejemplo de Web Beans Numberguess</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
>

	Habilitar y cargar el servlet de JSF
	Configurar peticiones .jsf para páginas que van a ser manejadas por JSF
	Decir a JSF que le estaremos dando a nuestros archivos fuente (facelets) una extensión de .jsf
	Configurar una pausa de 10 minutos

Nota

Aunque este demo es un demo de JSF, puede utilizar la IR de Web Beans con cualquier marco de la red basado en Servlet.

Observemos una vista de Facelet:

<!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
>Adivine un número...</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>
             Estoy pensando un número entre #{game.smallest} y #{game.biggest}.
             Le quedan #{game.remainingGuesses} de intentos.
          </div>
     
          <div>
             Su número: 
             <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 es un lenguaje de plantilla para JSF, aquí se delimita la página en una plantilla que define el encabezado.
	Hay una cantidad de mensajes que pueden ser enviados al usuario, "Mayor!", "Menor!" y "Correcto!"
	Mientras el usuario adivina, el rango de números que puede adivinar se vuelve cada vez más pequeño-esta oración cambia para estar seguros de que el usuario sabe en qué rango debe adivinar.
	Este campo de entrada está vinculado a un Web Bean, utilizando la expresión de valor.
	Un rango de validador se utiliza para garantizar que el usuario por accidente no entre un número fuera del rango en el que se puede adivinar - si el validador no estuviera aquí, el usuario podría tratar de adivinar fuera del rango.
	Y, obviamente, debe haber una forma para que el usuario pueda enviar el número al servidor. Aquí nos vincularnos a un método de acción en el Web Bean.

El ejemplo existe de 4 clases, las primeras dos son tipos de enlace. Primero, hay un tipo de enlace @Random, utilizado para inyectar un número aleatorio:

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

@Retention(RUNTIME)

@Documented

@BindingType

public @interface Random {}

También hay un tipo de enlace @MaxNumber, utilizado para inyectar el número máximo posible:

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

@Retention(RUNTIME)

@Documented

@BindingType

public @interface MaxNumber {}

La clase Generator es responsable de crear el número aleatorio, a través de un método de productor. También expone el número máximo posible a través del método de productor:

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

   }


}

Notará que el Generador es una aplicación en ámbito por lo tanto no obtenemos un número aleatorio diferente cada vez.

El Web Bean final en la aplicación es la sesión en ámbito Juego.

Notará que hemos utilizado la anotación @Named, para poder utilizar el bean a través de EL en la página JSF. Por último, hemos utilizado la inyección de constructor para inicializar el juego con un número aleatorio. Y, claro está, necesitamos decirle al jugador cuando haya ganado, por lo tanto le damos retroalimentación con 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

>Ejemplo Ear para la implementaci�n de referencia de 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.

Necesitamos ayuda en todas las áreas - corrección de errores, escritura de nuevas funciones, escritura de ejemplos y traducción de esta guía de referencia.

Web Beans soporta tres mecanismos primarios para inyección de dependencia:

Constructor de inyección de parámetro:

public class Checkout {

        

    private final ShoppingCart cart;

    

    @Initializer

    public Checkout(ShoppingCart cart) {

        this.cart = cart;

    }


}

Inyección de parámetro del método Inicializador:

public class Checkout {

        

    private ShoppingCart cart;


    @Initializer 

    void setShoppingCart(ShoppingCart cart) {

        this.cart = cart;

    }

    

}

E inyección directa de campo:

public class Checkout {


    private @Current ShoppingCart cart;

    

}

La inyección de dependencia siempre se presenta cuando la instancia de Web Bean es instanciada primero:

La inyección de parámetro constructor no es admitida por beans de EJB, porque EJB es instanciado por el contenedor de EJB, no por el administrador de Web Bean.

Los parámetros de constructores y métodos de inicializador no necesitan ser anotados explícitamente cuando se aplique el tipo de enlace predeterminado @Current. Los campos inyectados, sin embargo, deben especificar un tipo de enlace, cuando se aplique el tipo de enlace predeterminado. Si el campo no especifica ningún tipo de enlace, no será inyectado.

Los métodos de productor también admiten inyección de parámetro:

@Produces Checkout createCheckout(ShoppingCart cart) {

    return new Checkout(cart);

}

Por último, los métodos de observador (que encontraremos en Capítulo 9, Eventos), los métodos desechables y los métodos destructores, admiten inyección de parámetro.

La especificación de Web Beans define un procedimiento, llamado algoritmo de resolución de typesafe que el administrador de Web Bean sigue al identificar el Web Bean para inyectar a un punto de inyección. Este algoritmo parece complejo en un principio, pero una vez que lo entienda, es en realidad muy intuitivo. La resolución de Typesafe se realiza al inicializar el sistema, lo que significa que el administrador informará al usuario inmediatamente si se pueden cumplir las dependencias de un Web Bean, produciendo una UnsatisfiedDependencyException o una AmbiguousDependencyException.

El propósito de este algoritmo es permitir a múltiples Web Beans implementar el mismo tipo API ya sea:

Exploremos cómo el administrador de Web Beans determina una Web Bean para ser inyectado.

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

}

Hasta ahora, hemos visto algunos ejemplos de anotaciones de tipo ámbito. El ámbito de un Web Bean determina el ciclo de vida de instancias del Web Bean. El ámbito también determina qué clientes se refieren a qué instancias del Web Bean. Según la especificación de Web Beans, un ámbito determina:

Por ejemplo, si tenemos una sesión con ámbito Web Bean, UsuarioActual, todos los Web Beans que son llamados en el contexto de la misma HttpSession verán la misma instancia del UsuarioActual. Dicha instancia se creará automáticamente la primera vez que se necesite un UsuarioActual en esa sesión, y se destruirá automáticamente al terminar la sesión.

@Retention(RUNTIME)

@Target({TYPE, METHOD})

@ScopeType

public @interface ClusterScoped {}

@ClusterScoped

public class SecondLevelCache { ... }

@Current Conversation conversation;

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


}

Los métodos de productor nos permiten sobrepasar algunas limitaciones que se presentan cuando el administrador de Web Bean, en lugar de la aplicación, es responsable de instanciar objetos. También son la forma más fácil de integrar objetos que no son Web Beans dentro del entorno de Web Beans. (Veremos un segundo método en Capítulo 12, Definición de Web Beans utilizando XML.)

Según las especificaciones:

Por ejemplo, los métodos de productor nos permiten:

En particular, los métodos de productor nos permiten utilizar polimorfismo de tiempo de ejecución con Web Beans. Como hemos visto, los tipos de despliegue son una solución potente para el problema del polimorfismo de tiempo de despliegue. Sin embargo, una vez que el sistema es desplegado, la implementación de Web Bean es corregida. El método de productor no tiene dicha limitación:

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

        } 

    }

    

}

Consider an injection point:

@Preferred PaymentStrategy paymentStrat;

Este punto de inyección tiene el mismo tipo de anotaciones de enlace que el método de productor, por lo tanto apunta al método de productor mediante las reglas de inyección usuales de Web Beans. El método del productor será llamado por el administrador de Web Bean a fin de obtener una instancia para servir a este punto de inyección.

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

    } 

}