comment
IRC Chat
play_arrow
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
  • 2340 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:

• No tienes permisos para ver links. Registrate o Entra con tu cuenta
• No tienes permisos para ver links. Registrate o Entra con tu cuenta
• No tienes permisos para ver links. Registrate o Entra con tu cuenta (opcional, porque usaremos Maven).
• No tienes permisos para ver links. Registrate o Entra con tu cuenta
• No tienes permisos para ver links. Registrate o Entra con tu cuenta (opcional, usaremos Maven).
• No tienes permisos para ver links. Registrate o Entra con tu cuenta

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: No tienes permisos para ver links. Registrate o Entra con tu cuenta
PERFORMANCE_SCHEMA=0
Ahora, abrimos la terminal como Administrador y nos dirigimos hacia “bin”. Aquí ejecutaremos el comando:

Código: No tienes permisos para ver links. Registrate o Entra con tu cuenta
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 No tienes permisos para ver links. Registrate o Entra con tu cuenta;
    7.         T read(PK id) throws No tienes permisos para ver links. Registrate o Entra con tu cuenta;
    8.         T update(T t) throws No tienes permisos para ver links. Registrate o Entra con tu cuenta;
    9.         void delete(T t) throws No tienes permisos para ver links. Registrate o Entra con tu cuenta;
    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 No tienes permisos para ver links. Registrate o Entra con tu cuenta {
    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 No tienes permisos para ver links. Registrate o Entra con tu cuenta {
    35.                 return em.find(clazz, id);
    36.         }
    37.  
    38.         @Override
    39.         public T update(T t) throws No tienes permisos para ver links. Registrate o Entra con tu cuenta {
    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 No tienes permisos para ver links. Registrate o Entra con tu cuenta {
    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. @No tienes permisos para ver links. Registrate o Entra con tu cuenta
    16. @Table(name="employees")
    17. public class Employee implements No tienes permisos para ver links. Registrate o Entra con tu cuenta {
    18.         private static final long serialVersionUID = -4525913610632158800L;
    19.         @GeneratedValue(strategy = GenerationType.IDENTITY)
    20.         @Column(name="id_employee")
    21.         @Id
    22.         private No tienes permisos para ver links. Registrate o Entra con tu cuenta id;
    23.         @Column(name="names")
    24.         private No tienes permisos para ver links. Registrate o Entra con tu cuenta names;
    25.         @Column(name="surnames")
    26.         private No tienes permisos para ver links. Registrate o Entra con tu cuenta surnames;
    27.         @Temporal(TemporalType.DATE)
    28.         @Column(name="birth_date")
    29.         private No tienes permisos para ver links. Registrate o Entra con tu cuenta birthDate;
    30.         @Column(name="dni")
    31.         private No tienes permisos para ver links. Registrate o Entra con tu cuenta dni;
    32.         @Column(name="address")
    33.         private No tienes permisos para ver links. Registrate o Entra con tu cuenta address;
    34.         @Column(name="home_phone")
    35.         private No tienes permisos para ver links. Registrate o Entra con tu cuenta homePhone;
    36.         @Column(name="email")
    37.         private No tienes permisos para ver links. Registrate o Entra con tu cuenta email;
    38.         @Column(name="active")
    39.         private No tienes permisos para ver links. Registrate o Entra con tu cuenta active;
    40.        
    41.         public Employee() {}
    42.        
    43.         public Employee(No tienes permisos para ver links. Registrate o Entra con tu cuenta id, No tienes permisos para ver links. Registrate o Entra con tu cuenta names, No tienes permisos para ver links. Registrate o Entra con tu cuenta surnames, No tienes permisos para ver links. Registrate o Entra con tu cuenta birthDate,
    44.                         No tienes permisos para ver links. Registrate o Entra con tu cuenta dni, No tienes permisos para ver links. Registrate o Entra con tu cuenta address, No tienes permisos para ver links. Registrate o Entra con tu cuenta homePhone, No tienes permisos para ver links. Registrate o Entra con tu cuenta email,
    45.                         No tienes permisos para ver links. Registrate o Entra con tu cuenta active) {
    46.                 super();
    47.                 this.id = id;
    48.                 this.names = names;
    49.                 this.surnames = surnames;
    50.                 this.birthDate = birthDate;
    51.                 this.dni = dni;
    52.                 this.address = address;
    53.                 this.homePhone = homePhone;
    54.                 this.email = email;
    55.                 this.active = active;
    56.         }
    57.  
    58.         public No tienes permisos para ver links. Registrate o Entra con tu cuenta getId() {
    59.                 return id;
    60.         }
    61.  
    62.         public void setId(No tienes permisos para ver links. Registrate o Entra con tu cuenta id) {
    63.                 this.id = id;
    64.         }
    65.  
    66.         public No tienes permisos para ver links. Registrate o Entra con tu cuenta getNames() {
    67.                 return names;
    68.         }
    69.  
    70.         public void setNames(No tienes permisos para ver links. Registrate o Entra con tu cuenta names) {
    71.                 this.names = names;
    72.         }
    73.  
    74.         public No tienes permisos para ver links. Registrate o Entra con tu cuenta getSurnames() {
    75.                 return surnames;
    76.         }
    77.  
    78.         public void setSurnames(No tienes permisos para ver links. Registrate o Entra con tu cuenta surnames) {
    79.                 this.surnames = surnames;
    80.         }
    81.  
    82.         public No tienes permisos para ver links. Registrate o Entra con tu cuenta getBirthDate() {
    83.                 return birthDate;
    84.         }
    85.  
    86.         public void setBirthDate(No tienes permisos para ver links. Registrate o Entra con tu cuenta date) {
    87.                 this.birthDate = date;
    88.         }
    89.  
    90.         public No tienes permisos para ver links. Registrate o Entra con tu cuenta getDni() {
    91.                 return dni;
    92.         }
    93.  
    94.         public void setDni(No tienes permisos para ver links. Registrate o Entra con tu cuenta dni) {
    95.                 this.dni = dni;
    96.         }
    97.  
    98.         public No tienes permisos para ver links. Registrate o Entra con tu cuenta getAddress() {
    99.                 return address;
    100.         }
    101.  
    102.         public void setAddress(No tienes permisos para ver links. Registrate o Entra con tu cuenta address) {
    103.                 this.address = address;
    104.         }
    105.  
    106.         public No tienes permisos para ver links. Registrate o Entra con tu cuenta getHomePhone() {
    107.                 return homePhone;
    108.         }
    109.  
    110.         public void setHomePhone(No tienes permisos para ver links. Registrate o Entra con tu cuenta homePhone) {
    111.                 this.homePhone = homePhone;
    112.         }
    113.  
    114.         public No tienes permisos para ver links. Registrate o Entra con tu cuenta getEmail() {
    115.                 return email;
    116.         }
    117.  
    118.         public void setEmail(No tienes permisos para ver links. Registrate o Entra con tu cuenta email) {
    119.                 this.email = email;
    120.         }
    121.  
    122.         public No tienes permisos para ver links. Registrate o Entra con tu cuenta getActive() {
    123.                 return active;
    124.         }
    125.  
    126.         public void setActive(No tienes permisos para ver links. Registrate o Entra con tu cuenta active) {
    127.                 this.active = active;
    128.         }
    129.        
    130.        
    131. }

    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(No tienes permisos para ver links. Registrate o Entra con tu cuenta[] args) throws No tienes permisos para ver links. Registrate o Entra con tu cuenta {
    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 No tienes permisos para ver links. Registrate o Entra con tu cuenta("yyyy-MM-dd").parse("1994-03-20"));
    15.                         employee.setDni("12345678");
    16.                         employee.setAddress("Av. que te importa #123");
    17.                         employee.setEmail("pepito.perez@outlook.com");
    18.                         employee.setHomePhone("048389483");
    19.                         employee.setActive(true);
    20.                         employeeDao.create(employee);
    21.                 } catch (No tienes permisos para ver links. Registrate o Entra con tu cuenta e) {
    22.                         Logger.getLogger(Main.class.getName()).warning("Something was wrong: "+e.getMessage());
    23.                 } finally {
    24.                         No tienes permisos para ver links. Registrate o Entra con tu cuenta.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(No tienes permisos para ver links. Registrate o Entra con tu cuenta[] args) throws No tienes permisos para ver links. Registrate o Entra con tu cuenta {
    13.                 try {
    14.                         EmployeeDao employeeDao = new EmployeeDao();
    15.                         Employee employee = employeeDao.read(new No tienes permisos para ver links. Registrate o Entra con tu cuenta("1"));
    16.                         // hacer lo que se desea con el empleado recuperado de la bbdd
    17.                 } catch (No tienes permisos para ver links. Registrate o Entra con tu cuenta e) {
    18.                         Logger.getLogger(Main.class.getName()).warning("Something was wrong: "+e.getMessage());
    19.                 } finally {
    20.                         No tienes permisos para ver links. Registrate o Entra con tu cuenta.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(No tienes permisos para ver links. Registrate o Entra con tu cuenta[] args) throws No tienes permisos para ver links. Registrate o Entra con tu cuenta {
    12.                 try {
    13.                         EmployeeDao employeeDao = new EmployeeDao();
    14.                         Employee employee = employeeDao.read(new No tienes permisos para ver links. Registrate o Entra con tu cuenta("1"));
    15.                         employee.setNames("Bugs");
    16.                         employee.setSurnames("Bunny");
    17.                         employeeDao.update(employee);
    18.                 } catch (No tienes permisos para ver links. Registrate o Entra con tu cuenta e) {
    19.                         Logger.getLogger(Main.class.getName()).warning("Something was wrong: "+e.getMessage());
    20.                 } finally {
    21.                         No tienes permisos para ver links. Registrate o Entra con tu cuenta.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(No tienes permisos para ver links. Registrate o Entra con tu cuenta[] args) throws No tienes permisos para ver links. Registrate o Entra con tu cuenta {
    11.                 try {
    12.                         EmployeeDao employeeDao = new EmployeeDao();
    13.                         Employee employee = employeeDao.read(new No tienes permisos para ver links. Registrate o Entra con tu cuenta("1"));
    14.                         employeeDao.delete(employee);
    15.                 } catch (No tienes permisos para ver links. Registrate o Entra con tu cuenta e) {
    16.                         Logger.getLogger(Main.class.getName()).warning("Something was wrong: "+e.getMessage());
    17.                 } finally {
    18.                         No tienes permisos para ver links. Registrate o Entra con tu cuenta.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: 1546
Último mensaje Febrero 24, 2010, 04:26:07 pm
por ProcessKill
[JAVA][MYSQL] Tutorial Basico

Iniciado por LKI

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

Iniciado por Expermicid

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

Iniciado por Gus Garsaky

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

Iniciado por Mr_Pack

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