JPA HIBERNATE

HIBERNATE ES UN ORM DE
 Configuracion de hibernate jpa
Para usar hibernate con jpa debemos crear en el espacio de trabajo src/java/resources una carpeta llamada
META-INF y adentro de esa carpeta crear un archivo persistence.xml y colo camos la configutacion
 Iniciando con hibernate JPA

Las consultas jpql son similares a sql con algunas diferencias son como que en vez de trabajar con la tabla trabajamos con la
clase, aunque tambien son similares en algunas palabras claves o operadores claves como los son DISTINC CONCAT
UPPERCASE entre otras..


Para obtener el Manager y poder trabajar con jpa debemos obtener el gestor de persistencia para eso lo podemos obtener de
varias forma injectandolo con cdi o spring o con el EntitityManagerFactory para este caso vamos a obtenerlo con el
EntityManagerFactory


Para iniciar una operación de insercion, delete, update debemos inciar una transaccion, para hacer consultas no es necesario,
para iniciar una treansaccion debemos obtener el objeto EntityTransaction y llamar el metodo begin() y para terminar la
transaccion debemos hacer el commit()
 Insert, update ,delete, remove

Para hacer un insert tenemos el metodo persist(Entidad), para el update tenemos el metodo
merge(Entidad), para el delete tenemos el metodo remove(Entidad) y consultar por id con
find(entidad, ID)

Guardar Eliminar

Actualizar

Buscar por ID
 Consultas JPQL
Tambien tenemos las consultas JPQL O HQL que son consultas parecidas a sql solo que en vez de llamar
a las tablas llamamos a los objetos de entidad que representan nuestra tabla y sus atributos que
representas nuestros campos

Consulta de el objeto Cliente se

Entidad de la tabla cliente especifica el Cliente.class para que no
arroje un warning pero puede funcionar
sin especificar

Nota: las entidades deben ser pojos osea deben

tener un constructor vacion sin parametros y sus
getter y setter para que hibernate pueda insertar los
datos
 Consultas JPQL Part2

Si queremos obtener varios atributos de un objeto o entidad la consulta devolvera un array de objeto
con sus datos, en caso que queramos obtener varios registros de la tabla devolvera una lista de
arrays de tipo object

Obtenemos varios campos y varios registros de la base de datos cada array Object es
un registro que contiene los campos

Obtenemos varios campos de un solo objeto devuelve un array de tipo object con los
campos
 Consultas JPQL PART 3


De esta forma obtenemos el objeto cliente y un campo que queramos obtener

Tambien podemos crear consultas con el constructor, para poder hacer esto
debemos tener el constructo que especifiquemos en la consulta en la clase de la
entidad si no dara error
Tambien podemos usar otra clase que no sea una entidad y recibir los parametros
de la tabla por ejemplo podemos usar un ObjetoDTO en la consulta haciendo
referencia en el from a la Entidad de la clase ejemplo

SELECT new paquete.del.DTO.completo.clienteDTO(c.nombre,c.apellido)

from Cliente c

Para que esto funcione debemos colocar el paquete completo del DTO o de la clase
que queremos mappear
 Operadores o palabras para consultas JPQL
DISTICN :la palabra clave DISTINCT se usa en la instrucción SELECT para recuperar valores únicos de
una tabla de base de datos, es decir que no obtengamos valores repetidos. Cualquier valor duplicado solo
aparecerá una vez.
CONCANT: Esta funcion sirve para unir dos o mas cadenas juntas
UPPER:Convierte una cadena a mayuscula
LOWER:Convierte una cadena a minuscula
LIKE: sirve para buscar palabras o caracteres antes o despues dependiendo del operador que se le
coloque si le colocamos ‘%ana%’ buscara antes o despues la palabra que tenga los caracteres ana ,
tambien podemos usar el guion bajo para indicar que busque a partir de una posicion equis ‘_ede’ este
buscara apartir de la segunda letra para mas informacion consulte sql .. En otras palabras es para buscar
por coincidencia
BETWEEN: sirve para buscar entre un rango
ORDER BY: sirve para ordernar una consulta descendente mente o ascendentemen en base a un campo
o varios campos lo ordenara en orden del primer campo despues del segundo y asi sucecivamente
Min:Obtiene el numero minimo de los registros
Max:Obtiene el numero maximo de los registros
AVG:Obtiene el promedio de un valor
SUM:suma el valor de un campo de todos los registros
 Sub Consultas o sub querys

JPQL tambien soporta subConsultas al igual que en sql pero en base a

clases, por ejemplo en esta consulta traemos el largo de un nombre en
donde el largo de el cliente sea igual al largo minimo del cliente traido en la
sub consulta
 API CRITERIAL

Sirve para hacer consultas dinamicas es la alternativa a usar HQL o JPQL , para
usar el api criteria debemos usar manager para obtener el objeto


Luego creamos query del tipo de la entidad que queremos hacer la consulta


Creamos el select y filtramos con where en caso que sea necesario y luego
ejecutamos
 Parametros en criterial
Para pasar parametros tenemos el Objeto ParameterExpression<Tipo de dato>
param creamos el objeto y luego se lo pasamos en el where y le asignamos el valor
en en la consulta con SetParameter(key,value)
 Operador Like y Between con criterial
Para usar el operador like y Betwenn debemos usarlo en el where con el
objeto criterial que creamos criterial.Like() o criterial.Between()
 Operador in

Para usar el in podemos usarlo de varias maneras una separado por comas y colocamos los valores,
podemos crear una lista con los datos a evaluar o podemos crear un parametro tipo lista y se lo
pasamos en la query con setParameter al final
 Mayor igual ge(), mayor que gt(), menor que it(), menor
igual le()

Para usar estos debemos llamar en el where el objeto where(criterial.ge(from.get(columna), “dato
a comparar”)), de igual manera el dato se lo podemos pasar por parametro

where(criterial.gt(from.get(columna), “dato a comparar”))

where(criterial.it(from.get(columna), “dato a comparar”))

where(criterial.le(from.get(columna), “dato a comparar”))

Tambien tenemos el Equals que lo usamos para comparar si es igual

where(criterial.equals(from.get(columna), “dato a comparar”))
 And y Or
Para usar el AND y OR debemos crear un predicate o varios predicate dependiendo de la cantidad de
campos que queramos evaluar y luego se lo pasamos a la consulta en el where con
Criteria.and(predicateCreado...) o criteria.Or(PredicateCreado…) en este caso pasamos varios
predicate, tambien podemos combinar and y or como se ve en la segunda foto

Cabe mencionar que no solo sirve con el equals tambien lo podemos usar con el LIKE , BETWEEN entre
otros

Los predicate para las consultas son de jakarta.persistence no de java.util.funtion

 Order by y distinc

Tambien podemos usar order by para ordenar los campos que requiramos a travez del select o
despues del where lo podemos colocar y lo que recibe es el from.get(campo)


Podemos usar Distinc en caso que no queramos recibir campos duplicados podemos hacer en el
select(from.get(“columna”)).distinct(true) recibe un booleano
 Funciones concat, upper,lower

En caso que queramos usar concat podemos hacerlo llamando a
select(criteria.concat(from.get(columna)), “lo que queremos unir”)) en caso que queramos
concatenar columnas podemos usar un concat dentro de otro concat, si queremos hacer
concat(from.get(“columna1”), from.get(“columna2”), debemos usar un multiselec() en vez de
select() esto lo veremos mas adelante


Para usar el upper o lower como vimos en la imagen es solo envolver los campos que queremos
convertir en mayusculas o minusculas
 Consultas multiSelect

El multiSelect te permite traer varias columnas y no un objeto completo para esto colocamos la
consulta como la queramos hacer y en vez de poner select() colocamos multiSelect(), cabe
destacar que si colocamos diferentes datos devolvera es un array de object, el select devuelve un
unico objeto mientras que el multiSelect() lo usamos para devolver varios objetos pudiendo ser varios
campos de una entidad
 Count sum,max,min
Para usar estas funciones de agregacion debemos
 Consultas dinamicas con Criteria
Podemos crear una lista de Predicates y luego se lo pasamos a la query
Ciclo de vida de JPA
 @PrePersis,@PreUpdate,@PreRemove,
@PostRemove,@PostUpdate,@PostPersist

Estos anotaciones se deben colocar en la entidad en un metodo por cada anotacion

@PrePersis:Se usa para hacer un evento o hacer algo antes de persistir el objeto

@PreUpdate:Se usa para hacer algo antes de actualizar un objeto

@PreRemove:Se usa para hacer algo antes de eliminar el objeto

@PostPersist:Se usa para hacer algo despues de persistir o guardar la entidad

@PostUpdate:Se usa para hacer algo despues de actualizar la entidad

@PostRemove:Se usa para hacer algo despues de eliminar la entidad

Los metodos con estas anotaciones

deben estar en la entidad
 @Embeddable y @Embedded

Estas anotaciones se usan para que una clase forme parte de otra, @Embeddable se usa en la clase
que contendra los atributos mientras que @Embedded se usa en la clase cliente que contendra la
clase que contiene los atributos por ejemplo:
 Mapeo en JPA
Para representar las tablas en JPA debemos usar clases de entidad para esto es necesario crear una clase
y anotarla con @Entity y luego @Table para indicar la tabla, para indicar los campos tenemos la anotacion
@Column(name=””) en donde se coloca el nombre de la columna de la tabla , para indicar que columna
sera el id tenemos @Id en caso que tengamos un id compuesto podemos usar @EmbeableId en la clase
que tendra el ide y @Embeable en la clase que sera la que represente el id.
Nota: no hace falta colocar @Column si el campo se llama igual
 Relacion @OneToOne en JPA

@OneToOne:se usa para indicar la relacion entre dos clases, se coloca en el atributo de una de las
clase que sea dueña de la relacion en caso que sea unidireccional y la otra se deja mapeada normal,
en caso que sea bidireccional podemos agregar un atributo de la otra clase tambien la anotamos con
@OneToOne(mappedBy=”Atributo en otra clase”) el mappeby sirve para indicar donde esta
mappeada direccion en la clase dueña que seria cliente

Nota: la clase dueña es la que tienen el JoinColumns en este caso es

cliente y la que no lo es es la del mappeBy
Relacion @OneToMany y @ManyToOne con JPA
Se usan para indicar una relacion de muchos a uno y de uno a muchos en este
como por ejemplo libro y autor donde un libre tiene un autor y un autor tiene
michos libros, para representar esto jpa usa una lista en caso de libros y un
objeto en la parte de uno
 Ralacion @ManyToMany
Se usa para indicar una relacion de muchos a muchos entre dos entidades para esto se
coloca en el atributo de cada clase la anotacion @ManyToMany en un lado si es bidireccional
si es unidireccional se coloca en los dos lado

Nota: cabe mencionar que se creara una tabla intermedia , para personalizar esta
tabla podemos usar @JoinTable , si no se coloca hibernata creara una
automaticamente
 Egar y laizy
Lazy: se usa para indicar una cargar peresoza entre las entidades de bases de datos y solo se obtendra
al llamar al metodo get() de dicho objeto

Egar: se usa para indicar una carga apresurada todos los objetos dependientes se cargaran al hacer la
consulta(no es recomendable)

Para indicar donde se configura esto es en las anotaciones de relaciones, cabe mencionar que
todo lo que termine en One tendra una carga Egar mientras que todo lo que termine en Many tendra
una carga lazy
 Tambien podemos usar Fecht con lyze con jpql
Para usar fech y que haga una sola consulta podemos usar Left join pero esto al momento de llenar los
datos de direcciones en el objeto cliente no lo hara porque para eso necesitamos la plabra Fech en la
consulta , la palabra outer es opcional colocarla

En caso que vengan repetidos podemos usar Distinc

De igual forma lo trabajamos para @ManyToMany

 Join y Fech con Criterial

Para este caso tenemos el objeto fech como se ve en la imagen despues lo podemos volver a llmar
y pasarle otro join como se ve en la imagen en caso que traiga repetidos podemos usar DIstinct(true)