Hibernate 一对多映射实战：Customer 与 Order 实体配置详解

Order.java

package com.xiangshuai.hibernate;

/**
 * 订单类
 */
public class Order {
    private Integer id;
    private String oname;
    private Customer customer;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getOname() {
        return oname;
    }

    public void setOname(String oname) {
        this.oname = oname;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    @Override
    public String toString() {
        return "Order [id=" + id + ", oname=" + oname + "]";
    }
}

2. XML 映射配置

Hibernate 的 XML 映射是理解其底层机制的关键。这里需要特别注意'一的一方'和'多的一方'在外键维护上的区别。

Customer.hbm.xml（一的一方）

在 set 标签中，我们配置了 inverse="true"。这意味着 Customer 放弃维护外键，由 Order 表中的 cid 字段来维护关系。同时开启级联操作，保存或删除 Customer 时自动处理其订单。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.xiangshuai.hibernate">
    <class name="Customer" table="t_customer">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
        <property name="cname"></property>
        <!-- inverse=true 表示由多的一方维护外键 -->
        <!-- cascade="save-update,delete" 实现级联操作 -->
        <set name="orders" inverse="true" cascade="save-update,delete" lazy="false">
            <key column="cid"></key>
            <one-to-many class="Order"/>
        </set>
    </class>
</hibernate-mapping>

Order.hbm.xml（多的一方）

多的一方使用 many-to-one 标签指向 Customer，并指定外键列名 cid。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.xiangshuai.hibernate">
    <class name="Order" table="t_order">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
        <property name="oname"></property>
        <!-- 关联到 Customer 的外键 -->
        <many-to-one name="customer" class="Customer" column="cid"></many-to-one>
    </class>
</hibernate-mapping>

3. 全局配置文件

hibernate.cfg.xml 负责数据库连接及策略配置。这里开启了 SQL 打印以便调试，并设置了 hbm2ddl.auto 为 update，这样无需手动建表即可同步结构。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//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.username">root</property>
        <property name="hibernate.connection.password">root</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/demo</property>
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.autocommit">true</property>
        <property name="hibernate.current_session_context_class">thread</property>
        <mapping resource="com/xiangshuai/hibernate/Customer.hbm.xml"/>
        <mapping resource="com/xiangshuai/hibernate/Order.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

4. 测试用例与常见问题

测试类展示了保存、删除、更新以及懒加载的典型场景。

保存数据

由于 inverse="true"，虽然 Customer 放弃了外键维护，但配合 cascade="save-update"，执行 session.save(customer) 时，只要 Order 对象中已经设置了 customer 引用，Hibernate 就能正确写入外键。

@Test
public void demoSave() {
    Session session = getSession();
    Transaction tr = session.beginTransaction();
    
    Order order1 = new Order();
    Order order2 = new Order();
    Customer customer1 = new Customer();
    
    order1.setOname("订单 1");
    order1.setCustomer(customer1);
    order2.setOname("订单 2");
    order2.setCustomer(customer1);
    
    Set<Order> orders = new HashSet<>();
    orders.add(order1);
    orders.add(order2);
    
    customer1.setCname("小明");
    customer1.setOrders(orders);
    
    session.save(customer1);
    tr.commit();
    closeStream(sessionFactory, session);
}

级联删除

同样得益于级联配置，直接删除 Customer 会自动清除其关联的所有 Order。

@Test
public void delete() {
    Session session = getSession();
    Transaction tr = session.beginTransaction();
    
    Query query = session.createQuery("from Customer where id=?").setInteger(0, 4);
    Customer customer = (Customer) query.uniqueResult();
    
    session.delete(customer);
    tr.commit();
    closeStream(sessionFactory, session);
}

懒加载陷阱

这是新手最容易踩坑的地方。默认情况下，集合属性是 lazy="true"。如果在 Session 关闭后访问该集合，会抛出 LazyInitializationException。

@Test
public void update() {
    Session session = getSession();
    Transaction tr = session.beginTransaction();
    
    Query query = session.createQuery("from Customer where id=?").setInteger(0, 5);
    Customer customer = (Customer) query.uniqueResult();
    
    customer.setCname("小明改 2");
    session.update(customer);
    tr.commit();
    closeStream(sessionFactory, session);
    
    // 此时 Session 已关闭，若 customer.toString() 触发 orders 加载，将报错
    System.out.println(customer);
}

若要解决此问题，可在映射文件中设置 lazy="false" 强制预加载，或者在查询时使用 HQL 的 fetch join 策略。

@Test
public void lazySelect() {
    Session session = getSession();
    Transaction tr = session.beginTransaction();
    
    // 链式操作查询，确保在 Session 打开期间获取完整数据
    Customer customer = (Customer) session.createSQLQuery("select * from t_customer where id=?")
        .addEntity(Customer.class)
        .setInteger(0, 5)
        .uniqueResult();
    
    tr.commit();
    closeStream(sessionFactory, session);
    System.out.println(customer);
}

5. 工具方法

public Session getSession() {
    Configuration conf = new Configuration().configure();
    sessionFactory = conf.buildSessionFactory();
    return sessionFactory.openSession();
}

public void closeStream(SessionFactory sessionFactory, Session session) {
    if (session != null) {
        session.close();
    }
    if (sessionFactory != null) {
        sessionFactory.close();
    }
}

注意事项

1. 循环引用：如果 Customer 和 Order 的 toString() 方法都互相调用了对方，会导致 StackOverflowError。建议只在一个方向打印 ID 或名称。
2. 外键维护：生产环境中通常让'多的一方'维护外键（即 inverse="true"），这样可以减少不必要的 SQL 更新操作。
3. Session 生命周期：务必注意在访问懒加载属性前保持 Session 处于打开状态，或使用 Open Session In View 模式。