Como hacer un primer Mapeo en NetBeans

Cree en NetBeans, una base de datos “RegistroJPA” Cree una tabla “Estudiantes”, con los campos Código (Varchar 10), Nombre (Varchar 25), Apellido (Varchar 25) Inserte unos registros

Generación Entity Classes desde Database   JPA requiere que identifique las clases que almacenara en la base de datos. El API usa el termino entity para definir las clases que mapeara a la base de datos relacional. Identifique las entidades persistentes y defina sus relaciones usando anotaciones. Una entidad representa una tabla en una base de datos relacional. Cada instancia de entidad corresponde a una fila en la tabla. Una entidad es codificada como un POJO.

Generación Entity Classes desde Database   Cree un proyecto Java Application (sin main), denominado “ PersistenciaDemo.”

Generación Entity Classes desde Database   Dentro del proyecto cree un nuevo “ Entity Classes From Database”

Generación Entity Classes desde Database   Para este “ Entity Classes From Database” ingrese la siguiente información y oprima NEXT:

Generación Entity Classes desde Database  En la siguiente ventana, ingrese el “Package Name” como “demo” y oprima NEXT:

Generación Entity Classes desde Database  En la ventana de Mappings seleccione “Finish” con los valores por defecto:

Generación Entity Classes desde Database Inmediatamente se crea una clase con las respectivas anotaciones:

Generación Entity Classes desde Database La entidad creada se denomina “persistence unit”. Las Persistence units son configuradas en un archivo XML ubicado en la carpeta META-INF. Se usa para especificarle al proveedor de persistencia los nombres de las entidades y sus atributos, y las propiedades de la base de datos como connection URL, driver, user, password.

Generación Entity Classes desde Database

Implementado el CRUD usando JPA Los objetos Entity son instancias en memoria de las clases entity, las cuales representan objetos físicos de la base de datos. En JPA se pueden usar entity objects para muchas operaciones, incluyendo Crear , Consultar, Actualizar y Borrar objetos de la base de datos. Se necesitan tres artefactos para implementar las operaciones CRUD usando JPA: Una clase Entity Un archivo persistence.xml Una clase (o cliente) a través de la cual se realicen las respectivas operaciones.

Implementado la Inserción usando JPA Para crear el cliente que realizara dicha operaciones, se desarrollan los siguientes pasos: En el Proyecto PersistenciaDemo cree una nueva clase “InsertarEstudiante” y guárdela en el paquete Demo. Abra la clase e importe las siguientes clases: import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; 3. Cree el metodo main  en esta clase y adicione las siguientes líneas: public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaDemoPU"); EntityManager em = emf.createEntityManager(); }

Implementado la Inserción usando JPA

Implementado la Inserción usando JPA Este código muestra la creación de una instancia de EntityManager. De persistir una nueva entidad, se necesita una instancia de EntityManager. EntityManagerFactory es una fábrica para la creación de un EntityManager. EntityManager gestiona entidades y es responsable de su adición, actualización y eliminación. La instancia EntityManager representa una unidad de persistencia, y debe proporcionar el nombre de la unidad de persistencia. En este ejemplo PersistenceDemoPU es el nombre de la unidad de persistencia que se declara en el archivo persistencia.xml junto con otras propiedades.

Implementado la Inserción usando JPA Adicione el siguiente código al main Estudiantes p1 = new Estudiantes(); p1.setCodigo("201020"); p1.setNombre("Juan"); p1.setApellido("Perez"); em.persist(p1); Estudiantes p2 = new Estudiantes(); p2.setCodigo("2009020"); p2.setNombre("Maria"); p2.setApellido("Alvarez"); em.persist(p2); em.getTransaction().commit(); em.close(); emf.close(); Este código crea una transacción, 2 objetos de la clase Estudiantes, que se mantuvo como 2 filas de la tabla del Estudiantes.

Implementado la Inserción usando JPA

Implementado la Inserción usando JPA Adicione el jar del cliente de Derby, al proyecto

Implementado la Inserción usando JPA En la ventana Proyectos, haga clic derecho a la clase InsertarEstudiante.java y seleccione “Ejecutar”. Verifique la salida. Examine el contenido de la base de datos.

Recuperando Objetos Entity con JPA JPA proporciona varias maneras de recuperar los objetos de la base de datos. La recuperación de objetos no requiere una transacción activa porque no cambia el contenido de la base de datos. El contexto de persistencia sirve como memoria caché de objetos de entidad recuperados. Si no se encuentra un objeto entidad requerido en el contexto de persistencia, de un nuevo objeto se construye y se llena con los datos que se recuperan de la base de datos.

Recuperando Entidad objetos con JPA Consultando por clase y clave principal Cada objeto entity puede ser identificada y recuperada por la combinación de su clase y su clave primaria. Dado un EntityManager em: Employee employee = em.find(Employee.class, 201020); No se requiere el casting a ESTUDIANTES, porque con el mapeo se retorna un objeto de la misma clase. Una IllegalArgumentException se produce si la clase especificada no es una clase entity.

Recuperando Entidad objetos con JPA Consultando por clase y clave principal package demo; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; public class Gestor { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaDemoPU"); EntityManager em = emf.createEntityManager(); //retorna un objeto dado su clase y su llave Estudiantes p1= em.find(Estudiantes.class, "201020"); System.out.println(p1.getCodigo() +" "+p1.getNombre()+" "+p1.getApellido()); em.close(); emf.close(); }

Recuperando Entidad objetos con JPA Consultando por Query El método más flexible para la recuperación de objetos de la base de datos es utilizar consultas. El idioma oficial de consulta de JPA es JPQL (Java Persistence Query Language). Se permite la recuperación de objetos de la base de datos mediante consultas simples, así como sofisticados.

Recuperando Entidad objetos con JPA Consultando por Query El lenguaje de consulta de JPQ (JPQL) se puede considerar como una versión orientada a objetos de SQL. Los usuarios familiarizados con SQL deben encontrar JPQL muy fácil de aprender y utilizar. A continuación se muestran algunas consultas:

Recuperando Entidad objetos con JPA Consultando por Query import javax.persistence.Query; import javax.persistence.TypedQuery; ----------------------------------------------------------------------------------- public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaDemoPU"); EntityManager em = emf.createEntityManager(); //recuperando estudiantes por query TypedQuery<Estudiantes> query = em.createQuery("SELECT e FROM Estudiantes e", Estudiantes.class); List<Estudiantes> results = query.getResultList(); for (Estudiantes c : results) { System.out.println("Estudiante por query en grupo: "+c.getNombre() + " " + c.getApellido()); } //seleccionado un estudiante por query String codigo="201020"; Query query1 = em.createQuery("SELECT c FROM Estudiantes c WHERE c.codigo = '"+codigo+"'"); Estudiantes c = (Estudiantes) query1.getSingleResult(); System.out.println("EStudiante por query sencilla"+c.getNombre() + " " + c.getApellido()); em.close(); emf.close();

Recuperando Entidad objetos con JPA Consultando por @NamedQuery public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaDemoPU"); EntityManager em = emf.createEntityManager(); //consultas por @NamedQueries TypedQuery<Estudiantes> query0 = em.createNamedQuery("Estudiantes.findAll", Estudiantes.class); List<Estudiantes> results0 = query0.getResultList(); for (Estudiantes c0 : results0) { System.out.println("Estudiante por namedquery: " + c0.getNombre() + " " + c0.getApellido()); } TypedQuery<Estudiantes> consultaEstudiante = em.createNamedQuery("Estudiantes.findByNombre", Estudiantes.class); consultaEstudiante.setParameter("nombre", "Maria"); Estudiantes est = consultaEstudiante.getSingleResult(); System.out.println("Estudiante por namedquery por nombre: " + est.getNombre() + " " + est.getApellido()); em.close(); emf.close();

Actualizando Entidad objetos con JPA Actualizando con JPA Actualización transparente: Una vez que un objeto de entidad se recupera de la base de datos (no importa la forma) simplemente puede ser modificado en la memoria desde el interior de una transacción activa. Query de ACTUALIZACIÓN: el query de actualización proporciona una forma alternativa para la actualización de objetos entity en la base de datos. La modificación de objetos utilizando un query de actualización puede ser útil sobre todo cuando muchos objetos entity que tienen que ser modificados en una sola operación.

Actualizando Entidad objetos con JPA Actualización transparente public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaDemoPU"); EntityManager em = emf.createEntityManager(); //Actualizacion transparente Estudiantes estudiante = em.find(Estudiantes.class, "201020"); em.getTransaction().begin(); estudiante.setNombre("Jose el Plomero"); em.getTransaction().commit(); Estudiantes p3 = em.find(Estudiantes.class, "201020"); System.out.println("Estudiante actualizado: " + p3.getCodigo() + " " + p3.getNombre() + " " + p3.getApellido()); em.close(); emf.close(); }

Actualizando Entidad objetos con JPA Query de Actualización Actualizar una campo de todos los registros: UPDATE Estudiantes SET edad = edad + 1 Actualizar varios campos de un estudiante UPDATE Estudiantes SET edad = 10, nombre = “Pedro” Actualization selectiva Query query = em.createQuery( "UPDATE Estudiantes SET nombre=“Chuchin” + "WHERE codigo=20120"); int updateCount = em.executeUpdate();

Actualizando Entidad objetos con JPA Query de Actualización (selectiva) public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaDemoPU"); EntityManager em = emf.createEntityManager(); //Actualizacion selectiva em.getTransaction().begin(); String nom = "Maria la bandida"; String cod = "2009020"; Query query2 = em.createQuery("UPDATE Estudiantes SET nombre='" + nom + "' WHERE codigo='" + cod + "'"); query2.executeUpdate(); em.getTransaction().commit(); em.close(); emf.close(); }

Eliminando Entidad objetos con JPA Eliminación explicita: Primero el objeto debe ser consultado, y luego en una transacción activa debe ser borrado. Query de Eliminación: el query delete puede ser usado cuando una o varias entidades deben ser borradas en una sola operación.

Eliminando Entidad objetos con JPA Eliminación explicita public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaDemoPU"); EntityManager em = emf.createEntityManager(); //elimnacion de un estudiante Estudiantes estudiante3 = em.find(Estudiantes.class, "2020"); em.getTransaction().begin(); em.remove(estudiante3); em.getTransaction().commit(); em.close(); emf.close(); }

Eliminando Entidad objetos con JPA Eliminación con QUERY Remover todas las instancias de una clase DELETE FROM Country // no variable DELETE FROM Country c // an optional variable DELETE FROM Country AS c // AS + an optional variable DELETE queries son ejecutados usando el metodo executeUpdate: int deletedCount = em.createQuery("DELETE FROM Country").executeUpdate(); Si es exitosa: el método executeUpdate retorna el numero de objetos que han sido borrados en la consulta.

Eliminando Entidad objetos con JPA Eliminación con QUERY Eliminación selectiva public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaDemoPU"); EntityManager em = emf.createEntityManager(); //eliminacion selectiva String codElim = "2020"; em.getTransaction().begin(); Query query3 = em.createQuery("DELETE FROM Estudiantes c WHERE c.codigo='" + codElim + "'"); query3.executeUpdate(); em.getTransaction().commit(); em.close(); emf.close(); }

Bibliografía http://www.objectdb.com/java/jpa/persistence/crud http://www.aninki.net/joomla/index.php/18-JPA/53-jpa-crear-crud http://www.arquitecturajava.com/utilizando-jpa-namedqueries/ http://docs.oracle.com/javaee/6/tutorial/doc/bnbrg.html