10hibernate_one2many_1

本文介绍了一对多关联映射的实现方法,通过在多方表中添加外键指向一方表的方式建立联系,并提供了详细的代码示例。演示了如何在Hibernate中配置一对多关系,包括创建实体类、映射文件以及保存和加载数据。
hihernate一对多关联映射(单向Classes----->Student)

一对多关联映射利用了多对一关联映射原理

多对一关联映射:在多的一端加入一个外键指向一的一端,它维护的关系是多指向一
一对多关联映射:在多的一端加入一个外键指向一的一端,它维护的关系是一指向多

也就是说一对多和多对一的映射策略是一样的,只是站的角度不同

在一一端维护关系的缺点:
    * 如果将t_student表里的classesid字段设置为非空,则无法保存
    * 因为不是在student这一端维护关系,所以student不知道是哪个班的,
      所以需要发出多余的update语句来更新关系


 一方:Classes.java

package com.bjsxt.hibernate;

import java.util.Set;

public class Classes {
    
    private int id;
    
    private String name;
    
    private Set students; 
    
    <hibernate-mapping package="com.bjsxt.hibernate">
    <class name="Classes" table="t_classes">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <set name="students">
            <key column="classesid"/>
            <one-to-many class="Student"/>
        </set>
    </class>
</hibernate-mapping>

-------------------------------------------------------------------------------
       多方:
    public class Student {
    
    private int id;
    
    private String name;
    
    <hibernate-mapping>
    <class name="com.bjsxt.hibernate.Student" table="t_student">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
    </class>
</hibernate-mapping>
-------------------------------------------------------------------------------
ExportDB:

create table t_classes (id integer not null auto_increment, name varchar(255), primary key (id))

create table t_student (id integer not null auto_increment, name varchar(255), classesid integer, primary key (id))

alter table t_student add index FK4B9075708EBC77F7 (classesid), add constraint FK4B9075708EBC77F7 foreign key (classesid) references t_classes (id)     

public void testSave1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Student student1 = new Student();
            student1.setName("10");
            session.save(student1);
            
            Student student2 = new Student();
            student2.setName("祖儿");
            session.save(student2);
            
            Set students = new HashSet();
            students.add(student1);
            students.add(student2);
            
            Classes classes = new Classes();
            classes.setName("尚学堂");
            classes.setStudents(students);
            
            //可以正确保存
            session.save(classes);
            
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }    
测试结果:
Hibernate: insert into t_student (name) values (?)
Hibernate: insert into t_student (name) values (?)
Hibernate: insert into t_classes (name) values (?)
Hibernate: update t_student set classesid=? where id=?
Hibernate: update t_student set classesid=? where id=?    
-------------------------------------------------------------------------------
public void testLoad1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Classes classes = (Classes)session.load(Classes.class1);
            System.out.println("classes.name=" + classes.getName());
            Set students = classes.getStudents();
            for (Iterator iter=students.iterator(); iter.hasNext();) {
                Student student = (Student)iter.next();
                System.out.println("student.name=" + student.getName());
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }        
}

测试结果:
Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?
classes.name=尚学堂
Hibernate: select students0_.classesid as classesid1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_ from t_student students0_ where students0_.classesid=?
student.name=祖儿
student.name=10


mysql> desc t_classes;
+-------+--------------+------+-----+---------+----------------+
| Field | Type         | Null | Key | Default | Extra          |
+-------+--------------+------+-----+---------+----------------+
| id    | int(11)      | NO   | PRI | NULL    | auto_increment |
| name  | varchar(255) | YES  |     | NULL    |                |
+-------+--------------+------+-----+---------+----------------+
2 rows in set (0.08 sec)

mysql> desc t_student;
+-----------+--------------+------+-----+---------+----------------+
| Field     | Type         | Null | Key | Default | Extra          |
+-----------+--------------+------+-----+---------+----------------+
| id        | int(11)      | NO   | PRI | NULL    | auto_increment |
| name      | varchar(255) | YES  |     | NULL    |                |
| classesid | int(11)      | YES  | MUL | NULL    |                |
+-----------+--------------+------+-----+---------+----------------+
3 rows in set (0.02 sec)

 

转载于:https://www.cnblogs.com/alamps/archive/2012/08/04/2622918.html

<think>我们正在处理一个关于Hibernate中`<many-to-one>`映射错误的问题。根据引用内容,用户可能遇到配置错误或运行时异常。以下将分析可能的原因并提供解决方案。 ### 常见错误及解决方案 #### 1. **配置错误:缺少必需属性** - **错误示例**:未指定`column`属性或`class`属性。 ```xml <!-- 错误配置 --> <many-to-one name="department" /> ``` - **解决方案**:必须指定`column`(外键列)和`class`(目标实体类)属性。 ```xml <!-- 正确配置 --> <many-to-one name="department" class="com.example.Department" column="department_id" /> ``` #### 2. **延迟加载导致`LazyInitializationException`** - **原因**:当会话关闭后尝试访问未初始化的代理对象(引用[3])。 ```java // 错误示例:在会话外访问关联对象 Employee emp = session.get(Employee.class, 1); session.close(); Department dept = emp.getDepartment(); // 抛出LazyInitializationException ``` - **解决方案**: - **立即加载**:使用`fetch="join"`或HQL的`JOIN FETCH`。 ```xml <many-to-one name="department" fetch="join" ... /> ``` ```java // HQL示例 Employee emp = session.createQuery( "FROM Employee e JOIN FETCH e.department WHERE e.id = :id", Employee.class) .setParameter("id", 1) .getSingleResult(); ``` - **在会话内访问**:确保在会话关闭前访问关联对象。 #### 3. **外键约束问题** - **现象**:插入或更新时因外键无效失败。 - **解决方案**: - 确保被引用的实体已持久化。 - 检查数据库外键约束是否匹配Hibernate配置。 #### 4. **类型不匹配** - **错误**:关联字段类型与目标实体ID类型不一致。 - 例如:`Department`的ID为`Long`,但`Employee`的`department_id`字段配置为`Integer`。 - **解决方案**:统一类型,或使用`type`属性指定转换器。 #### 5. **集合映射冲突** - **错误**:同时配置双向关联时,`<many-to-one>`与`<set>`/`<list>`的`inverse`设置冲突(引用[2])。 - **解决方案**: - 在"一"方(`Department`)设置`inverse="true"`: ```xml <!-- Department.hbm.xml --> <set name="employees" inverse="true"> <key column="department_id"/> <one-to-many class="Employee"/> </set> ``` - 代码中从"多"方(`Employee`)维护关联: ```java Employee emp = new Employee(); emp.setDepartment(dept); // 只需设置多对一关系 ``` ### 高级调试技巧 - **启用SQL日志**:在`hibernate.cfg.xml`中添加: ```xml <property name="show_sql">true</property> <property name="format_sql">true</property> ``` - **检查代理初始化**:使用`Hibernate.initialize()`强制加载: ```java Employee emp = session.get(Employee.class, 1); Hibernate.initialize(emp.getDepartment()); // 显式初始化 ``` ### 示例配置 ```xml <!-- Employee.hbm.xml --> <class name="Employee" table="employees"> <id name="id" column="id"> <generator class="native"/> </id> <many-to-one name="department" class="Department" column="department_id" not-null="true" /> </class> <!-- Department.hbm.xml --> <class name="Department" table="departments"> <id name="id" column="id"> <generator class="native"/> </id> <set name="employees" inverse="true"> <key column="department_id"/> <one-to-many class="Employee"/> </set> </class> ``` > **关键原则**: > - 双向关联中由"多"方维护关系可提高性能[^2]; > - 避免在分离状态下访问延迟加载的关联对象[^3]。 --- §§相关问题§§ 1. Hibernate中如何配置单向一对多关系? 2. 什么是Hibernate的`inverse`属性?它如何影响性能? 3. 如何解决Hibernate的`org.hibernate.MappingException`? 4. Hibernate 6中`<many-to-one>`映射有哪些变化?</think>### Hibernate `<many-to-one>` 映射错误解决方案 以下是针对 Hibernate 中 `<many-to-one>` 映射常见错误的完整解决方案: --- #### 1. **基本配置错误** **错误示例**:缺少必需属性或类型不匹配 ```xml <!-- 错误配置 --> <many-to-one name="department" /> ``` **解决方案**: ```xml <!-- 正确配置 --> <many-to-one name="department" class="com.example.Department" <!-- 必须指定目标实体类 --> column="department_id" <!-- 明确外键列名 --> not-null="true" <!-- 按需设置空值约束 --> cascade="save-update" /> <!-- 级联操作配置 --> ``` **关键点**: - `class` 属性必须使用完全限定类名 - `column` 需与数据库外键列名一致 - 使用 `cascade` 控制级联操作行为[^2] --- #### 2. **延迟加载问题 (LazyInitializationException)** **错误现象**: ```java Employee emp = session.get(Employee.class, 1); session.close(); Department dept = emp.getDepartment(); // 抛出LazyInitializationException ``` **解决方案**: ```xml <!-- 方法1:关闭延迟加载 --> <many-to-one name="department" fetch="join" lazy="false"/> <!-- 方法2:在会话内初始化 --> Employee emp = session.createQuery( "FROM Employee e JOIN FETCH e.department WHERE e.id = :id", Employee.class) .setParameter("id", 1) .getSingleResult(); ``` **最佳实践**: - 在视图层使用 `Hibernate.initialize(emp.getDepartment())` 初始化代理 - 使用 Open Session in View 模式(需谨慎)[^3] --- #### 3. **双向关联不一致** **错误配置**(单向关联导致数据不一致): ```xml <!-- Employee.hbm.xml --> <many-to-one name="department" class="Department" column="dept_id"/> <!-- Department.hbm.xml 缺少反向关联 --> ``` **正确配置**: ```xml <!-- Department.hbm.xml 添加反向关联 --> <set name="employees" inverse="true"> <key column="dept_id"/> <one-to-many class="Employee"/> </set> ``` **代码维护**: ```java // 正确维护双向关联 Department dept = new Department(); Employee emp = new Employee(); emp.setDepartment(dept); // 设置多对一 dept.getEmployees().add(emp); // 设置一对多 ``` --- #### 4. **类型转换错误** **常见场景**:JSON 类型映射 ```java // 实体类 public class Employee { @Type(type = "json") // 自定义类型 private Department department; } ``` **解决方案**: 1. 添加依赖: ```xml <dependency> <groupId>com.vladmihalcea</groupId> <artifactId>hibernate-types-52</artifactId> <version>2.14.0</version> </dependency> ``` 2. 注册自定义类型: ```java @TypeDef(name = "json", typeClass = JsonType.class) public class Employee { @Type(type = "json") private Department department; } ``` Hibernate 会自动处理 JSON 列的映射转换[^1] --- #### 5. **性能优化 (N+1 问题)** **错误现象**:循环访问关联对象时产生大量查询 ```java List<Employee> employees = session.createQuery("FROM Employee").list(); for (Employee emp : employees) { emp.getDepartment().getName(); // 每个循环触发新查询 } ``` **解决方案**: ```sql <!-- 使用批量抓取 --> <many-to-one name="department" batch-size="10"/> <!-- 或使用HQL连接抓取 --> List<Employee> employees = session.createQuery( "SELECT e FROM Employee e JOIN FETCH e.department", Employee.class).list(); ``` --- #### 完整配置示例 **实体关系**: ```java public class Employee { private Long id; private Department department; // getters/setters } public class Department { private Long id; private Set<Employee> employees = new HashSet<>(); // getters/setters } ``` **映射文件**: ```xml <!-- Employee.hbm.xml --> <class name="Employee" table="employees"> <id name="id" column="id"> <generator class="identity"/> </id> <many-to-one name="department" class="Department" column="dept_id" cascade="save-update" fetch="select" lazy="proxy"/> </class> <!-- Department.hbm.xml --> <class name="Department" table="departments"> <id name="id" column="id"> <generator class="identity"/> </id> <set name="employees" inverse="true"> <key column="dept_id"/> <one-to-many class="Employee"/> </set> </class> ``` --- **调试建议**: 1. 启用 Hibernate SQL 日志: ```properties hibernate.show_sql=true hibernate.format_sql=true ``` 2. 使用 `hibernate.hbm2ddl.auto=validate` 验证映射 3. 检查数据库外键约束是否匹配 > **关键原则**:保持数据库外键、实体关联和 Hibernate 映射三者一致[^2] ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值