arquitectura de aplicaciones empresariales en...
TRANSCRIPT
Arquitectura de Aplicaciones Empresariales en Java
Relator: Juan Claudio Navarro [email protected], [email protected],
Agenda
n Bloque 1 (18:30 – 20:00) n Java EE n La capa de presentación n La capa de negocio
n Bloque 2 (20:30 – 21:30) n La capa de datos n Discusión
2
JAVA EE
3
Aplicaciones Empresariales
n Las aplicaciones empresariales suelen presentar algunos de los siguientes requerimientos n Interacción con diversas fuentes de datos n Interacción con otros sistemas (actuales
y/o legados) n Acceso Web n Concurrencia n Alta carga de procesamiento n Usuarios con diferentes perfiles n Requerimientos de seguridad
4
Java Platform, Enterprise Edition
n Java EE es la plataforma de Java para el desarrollo de aplicaciones en el servidor (anteriormente llamada J2EE: Java 2, Enterprise Edition)
n Provee un ambiente de ejecución y un conjunto de APIs: Servlets, JSP, JSF, EJB, JMS, JDBC, JPA, JNDI, JavaMail, JAXB, JAXP, JAX-WS, etc.
5
Beneficios de Java EE
n Transparencia de la ubicación n Visión OO de la base de datos n Manejo transaccional n Pools de recursos n Seguridad n Alta disponibilidad n Portabilidad
6
Contenedores Java EE
n La especificación Java EE define dos contenedores: n Web Container n EJB Container
n Estos contenedores son los responsables de manejar los componentes correspondientes
7
Servidores Java EE
8
Servidor Proveedor Tipo Notas
Weblogic Server Oracle (antes BEA) comercial
WebSphere Application Server
IBM comercial
Tomcat Apache libre Sólo Web Container
JBoss Application Server
Red Hat (antes JBoss) libre EJB Container, se integra con Tomcat
GlassFish Oracle (antes Sun) libre
JOnAS OW2 Consortium libre EJB Container, se integra con Tomcat
n Lista de servidores en http://en.wikipedia.org/wiki/Comparison_of_application_servers
n Análisis de Gartner sobre servidores de aplicaciones: http://www.gartner.com/technology/reprints.do?id=1-17GUO5Z&ct=110928&st=sb
LA CAPA DE PRESENTACION
Servlets JSP – JavaServer Pages JSF – JavaServer Faces Otras tecnologías: ZK
9
La Capa Web
n La operación de la capa Web es soportada por el contenedor Web n Maneja la interacción con el cliente (protocolo HTTP(S)) n Reenvía cada requerimiento HTTP al componente Web que
corresponda, entregándole los parámetros necesarios para que éste pueda realizar su tarea
n Maneja sesiones, filtros, eventos, seguridad, etc.
10
11
Servlets
n El contenedor Web maneja la interacción con los clientes Web (browser’s), y delega los requerimientos dinámicos a componentes Web (servlets y páginas JSP)
n Un servlet es una clase Java que es instanciada e invocada por el contenedor Web, en respuesta a requerimientos HTTP
12
Servlets
n Tareas que puede realizar un servlet n Leer data enviada por el usuario (por ejemplo a través
de un Form de una página Web) n Obtener otra información del requerimiento (browser
utilizado, cookies, dirección IP cliente, etc.) n Generar el resultado n Formatear el resultado en un documento (típicamente
una página HTML) n Establecer parámetros de respuesta (tipo de
documento retornado, cookies, etc.) n Enviar la respuesta al cliente (formato text/html,
image/gif, etc.)
13
public class ServletHolaMundo extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println("<html>"); out.println("<head>"); out.println("<title>Hola, mundo!</title>"); out.println("</head>"); out.println("<body>"); out.println("<h1>Hola, mundo!</h1>"); out.println("</body>"); out.println("</html>"); out.close(); } }
ServletHolaMundo.java <servlet> <servlet-name>ServletHolaMundo </servlet-name> <servlet-class>cl.servlets.ServletHolaMundo </servlet-class> </servlet> <servlet-mapping> <servlet-name>ServletHolaMundo </servlet-name> <url-pattern>/holamundo </url-pattern> </servlet-mapping>
WEB-INF/web.xml
Servlets - un Ejemplo Sencillo
14
Limitaciones de Servlets
n Con Servlets, es fácil: n Leer parámetros y form data n Manejar cookies y sesiones n Manejar HTTP: request/response headers, códigos
de estado n Compartir datos entre servlets
n Pero no resulta cómodo: n Usar sentencias println para generar HTML n Mantener el código HTML
15
JSP – JavaServer Pages
n La tecnología JSP facilita la construcción de aplicaciones Web dinámicas n Una página JSP (JavaServer Pages) es un documento de texto que
incluye dos tipos de texto: n Texto estático (template data), que puede ser expresado en cualquier
formato basado en texto (HTML, XML, WML, etc.) n Elementos JSP, que construyen contenido dinámico
Página JSP
Página HTML generada en request time y enviada al cliente
Página HTML desplegada
en el browser
Páginas JSP
n El contenedor Web genera un servlet a partir de una página JSP
n Elementos JSP al interior de una página n Elementos de scripting
n Scriptlets: <% código Java %> n Expresiones Java: <%= expresión Java %> n Declaraciones: <%! declaraciones Java %>
n Expression Language: ${ expresión } n Otros: directivas, custom tags, etc.
n Objetos predefinidos en una página JSP: request, response, out, session, application, exception
16
17
JSF – JavaServer Faces
n JSF es el framework para la capa de presentación provisto por Java EE
n JSF provee una arquitectura para manejar el estado de componentes, procesamiento de información, validación de información ingresada por el usuario, atención de eventos, y navegación entre páginas
n JSF separa la lógica de presentación y de aplicación, facilitando la conexión entre las correspondientes capas
JSF – Eventos y Navegación
... <h:inputText value="#{algoritmoBean.iteraciones}"/> <h:commandButton value="Calcular" action="#{algoritmoBean.calcular}"/>
18
public class Algoritmo { private int iteraciones = 10; public int getIteraciones() { return iteraciones; } public int setIteraciones(int n) { iteraciones = n; } public String calcular() { for (int i=0; i<iteraciones; i++) {…}; return "ok"; } } <managed-bean> <managed-bean-name>algoritmoBean</managed-bean-name> <managed-bean-class>modelo.algoritmos.Algoritmo</managed-bean-class> <managed-bean-scope>request</managed-bean-scope> </managed-bean> <navigation-rule> <from-view-id>algoritmo.jspx</from-view-id> <navigation-case> <from-outcome>ok</from-outcome> <to-view-id>home.jspx</to-view-id> </navigation-case> </navigation-rule>
Página JSP
Managed bean
Flujo de navegación (faces-config.xml)
evento
outcome
ZK – http://www.zkoss.org
n ZK Framework permite construir Rich Internet Applications (RIA) haciendo uso de Ajax de manera transparente para el programador
19
ZK Spreadsheet Demo
20
LA CAPA DE NEGOCIO
EJB – Enterprise JavaBeans Session Beans Message-Driven Beans Otras tecnologías: Spring
21
22
EJB - Enterprise JavaBeans
n Un Enterprise JavaBean es un componente que opera en el servidor, y que encapsula lógica de negocio de una aplicación
n La tecnología de EJB’s provee servicios de nivel de sistema (distribución, transacciones, pools de objetos, …), permitiendo que el programador se concentre en la lógica de negocio
n La especificación de EJB 3 (mayo 2006) incorporó el uso de anotaciones e inyección de dependencias, simplificando el desarrollo
Tipos de EJB
Session Bean Message-Driven Bean
Invocación Sincrónica Asincrónica: el cliente envía un mensaje JMS a una cola, y el servidor invoca al MDB de manera asíncrona para procesar el mensaje
Interfaz Local y/o remota No requiere, el cliente no invoca al MDB
23
n Existen 2 tipos de EJB n Session Beans n Message-Driven Beans (MDB)
24
Session Beans
n Un session bean representa una sesión de trabajo de un cliente al interior del servidor de aplicaciones
n El cliente invoca sincrónicamente los métodos del bean n No hay concurrencia en session beans: si varios clientes
ejecutan simultáneamente operaciones de un mismo session bean, cada uno de ellos opera con una instancia diferente del bean
n Dos tipos de session beans: n Stateless (SLSB):
n No mantiene estado conversacional para el cliente n El servidor crea un pool de instancias para cada SLSB n Cuando un cliente invoca un método de un SLSB, el servidor escoge
una instancia del pool para atender el requerimiento, y luego la instancia vuelve al pool
n Stateful (SFSB): n Mantiene estado conversacional en variables de instancia n Una instancia de un stateful session bean pertenece a un cliente, y
permanece asociado a él hasta que se da por terminada la sesión
25
Elementos de un Session Bean
n Un session bean se define mediante: n La interfaz de negocio (business interface) n La clase de implementación, que implementa la interfaz de
negocio
n La interfaz de negocio puede ser: n Local: utilizada por clientes locales (que se ejecutan en la
misma instancia del servidor de aplicaciones), con semántica Java
n Remote: utilizada por clientes Java remotos que interactúan con el bean mediante RMI
26
Objetos Remotos
n EJB utiliza RMI (Remote Method Invocation) para la invocación de objetos remotos
n El cliente invoca un stub (proxy del objeto remoto, en el cliente)
n El stub invoca al skeleton a través de la red (proxy del objeto remoto, en el servidor)
n El skeleton invoca al objeto remoto
n El stub y el objeto remoto implementan la misma interfaz, por lo que el cliente opera como si interactuara directamente con el objeto remoto
Un Session Bean
27
package cl.sii.facturaelectronica; @Local public interface ServicioFacturas { boolean valida(Factura factura); }
ServicioFacturas.java
package cl.sii.facturaelectronica; @Stateless public class ServicioFacturasBean implements ServicioFacturas { @Override public boolean valida(Factura factura) { ... } }
ServicioFacturasBean.java
n Interfaz de negocio n La anotación @Local indica que el bean
soporta acceso local n La anotación @Remote indica que el bean
soporta acceso remoto
n Clase de implementación n Las anotaciones @Stateless y @Stateful
indican que se trata de un session bean
28
Un Cliente Local
n En un componente de una aplicación Java EE (un servlet, un EJB, etc.), la anotación @EJB inyecta la interfaz de negocio
... import javax.ejb.EJB; ... public class FacturaServlet extends HttpServlet { @EJB private ServicioFacturas ejb; ... private void procesar(Factura factura) { if (ejb.valida(factura)) { ... } } }
FacturaServlet.java
29
Un Cliente Remoto (WebLogic)
n Los clientes remotos utilizan JNDI para acceder a session beans
... public class ClienteServicioFacturas { public void valida(Factura factura) throws NamingException { // Obtenemos el contexto inicial Properties properties = new Properties(); properties.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialContextFactory"); properties.put(Context.PROVIDER_URL, "t3://facturas.sii.cl:7001"); Context context = new InitialContext(properties); // Obtenemos una referencia a un EJB y lo utilizamos ServicioFacturasRemote ejb = (ServicioFacturasRemote)
context.lookup("FacturaApp/ServicioFacturas/remote"); if (ejb.valida(factura)) { ... } } }
ClienteServicioFacturas.java
Interfaces Locales v/s Remotas
n Las invocaciones remotas (diferentes procesos) son mucho más caras que las locales
n Lo anterior se acentúa si los procesos se encuentran en máquinas diferentes
n Por lo tanto, las interfaces remotas deben diseñarse de modo de minimizar las invocaciones
n Recomendaciones de Martin Fowler (Patterns of Enterprise Application Architecture) n Primera ley de Diseño de Objetos Distribuidos: no distribuya
sus objetos J n En general, para hacer uso de varios nodos utilice clustering:
replique los procesos completos n Es frecuente realizar una separación física entre la capa Web
y la capa de negocio, en este caso preocúpese de minimizar la interacción entre las capas
30
31
Message-Driven Beans (MDB)
n Un message-driven bean permite atender requerimientos asincrónicos en la plataforma Java EE
n A diferencia de session beans, los MDB no poseen interfaces de negocio, debido a que los clientes no manejan referencias al bean
n En lugar de ello, los clientes envían mensajes a sistemas de mensajería (Websphere MQ, etc.), y éstos son atendidos por objetos MDB
n No hay concurrencia en objetos MDB: si se procesan simultáneamente mensajes de un mismo destino, cada uno de ellos es procesado por una instancia diferente del bean
32
Un Cliente JMS
n El siguiente código envía un mensaje JMS a una cola, utilizando JNDI para acceder a los recursos
// Inicio de una sesión JMS ConnectionFactory factory = (ConnectionFactory) context.lookup("jms/QCF"); Connection connection = factory.createConnection(); Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE); // Creación de un MessageProducer asociado a un destino Destination destination = (Destination) context.lookup("jms/QProcesos"); MessageProducer producer = session.createProducer(destination); // Envío del mensaje producer.send(session.createObjectMessage(object)); session.commit(); // Cierre de la conexión connection.close();
33
Un Message-Driven Bean
n El método onMessage() procesa el mensaje n Si se produce un commit en la transacción, el mensaje es
consumido (es eliminado del destino) n Si se produce un rollback en la transacción, el mensaje no es
consumido (permanece en el destino)
@MessageDriven( messageListenerInterface=MessageListener.class, activationConfig = { @ActivationConfigProperty( propertyName="connectionFactoryJndiName", propertyValue="jms/QCF"), @ActivationConfigProperty( propertyName="destinationName", propertyValue="jms/QProcesos"), @ActivationConfigProperty( propertyName="destinationType", propertyValue="javax.jms.Queue") }) public class QProcesosBean implements MessageListener { public void onMessage(Message message) { ... } }
Una Alternativa a EJB: Spring
n Spring (http://www.springsource.com/developer/spring) es un framework que, entre otras cosas, entrega algunas de las funcionalidades provistas por EJBs (transacciones, integración con JPA, acceso remoto, etc.), sin requerir el uso de ellos
n La ventaja de no usar EJB es que se simplifican las pruebas: Spring se integra de manera natural con JUnit
n Spring opera sobre un contenedor de Inversión de Control, que permite configurar el “cableado” de componentes Java: los objetos se conocen entre sí mediante interfaces; Spring instancia los objetos que implementan las interfaces a partir de la configuración, y establece las referencias entre objetos
n Los objetos manejados por Spring pueden tener los siguientes scopes:
n Singleton (default) n Prototype (se crea un nuevo objeto cada vez que se solicita uno) n Session n Request n Desktop (en ZK, corresponde a las páginas de un requerimiento) 34
LA CAPA DE DATOS
Transacciones JPA – Java Persistence API
35
36
Transacciones
n La tecnología EJB provee Container-Managed Transactions
n En la figura, “method-A” inicia una transacción, y al interior de ella invoca a “method-B”
n El método “method-B”, ¿se ejecutará en la misma transacción o en una nueva?
n La respuesta a la pregunta anterior está dada por el atributo transaccional de “method-B”
37
Atributos Transaccionales
Descripción Atributo
Si el cliente se ejecuta en una transacción, se genera una excepción EJBException.
Never
Se ejecuta en la transacción del cliente si ésta existe (Required), de lo contrario el método es invocado con un contexto transaccional no especificado (NotSupported).
Supports
El método es invocado con un contexto transaccional no especificado. Si el cliente se ejecuta en una transacción, ésta es suspendida y retomada al finalizar el método invocado.
NotSupported
El método se ejecuta en la transacción del cliente. Si no hay una transacción en el cliente, se genera una excepción TransactionRequiredException.
Mandatory
Se inicia una transacción nueva. Si el cliente se ejecuta en una transacción, ésta es suspendida y retomada al finalizar el método invocado.
RequiresNew
Si el cliente se ejecuta en una transacción, se usa esa transacción. De lo contrario, se inicia una transacción nueva.
Required (default)
38
Especificación de Atributos
n La anotación @TransactionAttribute permite establecer un atributo transaccional diferente del default REQUIRED
@Stateless public class TestFacturasBean implements TestFacturas { @PersistenceContext private EntityManager em; @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) public void creaFactura() { Factura factura = new Factura(); ... em.persist(factura); } }
39
Alcance de una Transacción
n Usando Container-Managed Transaction Demarcation, las transacciones son iniciadas por el servidor en función del atributo transaccional del método invocado
n La transacción es finalizada por el servidor cuando termina el método cuya invocación causó el inicio de la transacción
n El contenedor cancela la transacción (Rollback) si: n Durante la ejecución del método se ha invocado al método
EJBContext.setRollbackOnly() n La ejecución del método genera una excepción de sistema n La ejecución del método genera una excepción de aplicación
declarada @ApplicationException(rollback=true)
n En caso contrario, la transacción es aceptada (Commit)
40
Transacciones Distribuidas
n El servidor Java EE provee soporte para el manejo de transacciones distribuidas (operaciones con diferentes RDBMS, y desde diferentes servidores Java EE, en una única transacción)
n Si se utiliza Container-Managed Transaction Demarcation, el servidor Java EE maneja automáticamente el protocolo two-phase commit en la interacción con las bases de datos (para lo cual los drivers deben soportar el protocolo XA)
Transacción incluye 3 RDBMS
41
Integración con JMS
n El uso de mensajería se integra de manera natural con el modelo transaccional de Java EE
n En el primer ejemplo, el EJB X envía un mensaje a la cola A, y modifica la base de datos B, y finalmente el EJB Y modifica la base de datos C, todo ello en una misma transacción
n En el segundo ejemplo, la transacción realizada por el EJB X incluye el consumo de un mensaje de la cola A, y la actualización de las bases de datos B y C
JPA – Java Persistence API
n JPA es el framework de persistencia de Java EE
n Provee un mecanismo de mapeo objeto-relacional que permite al programador Java utilizar un modelo de dominio para interactuar con una base de datos relacional
n Principales proveedores de persistencia: Hibernate, TopLink, Kodo, Apache OpenJPA
n Beneficios: simplicidad, productividad, mantenibilidad
42
43
Características JPA
n Modelo de persistencia basado en POJOs n Entidades pueden ser serializables n Herencia n Polimorfismo n Mapeo vía anotaciones o XML n Soporte de Java EE y Java SE n Proveedores de persistencia “pluggables”
44
Entidades
n Una entidad es una clase persistente, liviana, del modelo de dominio
n Puede ser una clase concreta o abstracta n Se mapea a una tabla n Sus campos o propiedades se mapean a columnas de
la tabla n Tiene un identificador persistente n Puede tener estado persistente y transiente n Soporta herencia y polimorfismo n Puede ser serializable n Las asociaciones entre entidades se manejan a través
de referencias y colecciones
Entidades
n La anotación @Table permite definir el nombre de la tabla (puede omitirse si la tabla se llama igual que la clase)
n El mapeo de columnas puede realizarse sobre campos o propiedades n La anotación @Column permite definir el nombre de la columna (puede omitirse
si la columna se llama igual que el campo/propiedad) n La anotación @Id permite indicar que la columna corresponde a la llave primaria n Las anotaciones @GeneratedValue y @SequenceGenerator permiten indicar el
uso de una secuencia
45
@Entity @Table(name="EMPRESAS") public class Empresa { @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_EMP_G") @SequenceGenerator(name="SEQ_EMP_G", sequenceName="SEQ_EMP", allocationSize=1) private long id; private String rut; @Column(name="RAZON_SOCIAL") private String razonSocial; }
EMPRESAS
ID RUT RAZON_SOCIAL
2 77.234.556-2 Restorán El Poroto S.A.
5 89.188.652-4 Librería Macondo
46
Asociaciones
n Pueden ser unidireccionales o bidireccionales n Es posible definir asociaciones:
n 1-1: @OneToOne n 1-n: @OneToMany n n-1: @ManyToOne n n-n: @ManyToMany
n Se implementan mediante referencias y la librería de colecciones de Java: Collection, List, Set, Map
n Se puede definir la propagación de operaciones en cascada: n PERSIST n REMOVE n MERGE n REFRESH n ALL
Asociación @ManyToOne
n La anotación @ManyToOne indica que el campo/propiedad es una referencia a una instancia de otra entidad
n La anotación @JoinColumn permite indicar los nombres de las columnas que definen la asociación
47
@Entity @Table(name="EMPLEADOS") public class Empleado { @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_EMPL_G") @SequenceGenerator(name="SEQ_EMPL_G", sequenceName="SEQ_EMPL", allocationSize=1) private long id; private String rut; private String nombre; @ManyToOne @JoinColumn(name="ID_EMPR", referencedColumnName="ID") private Empresa empresa; }
EMPLEADOS
ID RUT NOMBRE ID_EMPR
1 9.345.222-4 Carlos Rojas 2
8 8.336.235-6 Daniela Merino 2
Asociación @OneToMany
n La anotación @OneToMany indica que el campo/propiedad es una colección de instancias (Set, List) de otra entidad
n El atributo mappedBy indica el nombre del campo/propiedad en la otra entidad de la asociación
48
@Entity @Table(name="EMPRESAS") public class Empresa { ... @OneToMany(mappedBy="empresa") private Set<Empleado> empleados; }
49
Herencia
n Una entidad puede extender: n Una entidad abstracta o concreta n Una clase (no entidad) abstracta o
concreta
n JPA soporta 3 estrategias de herencia: n SINGLE_TABLE: una tabla para la jerarquía n JOINED: una tabla para cada entidad
(abstracta o concreta) de la jerarquía n TABLE_PER_CLASS (opcional): una tabla
para cada clase concreta
50
Herencia – SINGLE_TABLE
@Entity @Table(name="PERSONA") @Inheritance(strategy=InheritanceType.SINGLE_TABLE) @DiscriminatorColumn(name="TIPO",
discriminatorType=DiscriminatorType.STRING, length=2) public abstract class Persona { @Id private long id; private String rut; } @Entity @DiscriminatorValue(value="PN") public class PersonaNatural extends Persona { private String nombre; } @Entity @DiscriminatorValue(value="PJ") public class PersonaJuridica extends Persona { @Column(name="RAZON_SOCIAL") private String razonSocial; }
51
Herencia – JOINED
@Entity @Table(name="PERSONA") @Inheritance(strategy=InheritanceType.JOINED) public abstract class Persona { @Id private long id; private String rut; } @Entity @Table(name="PERSONA_NATURAL") public class PersonaNatural extends Persona { private String nombre; } @Entity @Table(name="PERSONA_JURIDICA") public class PersonaJuridica extends Persona { @Column(name="RAZON_SOCIAL") private String razonSocial; }
52
Herencia – TABLE_PER_CLASS
@Entity @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) public abstract class Persona { @Id private long id; private String rut; } @Entity @Table(name="PERSONA_NATURAL") public class PersonaNatural extends Persona { private String nombre; } @Entity @Table(name="PERSONA_JURIDICA") public class PersonaJuridica extends Persona { @Column(name="RAZON_SOCIAL") private String razonSocial; }
53
Uso de JPA
n La interfaz EntityManager es la fachada de JPA hacia el programador
n La anotación @PersistenceContext “inyecta” el Entity Manager
@Stateless public class TestFacturasBean implements TestFacturas { @PersistenceContext private EntityManager em; public void creaFactura() { // creamos una factura y establecemos su data Factura factura = new Factura(); factura.setFecha(...); ... // agregamos lineas a la factura factura.addLinea("computadores", 10000000); factura.addLinea("impresoras", 600000); ... // grabamos la factura y las líneas en la base de datos em.persist(factura); } }
54
Operaciones sobre Entidades
n El Entity Manager provee las siguiente operaciones: persist() Inserta una instancia en la base de datos
remove() Elimina una instancia de la base de datos
refresh() Recarga el estado de una instancia de la base de datos
merge() Sincroniza el estado de una instancia “detached” con el contexto de persistencia
find() Ejecuta un query por llave primaria
createQuery() Crea una instancia de un query usando JPA QL dinámico
createNamedQuery() Crea una instancia de un query predefinido
createNativeQuery() Crea una instancia de un query a partir de una consulta SQL
contains() Determina si una entidad pertenece a un contexto de persistencia
flush() Fuerza la sincronización del contexto de persistencia con la base de datos
55
Queries
n JPA provee un lenguaje de consultas llamado Java Persistence Query Language
n Soporta queries dinámicas y estáticas (named) n Soporta binding de parámetros y paginación n Similar a SQL, maneja agregaciones y funciones n Soporta polimorfismo n Estandariza el acceso a diferentes bases de datos n Puede usar SQL
List<Factura> findFacturasCliente(Long idCliente) { Query q = em.createQuery( "select f from Factura f where f.empresa.id = :idEmpresa order by f.fecha"); q.setParameter("idEmpresa", idEmpresa); q.setFirstResult(20); q.setMaxResults(10); return (List<Factura>) q.getResultList(); }
56
Funcionalidades Query Language
n Inner joins n select o from Order o join o.lineItems li where li.amount > 100
n Outer joins n select o from Order o left join o.lineItems li where li.amount > 100
n Subselects n select o from Order o where exists(
select li from o.lineItems li where li.amount > 100) n Agregación
n select o.id, sum(li.amount) from Order o join o.lineItems li group by o.id
n Funciones n trim(), concat(), substring(), lower(), upper(), length(), abs(),
sqrt(), mod(), size() n Delete y update
n delete from Customer cust where cust.id = 12345 n update OrderLine ol set ol.fulfilled = 'Y' where ol.order.id = 987654
DISCUSION / PREGUNTAS
57