El desfase objeto-relacional surge cuando en el desarrollo de una aplicación con un lenguaje orientado a objetos se hace uso de una base de datos relacional. Hay que tener en cuenta que esta situación se da porque tanto los lenguajes orientados a objetos como las bases de datos relacionales están ampliamente extendidas.

En cuanto al desfase, ocurre que en nuestra aplicación Java (como ejemplo de lenguaje Orientada a Objetos) tendremos, por ejemplo, la definición de una clase cualquiera con sus atributos y métodos:

public class Personaje {
  private int id;
  private String nombre;
  private String descripcion;
  private int vida;
  private int ataque;
 
  public Personaje(. . .) {
    . . .
  }
 
  // getters y setters
}

Mientras que en la base de datos tendremos una tabla cuyos campos se tendrán que corresponder con los atributos que hayamos definido anteriormente en esa clase. Puesto que son estructuras que no tienen nada que ver entre ellas, tenemos que hacer el mapeo manualmente, haciendo coincidir (a través de los getters o setters) cada uno de los atributos con cada uno de los campos (y vicerversa) cada vez que queramos leer o escribir un objeto desde y hacia la base de datos, respectivamente.

CREATE TABLE personajes (
  id INT PRIMARY KEY AUTO_INCREMENT;
  nombre VARCHAR(50) NOT NULL,
  descripcion VARCHAR(50),
  vida INT DEFAULT 10,
  ataque INT DEFAULT 10;
);

Eso hace que tengamos que estar continuamente descomponiendo los objetos para escribir la sentencia SQL para insertar, modificar o eliminar, o bien recomponer todos los atributos para formar el objeto cuando leamos algo de la base de datos.

Mapeo Objeto-Relacional (ORM)

Por ejemplo, si trabajamos directamente con JDBC tendremos que descomponer el objeto para construir la sentencia INSERT del siguiente ejemplo

. . .				
String sentenciaSql = "INSERT INTO personajes (nombre, descripcion, vida, ataque)" +
  ") VALUES (?, ?, ?, ?)";
PreparedStatement sentencia = conexion.prepareStatement(sentenciaSql);
sentencia.setString(1, personaje.getNombre());
sentencia.setString(2, personaje.getDescripcion());
sentencia.setInt(3, personaje.getVida());
sentencia.setInt(4, personaje.getAtaque());
sentencia.executeUpdate();
 
if (sentencia != null)
  sentencia.close();
. . .

Si contamos con un framework como Hibernate, esta misma operación se traduce en unas pocas líneas de código en las que podemos trabajar directamente con el objeto Java, puesto que el framework realiza el mapeo en función de las anotaciones que hemos implementado a la hora de definir la clase, que le indican a éste con que tabla y campos de la misma se corresponde la clase y sus atributos, respectivamente.

@Entity
@Table(name="personajes")
public class Personaje {
  @Id // Marca el campo como la clave de la tabla
  @GeneratedValue(strategy = IDENTITY)
  @Column(name="id")
  private int id;
  @Column(name="nombre")
  private String nombre;
  @Column(name="descripcion")
  private String descripcion;
  @Column(name="vida")
  private int vida;
  @Column(name="ataque")
  private int ataque;
 
  public Personaje(. . .) {
    . . .
  }
 
  // getters y setters
}

Así, podemos simplemente establecer una sesión con la Base de Datos y enviarle el objeto, en este caso invocando al método save que se encarga de registrarlo en la Base de Datos donde convenga según sus propias anotaciones.

. . .
sesion = HibernateUtil.getCurrentSession();
sesion.beginTransaction();
sesion.save(personaje);
sesion.getTransaction().commit();
. . .

En nuestro caso usaremos Hibernate como librería ORM, concretamente Hibernate 5.2. Habrá que tenerlo en cuenta puesto que algunas clases/métodos pueden variar entre diferentes versiones de este framework, especialmente a la hora de configurar (hibernate.cfg.xml) e implementar el gestor de sesiones (HibernateUtil.java)

El fichero de configuración de hibernate hibernate.cfg.xml se debe crear directamente dentro de la carpeta src del proyecto y el propio framework Hibernate será el encargado de leerlo para obtener las sesiones que permitan conectar con la Base de Datos con el código que se implementa en el fichero HibernateUtil.java que se muestra justo después del primero.

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
           "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 
<hibernate-configuration>
  <session-factory>
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/basededatos</property>
    <property name="hibernate.connection.username">usuario</property>
    <property name="hibernate.connection.password">contraseña</property>
    <property name="hibernate.dialect">org.hibernate.dialect.MySQL55Dialect</property>
 
    <!--muestra las consultas por consola -->
    <property name="hibernate.show_sql">true</property>
 
    <!--Configuracion de libreria C3P0 para gestionar el pool de conexiones  -->
    <property name="c3p0.acquire_increment">1</property>
    <property name="c3p0.idle_test_period">100</property>
    <property name="c3p0.max_size">5</property>
    <property name="c3p0.max_statements">10</property>
    <property name="c3p0.min_size">2</property>
    <property name="c3p0.timeout">200</property>
  </session-factory>
</hibernate-configuration>

Todas las configuraciones anteriores también se pueden indicar mediante código Java en el siguiente fichero, como veremos más adelante.

HibernateUtil.java

public class HibernateUtil {
 
  private static SessionFactory sessionFactory;
  private static Session session;
 
  /**
   * Crea la factoria de sesiones
   */
  public static void buildSessionFactory() {
 
    Configuration configuration = new Configuration();
    // La llamada al método configure() carga los parámetros del fichero hibernate.cfg.xml
    configuration.configure();
 
    // Se registran las clases que hay que mapear con cada tabla de la base de datos
    configuration.addAnnotatedClass(Clase1.class);
    configuration.addAnnotatedClass(Clase2.class);
    configuration.addAnnotatedClass(Clase3.class);
    . . .
    //Se crea una SessionFactory a partir del objeto Configuration
    ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(
      configuration.getProperties()).build();
    sessionFactory = configuration.buildSessionFactory(serviceRegistry);
  }
 
  /**
   * Abre una nueva sesión
   */
  public static void openSession() {
    session = sessionFactory.openSession();
  }
 
  /**
   * Devuelve la sesión actual
   * @return
   */
  public static Session getCurrentSession() {
 
    if ((session == null) || (!session.isOpen()))
      openSession();
 
    return session;
  }
 
  /**
   * Cierra Hibernate
   */
  public static void closeSessionFactory() {
 
    if (session != null)
      session.close();
 
    if (sessionFactory != null)
      sessionFactory.close();
  }
}

Si no uso un fichero de configuración xml, no necesito llamar al método configure()

Si tenemos distintos valores de configuración para conectar con diferentes sistemas de bases de datos, necesitamos diferentes ficheros de configuración (p.e. mysql.cfg.xml, postgre.cfg.xml, mssqlserver.cfg.xml, etc).

Por ejemplo, para conectar con postgreSQL, el fichero de configuración sería:

...
 
<hibernate-configuration>
  <session-factory>
    <property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
    <property name="hibernate.connection.url">jdbc:postgresql://localhost:5432/baseDatos</property>
    <property name="hibernate.connection.username">usuario</property>
    <property name="hibernate.connection.password">password</property>
    <property name="hibernate.dialect">org.hibernate.dialect.PostgreSQL9Dialect</property>
 
    <!-- la configuracion de C3P0 es la misma -->
...
 
 
  </session-factory>
</hibernate-configuration>

En ellos indicaremos los parámetros y propiedades de la conexión con dicho sgbd. En el método que configura la SessiónFactory deberemos indicar por parámetro el fichero necesario en cada caso:

SessionFactory postgreSF = configuration.configure("postgre.cfg.xml").buildSessionFactory();
SessionFactory msSF = configuration.configure("mssqlserver.cfg.xml").buildSessionFactory();

Si deseo cambiar los parámetros de configuración en tiempo de ejecución en lugar de usar un fichero xml de configuración, también puedo indicárselo mediante el código Java en el fichero HibernateUtil.java. Indico las propiedades con los mismos valores que en hibernate.cfg.xml.

En el siguiente enlace podemos ver el significado de las propiedades que podemos configurar en Hibernate, y también del gestor del pool de conexiones C3P0. http://docs.jboss.org/hibernate/orm/5.2/userguide/html_single/Hibernate_User_Guide.html#configurations

Configuration configuracion = new Configuration();
 
//Propiedades de Hibernate
configuracion.setProperty("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
configuracion.setProperty("hibernate.connection.url", "jdbc:mysql://localhost/bbdd");
configuracion.setProperty("hibernate.connection.username", "root");
configuracion.setProperty("hibernate.connection.password", "");
configuracion.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL55Dialect");
configuracion.setProperty("Hibernate.show_sql", "true");
 
//Propiedades del gestor de conexiones C3P0
configuracion.setProperty("hibernate.c3p0.acquire_increment", "1");
configuracion.setProperty("hibernate.c3p0.idle_test_period", "100");
configuracion.setProperty("hibernate.c3p0.max_size", "5");
configuracion.setProperty("hibernate.c3p0.max_statements", "10");
configuracion.setProperty("hibernate.c3p0.min_size", "2");
configuracion.setProperty("hibernate.c3p0.timeout", "200");

Hibernate también permite crear la base de datos en nuestro SGBD cuando ya tengo las clases de Java mapeadas con las anotaciones. Para ello basta con incluir la siguiente propiedad en el fichero de configuración hibernate.cfg.xml:

...
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/basededatos?createDatabaseIfNotExist=true</property>
...
<property name="hibernate.hbm2ddl.auto">update</property>

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.

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.

Por defecto, Hibernate cuenta con un pool de conexiones muy simple, pero el mismo Hibernate desaconseja su uso fuera de un entorno de pruebas. En nuestro caso usaremos las librerías C3P0 por ser ampliamente usadas en diversos proyectos y ser de código abierto. Estas librerías están incluidas en la descarga del paquete completo de Hibernate (libs→hibernate→optional):

• c3p0-0.9.5.2.jar
• mchange-commons-java-0.2.11.jar
• hibernate-c3p0-5.2.12.jar

Como hemos visto en el fichero hibernate.cfg.xml, podemos configurar ciertas propiedades de este gestor de conexiones; a continuación se indica el significado de algunas de sus propiedades:

• acquireIncrement Determina cuantas conexiones intentará adquirir C3P0 cuando se saturen las conexiones del pool.
• idleTestPeriod Si este numero es mayor que 0, C3P0 hará una prueba en todas las conexiones que estén dormidas pero sigan en el pool cada X segundos para permitir que sigan activas.
• max_size indica el número máximo de conexiones que podrá tener en cualquier momento el pool. Si no se indica esta propiedad, hibernate no utiliza el connection pool de C3P0.
• min_size indica el número mínimo de conexiones que podrá tener en cualquier momento el pool
• timeout es el número de segundos que una conexión puede estar en el pool sin ser utilizada antes de ser descartada o eliminada. Un cero indica que nunca se descartarán.
• max_statements indica el tamaño del caché de PreparedStatements que guardará C3P0. Un cero indica que el caché está deshabilitado.

En el caso de las entidades, se deben anotar tanto la propia clase como cada uno de los atributos (se puede hacer en el atributo o en su getter/setter) para indicar con qué tabla mapearla y cómo mapear los atributos con los campos que corresponda, respectivamente.

Las anotaciones que nos podemos encontrar para anotar una clase Java que debe ser mapeada con una tabla son:

• @Entity Indica que la clase es una tabla en la base de datos
• @Table(name = “nombre_tabla”, catalog = “nombre_base_datos”) Indica el nombre de la tabla y la base de datos a la que pertenece (este último parámetro no es necesario ya que esa información viene en el fichero de configuración)

En el caso de los atributos simples que deben ser mapeados con los campos de la tabla correspondiente:

• @Id Indica que un atributo es la clave
• @GeneratedValue(strategy = GenerationType.IDENTITY) Indica que es un valor autonumérico (PRIMARY KEY en MySQL, por ejemplo)
• @Column(name = “nombre_columna”) Se utiliza para indicar el nombre de la columna en la tabla donde debe ser mapeado el atributo

@Entity
@Table(name = "actor", catalog = "db_peliculas")
public class Actor {
 
  private Integer id;
  private String nombre;
  private Date fechaNacimiento;
 
  // Constructor/es
  public Actor() { . . .}
  . . .
 
  @Id
  @GeneratedValue(strategy = IDENTITY)
  @Column(name = "id")
  public Integer getId() {
    return this.id;
  }
 
  public void setId(Integer id) {
    this.id = id;
  }
 
  @Column(name = "nombre")
  public String getNombre() {
    return this.nombre;
  }
 
  public void setNombre(String nombre) {
    this.nombre = nombre;
  }
 
  @Column(name = "fecha_nacimiento")
  public Date getFechaNacimiento() {
    return this.fechaNacimiento;
  }
 
  public void setFechaNacimiento(Date fechaNacimiento) {
    this.fechaNacimiento = fechaNacimiento;
  }
 
  . . .
 
  // El resto de métodos se implementan como siempre
  @Override
  public String toString() {
    return nombre;
  }
 
  . . .
}

Para el mapeo de las relaciones, además de crear el correspondiente objeto que permita mantener la relación entre las clases (de forma bidireccional), éstos atributos deben ser mapeados según convenga. Para todos los casos, en ambos casos se indicará el tipo de relación visto desde el lado correspondiente pero sólo se codificará la información de mapeo en uno de los lados:

• @OneToOne Indica que el objeto es parte de una relación 1-1
• @ManyToOne Indica que el objeto es parte de una relación N-1. En este caso el atributo sería el lado 1
• @OneToMany Indica que el objeto es parte de una relación 1-N. En este caso el atributo sería el lado N
• @ManyToMany Indica que el objeto es parte de una relación N-M. En este caso se indica la tabla que mantiene la referencia entre las tablas y los campos que hacen el papel de claves ajenas en la base de datos

En el otro lado de la relación indicaremos el tipo de relación acompañado de la anotación @MappedBy añadiendo el atributo de la otra clase donde se especifica toda la información sobre el mapeo

@Entity
@Table(name = "personajes")
public class Personaje {
 
  . . .
  private Arma arma;
  . . .
  @OneToOne(cascade = CascadeType.ALL)
  @PrimaryKeyJoinColumn
  public Arma getArma() { return arma; }
  . . .
}

@Entity
@Table(name = "armas")
public class Arma {
 
  . . .
  private Personaje personaje;
  . . .
  @OneToOne(cascade = CascadeType.ALL)
  @PrimaryKeyJoinColumn
  public Personaje getPersonaje() { return personaje; }
  . . .
}

@Entity
@Table(name = "personajes")
public class Personaje {
  . . .
  private Arma arma;
  . . .
  @ManyToOne
  @JoinColumn(name="id_arma")
  public Arma getArma() { return arma; }
  . . .
}

@Entity
@Table(name = "armas")
public class Arma {
  . . .
  private List<Personaje> personajes;
  . . .
  @OneToMany(mappedBy = "arma", cascade = CascadeType.ALL)
  public List<Personaje> getPersonajes() { return personajes; }
  . . .

@Entity
@Table(name = "enemigos")
public class Enemigo {
  . . .
  private List<Arma> armas;
  . . .
  // Cuando se elimine un personaje se desvínculará el arma pero ésta no se borrará (DETACH)
  @ManyToMany(cascade = CascadeType.DETACH) 
  @JoinTable(name="enemigo_arma", 
    joinColumns={@JoinColumn(name="id_enemigo")}, 
    inverseJoinColumns={@JoinColumn(name="id_arma")})
  public List<Arma> getArmas() { return armas; }
  . . .
}

@Entity
@Table(name = "armas")
public class Arma {
  . . .
  private List<Enemigo> enemigos;
  . . .
  @ManyToMany(mappedBy = "armas", cascade = CascadeType.DETACH)
  public List<Enemigo> getEnemigos() { return enemigos; }
  . . .
}

Mapeado de una base de datos usando el pluggin de Hibernate

En el repositorio de bitbucket de este tema se pueden encontrar proyectos que muestran cómo mapear clases para los 3 tipos de relaciones:

• HibernateRelacion1a1 Muestra cómo mapear dos clases cuyas tablas mantienen una relación 1-1
• HibernateRelacion1aN Muestra cómo mapear dos clases cuyas tablas mantienen una relación 1-N
• HibernateRelacionNaM Muestra cómo mapear dos clases cuyas tablas mantienen una relación N-M

Para registrar un nuevo objeto en la Base de Datos necesitamos haber creado previamente la clase y haberla mapeado correctamente con la tabla que le corresponda. Entonces, utilizando la clase HibernateUtil podremos obtener una sesión (conexión con la Base de Datos) para registrar ese objeto directamente en la Base de Datos de la siguiente forma.

. . .
UnaClase unObjeto = new UnaClase();
. . .
Session sesion = HibernateUtil.getCurrentSession();
sesion.beginTransaction();
sesion.saveOrUpdate(unObjeto);
sesion.getTransaction().commit();
. . .

Hay que tener en cuenta que entre el inicio y cierre de la transacción podemos realizar más de una operación y éstas se ejecutarán como tal. Es la forma correcta en el caso de que queramos registrar más de un objeto cuando éstos estén relacionados de alguna forma y dependan entre ellos. Un caso muy claro sería el del registro de un pedido junto con todas sus líneas de detalle puesto que no tendría sentido registrarlo sin los detalles, por lo que la forma más segura sería darlos de alta dentro de una misma transacción.

. . .
Session sesion = HibernateUtil.getCurrentSession();
sesion.beginTransaction();
sesion.saveOrUpdate(unPedido);
for (DetallePedido detallePedido : detallesDelPedido)
  sesion.save(detallePedido);
sesion.getTransaction().commit();
. . .

En el caso de que queramos modificar un objeto, la operación se realiza de la misma forma que para el caso de registrar uno nuevo. Hibernate decide qué hacer (si registrar o modificar) comprobando si el objeto que se le envía tiene un valor válido para el campo id. Así, la única diferencia con el ejemplo anterior es que ahora dispondremos de un objeto que hemos obtenido previamente de la Base de Datos y al que hemos realizado algunas modificaciones (nunca el campo id).

. . .
Session sesion = HibernateUtil.getCurrentSession();
sesion.beginTransaction();
sesion.saveOrUpdate(unObjeto);
sesion.getTransaction().commit();
. . .

. . .
Session sesion = HibernateUtil.getCurrentSession();
sesion.beginTransaction();
sesion.delete(unObjeto);
sesion.getTransaction().commit();
. . .

Para el caso de las búsquedas se utiliza el lenguaje HQL (Hibernate Query Language), muy similar al lenguaje SQL que se usa en las base de datos relacionales, pero en este caso totalmente Orientado a Objetos puesto que en vez de trabajar con las tablas se trabaja con las clases y sus atributos directamente.

• Obtener un objeto identificado por el id

. . .
int id = . . .;
Cliente cliente = HibernateUtil.getCurrentSession().get(Cliente.class, id);
. . .

• Obtener todos los objetos de una clase

. . .
Query query = HibernateUtil.getCurrentSession().createQuery("FROM Cliente");
ArrayList<Cliente> clientes = (ArrayList<Cliente>) query.list();
. . .

• Obtener objetos de una clase añadiendo algún criterio de búsqueda

→ Si el criterio especificado nos devuelve un solo objeto:

. . .
String nombre = . . .;
. . .
Query query = HibernateUtil.getCurrentSession().
  createQuery("FROM Cliente c WHERE c.nombre = :nombre");
query.setParameter("nombre", nombre);
Cliente cliente = (Cliente) query.uniqueResult();
. . .

→ Si el criterio especificado nos puede devolver más de un objeto:

. . .
String ciudad = . . .;
. . .
Query query = HibernateUtil.getCurrentSession().
  createQuery("FROM Cliente c WHERE c.ciudad = :ciudad");
query.setParameter("ciudad", ciudad);
ArrayList<Cliente> clientes = (ArrayList<Cliente>) query.list();
. . .

• Obtener objetos de una clase utilizando las relaciones entre clases

. . .
Query query = HibernateUtil.getCurrentSession().
  createQuery("FROM DetallePedido dp WHERE dp.pedido.numeroPedido = :numeroPedido");
query.setParameter("numeroPedido", numeroPedido);
 
ArrayList<DetallePedido> detalles = (ArrayList<DetallePedido>) query.list();
. . .

• Y también es posible lanzar consultas directamente en lenguaje SQL, trabajando entonces directamente con las tablas y campos de la base de datos

. . .
SQLQuery sqlQuery = HibernateUtil.getCurrentSession().
  createSQLQuery("SELECT nombre, apellidos FROM clientes WHERE ciudad = :ciudad");
query.setParameter("ciudad", ciudad);
List resultado = query.list();
 
for (Object objeto : resultado) {
  Map fila = (Map) objeto;
  String nombre = fila.get("nombre"); 
  String apellidos = fila.get("apellidos");
  . . .
}
. . .

Operaciones CRUD con hibernate

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.

En las relaciones @OneToMany y @ManyToOne es recomendable que contenga algunos métodos utilitarios para mantener las relaciones:

@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);
  }
  . . .
}

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:

  . . .
  public void removeAllPersonajes(){
     //Desvinculo todos los personajes con este arma
     for(Personaje personaje : personajes){
        persona.setArma(null);
     }
     personajes.clear();   //Vacio la coleccion
  }
  . . .

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.

@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();
  }
  . . .
}

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.

• Repositorio de bitbucket con ejemplos y los proyectos realizados en clase (Fernando)
• Repositorio Bitbucket Repositorio con proyectos de ejemplo (Santi Faci)

• Práctica 3.1 Desarrollar una aplicación que conecta con una Base de Datos Relacional utilizando una herramienta de mapeo objeto-relacional

© 2024 Santiago Faci y Fernando Valdeón