Hoy vamos a cambiar un poco, a dejar la teoría y pasar un poco a la práctica para hacer un pequeño recordatorio de cosas básicas. En este caso, vamos a hacer una pequeña aplicación en JPA. Espero que este sea el primero de una serie de artículos sobre “hola mundos” en tecnologías JavaEE y algunos de sus frameworks.

El por qué de estos artículos, es ver de una forma fácil y rápida como crear un proyecto en estas tecnologías, ya que por lo que me he dado cuenta, después de pasar varios años en el mundo laboral, es de que mucha gente siempre llega a grandes proyecto ya empezados y nunca realizan la tarea básica de crear un proyecto desde cero, lo cual les dificulta muchísimo el realizar la parte práctica en entrevistas de trabajo, pro ejemplo. Con esta serie de artículos vamos a intentar ayudar en estas situaciones en las que tenemos que crear un mini proyecto para probar algo en nuestro día a día o para una entrevista, pero nunca hemos hecho uno desde cero.

En el caso de hoy lo vamos a hacer de JPA, ya sabéis el Java Persistance API. Es una capa de persistencia para la BBDD ofrecida por la implementación estándar de JavaEE. Para ello vamos a utilizar Eclipse, Maven y MySQL. Voy a partir de la idea de que lo tenéis todo configurado o de que, con un par de búsquedas en Google, lo tendréis todo fácilmente. Si tenéis algún problema comentadlo y haremos un artículo con la configuración de todo ello o incluso de explicación si es necesario.

Vamos empezar.

Lo primero es crear un proyecto Maven en Eclipse. Nada complejo, creadlo sin arquetipo y sin nada más que el pom.xml y el árbol de carpetas básico.

Lo primero que vamos a hacer es añadir las dependencias básicas del proyecto en el fichero pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.wordpress.infow</groupId>
  <artifactId>jpa</artifactId>
  <version>1.0</version>
  <name>jpa</name>
  <description>JPA Hello World Example</description>
  <url>http://www.infow.wordpress.com</url>

  <dependencies>
    <!-- MySql Connector -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.25</version>
      <scope>runtime</scope>
    </dependency>
    <!-- Hibernate -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>4.2.1.Final</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

El fichero se genera de forma automática. Nosotros tendremos solo que tener un par de cosas en consideración:

• Las dependencias: En este apartado tenemos que añadir las librerías necesarias.
• Plugins: La versión de Java que estamos utilizando (a grandes rasgos)

Lo siguiente que vamos a crear es el fichero “persistence.xml” para configurar nuestra fuente de datos para JPA. Este fichero lo alamacenaremos en “/src/main/resources/META-INF/” y tendrá el siguiente contenido:

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
             version="1.0">
  <persistence-unit name="jpa" transaction-type="RESOURCE_LOCAL">
    <class>com.wordpress.infow.jpa.entity.MessageEntity</class>
    <properties>
      <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
      <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
      <property name="hibernate.connection.username" value="root" />
      <property name="hibernate.connection.password" value="" />
      <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/jpa" />
      <property name="hibernate.hbm2ddl.auto" value="create" />
      <property name="hibernate.show_sql" value="true" />
    </properties>
  </persistence-unit>
</persistence>

En él configuraremos:

• Nombre de la entidad de persistencia: Para poder hacer referencia a ella más tarde.
• Entidades de nuestra aplicación: Aquellas clases de nuestro proyecto que son entidades.
• Propiedades de la conexión: Prestad especial atención a “hibernate.dialect” ya que según la versión de MySQL cambia, y al valor “hibernate.hbm2ddl.auto” que define el comportamiento que se tendrá sobre la BBDD cada vez que ejecutemos. Los posibles valores son:
  • validate: valida en esquema. No realiza cambios en la BBDD.
  • update: actualiza el esquema.
  • create: crea el esquema. Destruye los datos previos.
  • create-drop: borra el esquema al final de la sesión.

Y ya finalmente el código Java. Vamos a implementar una clase Entity que gestionará nuestros mensajes “Hola Mundo” en diferentes idiomas y un fichero “Main” que insertará y recuperará de la BBDD.

Entity

@Entity
@Table(name = "messages")
@NamedQueries({ @NamedQuery(name = "MessageEntity.findAllMessages", query = "select m from MessageEntity m") })
public class MessageEntity {
  @Id
  @GeneratedValue
  private int id;
  private String language;
  private String message;

  public MessageEntity() {

  }

  public MessageEntity(String language, String message) {
    this.language = language;
    this.message = message;
  }

  @Override
  public String toString() {
    return String.format("Language: %s - Message: %s", this.language, this.message);
  }

  /* Getters and Setters */
}

• @Entity: Marcamos el fichero como que pertenece a una entidad.
• @Table: Podemos definir el nombre de la tabla (optativo)
• @NamedQueries: Para definir sentencias a ejecutar
• @Id: Marca el campo como ID
• @GeneratedValue: Lo marca como un autoincremental gestionado.

Main

//@SuppressWarnings("unchecked")
public static void main(String[] args) {
  EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa");
  EntityManager em = emf.createEntityManager();

  em.getTransaction().begin();

  MessageEntity es = new MessageEntity("es", "¡Hola Mundo!");
  MessageEntity en = new MessageEntity("en", "Hello World!");
  MessageEntity de = new MessageEntity("de", "Hallo Welt!");

  MessageEntity[] messages = new MessageEntity[] { es, en, de };
  for (MessageEntity message : messages) {
    em.persist(message);
  }

  em.getTransaction().commit();

  //Query query = em.createNamedQuery("MessageEntity.findAllMessages");
  TypedQuery<MessageEntity> query = em.createNamedQuery("MessageEntity.findAll", MessageEntity.class);
  List<MessageEntity> messagesList = query.getResultList();
  for (MessageEntity messageEntity : messagesList) {
    System.out.println(messageEntity.toString());
  }
}

• EntityManagerFactory: Creamos el objeto con los datos de nuestra unidad de persistencia. (fichero persistence.xml).
• EntitytManager: Creamos el objeto para trabajar con él y con las transacciones.
• em.persist(…): Salva el objeto en la BBDD.
• Las últimas lineas recuperan los mensajes de la BBDD ejecutando la query que hemos definido.

A parte, os dejo el código para que podáis echarle un ojo y deplegarlo en vuestros servidores.

Código JPA Hello World: JPA

Se que la explicación del código ha sido un poco rápida, pero como ya he dicho al principio del artículo, el objetivo no es aprender JPA, sino a hacer un proyecto desde cero. Espero que os sirva. Un saludo.

[Actualización] Gracias al amigo “facundodonato” que me ha recordado la existencia de las “TypeQuery” he eliminado del código el “@SuppressWarnings” dejándolo un poco mejor. Como podéis ver en el código del Main, he dejado comentadas la opción anterior. [/Actualización]