El uso de un JPA Database schema es bastante habitual . Cuando trabajamos con JPA nos podemos encontrar con dos opciones principales. La primera que el schema de base de datos ya exista y que nosotros únicamente tengamos que adaptarnos a él. En segundo lugar una situación en la que no existe schema de base de datos y utilizaremos nuestros objetos de negocio para generar dicho schema.
JPA DataBase Schema y objetos
Vamos a abordar un ejemplo que se encargue de construir un JPA Database Schema a partir de los objetos de negocio que diseñamos con nuestras clases Java . Para ello el primer paso será configurar las dependencias de maven que el proyecto necesita:
<dependency> <groupId>org.hibernate.javax.persistence</groupId> <artifactId>hibernate-jpa-2.1-api</artifactId> <version>1.0.0.Final</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>5.2.10.Final</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.6</version> </dependency> </dependencies>
El siguiente paso es diseñar los objetos de negocio que vamos a utilizar en nuestro modelo:
package com.arquitecturajava; import java.util.ArrayList; import java.util.List; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.OneToMany; @Entity public class Persona { @Id private String nombre; private String apellidos; private int edad; @OneToMany(mappedBy="persona") private List<Telefono> telefonos= new ArrayList<Telefono>(); public void addTelefono(Telefono telefono) { telefonos.add(telefono); } public List<Telefono> getTelefonos() { return telefonos; } public void setTelefonos(List<Telefono> telefonos) { this.telefonos = telefonos; } public Persona() { super(); } public Persona(String nombre, String apellidos, int edad) { super(); this.nombre = nombre; this.apellidos = apellidos; this.edad = edad; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public String getApellidos() { return apellidos; } public void setApellidos(String apellidos) { this.apellidos = apellidos; } public int getEdad() { return edad; } public void setEdad(int edad) { this.edad = edad; } }
package com.arquitecturajava; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.ManyToOne; @Entity public class Telefono { @Id private String marca; private int nserie; @ManyToOne private Persona persona; public String getMarca() { return marca; } public void setMarca(String marca) { this.marca = marca; } public int getNserie() { return nserie; } public void setNserie(int nserie) { this.nserie = nserie; } }
Una vez que tenemos el modelo de objeto nos queda configurar el persistence.xml para que soporte la generación de schemas.
<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 http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd" version="2.0"> <persistence-unit name="arquitecturajava2"> <properties> <property name="hibernate.show_sql" value="true" /> <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" /> <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" /> <property name="javax.persistence.jdbc.user" value="root" /> <property name="javax.persistence.jdbc.password" value="mysql" /> <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/java2" /> <property name="javax.persistence.schema-generation.database.action" value="drop-and-create" /> </properties> </persistence-unit> </persistence>
En este caso lo hemos configurado para que borre (drop) y vuelve a crear todas las tablas. Para ello hemos tenido que añadir la propiedad javax.persistence.schema-generation.database.action. Una vez hecho esto es suficiente con crear un programa main muy sencillo que invoque el método generate schema:
package com.arquitecturajava; import javax.persistence.Persistence; public class Principal { public static void main(String[] args) { Persistence.generateSchema("arquitecturajava2",null); } }
Una vez ejecutado el programa veremos como se lanzan las diferentes consultas SQL
Como resultado se generarán las diferentes tablas en la base de datos:
Otros artículos relacionados:
¿Corregido? ¿entonces en la clase persona no debería ser?
@OneToMany(mappedBy=”persona”)
private List telefonos= new ArrayList();
gracias , perdona pero a veces uno se lía con los comentarios ,creo que ahora está 🙂 . Son bastantes comentarios a responder cada día y a veces es de artículos de hace 3 años.
gracias por insistir 😉
Hola, buenos días. Antes que nada te felicito por tu página, la verdad muy buena :D. Estuve viendo el código, y me llama la atención en la relación de Teléfono a Persona, no debería ser @ManyToOne private Persona persona en vez de @ManyToOne private Telefono telefono?
Gracias. Saludos!
Corregido , muchas gracias 🙂
Muy bueno el articulo. Podrías hacer otro del proceso inverso. Gracias
gracias , me apunto la idea 😉