hibernate中的对象关系映射

Hibernate是一个Java开源框架，它提供了一种旨在使用面向对象的方式来操作数据库的方法，其中对象关系映射（ORM）是Hibernate的核心。具体来说，Hibernate可以将Java类映射到数据库中的关系型表，并通过一系列简单易懂的配置，自动将Java对象与数据库操作关联起来。

下面是使用Hibernate进行对象关系映射的完整攻略：

1. 配置Hibernate

在项目中引入Hibernate框架，添加相关依赖包（例如hibernate-core、hibernate-entitymanager等）到项目的类路径中。同时，在项目的配置文件中设置相关的Hibernate属性，例如数据源、连接池、缓存等。

2. 创建实体类

创建Java实体类，并在实体类中指定与数据库中的表对应的表名、主键等信息。同时，在实体类中指定类的属性与表的列之间的映射关系，例如使用注解或XML文件来进行映射配置。

例如，我们创建一个Person类，并将其与数据库中的person表进行映射：

@Entity
@Table(name = "person")
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private Integer age;

    // 省略getter和setter方法
}

在上述代码中，@Entity注解表示这是一个实体类，@Table注解指定该类对应的表名，@Id注解指定该字段为主键，@GeneratedValue注解指定主键的生成方式。@Column注解指定该属性对应的列名。

3. 创建Hibernate SessionFactory

使用Hibernate SessionFactory来创建Session对象，Session对象用于执行对实体类对象的持久化操作。SessionFactory是线程安全的，通常情况下应该在应用程序的启动阶段只创建一次。

例如，在Java中创建SessionFactory：

Configuration configuration = new Configuration()
    .configure("hibernate.cfg.xml");
SessionFactory sessionFactory = configuration.buildSessionFactory();

在上述代码中，Configuration对象用于读取Hibernate的配置文件，configure方法指定该文件的路径。buildSessionFactory方法用于创建SessionFactory对象。

4. 通过Session执行CRUD操作

使用Session对象来执行对实体类的持久化操作，包括创建、读取、更新和删除实体。

例如，创建一个新的Person对象并将其保存到数据库中：

Session session = sessionFactory.openSession();
session.getTransaction().begin();
Person person = new Person();
person.setName("Tom");
person.setAge(20);
session.save(person);
session.getTransaction().commit();
session.close();

在上述代码中，首先通过SessionFactory创建Session对象。然后通过调用beginTransaction方法开启一个事务。接着创建一个新的Person对象，并通过调用save方法将其保存到数据库中。最后调用commit方法提交事务，并关闭Session对象。

示例1 - 一对多关系映射

下面是一个一对多关系的示例，其中一个订单(Order)可以包含多个订单项(OrderItem)。在这个示例中，一个订单项只属于一个订单，而一个订单可以包含多个订单项。

1. 创建实体类

创建Order和OrderItem两个实体类，并且在实体类之间相互引用。

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();

    // 省略getter和setter方法
}

@Entity
@Table(name = "orderitems")
public class OrderItem {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "product_name")
    private String productName;

    @Column(name = "price")
    private Double price;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id")
    private Order order;

    // 省略getter和setter方法
}

在上述代码中，Order类中使用@OneToMany注解指定了实体类之间的一对多关系，指定了items属性、order属性的名称映射关系、级联操作和孤儿删除。而OrderItem类中使用@ManyToOne注解指定了实体类之间的多对一关系，指定了order属性与外键的映射关系。

2. 通过Session执行CRUD操作

利用Hibernate API，可以通过Session对象来执行对实体类的CRUD操作。下面是一个增删查改的示例：

// 添加新订单
Session session = sessionFactory.openSession();
Transaction tx = session.getTransaction();
tx.begin();

Order order = new Order();
order.setItems(new ArrayList<>());

OrderItem item1 = new OrderItem();
item1.setProductName("iPhone 12");
item1.setPrice(1199.0);
item1.setOrder(order);

OrderItem item2 = new OrderItem();
item2.setProductName("MacBook Air");
item2.setPrice(999.0);
item2.setOrder(order);

order.getItems().add(item1);
order.getItems().add(item2);
session.save(order);

tx.commit();
session.close();

// 修改订单
Session session = sessionFactory.openSession();
Transaction tx = session.getTransaction();
tx.begin();

Order order = session.get(Order.class, 1L);
order.getItems().get(0).setPrice(1100.0);
session.update(order);

tx.commit();
session.close();

// 查询订单
Session session = sessionFactory.openSession();
Transaction tx = session.getTransaction();
tx.begin();

Order order = session.get(Order.class, 1L);
System.out.println(order);

tx.commit();
session.close();

// 删除订单
Session session = sessionFactory.openSession();
Transaction tx = session.getTransaction();
tx.begin();

Order order = session.get(Order.class, 1L);
session.delete(order);

tx.commit();
session.close();

在上述代码中，我们使用Session对象执行增加、查找、修改和删除实体对象。具体来说，我们创建了一个包含了两个OrderItem的Order对象，并将其保存到数据库中。然后我们通过get方法从数据库中查询到Order对象并修改了其中第一个订单项的价格。接着我们再次使用get方法从数据库中查询到Order对象并打印出来。最后，我们通过删除Order对象来删除Order和OrderItem对象。

示例2 - 多对多关系映射

下面是一个多对多关系的示例，其中一个学生(Student)可以报读多个课程(Course)，而一个课程也可以有多个学生报读。

1. 创建实体类

创建Student和Course两个实体类，并且在实体类之间相互引用。

@Entity
@Table(name = "students")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(
        name = "enrollments",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();

    // 省略getter和setter方法
}

@Entity
@Table(name = "courses")
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students = new HashSet<>();

    // 省略getter和setter方法
}

在上述代码中，Student类中，使用@ManyToMany注解指定实体类之间的多对多关系，指定了courses属性和表名，由于Student被认为是关系的拥有者，所以使用了@JoinTable注解来映射成一个中间表，并指明该表对应的列名。而在Course类中，使用@ManyToMany注解指定实体类之间的多对多关系，同时使用mappedBy指定 Student 的 Set 属性（实体类中）表示与此类相关联。

2. 通过Session执行CRUD操作

利用Hibernate API，可以通过Session对象来执行对实体类的CRUD操作。下面是一个增删查改的示例：

// 添加新学生
Session session = sessionFactory.openSession();
Transaction tx = session.getTransaction();
tx.begin();

Course course1 = new Course();
course1.setName("Java Programming");

Course course2 = new Course();
course2.setName("Database Design");

Student student = new Student();
student.setName("Tom");
student.setCourses(new HashSet<>());

student.getCourses().add(course1);
student.getCourses().add(course2);

session.save(student);

tx.commit();
session.close();

// 修改学生课程
Session session = sessionFactory.openSession();
Transaction tx = session.getTransaction();
tx.begin();

Student student = session.get(Student.class, 1L);
Course course = session.get(Course.class, 2L);

student.getCourses().add(course);
session.update(student);

tx.commit();
session.close();

// 查询学生课程
Session session = sessionFactory.openSession();
Transaction tx = session.getTransaction();
tx.begin();

Student student = session.get(Student.class, 1L);
System.out.println(student);

tx.commit();
session.close();

// 删除学生课程
Session session = sessionFactory.openSession();
Transaction tx = session.getTransaction();
tx.begin();

Student student = session.get(Student.class, 1L);
student.getCourses().remove(course);
session.update(student);

tx.commit();
session.close();

在上述代码中，我们使用Session对象执行增加、查找、修改和删除实体对象。具体来说，我们创建了一个包含了两个Course的Student对象，并将其保存到数据库中。然后我们通过get方法从数据库中查询到Student对象，并将第一个学生和第二个课程关联。接着我们再次使用get方法从数据库中查询到Student对象并打印出来。最后，我们通过update方法来删除Student对象中的一门课程。

以上就是Hibernate中的对象关系映射攻略，通过详细的配置过程和示例代码即使您是初学者也可以快速上手。