Yakarta EE. UU.

Jakarta EE, anteriormente Java Platform, Enterprise Edition (Java EE) y Java 2 Platform, Enterprise Edition (J2EE), es un conjunto de especificaciones que amplían Java SE con especificaciones para funciones empresariales como la informática distribuida y los servicios web. Las aplicaciones de Jakarta EE se ejecutan en tiempos de ejecución de referencia, que pueden ser microservicios o servidores de aplicaciones, que manejan transacciones, seguridad, escalabilidad, concurrencia y administración de los componentes que está implementando.

Jakarta EE se define por su especificación. La especificación define las API (interfaz de programación de aplicaciones) y sus interacciones. Al igual que con otras especificaciones de Java Community Process, los proveedores deben cumplir con ciertos requisitos de conformidad para declarar sus productos como compatibles con Jakarta EE.

Ejemplos de contextos en los que se utilizan tiempos de ejecución de referencia de Jakarta EE: comercio electrónico, contabilidad, sistemas de información bancaria.

Historia

La plataforma se conocía como Java 2 Platform, Enterprise Edition o J2EE a partir de la versión 1.2, hasta que se cambió el nombre a Java Platform, Enterprise Edition o Java EE en la versión 1.5.

Java EE fue mantenido por Oracle bajo el Proceso de la Comunidad Java. El 12 de septiembre de 2017, Oracle Corporation anunció que enviaría Java EE a la Fundación Eclipse. El proyecto de nivel superior de Eclipse se ha denominado Eclipse Enterprise for Java (EE4J). La Fundación Eclipse no pudo ponerse de acuerdo con Oracle sobre el uso de las marcas registradas javax y Java. Oracle es propietario de la marca comercial del nombre "Java" y se cambió el nombre de la plataforma de Java EE a Jakarta EE. El nombre hace referencia a la ciudad más grande de la isla de Java y también a la capital de Indonesia, Yakarta. El nombre no debe confundirse con el antiguo Proyecto Jakarta, que fomentó una serie de proyectos Java actuales y anteriores en la Apache Software Foundation.

Especificaciones

Jakarta EE incluye varias especificaciones que sirven para diferentes propósitos, como generar páginas web, leer y escribir desde una base de datos de forma transaccional, administrar colas distribuidas.

Las API de Jakarta EE incluyen varias tecnologías que amplían la funcionalidad de las API básicas de Java SE, como Jakarta Enterprise Beans, conectores, servlets, Jakarta Server Pages y varias tecnologías de servicios web.

Especificaciones web

• Yakarta Servlet: define cómo gestionar las solicitudes HTTP, de manera sincronizada o asincrónica. Es de bajo nivel y otras especificaciones de Yakarta EE dependen de él;
• Jakarta WebSocket: Especificación de API que define un conjunto de API a las conexiones WebSocket de servicio;
• Yakarta Server Faces: una tecnología para construir interfaces de usuario fuera de los componentes;
• Idioma de Expresión de YakartaEL) es un lenguaje simple diseñado originalmente para satisfacer las necesidades específicas de los desarrolladores de aplicaciones web. Se utiliza específicamente en Yakarta Faces para atar componentes a frijoles (retrocedentes) y en Contextos e Inyección de dependencia a frijoles llamados, pero se puede utilizar en toda la plataforma.

Especificaciones del servicio web

• Yakarta RESTful Web Services proporciona soporte para la creación de servicios web de acuerdo con el patrón arquitectónico Representational State Transfer (REST);
• Jakarta JSON El procesamiento es un conjunto de especificaciones para gestionar la información codificada en formato JSON;
• Jakarta JSON Binding proporciona especificaciones para convertir la información JSON en o desde clases de Java;
• Jakarta XML La fijación permite mapear XML en objetos Java;
• Jakarta XML Servicios Web se pueden utilizar para crear servicios web SOAP.

Especificaciones empresariales

• Activación de YakartaJAF) especifica una arquitectura para ampliar componente Beans by providing data typing and bindings of such types.
• Contextos de Yakarta e inyección de dependencia (CDI) es una especificación para proporcionar un contenedor de inyección de dependencia;
• Jakarta Enterprise BeansEJB) especificación define un conjunto de API de peso ligero que un contenedor de objetos (el contenedor EJB) apoyará para proporcionar transacciones (utilizando JTA), llamadas de procedimiento remoto (utilizando RMI o RMI-IIOP), control de concurrencia, inyección de dependencia y control de acceso para objetos de negocios. Este paquete contiene las clases e interfaces de Yakarta Enterprise Beans que definen los contratos entre el frijol empresarial y sus clientes y entre el frijol empresarial y el contenedor ejb.
• Persistencia de YakartaJPA) son especificaciones sobre mapeo de objetos-relacional entre tablas de bases de datos de relación y clases de Java.
• Transacciones de Yakarta ()JTA) contiene las interfaces y anotaciones para interactuar con el soporte de transacción ofrecido por Yakarta EE. A pesar de que este API abstrae de los detalles realmente de bajo nivel, las interfaces también se consideran algo de bajo nivel y el desarrollador promedio de aplicaciones en Yakarta EE se supone que depende de la manipulación transparente de las transacciones por las abstracciones EJB de mayor nivel, o utilizando las anotaciones proporcionadas por esta API en combinación con los frijoles administrados por CDI.
• Mensajería de Yakarta (JMS) proporciona una manera común para los programas Java para crear, enviar, recibir y leer los mensajes del sistema de mensajería empresarial.

Otras especificaciones

• Validación: Este paquete contiene las anotaciones e interfaces para el soporte de validación declarativa ofrecido por la API de validación Bean. La validación de los frijoles proporciona una forma unificada de proporcionar restricciones a los frijoles (por ejemplo, las clases modelo de JPA) que pueden ser aplicados cruzados. En Yakarta EE, JPA honra las limitaciones de validación de frijoles en la capa de persistencia, mientras que JSF lo hace en la capa de visión.
• Yakarta Batch proporciona los medios para el procesamiento por lotes en aplicaciones para ejecutar tareas de fondo de larga duración que posiblemente implican un gran volumen de datos y que pueden necesitar ser ejecutados periódicamente.
• Yakarta Connectors es una herramienta basada en Java para conectar servidores de aplicaciones y sistemas de información empresarial (EIS) como parte de la integración de aplicaciones empresariales (EAI). Esta es una API de bajo nivel dirigida a los proveedores que el desarrollador de aplicaciones promedio normalmente no entra en contacto con.

Perfil web

En un intento por limitar la huella de los contenedores web, tanto en términos físicos como conceptuales, se creó el perfil web, un subconjunto de las especificaciones Jakarta EE. El perfil web de Jakarta EE comprende lo siguiente:

Tiempos de ejecución de referencia certificados

Aunque, por definición, todas las implementaciones de Jakarta EE proporcionan el mismo nivel básico de tecnologías (es decir, la especificación de Jakarta EE y las API asociadas), pueden diferir considerablemente con respecto a las funciones adicionales (como conectores, agrupación, tolerancia a fallas, alta disponibilidad, seguridad, etc.), tamaño instalado, consumo de memoria, tiempo de inicio, etc.

EE.UU. de Yakarta

Java EE

Ejemplo de código

El ejemplo de código que se muestra a continuación demuestra cómo se utilizan varias tecnologías en Java EE 7 juntas para crear un formulario web para editar un usuario.

En Jakarta EE, se puede crear una interfaz de usuario (web) utilizando Jakarta Servlet, Jakarta Server Pages (JSP) o Jakarta Server Faces (JSF) con Facelets. El siguiente ejemplo usa Faces y Facelets. No se muestra explícitamente que los componentes de entrada utilizan la API de validación de EE Bean de Jakarta encubierta para validar las restricciones.

html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://xmlns.jcp.org/jsf/html" xmlns:f="http://xmlns.jcp.org/jsf/core"■ ▪f:metadata ■f:viewParam nombre="user_id" valor="#{userEdit.user" convertidor="Convertor" / ■/f:metadata confianza - No. ■h:mensajes / - No. ■h:panelGrid columnas="2"■ ■h:outputLabel para="primer nombre" valor="Primero nombre" / ■h:inputText id="primer nombre" valor="#{userEdit.user.firstName" etiqueta="Primero nombre" / ■h:outputLabel para="La última Navidad" valor="El apellido" / ■h:inputText id="La última Navidad" valor="#{userEdit.user.lastName" etiqueta="El apellido" / ##### ########################################################################################################################################################################################################################################################### acción="#{userEdit.saveUser" valor="Save" / ▪/h:panelGrid - No. ■/h:bodyIdentificado/html

Ejemplo de clase Backing Bean

Para ayudar a la vista, Jakarta EE utiliza un concepto llamado "Backing Bean". El siguiente ejemplo utiliza contextos e inyección de dependencia (CDI) y Jakarta Enterprise Beans (EJB).

@Named@ViewScopedpúblico clase UserEdit {} privado Usuario usuario; @Inject privado UserDAO userDAO; público String saveUser() {} userDAO.Guardar()esto.usuario); añadir FlashMessage()"User" + esto.usuario.# Id() + "Salvado"); retorno "users.xhtml?faces-redirect=true"; } público vacío set Usuario()Usuario usuario) {} esto.usuario = usuario; } público Usuario # Usuario() {} retorno usuario; }}

Ejemplo de clase de objeto de acceso a datos

Para implementar la lógica empresarial, Jakarta Enterprise Beans (EJB) es la tecnología dedicada en Jakarta EE. Para la persistencia real, se puede usar JDBC o Jakarta Persistence (JPA). El siguiente ejemplo utiliza EJB y JPA. No se muestra explícitamente que EJB utiliza JTA encubiertamente para controlar el comportamiento transaccional.

@Statelesspúblico clase UserDAO {} @PersistenceContext privado EntityManager entidad Manager; público vacío Guardar()Usuario usuario) {} entidad Manager.persistencia()usuario); } público vacío actualización()Usuario usuario) {} entidad Manager.merge()usuario); } público Lista.Usuario■ # Todos() {} retorno entidad Manager.createNamedQuery()"User.getAll", Usuario.clase) .ResultadosLista(); }}

Clase de entidad de ejemplo

Para definir clases de entidad/modelo, Jakarta EE proporciona la persistencia de Jakarta (JPA), y para expresar restricciones en esas entidades, proporciona la API de validación de beans. El siguiente ejemplo utiliza ambas tecnologías.

@Entitypúblico clase Usuario {} @Id @GeneratedValue()estrategia = IDENTIDAD) privado Integer id; @Size()min = 2, Mensaje="El primer nombre es demasiado corto") privado String primero Nombre; @Size()min = 2, Mensaje="El apellido es demasiado corto") privado String LastName; público Integer # Id() {} retorno id; } público vacío set Id()Integer id) {} esto.id = id; } público String # FirstName() {} retorno primero Nombre; } público vacío setFirstName()String primero Nombre) {} esto.primero Nombre = primero Nombre; } público String getLastName() {} retorno LastName; } público vacío setLastName()String LastName) {} esto.LastName = LastName; }}