Diferencias

Muestra las diferencias entre dos versiones de la página.

--- apuntes:hibernate [2019/02/03 14:33] – [Mapeado de las relaciones con atributos Java] fernando
+++ apuntes:hibernate [2024/09/16 16:03] (actual) – editor externo 127.0.0.1
@@ Línea 117: / Línea 117: @@
     <property name="hibernate.connection.username">usuario</property>
     <property name="hibernate.connection.password">contraseña</property>
-    <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
+    <property name="hibernate.dialect">org.hibernate.dialect.MySQL55Dialect</property>
     <!--muestra las consultas por consola -->
@@ Línea 245: / Línea 245: @@
 configuracion.setProperty("hibernate.connection.username", "root");
 configuracion.setProperty("hibernate.connection.password", "");
-configuracion.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");
+configuracion.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL55Dialect");
 configuracion.setProperty("Hibernate.show_sql", "true");
@@ Línea 263: / Línea 263: @@
 <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/basededatos?createDatabaseIfNotExist=true</property>
 ...
-<property name="hibernate.hbm2ddl.auto">create</property>
+<property name="hibernate.hbm2ddl.auto">update</property>
 </code>
-Si ya existe la base de datos, también puedo modificar su estructura, en caso de haber algún cambio en las anotaciones de las clases. Para ello uso la palabra ''update'' en lugar de ''create''.
+Puedo utilizar //create// o //update//. //Create// crea la base de datos completa. //Update// la crea si no existe, y si ya existe simplemente modifica los cambios que haya en su estructura.
+Si quiero crear las claves ajenas de forma correcta, me interesa que el motor de datos de la base de datos sea //InnoDB//.
 ==== Pool de conexiones ====
 Cuando un programa trabaja con una bbdd se deben abrir y cerrar conexiones con ella, y si el programa permite conectar diversos clientes, nos encontramos con el problema de conectar y desconectar conexiones a la base de datos. Un //pool// de conexiones es un conjunto (pool) de conexiones ya conectadas a la base de datos que puedan ser reutilizadas entre distintas peticiones.
@@ Línea 616: / Línea 618: @@
 {{ youtube>w1-Zm9DCmTY }}
-\\
+> Operaciones CRUD con hibernate
+==== Consideraciones sobre mapeo de relaciones====
+Cuando realizamos relaciones bi-direccionales de las clases, desde Java podemos acceder a los elementos relacionados desde cualquier de los dos objetos de una relación. Para ello utilizaremos atributos únicos en el lado de ''@ManytoOne'' y colecciones (List, Set, Map) para el lado de ''@OneToMany'' o ''@ManyToMany''.
+Aunque las relaciones sean bidireccionales, hibernate enfoca las relaciones desde una jerarquía //**padre-hijo**//. Para asegurarnos de mantener la relaciones de forma correcta en la base de datos, añadiremos a las clases mapeadas una serie de //métodos utilitarios//.
+===Relaciones 1:N===
+En las relaciones ''@OneToMany'' y ''@ManyToOne'' es recomendable que contenga algunos métodos utilitarios para mantener las relaciones:
+<code java>
+@Entity
+@Table(name = "armas")
+public class Arma {
+  . . .
+  private List<Personaje> personajes;
+  . . .
+  @OneToMany(mappedBy = "arma", cascade = CascadeType.ALL)
+  public List<Personaje> getPersonajes() { return personajes; }
+  . . .
+  //Métodos utilitarios
+  //Añadir/Eliminar un personajes
+  public void addPersonaje(Personaje personaje){
+     personajes.add(personaje);
+     personaje.setArma(this);
+  }
+  public void removePersonaje(Personaje personaje){
+     personaje.setArma(null);
+     personajes.remove(personaje);
+  }
+  //Añadir varios (también puedo tener un método de eliminar varios)
+  public void addPersonajes(Collection<Personaje> personajes){
+     for(Personaje personaje : personajes){
+        personaje.setArma(this);
+     }
+     this.parsonajes.addAll(personajes);
+  }
+  . . .
+}
+</code>
+**Los métodos anteriores también se deben codificar en la clase //Personaje//.**
+Además en esta clase //padre//, cuando borramos un arma también se borrarán los personajes relacionados con dicho arma en la base de datos, para mantener la integridad de las claves ajenas (personaje.id_arma). Si queremos que al borrar un arma no se borren los personajes en cascada, primero podemos eliminar las relaciones del arma con los personajes, antes de borrar el arma. Podemos realizarlo con un método utilitario:
+<code java>
+  . . .
+  public void removeAllPersonajes(){
+     //Desvinculo todos los personajes con este arma
+     for(Personaje personaje : personajes){
+        persona.setArma(null);
+     }
+     personajes.clear();   //Vacio la coleccion
+  }
+  . . .
+</code>
+===Relaciones N:M===
+En las relaciones @ManytoMany ambas clases funcionan como //padre// y también como //hijo//. También creamos //métodos utilitarios// para matener la integridad de las relaciones en la base de datos.
+<code java>
+@Entity
+@Table(name = "armas")
+public class Arma {
+  . . .
+  private Set<Enemigo> enemigos;
+  . . .
+  @ManyToMany(mappedBy = "armas", cascade = CascadeType.DETACH)
+  public Set<Enemigo> getEnemigos() { return enemigos; }
+  . . .
+  //Métodos utilitarios
+  //Para añadir/eliminar uno
+  public void addEnemigo(Enemigo enemigo){
+     enemigo.getArmas().add(this);
+     enemigos.add(enemigo);
+  }
+  public void removeEnemigo(Enemigo enemigo){
+     enemigo.getArmas.remove(this);
+     enemigos.remove(enemigo);
+  }
+  //Para añadir/eliminar varios
+  public void addEnemigos(Collection<Enemigo> enemigos){
+     for(Enemigo enemigo : enemigos){
+        enemigo.getArmas().add(this);
+     }
+     this.enemigos.addAll(enemigos);
+  }
+  public void removeEnemigos(Collection<Enemigo> enemigos){
+     for(Enemigo enemigo: enemigos){
+        enemigo.getArmas().remove(this);
+     }
+     this.enemigos.removeAll(enemigos);
+  }
+  //Eliminar las relaciones con este arma
+  public void removeAllEnemigos(Collection<Enemigo> enemigos){
+     for(Enemigo enemigo: enemigos){
+        enemigo.getArmas().remove(this);
+     }
+     this.enemigos.clear();
+  }
+  . . .
+}
+</code>
+**También debemos incluir los métodos en la clase //Enemigo//.**
+Otro aspecto a tener en cuenta en las relaciones ''@ManyToMany'' es el uso de colecciones tipo ''Set<>'', ya que favorecen el rendimiento respecto a colecciones de tipo ''List<>''. Hibernate necesita lanzar más consultas para las eliminaciones o inserciones usando una lista, frente a un conjunto.
+Del mismo modo, si queremos crear el esquema de la base de datos a partir de las clases mapeadas, **solo usando colecciones tipo ''Set'' se crean las claves primarias de la tabla de relación.**
 ===== Proyectos de ejemplo =====
   * [[https://bitbucket.org/fvaldeon/accesodatosud3/src| Repositorio de bitbucket]] con ejemplos y los proyectos realizados en clase (Fernando)