Anotaciones entidades
Algunas de las anotaciones más comunes que se utilizan en Hibernate son las siguientes:
@Entity: Anotación que se utiliza para especificar que una clase Java es una entidad y que debe ser mapeada a una tabla de la base de datos.
@Id: Anotación que se utiliza para especificar el atributo de la entidad que representa la clave primaria de la tabla.
@GeneratedValue: Anotación que se utiliza para especificar cómo se generará el valor de la clave primaria, por ejemplo, utilizando una secuencia de la base de datos.
@Column: Anotación que se utiliza para especificar el mapeo entre un atributo de la entidad y una columna de la tabla.
@Table: Anotación que se utiliza para especificar el mapeo entre una entidad y una tabla de la base de datos.
@OneToOne, @OneToMany, @ManyToOne, @ManyToMany: Anotaciones que se utilizan para especificar las relaciones entre entidades, por ejemplo, una relación de uno a uno, uno a muchos, muchos a uno o muchos a muchos.
@JoinColumn: Anotación que se utiliza para especificar la columna de unión entre dos entidades en una relación.
La anotación @Entity se utiliza para marcar una clase Java como una entidad, lo que significa que esta clase representa una tabla en una base de datos relacional. La anotación @Entity debe ser colocada encima de la declaración de la clase Java, como se muestra en el siguiente ejemplo:
@Entity
@Table(name = "employee")
public class Employee {
...
}
En este ejemplo, la clase Java Employee representa la tabla "employee" en una base de datos relacional. La anotación @Table se utiliza para especificar el nombre de la tabla en la base de datos que la clase Java debe representar.
La anotación @Column se utiliza para mapear un atributo de una clase Java a una columna de la tabla correspondiente en la base de datos. La anotación @Column debe ser colocada encima del atributo que se desea mapear, como se muestra en el siguiente ejemplo:
@Entity
@Table(name = "employee")
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;
@Column(name = "first_name")
private String firstName;
@Column(name = "last_name")
private String lastName;
@Column(name = "email")
private String email;
...
}
En este ejemplo, los atributos "firstName", "lastName" y "email" de la clase Java Employee están mapeados a las columnas correspondientes en la tabla "employee" de la base de datos. La anotación @Id se utiliza para marcar el atributo "id" como la clave primaria de la tabla, mientras que la anotación @GeneratedValue se utiliza para especificar cómo se generará el valor de la clave primaria automáticamente.
La anotación @OneToMany en Hibernate se utiliza para establecer una relación uno a muchos entre dos entidades. Esto significa que una entidad tiene una colección de otra entidad. La anotación @OneToMany se coloca encima de la propiedad de la colección en la entidad principal y se especifica la propiedad mappedBy en la anotación @OneToMany para indicar la propiedad en la entidad secundaria que mapea la relación.
Aquí hay un ejemplo de cómo usar la anotación @OneToMany en Hibernate:
Supongamos que tenemos dos entidades: Book y Author. Cada libro tiene un solo autor, pero cada autor puede escribir muchos libros. Por lo tanto, hay una relación uno a muchos entre las entidades Book y Author. La entidad Book tiene una propiedad author que es una instancia de la entidad Author.
La clase Book sería algo así:
@Entity
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String title;
@ManyToOne
@JoinColumn(name = "author_id")
private Author author;
// getters and setters
}
La clase Author sería algo así:
@Entity
public class Author {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
@OneToMany(mappedBy = "author", cascade = CascadeType.ALL)
private List<Book> books = new ArrayList<>();
// getters and setters
}
En este ejemplo, la entidad Book tiene una propiedad author que se mapea a la entidad Author mediante una relación ManyToOne. En la entidad Author, la propiedad books es una colección de libros que se mapea a la entidad Book mediante una relación OneToMany.
La propiedad mappedBy en la anotación @OneToMany se establece en "author" para indicar que la propiedad author en la entidad Book mapea esta relación. La propiedad cascade = CascadeType.ALL se utiliza para indicar que todas las operaciones de persistencia (guardar, actualizar, eliminar) realizadas en la entidad Author también se aplicarán a la colección de libros en la entidad Book.
Entonces, si quisieras agregar un nuevo libro para un autor en particular, simplemente crearías un nuevo objeto Book, lo establecerías en la colección books en el objeto Author correspondiente y guardarías el objeto Author. Hibernate se encargará de las relaciones entre las dos entidades. Por ejemplo:
Author author = new Author();
author.setName("J.K. Rowling");
Book book1 = new Book();
book1.setTitle("Harry Potter and the Philosopher's Stone");
book1.setAuthor(author);
Book book2 = new Book();
book2.setTitle("Harry Potter and the Chamber of Secrets");
book2.setAuthor(author);
author.getBooks().add(book1);
author.getBooks().add(book2);
session.save(author);
En este ejemplo, creamos un nuevo autor y dos libros, y los agregamos a la colección de libros en el autor. Luego guardamos el objeto Author en la base de datos. Hibernate automáticamente establecerá las claves externas y guardará los registros en las tablas correspondientes.
La anotación @ManyToMany en Hibernate se utiliza para establecer una relación muchos a muchos entre dos entidades. Esto significa que una entidad tiene una colección de otra entidad y viceversa. La anotación @ManyToMany se coloca en ambas entidades para indicar la relación.
Aquí hay un ejemplo de cómo usar la anotación @ManyToMany en Hibernate:
Supongamos que tenemos dos entidades: Book y Genre. Cada libro puede tener varios géneros, y cada género puede estar asociado con muchos libros. Por lo tanto, hay una relación muchos a muchos entre las entidades Book y Genre. La entidad Book tiene una colección de instancias de la entidad Genre, y la entidad Genre tiene una colección de instancias de la entidad Book.
La clase Book sería algo así:
@Entity
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String title;
@ManyToMany(cascade = { CascadeType.ALL })
@JoinTable(
name = "book_genre",
joinColumns = { @JoinColumn(name = "book_id") },
inverseJoinColumns = { @JoinColumn(name = "genre_id") }
)
private Set<Genre> genres = new HashSet<>();
// getters and setters
}
La clase Genre sería algo así:
@Entity
public class Genre {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
@ManyToMany(mappedBy = "genres")
private Set<Book> books = new HashSet<>();
// getters and setters
}
En este ejemplo, la entidad Book tiene una colección de géneros que se mapea a la entidad Genre mediante una relación ManyToMany. En la entidad Genre, la propiedad books es una colección de libros que se mapea a la entidad Book mediante una relación ManyToMany.
La anotación @JoinTable se utiliza para especificar la tabla de unión que se utiliza para mapear la relación ManyToMany. Las columnas joinColumns y inverseJoinColumns se utilizan para especificar las columnas que se utilizan para mapear la relación.
La propiedad mappedBy en la anotación @ManyToMany en la entidad Genre se establece en "genres" para indicar que la colección de géneros en la entidad Book mapea esta relación.
Entonces, si quisieras agregar un nuevo género para un libro en particular, simplemente crearías un nuevo objeto Genre, lo agregarías a la colección genres en el objeto Book correspondiente y guardarías el objeto Book. Hibernate se encargará de las relaciones entre las dos entidades. Por ejemplo:
Book book = new Book();
book.setTitle("The Lord of the Rings");
Genre genre1 = new Genre();
genre1.setName("Fantasy");
Genre genre2 = new Genre();
genre2.setName("Adventure");
book.getGenres().add(genre1);
book.getGenres().add(genre2);
genre1.getBooks().add(book);
genre2.getBooks().add(book);
session.save(book);
En este ejemplo, creamos un nuevo libro y dos géneros, y los agregamos a la colección de géneros en el libro. También agregamos el libro a la colección de libros en cada uno de los géneros correspondientes. Luego guardamos el objeto Book en la base de datos. Hibernate automáticamente establecerá las claves externas y guardará los registros en las tablas correspondientes.
https://www.tutorialspoint.com/hibernate/hibernate_annotations.htm
https://www.geeksforgeeks.org/hibernate-annotations/
https://premika-17.medium.com/hibernate-relations-a-beginners-guide-eba9f0c6e6d5