Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

[Tutorial] JPA 2.1 - Parte I

  • 1 Respuestas
  • 3328 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Gus Garsaky

  • *
  • Underc0der
  • Mensajes: 93
  • Actividad:
    0%
  • Reputación -1
    • Ver Perfil
  • Skype: gus.garsaky
« en: Abril 10, 2015, 09:48:35 am »
TUTORIAL JPA 2.1


El presente tutorial tiene como finalidad mostrar los aspectos básicos de la especificación de Java JPA (API de Persistencia de Java por sus siglas en inglés). Se cubrirán los aspectos más básicos de ésta API para que el lector se dé cuenta del potencial que nos ofrece y que se puede aplicar en nuestros proyectos. Así mismo,



¿QUÉ ES JPA?

Como en todo proceso de aprendizaje, primero debes saber qué es exactamente el objeto de nuestro estudio. JPA como ya dijimos es el API para la persistencia en Java, pero, ¿qué es en concreto? Bien, JPA es un ORM, aunque no propiamente. Explicaremos esto en detalle a continuación.

La Java Community Process (JCP), es la encargada de las especificaciones en Java. ¿Qué quiero decir con especificaciones? Pues, una especificación no es más que un estándar. La JCP propone un estándar y si por mayoría de votos se acepta la proposición, se designa un equipo experto para que trabaje en ella. Aquí el equipo se encarga de definir la estructura de la especificación, sus características y forma de trabajar. Pero no podemos empezar a trabajar con una especificación si no tiene una implementación. Una implementación es una representación real de dicha especificación. Es como en el mismo lenguaje, una interface vendría a ser la especificación y una clase que implemente dicha interface vendría a ser la implementación o representación. Así mismo, la JCP puede o no realizar la implementación de una especificación, como lo hizo con Servlet, JAXB, JMS, JAAS, y algunos otros.

Comprendido lo anteriormente explicado, se procede a listar las mejores implementaciones de JPA:

• Hibernate
• EclipseLink
• MyBatis

Hibernate y MyBatis se pueden usar nativamente, es decir, sin usar a JPA como interfaz o también con JPA. En éste tutorial se usará Hibernate por ser el más adoptado por los desarrolladores.



PREPARANDO NUESTRO ENTORNO DE TRABAJO

Primero que todo, vamos a disponer del siguiente material:

JDK 8
Eclipse Luna
Hibernate 4.3.8 (opcional, porque usaremos Maven).
MySQL 5.6
MySQL JDBC (opcional, usaremos Maven).
MySQL Workbench 6.2.5

Instalación de MySQL como servicio

Nos dirigimos a “C:\Program Files\MySQL\MySQL Server 5.6” y renombramos el archivo “my-default.ini” a “my.ini”. Lo editamos y al final agregamos la línea:

Código: [Seleccionar]
PERFORMANCE_SCHEMA=0
Ahora, abrimos la terminal como Administrador y nos dirigimos hacia “bin”. Aquí ejecutaremos el comando:

Código: [Seleccionar]
mysqld –install
Y ya tenemos MySQL instalado como servicio. Si no está corriendo lo iniciamos.


CREACIÓN DE LA BASE DE DATOS


Creación de la base de datos y la tabla Employees

Abrimos MySQL Workbench e iniciamos sesión. En el editor SQL escribimos el siguiente código para crear nuestra base de datos “jpa2_tuto” y nuestra primera tabla “employees”:


Desconectado Gus Garsaky

  • *
  • Underc0der
  • Mensajes: 93
  • Actividad:
    0%
  • Reputación -1
    • Ver Perfil
  • Skype: gus.garsaky
« Respuesta #1 en: Abril 10, 2015, 09:49:19 am »

CREACIÓN DEL PROYECTO


Vamos a crear nuestro proyecto en Eclipse. El proyecto será maven para que gestione nuestras dependencias y no tener que preocuparnos por bajar las bibliotecas/librerías. Vamos al menú “File” -> “New” -> “Maven Project”. Tildamos la opción create a simple project:


Clic en Next. A continuación llenamos la información de nuestro proyecto, de tal modo que quede así:


Click en finish y ya tenemos listo nuestro proyecto.


AGREGANDO DEPENDENCIAS AL PROYECTO Y CONFIGURACIÓN


Abrimos el archivo pom.xml, que se encuentra en la raíz del proyecto. Éste archivo es el encargado de gestionar las dependencias del proyecto. Si hemos visto PHP, se puede comparar a Composer, PEAR, o RubyGems de Ruby. En éste archivo debemos de especificar las dependencias que requerirá el proyecto y algunas configuraciones de ser necesario. Editamos su contenido, de tal modo que quede así:

Código: XML
  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.   <modelVersion>4.0.0</modelVersion>
  5.   <groupId>com.company</groupId>
  6.   <artifactId>jpa2-tuto</artifactId>
  7.   <version>0.0.1-SNAPSHOT</version>
  8.   <name>JPA2-Tuto</name>
  9.   <description>Tutorial de JPA 2</description>
  10.  
  11.   <properties>
  12.         <maven_compiler_source>1.8</maven_compiler_source>
  13.         <maven_compiler_target>1.8</maven_compiler_target>
  14.   </properties>
  15.  
  16.   <build>
  17.         <plugins>
  18.                 <plugin>
  19.                         <artifactId>maven-compiler-plugin</artifactId>
  20.                         <version>3.1</version>
  21.                         <configuration>
  22.                                 <source>1.8</source>
  23.                                 <target>1.8</target>
  24.                         </configuration>
  25.                 </plugin>
  26.         </plugins>
  27.   </build>
  28.  
  29.   <dependencies>
  30.         <dependency>
  31.             <groupId>org.hibernate</groupId>
  32.             <artifactId>hibernate-core</artifactId>
  33.             <version>4.3.8.Final</version>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.hibernate</groupId>
  37.             <artifactId>hibernate-validator</artifactId>
  38.             <version>5.1.3.Final</version>
  39.         </dependency>
  40.         <dependency>
  41.             <groupId>org.hibernate.common</groupId>
  42.             <artifactId>hibernate-commons-annotations</artifactId>
  43.             <version>4.0.5.Final</version>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>org.hibernate.javax.persistence</groupId>
  47.             <artifactId>hibernate-jpa-2.0-api</artifactId>
  48.             <version>1.0.1.Final</version>
  49.         </dependency>
  50.         <dependency>
  51.             <groupId>org.hibernate</groupId>
  52.             <artifactId>hibernate-entitymanager</artifactId>
  53.             <version>4.3.8.Final</version>
  54.         </dependency>
  55.         <dependency>
  56.             <groupId>javax.validation</groupId>
  57.             <artifactId>validation-api</artifactId>
  58.             <version>1.1.0.Final</version>
  59.             <scope>provided</scope>
  60.         </dependency>
  61.         <dependency>
  62.             <groupId>mysql</groupId>
  63.             <artifactId>mysql-connector-java</artifactId>
  64.             <version>5.1.34</version>
  65.         </dependency>
  66.   </dependencies>
  67.  
  68. </project>

Primero especificamos que la versión de Java será la 1.8 porque por defecto un proyecto Maven crea una proyecto para la versión 1.5. Más abajo especificamos las dependencias de nuestro proyecto*, es decir, frameworks, bibliotecas/librerías, etc. Como se puede observar, la gran mayoría pertenece a Hibernate, del que ya hablamos anteriormente y al final, agregamos la dependencia MySQL jdbc.
Para actualizar el proyecto Maven con las nuevas dependencias y configuraciones, le damos clic derecho > Maven > Update Project…
Ya tenemos nuestro proyecto con todas las dependencias que necesitamos. Ahora solo queda empezar a programar.







* Para saber que versión o que artifactId poner, debemos ir al repositorio Maven y buscar las dependencias que queramos. Cada dependencia tendrá su código para solo copiar y pegar en nuestro pom.xml


PRIMER CONTACTO CON JPA


Primero, crearemos nuestro archivo persistence.xml, el cual contendrá toda la información sobre nuestra conexión a la base de datos. Creamos un folder dentro de src/main/resources llamado META-INF y dentro de éste folder creamos un fichero xml llamado persistence.xml. Éste fichero tendrá el siguiente aspecto:

Código: XML
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
  3.             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
  5.             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
  6.             version="2.1">
  7.              
  8.              <persistence-unit name="JPA2-tuto" transaction-type="RESOURCE_LOCAL">
  9.                 <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
  10.                
  11.                 <properties>
  12.                         <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
  13.                         <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa2_tuto"/>
  14.                         <property name="javax.persistence.jdbc.user" value="root"/>
  15.                         <property name="javax.persistence.jdbc.password" value="toor"/>
  16.                         <property name="org.hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
  17.                         <property name="show_sql" value="true"/>
  18.                         <property name="format_sql" value="true"/>
  19.                         <property name="hbm2ddl.auto" value="auto"/>
  20.                 </properties>
  21.              </persistence-unit>
  22.              
  23. </persistence>

Éste fichero especifica la configuración de nuestra conexión con JPA. Aquí describimos el proveedor de la implementación de JPA, el driver del SGBD, el url, el usuario y contraseña, el dialecto, etc. A continuación se describen algunas palabras clave de persistence.xml:

  • transaction-type, indica que las transacciones se harán de forma local. Si tuviésemos un servidor de aplicaciones, las transacciones las manejaría el servidor, y la conexión a nuestra base de datos también. Por lo que dicha conexión estaría siempre disponible para cualquier aplicación que la quiera usar. En nuestro caso, lo haremos de forma local.

  • <provider>, especifica el proveedor de la implementación de JPA (¿recuerdas la charla que tuvimos sobre especificaciones e implementaciones?), en nuestro caso Hibernate.

  • <properties>, almacena un conjunto de propiedades que hacen referencia a nuestra conexión: driver, url, usuario, contraseña, dialecto del SGBD que usaremos (MySQL) y otras propiedades como show_sql que muestra el código SQL generado por Hibernate y format_sql que lo formatea para que sea más amigable a la vista.



    CREACIÓN DE UN DAO GENÉRICO


    Para ahorrar código, haremos uso de un Dao Genérico del cual extenderemos para tener a nuestra disposición todas las acciones de persistencia. Empezaremos por crear nuestra interface GenericDao, la cual especificará que todo DAO tendrá los métodos básicos: create, read, update y delete.

    Código: Java
    1. package model.dao;
    2.  
    3. import java.io.Serializable;
    4.  
    5. public interface GenericDao<T, PK extends Serializable> {
    6.         T create(T t) throws Exception;
    7.         T read(PK id) throws Exception;
    8.         T update(T t) throws Exception;
    9.         void delete(T t) throws Exception;
    10. }
    11.  

    Como se puede observar, ésta interface acepta un tipo de clase y un tipo de PK, que viene a ser el tipo de dato de la llave primaria. Veamos su implementación, GenericDaoJpaImpl, de la cual extenderán todos los DAOs:

    Código: Java
    1. package model.dao;
    2.  
    3. import java.io.Serializable;
    4. import java.lang.reflect.ParameterizedType;
    5.  
    6. import javax.persistence.EntityManager;
    7. import javax.persistence.EntityTransaction;
    8. import javax.persistence.Persistence;
    9.  
    10. public class GenericDaoJpaImpl<T, PK extends Serializable> implements GenericDao<T, PK> {
    11.  
    12.         protected EntityManager em = Persistence.createEntityManagerFactory("JPA2-tuto").createEntityManager();
    13.         protected Class<T> clazz;
    14.        
    15.         @SuppressWarnings("unchecked")
    16.         public GenericDaoJpaImpl() {
    17.                 ParameterizedType genericSuperclass = (ParameterizedType) getClass()
    18.                      .getGenericSuperclass();
    19.                 this.clazz = (Class<T>) genericSuperclass
    20.                      .getActualTypeArguments()[0];
    21.         }
    22.        
    23.         @Override
    24.         public T create(T t) throws Exception {
    25.                 EntityTransaction tx = em.getTransaction();
    26.                 tx.begin();
    27.                 em.persist(t);
    28.                 em.flush();
    29.                 tx.commit();
    30.                 return t;
    31.         }
    32.  
    33.         @Override
    34.         public T read(PK id) throws Exception {
    35.                 return em.find(clazz, id);
    36.         }
    37.  
    38.         @Override
    39.         public T update(T t) throws Exception {
    40.                 EntityTransaction tx = em.getTransaction();
    41.                 tx.begin();
    42.                 em.persist(t);
    43.                 em.flush();
    44.                 tx.commit();
    45.                 return t;
    46.         }
    47.  
    48.         @Override
    49.         public void delete(T t) throws Exception {
    50.                 EntityTransaction tx = em.getTransaction();
    51.                 tx.begin();
    52.                 em.remove(t);
    53.                 em.flush();
    54.                 tx.commit();
    55.         }
    56.  
    57. }

    Analicemos un poco la siguiente línea:

    Código: Java
    1. protected EntityManager em = Persistence.createEntityManagerFactory("JPA2-tuto").createEntityManager();

    Creamos un objeto EntityManager, pero ¿Qué es un EntityManager?. Pues bien, éste objeto es el encargado, como su nombre lo dice, de manejar todas las entidades que existen en el proyecto. Gracias a éste objeto, podemos guardar objetos y convertirlos internamente a SQL transparente para nosotros. El EntityManager es el que hace la “magia”.

    La instrucción:

    Código: Java
    1. Persistence.createEntityManagerFactory("JPA2-tuto")

    Crea una fábrica de EntityManager (solo habrá una fábrica por proyecto). Éste método recibe como parámetro el nombre de la unidad de persistencia que se especifica en el fichero persistence.xml. El método concatenado:

    Código: Java
    1. createEntityManager()

    Devuelve un EntityManager para manejar las entidades. Más abajo, tenemos una propiedad Class<T> clazz. Ésta propiedad especificará el tipo de Clase (T) de la entidad en tiempo de ejecución para que el EntityManager sepa con qué entidad está trabajando, además del tipo de dato de la llave primaria (PK). En cada método de persistencia, primero iniciamos obteniendo una transacción:

    Código: Java
    1. EntityTransaction tx = em.getTransaction();

    Toda acción, se debe de realiza en una transacción. Esto es importante, si no, tendrás una excepción. Toda transacción debe de iniciarse llamando al método begin() y finalizar con el método commit().

    A continuación, describiremos los métodos más importantes de EntityManager:

    persist(T t): guarda en la base de datos una entidad. Pero no se ejecutará directamente en la base de datos, si no que internamente es marcado para que al finalizar la transacción se guarde en la base de datos. Con el método flush(), forzamos a que dicha instrucción se guarde inmediatamente.

    find(T, PK id): Busca en la entidad T un registro con el id especificado. Si lo encuentra, lo devuelve, caso contrario, devuelve null.

    remove(PK id): Elimina la entidad con el id especificado de la base de datos.

    flush(): Forza al EntityManager a ejecutar inmediatamente las acciones que se han llevado acabo dentro de la transacción actual.

    Sabiendo cómo funcionan éstos métodos, creo que no es necesario explicar cada método de GenericDaoJpaImpl.


    Creación de un DAO concreto: EmployeeDao


    Dado que todo el trabajo ya lo hace nuestro DAO genérico, no necesitamos especificar nada en nuestros DAOs concretos, tan solo basta extenderlo y llamar al constructor padre para que reciba el tipo de entidad que le pasamos por parámetros al DAO genérico. Veamos:

    Código: Java
    1. package model.dao;
    2.  
    3. import model.entities.Employee;
    4.  
    5. public class EmployeeDao extends GenericDaoJpaImpl<Employee, Short> {
    6.  
    7.         public EmployeeDao() {
    8.                 super();
    9.         }
    10.        
    11. }

    Como se puede observar, extendemos de nuestro DAO genérico pasándole por parámetros nuestra entidad, en este caso, Employee y nuestro tipo de PK, que es en nuestro caso Short. Luego, llamamos al constructor padre para que éste tome los parámetros y se los asigne al elemento T y PK respectivamente. El resultado, un DAO extremadamente pequeño.
    Ahora que ya tenemos nuestro DAO genérico y nuestro DAO concreto para la entidad Employee, procedemos a crear nuestra entidad Employee.


    CREACIÓN DE LA ENTIDAD EMPLOYEE


    Crearemos nuestra entidad Employee:

    Código: Java
    1. package model.entities;
    2.  
    3. import java.io.Serializable;
    4. import java.util.Date;
    5.  
    6. import javax.persistence.Column;
    7. import javax.persistence.Entity;
    8. import javax.persistence.GeneratedValue;
    9. import javax.persistence.GenerationType;
    10. import javax.persistence.Id;
    11. import javax.persistence.Table;
    12. import javax.persistence.Temporal;
    13. import javax.persistence.TemporalType;
    14.  
    15. @Table(name="employees")
    16. public class Employee implements Serializable {
    17.         private static final long serialVersionUID = -4525913610632158800L;
    18.         @GeneratedValue(strategy = GenerationType.IDENTITY)
    19.         @Column(name="id_employee")
    20.         @Id
    21.         private Short id;
    22.         @Column(name="names")
    23.         private String names;
    24.         @Column(name="surnames")
    25.         private String surnames;
    26.         @Temporal(TemporalType.DATE)
    27.         @Column(name="birth_date")
    28.         private Date birthDate;
    29.         @Column(name="dni")
    30.         private String dni;
    31.         @Column(name="address")
    32.         private String address;
    33.         @Column(name="home_phone")
    34.         private String homePhone;
    35.         @Column(name="email")
    36.         private String email;
    37.         @Column(name="active")
    38.         private Boolean active;
    39.        
    40.         public Employee() {}
    41.        
    42.         public Employee(Short id, String names, String surnames, Date birthDate,
    43.                         String dni, String address, String homePhone, String email,
    44.                         Boolean active) {
    45.                 super();
    46.                 this.id = id;
    47.                 this.names = names;
    48.                 this.surnames = surnames;
    49.                 this.birthDate = birthDate;
    50.                 this.dni = dni;
    51.                 this.address = address;
    52.                 this.homePhone = homePhone;
    53.                 this.email = email;
    54.                 this.active = active;
    55.         }
    56.  
    57.         public Short getId() {
    58.                 return id;
    59.         }
    60.  
    61.         public void setId(Short id) {
    62.                 this.id = id;
    63.         }
    64.  
    65.         public String getNames() {
    66.                 return names;
    67.         }
    68.  
    69.         public void setNames(String names) {
    70.                 this.names = names;
    71.         }
    72.  
    73.         public String getSurnames() {
    74.                 return surnames;
    75.         }
    76.  
    77.         public void setSurnames(String surnames) {
    78.                 this.surnames = surnames;
    79.         }
    80.  
    81.         public Date getBirthDate() {
    82.                 return birthDate;
    83.         }
    84.  
    85.         public void setBirthDate(Date date) {
    86.                 this.birthDate = date;
    87.         }
    88.  
    89.         public String getDni() {
    90.                 return dni;
    91.         }
    92.  
    93.         public void setDni(String dni) {
    94.                 this.dni = dni;
    95.         }
    96.  
    97.         public String getAddress() {
    98.                 return address;
    99.         }
    100.  
    101.         public void setAddress(String address) {
    102.                 this.address = address;
    103.         }
    104.  
    105.         public String getHomePhone() {
    106.                 return homePhone;
    107.         }
    108.  
    109.         public void setHomePhone(String homePhone) {
    110.                 this.homePhone = homePhone;
    111.         }
    112.  
    113.         public String getEmail() {
    114.                 return email;
    115.         }
    116.  
    117.         public void setEmail(String email) {
    118.                 this.email = email;
    119.         }
    120.  
    121.         public Boolean getActive() {
    122.                 return active;
    123.         }
    124.  
    125.         public void setActive(Boolean active) {
    126.                 this.active = active;
    127.         }
    128.        
    129.        
    130. }

    Como se puede observar, nuestra entidad Employee es un POJO simple, pero con algunas novedades. Veamos cuáles son:

  • @Entity: indica que la clase es una entidad.
  • @Table: indica que dicha clase es una tabla en la base de datos. Su nombre es especifica por el atributo name.
  • @Column: indica que dicho atributo es una columna en la tabla.
  • @Temporal: indica que dicha columna es de tipo temporal, de tiempo. El atributo TemporalType indica exactamente que tipo de temporal es.
  • @GeneratedValue: indica que hay una generación de valores. Es usada generalmente para especificar una generación para
  • los IDs. El tipo de generación se especifica a través del atributo GenerationType, que puede tomar valores como AUTO, SEQUENCE, IDENTITY, entre otras.
  • @Id: Indica que dicha columna es la llave primaria.

    Ésta entidad representa a la tabla employees de la base de datos y cada instancia de ésta entidad, representa un registro. Es por ésta razón, que cada vez que creemos un objeto Employee representará un registro de la tabla employees y cuando el método create lo persiste, es transformado a una setencia SQL e insertado en la tabla employees.


    CRUD


    Para probar el funcionamiento de nuestro programa, haremos un CRUD básico.

    INSERCIÓN

    Código: Java
    1. import java.util.logging.Logger;
    2.  
    3. import model.dao.EmployeeDao;
    4. import model.entities.Employee;
    5.  
    6. public class Main {
    7.  
    8.         public static void main(String[] args) throws ParseException {
    9.                 try {
    10.                         EmployeeDao employeeDao = new EmployeeDao();
    11.                         Employee employee = new Employee();
    12.                         employee.setNames("Pepito");
    13.                         employee.setSurnames("Pérez");
    14.                         employee.setBirthDate(new SimpleDateFormat("yyyy-MM-dd").parse("1994-03-20"));
    15.                         employee.setDni("12345678");
    16.                         employee.setAddress("Av. que te importa #123");
    17.                         employee.setEmail("[email protected]");
    18.                         employee.setHomePhone("048389483");
    19.                         employee.setActive(true);
    20.                         employeeDao.create(employee);
    21.                 } catch (Exception e) {
    22.                         Logger.getLogger(Main.class.getName()).warning("Something was wrong: "+e.getMessage());
    23.                 } finally {
    24.                         System.exit(0);
    25.                 }
    26.         }
    27.  
    28. }

    Ésta clase es sumamente sencilla. Solo creamos un EmployeeDao y un objeto tipo Employee que es una entidad como ya hemos comentado. Le asignamos valores a las propiedades de la entidad y llamamos al método create de EmployeeDao para guardar dicha entidad en la base de datos.

    Ahora, verifiquemos que se haya insertado el empleado en la base de datos:


    Efectivamente, se ha registrado el objeto en la base de datos.

    LECTURA

    Código: Java
    1. package main;
    2.  
    3. import java.text.ParseException;
    4. import java.text.SimpleDateFormat;
    5. import java.util.logging.Logger;
    6.  
    7. import model.dao.EmployeeDao;
    8. import model.entities.Employee;
    9.  
    10. public class Main {
    11.  
    12.         public static void main(String[] args) throws ParseException {
    13.                 try {
    14.                         EmployeeDao employeeDao = new EmployeeDao();
    15.                         Employee employee = employeeDao.read(new Short("1"));
    16.                         // hacer lo que se desea con el empleado recuperado de la bbdd
    17.                 } catch (Exception e) {
    18.                         Logger.getLogger(Main.class.getName()).warning("Something was wrong: "+e.getMessage());
    19.                 } finally {
    20.                         System.exit(0);
    21.                 }
    22.         }
    23.  
    24. }

    ACTUALIZACIÓN

    Código: Java
    1.  package main;
    2.  
    3. import java.text.ParseException;
    4. import java.util.logging.Logger;
    5.  
    6. import model.dao.EmployeeDao;
    7. import model.entities.Employee;
    8.  
    9. public class Main {
    10.  
    11.         public static void main(String[] args) throws ParseException {
    12.                 try {
    13.                         EmployeeDao employeeDao = new EmployeeDao();
    14.                         Employee employee = employeeDao.read(new Short("1"));
    15.                         employee.setNames("Bugs");
    16.                         employee.setSurnames("Bunny");
    17.                         employeeDao.update(employee);
    18.                 } catch (Exception e) {
    19.                         Logger.getLogger(Main.class.getName()).warning("Something was wrong: "+e.getMessage());
    20.                 } finally {
    21.                         System.exit(0);
    22.                 }
    23.         }
    24.  
    25. }

    De la misma manera que al eliminar un registro, primero obtenemos el empleado objetivo. En éste caso, le cambiamos las propiedades y llamamos al método update(T t) que internamente hace lo mismo que create(T t), es decir, un em.persist(t) que guardará el mismo objeto pero con las nuevas propiedades, es decir, hará un UPDATE en la tabla.

    Verifiquemos que ha actualizado al empleado:


    ELIMINACIÓN

    Código: Java
    1.  package main;
    2.  
    3. import java.text.ParseException;
    4. import java.util.logging.Logger;
    5. import model.dao.EmployeeDao;
    6. import model.entities.Employee;
    7.  
    8. public class Main {
    9.  
    10.         public static void main(String[] args) throws ParseException {
    11.                 try {
    12.                         EmployeeDao employeeDao = new EmployeeDao();
    13.                         Employee employee = employeeDao.read(new Short("1"));
    14.                         employeeDao.delete(employee);
    15.                 } catch (Exception e) {
    16.                         Logger.getLogger(Main.class.getName()).warning("Something was wrong: "+e.getMessage());
    17.                 } finally {
    18.                         System.exit(0);
    19.                 }
    20.         }
    21.  
    22. }

    Verificamos que ha eliminado al usuario:




    -> Próximo capítulo: Relaciones en JPA + ejemplo funcional.


    By Gus.
« Última modificación: Abril 10, 2015, 05:53:00 pm por Gus Garsaky »

 

¿Te gustó el post? COMPARTILO!



Tutorial: Traduccion de aplicaciones JAVA - Moviles [By :: SmartGenius :: ]

Iniciado por ProcessKill

Respuestas: 0
Vistas: 2396
Último mensaje Febrero 24, 2010, 04:26:07 pm
por ProcessKill
[JAVA][MYSQL] Tutorial Basico

Iniciado por LKI

Respuestas: 8
Vistas: 4801
Último mensaje Octubre 06, 2014, 06:21:49 am
por blackdrake
Tutorial Java + Arduino – JAVADUINO

Iniciado por Expermicid

Respuestas: 1
Vistas: 3327
Último mensaje Julio 28, 2013, 01:30:02 pm
por ANTRAX
[Tutorial] Peticiones AJAX a Servlets

Iniciado por Gus Garsaky

Respuestas: 4
Vistas: 7033
Último mensaje Abril 11, 2015, 06:26:34 pm
por Gabriela
[ Java Básico - Tutorial 2 ]

Iniciado por Mr_Pack

Respuestas: 0
Vistas: 1919
Último mensaje Enero 08, 2013, 08:13:36 pm
por Mr_Pack