Enterprise JavaBeans
La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la
versión revisada el 24 de agosto de 2016; las comprobaciones requieren
9 ediciones .
Enterprise JavaBeans (también utilizado a menudo como abreviatura EJB) es una especificación de tecnología para escribir y admitir componentes del lado del servidor que contienen lógica empresarial . Es parte de Java EE .
Esta técnica generalmente se aplica cuando la lógica empresarial requiere al menos uno de los siguientes servicios y, a menudo, todos ellos:
- soporte para la integridad de datos (persistencia); los datos deben conservarse incluso después de detener el programa, lo que se logra con mayor frecuencia mediante el uso de 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 )
- restricción de seguridad y acceso a datos
- soporte para instalación automatizada en el servidor de aplicaciones
- acceso remoto
Cada componente EJB es un conjunto de clases Java con reglas de nomenclatura de métodos estrictamente definidas (es cierto para EJB 2.0, en EJB 3.0 debido al uso de anotaciones , la elección de nombres es libre). Hay tres tipos principales:
- objeto (Entity Bean) - movido a la especificación de la API de persistencia de Java
- session (Session Beans), que son
- apátrida (sin estado)
- stateful (apoyando el estado actual de la sesión)
- singleton (un objeto por aplicación; desde la versión 3.1)
- controlados por mensajes (Message Driven Beans): su lógica es una reacción a los eventos en el sistema
Ejemplo de bean de entidad
paquete org.prueba.entidad ;
importar java.io.Serializable ;
importar java.util.Date ;
importar javax.persistencia.* ;
importar javax.validation.constraints.Size ;
importar org.test.entity.listener.GalleryListener ;
@Entity
@EntityListeners ({ GalleryListener . class })
@Table ( name = "gallery" ,
uniqueConstraints = {
@UniqueConstraint ( columnNames = { "id" })
}
)
@NamedQueries ({
@NamedQuery ( name = Gallery . QUERY_FIND_ALL , consulta = "SELECCIONAR g DE Galería g ORDENAR POR g.nombre ASC" ,
@NamedQuery ( nombre = Galería . QUERY_FIND_BY_NAME , consulta = "SELECCIONAR g DE Galería g DONDE g.nombre = :nombre" )
})
public class Gallery implements Serializable {
privado estático final largo serialVersionUID = 1L ;
Cadena final estática pública QUERY_FIND_ALL = "Gallery.findAll" ; Cadena final estática pública QUERY_FIND_BY_NAME = "Gallery.findByName" ;
@Id
@GeneratedValue ( estrategia = GenerationType . IDENTIDAD )
@Column ( name = "id" , anulable = false )
private Long id ;
@Tamaño ( máx . = 100 )
@Columna ( nombre = "nombre" , longitud = 100 )
cadena privada nombre ;
@Column ( name = "created_at" )
@Temporal ( TemporalType . TIMESTAMP )
private Date createdAt ;
galería pública () {
}
galería pública ( nombre de la cadena ) { este . nombre = nombre ; }
fecha pública getCreatedAt () {
return createdAt ;
}
public void setCreatedAt ( Fecha de creación en ) {
this . creado en = creado en ;
}
getId largo público () { id de retorno ; }
public void setId ( Id largo ) { este . identificación = identificación ; }
public String getName () {
volver nombre ;
}
public void setName ( String nombre ) {
this . nombre = nombre ;
}
@Override
public boolean equals ( Object obj ) {
if ( obj == null ) {
return false ;
}
if ( getClass () != obj . getClass ()) {
return false ;
}
final Galería otro = ( Galería ) obj ;
if ( this . id != other . id && ( this . id == null || ! this . id . equals ( other . id ))) {
return false ;
}
devuelve verdadero ;
}
@Override
public int hashCode () {
int hash = 7 ;
hash = 47 * hash + ( this . id != null ? this . id . hashCode () : 0 );
hash de retorno ; }
}
Ejemplo de oyente de bean de entidad
paquete org.test.entity.listener ;
importar java.util.Date ;
importar javax.persistencia.PrePersist ;
importar org.test.entity.Gallery ;
clase pública GalleryListener {
@PrePersist
public void prePersist ( Galería galería ) {
galería . setCreatedAt ( nueva fecha ());
}
}
Ejemplo de bean de sesión: EAO sin estado (objeto de acceso a la entidad)
paquete org.test.eao ;
importar java.util.List ;
importar javax.ejb.LocalBean ;
importar javax.ejb.Sin estado ;
importar javax.ejb.TransactionAttribute ;
importar javax.ejb.TransactionAttributeType ;
importar javax.persistencia.EntityManager ;
importar javax.persistencia.PersistenciaContext ;
importar org.test.entity.Gallery ;
@Stateless
@LocalBean
clase pública GalleryEAO extiende AbstractEAO < Galería > {
@PersistenceContext ( nombreUnidad = "UnidadPersistencia" )
privado EntityManager entidadManager ;
public GalleryEAO () {
super ( Galería . clase );
}
@Override
protected EntityManager getEntityManager ( ) {
returnentityManager ; }
@TransactionAttribute ( TransactionAttributeType . SOPORTES )
public List < Gallery > findAll () {
return namedQuery ( Gallery . QUERY_FIND_ALL ). obtenerListaResultados ();
}
@TransactionAttribute ( TransactionAttributeType . SOPORTES )
Galería pública findByName ( String name ) { return namedQuery ( Galería . QUERY_FIND_BY_NAME ) . setParameter ( "nombre" , nombre ) . obtenerResultadoÚnico (); } }
Ejemplo abstracto de EAO (objeto de acceso a la entidad)
paquete org.test.eao ;
importar java.io.Serializable ;
importar javax.persistencia.EntityManager ;
importar javax.persistencia.Consulta ;
importar javax.persistencia.TypedQuery ;
importar javax.persistencia.criterios.CriteriaQuery ;
importar javax.persistencia.criterios.Raíz ;
public abstract class AbstractEAO < T extiende Serializable > {
EntityManager abstracto protegido getEntityManager ();
clase privada < T > clase de entidad ;
public Class < T > getEntityClass ( ) {
returnentityClass ; }
public AbstractEAO ( Clase < T > entidad Clase ) {
this . entidadClase = entidadClase ;
}
public void persistir ( T entidad ) {
getEntityManager (). persistir ( entidad );
}
combinación de vacío público ( entidad T ) { getEntityManager (). fusionar ( entidad ); }
public void remove ( T entidad ) {
if ( entidad != nulo ) {
getEntityManager (). eliminar ( entidad );
}
}
eliminación de vacío público ( Id . de objeto ) { T entidad = ( T ) getEntityManager (). encontrar ( entityClass , id ); eliminar ( entidad ); }
public T find ( Object id ) {
return getEntityManager (). encontrar ( entityClass , id );
}
actualización de vacío público ( entidad T ) { getEntityManager (). actualizar ( entidad ); }
public TypedQuery < T > namedQuery ( String queryName ) {
return getEntityManager (). createNamedQuery ( queryName , entidadClass );
}
consulta pública TypedQuery < T > consulta ( String queryString ) {
devuelve getEntityManager (). createQuery ( cadena de consulta , clase de entidad );
}
public long count () {
CriteriaQuery criteriaQuery = getEntityManager (). getCriteriaBuilder (). crear consulta ();
Raíz < T > raíz = consultacriterios . de ( claseentidad );
consulta de criterios . seleccione ( getEntityManager (). getCriteriaBuilder (). cuenta ( raíz ));
Consulta consulta = getEntityManager (). createQuery ( criteriosConsulta );
retorno ( consulta ( larga ) . getSingleResult ()). valorlargo (); } }
Ejemplo de bean de sesión (sin estado) - Fachada de la galería
paquete org.prueba.fachada ;
importar java.util.List ;
importar javax.ejb.* ;
importar org.test.eao.GalleryEAO ;
importar org.test.entity.Gallery ;
importar org.test.exception.GalleryAlreadyExistsException ;
importar org.test.exception.GalleryNotFoundException ;
@Stateless
@LocalBean
clase pública GalleryFacade {
@Inject
privado GalleryEAO galeríaEAO ;
@TransactionAttribute ( TransactionAttributeType . SOPORTES )
Galería pública findById ( ID largo ) lanza GalleryNotFoundException { Galería galería = galeríaEAO . encontrar ( id ); if ( galería == nulo ) arroja una nueva excepción GalleryNotFoundException ( "Galería no encontrada" ); volver galeria ; }
@TransactionAttribute ( TransactionAttributeType . SOPORTES )
lista pública < Galería > findAll () { return galeríaEAO . encontrarTodo (); }
@TransactionAttribute ( TransactionAttributeType . REQUIRED )
public void create ( String name ) throws GalleryAlreadyExistsException {
if ( galleryEAO . findByName ( nombre ) != null ) throw new GalleryAlreadyExistsException ( "La galería ya existe" , nombre );
Galería galería = nueva Galería ( nombre );
galeríaEAO . persistir ( galería );
}
@TransactionAttribute ( TransactionAttributeType . REQUIRED )
public void remove ( Long id ) throws GalleryNotFoundException {
Galería galería = findById ( id );
galeríaEAO . eliminar ( galería );
}
}
Ejemplo de excepción de aplicación - GalleryNotFoundException
paquete org.prueba.excepción ;
importar javax.ejb.ApplicationException ;
@ApplicationException ( rollback = true )
clase pública GalleryNotFoundException extiende la excepción {
GalleryNotFoundException pública () {
}
GalleryNotFoundException pública ( mensaje de cadena ) { super ( mensaje ); } }
Ejemplo de excepción de aplicación - GalleryAlreadyExistsException
paquete org.prueba.excepción ;
importar javax.ejb.ApplicationException ;
@ApplicationException ( rollback = true )
clase pública GalleryAlreadyExistsException extiende Excepción {
nombre de cadena privado ; _
GalleryAlreadyExistsException pública () {
}
GalleryAlreadyExistsException pública ( mensaje de cadena , nombre de cadena ) { super ( mensaje ); esto _ nombre = nombre ; }
public String getName () {
volver nombre ;
}
}
Literatura
- Panda D. EJB 3 en acción. - Prensa DMK , 2014. - 618 p. — ISBN 978-5-97060-135-8 .
Enlaces