Question

hibernate的映射关系怎样判断用单向还是双向

RT，求解。什么情况用双向，什么情况不需要
双向比起单向的优势和缺点？
有例子么？

Answer 1

双向更灵活些。你只想根据多的一方存储一的一方，而用一的一方存储多的一方无效，即便是有数据也不会插入到数据库里面的。一般选择双向毕竟灵活。
@Entity
public class Classes {
private int id;
private String name;

// 一对多通常使用Set来映射，Set是不可重复内容。
// 注意使用Set这个接口，不要使用HashSet,因为hibernate有延迟加载，
private Set<Student> students = new HashSet<Student>();
@OneToMany//进行注解为一对多的关系
@JoinColumn(name="classesId")//注释的是另一个表指向本表的外键。
在多的一端注解一个字段(名为classessid)
@JoinColumn(name="classesId")
public Set<Student> getStudents() {
return students;
}

(七) 导出至数据库(hbmddl)生成的SQL语句：
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 FK4B90757070CFE27A (classesid), add constraint FK4B90757070CFE27A foreign key (classesid) references t_classes (id)
(八) 一对多 单向存储实例：
session = HibernateUtils.getSession();
tx = session.beginTransaction();

Student student1 = new Student();
student1.setName("10");
session.save(student1);//必需先存储，否则在保存classess时出错.

Student student2 = new Student();
student2.setName("祖儿");
session.save(student2);//必需先存储，否则在保存classess时出错.

Set<Student> students = new HashSet<Student>();
students.add(student1);
students.add(student2);

Classes classes = new Classes();
classes.setName("wjt276");
classes.setStudents(students);

session.save(classes);
tx.commit();
(九) 生成的SQL语句：
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=?

双向

是加载学生时，能够把班级加载上来。当然加载班级也可以把学生加载上来
1、 在学生对象模型中，要持有班级的引用,并修改学生映射文件就可以了。。
2、 存储没有变化
3、 关系模型也没有变化
(一) xml方式：映射
学生映射文件修改后的：
<class name="com.wjt276.hibernate.Student" table="t_student">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name" column="name"/>
<!--使用多对一标签映射 一对多双向，下列的column值必需与多的一端的key字段值一样。-->
<many-to-one name="classes" column="classesid"/>
</class>

如果在一对多的映射关系中采用一的一端来维护关系的话会存在以下两个缺点：①如果多的一端那个外键设置为非空时，则多的一端就存不进数据；②会发出多于的Update语句，这样会影响效率。所以常用对于一对多的映射关系我们在多的一端维护关系，并让多的一端维护关系失效(见下面属性)。
代码：
<class name="com.wjt276.hibernate.Classes" table="t_classes">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name" column="name"/>

<!--
<set>标签 映射一对多(映射set集合),name="属性集合名称"
然后在用<key>标签，在多的一端加入一个外键(column属性指定列名称)指向一的一端
再采用<one-to-many>标签说明一对多，还指定<set>标签中name="students"这个集合中的类型
要使用完整的类路径(例如：class="com.wjt276.hibernate.Student")
inverse="false":一的一端维护关系失效(反转) ：false：可以从一的一端维护关系(默认)；true：从一的一端维护关系失效，这样如果在一的一端维护关系则不会发出Update语句。 -->
<set name="students" inverse="true">
<key column="classesid"/>
<one-to-many class="com.wjt276.hibernate.Student"/>
</set>
</class>

(二) annotateon方式注解
首先需要在多的一端持有一的一端的引用
因为一对多的双向关联，就是多对一的关系，我们一般在多的一端来维护关系，这样我们需要在多的一端实体类进行映射多对一，并且设置一个字段，而在一的一端只需要进行映射一对多的关系就可以了，如下：
多的一端
@Entity
public class Student {
private int id;
private String name;
private Classes classes;

@ManyToOne
@JoinColumn(name="classesId")
public Classes getClasses() {
return classes;
}
一的一端
@Entity
public class Classes {
private int id;
private String name;
// 一对多通常使用Set来映射，Set是不可重复内容。
// 注意使用Set这个接口，不要使用HashSet,因为hibernate有延迟加载，
private Set<Student> students = new HashSet<Student>();

@OneToMany(mappedBy="classes")//进行注解为一对多的关系
public Set<Student> getStudents() {
return students;}
(三) 数据保存：
一对多 数据保存，从多的一端进行保存：
session = HibernateUtils.getSession();
tx = session.beginTransaction();

Classes classes = new Classes();
classes.setName("wjt168");
session.save(classes);

Student student1 = new Student();
student1.setName("10");
student1.setClasses(classes);
session.save(student1);

Student student2 = new Student();
student2.setName("祖儿");
student2.setClasses(classes);
session.save(student2);

//提交事务
tx.commit();
注意：一对多，从多的一端保存数据比从一的一端保存数据要快，因为从一的一端保存数据时，会多更新多的一端的一个外键(是指定一的一端的。)
(四) 关于inverse属性：
inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签<set>上，默认inverse为false，所以我们可以从一的一端和多的一端维护关联关系，如果设置inverse为true，则我们只能从多的一端维护关联关系。
注意：inverse属性，只影响数据的存储，也就是持久化
(五) Inverse和cascade区别：
Inverse是关联关系的控制方向
Casecade操作上的连锁反应
(六) 一对多双向关联映射总结：
在一的一端的集合上使用<key>，在对方表中加入一个外键指向一的一端
在多的一端采用<many-to-one>
注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引用字段的错误
如果在一的一端维护一对多的关系，hibernate会发出多余的update语句，所以我们一般在多的一端来维护关系。

Answer 2

双向可以两端都直接关联对方，比如学生和老师，处理成双向，可以查学生时也查出老师是谁，查老师时也查出有哪些学生。

单向用在某一端不需要关联查对方的时候，比如学校和学生，查学校时一般不会需要关联把所有学生都查出来的吧？这样太费性能了，也没实用性。于是就设为单向，学生关联学校，简化了维护关系。

需要通过学校查学生时再另写查询语句好了。

Answer 3

是的!
单向:有一方不能级联操作!

Answer 4

一般要看实现使用情况来决定，最好配置成双向的，这样hibernate可以有更多的优化