Presentando EJB

En este artículo veremos EJB - Enterprise JavaBeans. Esta tecnología es parte de la especificación Java EE. Tocaremos temas como:

• ¿Qué es EJB?
• ¿Cuál es la historia de EJB?
• ¿Qué tipos de EJB existen?

También escribiremos una pequeña aplicación HelloWorld usando EJB y servlets. Este artículo será útil para los lectores que se sientan cómodos con Java SE y estén comenzando a aprender Java EE. Para comprender completamente la parte práctica de este artículo, se recomienda leer primero el artículo " Configuración del entorno local ".

Una breve historia de EJB

En 1996, cuando el autor de este artículo tenía 5 años, Java ya era popular entre los desarrolladores. La razón de esto fue la API amigable, la recolección automática de basura, etc. Java fue ampliamente utilizado en los sistemas responsables del backend. Sin embargo, a pesar de todas las delicias del lenguaje, los programadores de esa época necesitaban cierta funcionalidad que aún no estaba implementada en el JDK. Estas necesidades fueron:

• asegurar la persistencia de los datos;
• integridad de la transacción
• acceso competitivo a los datos (control de subprocesos múltiples);
• y muy probablemente algo más.

Todo esto condujo a un crecimiento natural de la población de bibliotecas cerradas, escritas por ellos mismos y de cosecha propia. En otras palabras, cada uno cubrió sus necesidades lo mejor que pudo. Eso fue hasta que IBM lanzó el lema "Todos deberían satisfacer sus necesidades de la misma manera" y lanzó la especificación Enterprise Java Bean (EJB) en 1997. Fue esto lo que hizo posible unificar el proceso de desarrollo y llevar la solución a los problemas típicos (descritos anteriormente como necesidades) al marco. Sun ha estado adaptando la creación de IBM durante 2 años y en 1999 lanzó la especificación EJB 1.0. Así nació la tecnología, que se analizará más a fondo en un sentido más aplicado.

¿Qué es EJB?

EJB en cierto sentido es un término colectivo que, según el contexto, puede significar la tecnología Enterprise JavaBeans en sí en general o algún componente de software (bean) Enterprise JavaBean específico que forma parte de la tecnología EJB. La definición de EJB como tecnología se encuentra en Wikipedia: Enterprise JavaBeans (también utilizado a menudo como abreviatura EJB) es una especificación de una tecnología para escribir y soportar componentes de servidor que contienen lógica empresarial. Es parte de Java EE. Esta tecnología se utiliza normalmente cuando la lógica empresarial requiere al menos uno de los siguientes servicios y, a menudo, todos:

• soporte para la persistencia de datos: los datos deben estar seguros incluso después de detener el programa. La mayoría de las veces se logra utilizando una base de datos;
• soporte para transacciones distribuidas;
• soporte para modificación de datos paralelos y subprocesos múltiples;
• soporte de eventos;
• soporte de nombres y directorios (JNDI);
• seguridad y restricción de acceso a los datos;
• soporte para instalación automatizada en el servidor de aplicaciones;
• acceso remoto.

Los servicios enumerados anteriormente son una ventaja indudable de la tecnología EJB. Otra de estas ventajas es que todo lo enumerado anteriormente funciona de inmediato. Aquellos. el programador no necesita pensar en admitir transacciones distribuidas. El programador sólo necesita pensar en la lógica empresarial que está intentando implementar actualmente. Un EJB como componente de software específico es una clase Java con una o más anotaciones de la especificación EJB que contiene parte de la lógica empresarial de la aplicación. Las anotaciones de la especificación EJB otorgan a la clase etiquetada ciertos poderes, poderes y superpoderes. Lea más sobre esto a continuación.

tipos de EJB

Resumamos. Un EJB es una clase Java normal marcada con una de las anotaciones especiales. Estas clases se denominan beans. Dependiendo de con qué anotación esté marcada la clase, será representativa de uno u otro tipo de EJB (beans). Hay tres tipos principales de frijoles:

• Beans controlados por mensajes (beans controlados por mensajes);
• Entity Beans: definidos en la especificación JPA (Java Persistence API) y utilizados para almacenar datos;
• Frijoles de sesión.

Estos últimos (beans de sesión) se dividen en varios subtipos:

• apátrida (sin estado);
• con estado (con soporte para el estado de la sesión actual);
• singleton (un objeto para toda la aplicación; a partir de EJB 3.1).

A continuación veremos cada tipo de frijol con más detalle.

Frijoles de sesión

Los beans de sesión, o beans de sesión, son un tipo específico de bean. Encapsulan la lógica empresarial que el cliente puede invocar mediante programación llamando a los métodos del bean. Una llamada a un método puede hacer:

• localmente, por otra clase en la misma JVM que el bean de sesión;
• de forma remota, a través de la red, desde otra JVM, utilizando la tecnología Java RMI (Remote Method Invocation).

La palabra "sesión" implica que el bean está disponible sólo mientras el servidor realiza una tarea específica y se destruye irremediablemente en caso de falla o apagado del servidor. El ciclo de vida de una instancia de bean de sesión está controlado por un contenedor EJB (puede leer más sobre los contenedores EJB en la primera lección de la serie ). Los beans de sesión sin estado no almacenan información sobre su estado. Este tipo de componente puede ser utilizado por varios clientes. Los beans sin estado se utilizan para implementar procesos comerciales que se pueden completar en una sola operación. Por ejemplo, comprobar el historial crediticio de los clientes. Debido a que varios clientes pueden utilizar una única instancia de bean, el desarrollador debe proporcionar acceso seguro para subprocesos a los datos del bean. Crear un bean de este tipo (así como todos los demás beans de sesión) es bastante sencillo. Esta es una clase Java normal con una anotación @Stateless. Pongamos un ejemplo a continuación:

import javax.ejb.Stateless;

@Stateless
public class StatelessEjbExample {
    public String sayHi() {
        return "Hi, I'm Stateless EJB!";
    }
}

Los beans de sesión que admiten el estado de la sesión actual (Stateful) retienen información sobre su estado entre llamadas del mismo cliente y finalizan su existencia ante una solicitud explícita del cliente. Esto se logra debido al hecho de que los beans con estado son únicos para cada cliente. Un ejemplo de tarea de la que se puede encargar este tipo de bean es mantener actualizado el carrito de la compra de una tienda online de cada usuario. El ciclo de vida de estos beans lo gestiona el contenedor EJB. Estos beans también se destruyen cuando el cliente sale. Estos frijoles también son bastante fáciles de crear. Esta es una clase Java marcada con la anotación Stateful. Ejemplo a continuación:

import javax.ejb.Stateful;

@Stateful
public class StatefulEjbExample {
    public String sayHi() {
        return "Hi, I,m Stateful EJB";
    }
}

Los beans de sesión singleton se inician una vez durante la vida útil de la aplicación y existen durante toda la vida útil de la aplicación. Estos beans están diseñados para situaciones en las que se debe compartir un estado entre todos los clientes. Al igual que los beans sin estado, en los beans independientes el desarrollador debe asegurarse de que el entorno dentro del bean esté organizado de manera segura para subprocesos. Pongamos un ejemplo de un bean Singleton, que es tan fácil de crear como sus contrapartes, que se discutieron anteriormente. Es fácil adivinar que se trata de una clase Java con la anotación @Singleton. Sin embargo, en este caso hay que tener cuidado. Hay dos anotaciones, idénticas en sintaxis, pero diferentes en propósito y ubicadas en diferentes paquetes:

• javax.ejb.Singleton
• javax.inject.Singleton

Para crear un EJB, debe utilizar la anotación del archivo javax.ejb. Ejemplo a continuación:

import javax.ejb.Singleton;

@Singleton
public class SingletonEjbExample {
    public String sayHi() {
        return "Hi, I'm Singleton EJB!";
    }
}

Beans controlados por mensajes

Los beans controlados por mensajes, o MDB, o beans controlados por mensajes, implementan cierta lógica empresarial, como los beans de sesión. Pero a diferencia de sus parientes, MDB tiene una diferencia importante. Los clientes nunca llaman directamente a los métodos MDB. Estos beans suelen actuar como escuchas de mensajes JMS (Java Message Service) y sirven para organizar el intercambio de mensajes asincrónicos entre partes del sistema. Un ejemplo de dicho mensaje sería una solicitud de entrega de inventario desde un sistema minorista automatizado a un sistema de gestión de suministros. A continuación se muestra un ejemplo de un bean MDB. A diferencia de los beans de sesión, su creación es un poco más interesante:

import javax.annotation.Resource;
import javax.ejb.MessageDriven;
import javax.ejb.MessageDrivenContext;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

@MessageDriven(mappedName = "jms/TestQueue")
public class MessageDrivenEjbExample implements MessageListener {

    @Resource
    private MessageDrivenContext messageDrivenContext;

    public void onMessage(Message message) {
        try {
            if (message instanceof TextMessage) {
                TextMessage msg = (TextMessage) message;
                msg.getText();
            }
        } catch (JMSException e) {
            messageDrivenContext.setRollbackOnly();
        }
    }

}

La anotación MessageDrivenconvierte nuestra clase MDB en un bean. Dentro de la anotación, utilizando JNDI (lea sobre JNDI aquí ), se determina el nombre de la distribución JMS, de la cual nuestra clase se convierte en oyente. Además, nuestra clase implementa la interfaz MessageListenery su método onMessage. Este método se llamará cuando llegue algún mensaje de la cola/distribución con el nombre definido dentro de la anotación MessageDriven.

Beans de entidad

Parte de la tecnología EJB es la especificación JPA. JPA, o Java Persistence API, es una especificación que proporciona mapeo relacional de objetos (ORM) de objetos Java (Entity beans) y proporciona una API para almacenar, recuperar y administrar dichos objetos. JPA le permite representar datos de una base de datos como objetos Java, así como guardar objetos Java como registros en la base de datos. No todas las clases pueden actuar como tales objetos, excepto los Entity beans. Entity Bean es una clase Java que representa una tabla en una base de datos. La visualización (mapeo) se logra mediante el uso de anotaciones especiales. Con su ayuda, se compara una clase Java con una tabla de la base de datos, así como los campos de una clase Java con los campos de una tabla de la base de datos. A continuación se muestra un ejemplo de un bean de entidad, con comentarios en el código:

@Entity // Делает данный класс Entity бином
@Table(name = "employee") // "Связывает" данный класс с таблицей employee в БД
public class Employee implements Serializable {

    @Id // Говорит о том, что поле ниже является первичным ключом
    @GeneratedValue(strategy = GenerationType.AUTO) // Определяет тип генерации значений первичного ключа
    private int id;

    @Column(name="name") // "Связывает" поле ниже с полем name в таблице employee в БД
    private String name;

    @Column (name="age") // "Связывает" поле ниже с полем age в таблице employee в БД
    private int age;

    // getters and setters...
}

Vale la pena señalar que tiene sentido estudiar este tipo de frijol solo en el contexto del estudio de la especificación JPA.

Escribir una aplicación: EJB HelloWorld

En esta sección, escribiremos una pequeña aplicación Java EE HelloWorld, que implementaremos en el servidor GlassFish. Antes de leer este artículo, se recomienda encarecidamente que lea el artículo sobre cómo configurar su entorno local .

1. Cree un nuevo proyecto Maven en IntelliJ IDEA.

   Archivo -> Nuevo -> Proyecto...

2. Haga clic en Siguiente .

3. Complete los parámetros del proyecto Maven:

4. Haga clic en Finalizar

5. El proyecto ha sido creado y tiene la siguiente estructura:

El archivo pom.xml se ve así: En primer lugar, debemos agregar una dependencia de la API de Java EE y también especificar el empaquetado de nuestro proyecto en forma de un archivo de aplicación web (war). Para hacer esto, necesita cambiar el código pom.xml al siguiente formulario:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.javarush.lectures</groupId>
    <artifactId>ejb_demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>
    </dependencies>

</project>

A continuación, puede pasar al código Java. Nuestra aplicación será la más sencilla. Tendremos 1 servlet y 1 EJB. Este será un bean de sesión sin estado. Dentro del EJB definiremos solo 1 método que devolverá la cadena “Hello World”. Primero que nada, creemos un paquete com.javarush.lectures. Luego, dentro del paquete com.javarush.lectures, crearemos nuestro bean: DemoEJB. El código del bean se proporciona a continuación:

import javax.ejb.Stateless;

@Stateless
public class DemoEJB {
    public String helloWorld() {
        return "Hello world!";
    }
}

Como dije antes, todo es bastante sencillo. Nuestro siguiente paso es crear un servlet que pasará el valor del EJB como respuesta a la solicitud HTTP. Vale la pena señalar que los servlets no son el tema de este artículo, pero aun así necesitarás usarlos para demostrar EJB. Para hacer esto, creemos un nuevo servlet DemoServleten el mismo paquete que el EJB. Su código está a continuación:

@WebServlet("/helloWorld")
public class DemoServlet extends HttpServlet {

    @EJB
    private DemoEJB ejb;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write(ejb.helloWorld());
    }
}

Aquí hay algunos comentarios breves sobre el código. Resumen @WebServlet("/helloWorld"): define nuestra clase como un servlet que procesará solicitudes HTTP al punto final /helloWorld. Nuestra clase tiene un campo: DemoEJB ejb. Este es nuestro frijol definido anteriormente. Una anotación sobre un campo de clase: @EJBrealiza una inyección de dependencia (DI). Aquellos. La variable ejb se inicializa automáticamente con una nueva instancia cuando es necesario. Nuestra clase es descendiente de HttpServlet y anula uno de los métodos de la superclase: doGet. Este método procesa solicitudes HTTP GET y toma dos parámetros: HttpServletRequesty HttpServletResponse. HttpServletRequestSirve para obtener información sobre una solicitud HTTP entrante. HttpServletResponsenecesario para generar una respuesta a una solicitud. Dentro del método, obtenemos el objeto PrintWriterdel objeto de respuesta ( HttpServletResponse), usando el método getWriter(). A continuación, podemos escribir algún valor en el objeto resultante usando el archivo write. Que, de hecho, es lo que usamos al escribir en el PrintWriterobjeto -a el valor obtenido del EJB que definimos (el valor es la cadena “¡Hola mundo!”). El cliente que envió la solicitud HTTP recibirá este valor como respuesta a su solicitud. El siguiente paso es iniciar la aplicación en el servidor GlassFish Java EE. Para hacer esto, crearemos una nueva configuración, como se describe en el artículo sobre cómo configurar el entorno local . A continuación se muestra una captura de pantalla de la configuración finalizada para el proyecto actual. Asegúrese de tener instalado el servidor GlassFish antes de comenzar: después de crear la configuración de inicio, inicie la aplicación usando el menú Ejecutar -> Ejecutar 'ejb_demo' o usando la tecla de acceso rápido Shift+F10 . Después del lanzamiento, puede ver sus registros: Y también el navegador que se abre: Todo esto indica que la aplicación funciona según lo previsto.

Conclusión

En este artículo nos familiarizamos con EJB - Enterprise JavaBeans. Consideramos preguntas como:

• ¿Qué es EJB?
• Historia de EJB
• Diferentes tipos de EJB

Recuerde que los EJB vienen en los siguientes tipos:

• Beans controlados por mensajes (beans controlados por mensajes);
• Beans de entidad: definidos en la especificación de entidades JPA (Java Persistence API) y utilizados para almacenar datos;
• Frijoles de sesión:
  • apátrida (sin estado)
  • con estado (con soporte para el estado de la sesión actual)
  • singleton (un objeto para toda la aplicación; a partir de EJB 3.1)

También escribimos una pequeña aplicación HelloWorld usando EJB. Como PD, puedes repetir tú mismo la parte práctica de este artículo. Y luego agregue dos servlets más a su aplicación que utilizarán beans con estado y singleton para recibir el valor.