Hibernate一对多映射
hibernate一对多关联映射—单向
一、简述
一对多关联映射（one-to-many）
1、在对象模型中，一对多的关联关系，使用集合表示
比如Classes（班级）和Student（学生）之间是一对多的关系
public class Classes{
private String id;
private String name;
private Set students;
}
public class Student{
public String id;
public String name;
}
2、我们以前学过学生对班级是多对一，返过来，班级对学生就是一对多。
3、我们多对一的关系是用户和组。返过来看，从组这边来看，就是一对多了。
下面学生的示例是班级和学生。和用户和组是一样的。
一个班级有多个学生，这是一对多的关系；返过来，多个学生属于一个班级，这就是多对一了。
4、建立对象模型
5、这两个对象模型之间是有关系的。我们现在讲的是一对多。一的一端是班级。多的一端是学生。那么怎么样能体现出这种关系呢？
我们在学习多对一时，是在多的一端加上一个字段。这个字段做为外键关联一的一端。多对一，就是我们在看到学生的时候，能够知道这个学生是哪个班级的。或者是当我们看到用户的时候，知道这个用户是哪个组的。所以在用户里面持有组的引用。
6、那么一对多，就是一个组里面有多少个用户。所以要维护这种关系，必须在组里面持有用户的集合。
班级和学生也是一样的。一个班级有多少学生，所以在班级里面要持有相应的学生的集合。如下图
我们用Set，通常用户Set做映射。
箭头表示两者之间是有关系的。
7、上面的是对象模型，那么这种模型要映射成什么样呢？
当我们定义多对一的关系时，在加载多的一端时，能够把1的一端加载上来。因为两者之间是有关系的。
同理，一对多也是一样的，它要维护这种关系。这种关系就是一对多。一的一端要指向多。在维护这种关系时，在加载一的时候，就会把一的一端加载上来。
也就是说，在我在加载班级时，这个班级有多少个学生，它会把所有的学生自动查询上来，放到Set集合里面。这就是维护这个关系的目的。
8、我们知道，实体类要映射成表。所在下面画两个表。
依我们来看，是先有班级。再分配学生。
学生有了，班级有了。要保证知道一个班级有多少学生。
因为students这个集合是在Classes上，要映射它的时候，那么我们是要在t_classes表上加一个字段，然后将所有的学生用，表达式表达出来吗？可是这样做不符合数据库的设计范式。
9、所以说，这种关系的维护应该是在t_student这一端。也就是说，在t_student表中加一个字段，这个字段就是classesid。
也就是说，一对多关联映射，要把两个表的关联字段加到多的一端。
10、所以说，一对多与多对一的映射是一样的。没有区别。都在多的一端加一个外键，指向一的一端。
但是两者也是有区别的。区别就是关系。如果维护的是多对一，则加载多的时候，能把1加上来。如果维护的是一对多，则加载班级时，能把WHSD1011对应的两个学生加载上来。
我的理解：对于要相关联的表来说，如果一个表想要看到对方的表内容，则就要在自己的实体类中持有对方的引用。
如果只有一方看到另一方，就是单向的。
如果要双方都看到，就要在实体模型中彼此都持有对方的引用。
二、新建项目hibernate_one2many_1（拷贝hibernate_session）这个项目就O了。：我们这个实例还是单向的。只能在加载班级时，把所有的学生加载上来。但是当把学生拿上来的时候，看不到这个学生所在的班级。
三、建立对象模型
1、注意：一对多关联映射，通常用Set这个集合，那么为什么用Set呢？我们可以这样理解：Set里面的对象是不能重复的。当然也可以用其他的。不过一般情况下用Set。
一定要用Set这个接口，而不用HashSet。因为Hibernate中有延迟加载。实体对象就实现了延迟加载。也就是采用代理的方式。集合也有延迟加载。hibernate中对JDK中的Set集合进行了扩展，也就是实现了这个接口，所以不能用HashSet。
所以要用Set接口。因为hibernate对Set有相应的实现，对Set进行了扩展。
2、我们的Set里面就是Student对象的集合。这样就构成了一对多的关系。
2．1 Classes.java
package com.bjsxt.hibernate;
import java.util.Set;
public class Classes {
private int id;
private String name;
private Set students;
public Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = students;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
https://www.sodocs.net/doc/7b3105109.html, = name;
}
}
2.2Student.java
package com.bjsxt.hibernate;
public class Student {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
https://www.sodocs.net/doc/7b3105109.html, = name;
}
}
四、对象模型建立好之后，就开始写映射文件，这是hibernate开发的正确思路。
1、在写映射文件时，先从简单的写起。
写Students.hmb.xml文件。
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://www.sodocs.net/doc/7b3105109.html,/hibernate-mapping-3.0.dtd">
2、再映射难一点的，Classes.hbm.xml文件如下：
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://www.sodocs.net/doc/7b3105109.html,/hibernate-mapping-3.0.dtd">
五、到hibernate.cfg.xml文件中，修改数据库，并把我们的两个实体类加到配置文件中
文件内容为：
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"https://www.sodocs.net/doc/7b3105109.html,/hibernate-configuration-3.0.dtd">
六、打MySql，创建数据库
root;
create database hibernate_one2many_1;
use hibernate_one2many_1;
show tables;
七、执行ExportDB.class类，将对象导出为表
ExportDB.class 文件内容为：
package com.bjsxt.hibernate;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
//这个类写完之后，以后就再也不用写了。
//这个类就是把hibernate的配置文件，转换成DDL。
public class ExportDB {
public static void main(String[] args){
//读取hibernate.cfg.xml文件
Configuration cfg=new Configuration().configure(); //hibernate中的一个api，是Configuraton。引入时，将光标定位在Configuration上
//右击，选择"Source"命令的"Add Import"命令，找到hibernate的Configuration。
//它是用来读取hibernate中的配置文件的。即hibernate.cfg.xml文件。(相当于Struts中的
//ActionServlet)
//这样直接写Configuration cfg=new Configuration();会有问题，因为
//hibernate有两个配置文件，一个是property类型的，一个是xml类型的，这样
//new完，就会默认的读取property类型的配置文件，这样就会有问题。所以必须加上它的一个
//方法configure()。
//hibernate中有一个工具类，叫SchemaExport,这个工具类需要传送configuration.
//这个对象就把我们的类生成（导成）表出来。
SchemaExport export=new SchemaExport(cfg);
export.create(true, true); //script是判断生成不生成,它实际是生成ddl.
//这两个参数都设置成true就可以了。
//这个方法的具体含义可以直接看它的api。
//或者关联上它的源代码，可以在create上，点击F3，
//选择"Attach Resource"，选择“External File",
//再找到F:\java program\Hibernate相关资料\hibernate-3.2.0.ga,就关联上了。
//export.create(..)是拿到对象，直接生成就可以了。
}
}
八、导出表后，在控制台显示：
drop table if exists t_classes
drop table if exists t_student
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), classid integer, primary key (id))
注意：在student表中加的字段classid是在写Classes.hbm.xml映射文件时，key标签起的作用哦！
alter table t_student add index FK4B907570C229DCC9 (classid), add constraint FK4B907570C229DCC9 foreign key (classid) references t_classes (id)
这条语句是在t_student这张表中加了约束。也就是classid作为外键参照了t_classes的id字段。
2、到MysQL中
输入show tables;
desc t_classes;
+-------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| name | varchar(255) | YES | | NULL | |
+-------+--------------+------+-----+---------+----------------+
输入命令：
desc t_student;
显示结果为：我们发现在t_student这张表中加了一个字段classid。
+---------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+---------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| name | varchar(255) | YES | | NULL | |
| classid | int(11) | YES | MUL | NULL | |
+---------+--------------+------+-----+---------+----------------+
九、所以我们项目上用hibernate进行持久层映射时，最重要的是要发现对象，然后建立对象之间的关系
十、readme.xml文件内容为：
hibernate 一对多关联映射。（单向日葵Classed----->Student)
一对多关联映射利用了多对一关联映射原理。
多对一关联映射，在多的一端加入一个外键，指向一的一端。但是它维护的关系是多指向一的。
一对多关联映射，在多的一端加入一个外键，指向一的一端。但是它维护的关系是一指向多的。
也就是说，一对多与多对一映射策略是一样的，只不过站的角度不同。
hibernate一对多关联映射——单向（继。空间不够了）
十一、接着看存储与加载
建立单元测试类One2ManyTest
package com.bjsxt.hibernate;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import junit.framework.TestCase;
public class One2ManyTest extends TestCase {
}
十二、测试save（保存）
一对多的存储方式应该与多对一不一样。一对多存储的应该是classes。因为班级与学生的关系是在classes类里面的students集合。所以应该是先有学生，把学生建立好之后，再放到Classes类的students这个集合里面。
1、testSave()方法内容如下：
public void testSave(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
Student student1=new Student();
student1.setName("菜10");
Student student2=new Student();
student2.setName("容祖儿");
Set
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);
}
}
当testSave()方法执行时，会出现这个
org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: com.bjsxt.hibernate.Student 异常。
2、正确的保存testSave2()
public void testSave2(){
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.add(student1);
students.add(student2);
//要知道哪个学生所在的班级，要new 班级出来
Classes classes=new Classes();
classes.setName("尚学堂");
//这个班级里面有哪些学生，要用set方法加上去。
//这样这个尚学堂班级里面就有两个学生了
classes.setStudents(students);
session.save(classes);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
2.1执行后出现SQL语句：
insert into t_student (name) values (?)
只保存了学生的name，此时classesid字段值为null.
insert into t_student (name) values (?)
insert into t_classes (name) values (?)
hibernate又连接发了两条update,因为只有两个学生
update就是要把学生的classesid字段值更新上
根据学生id把classesid更新上。
也就是说，要由班级（一的一端）来维护这种关系：你菜10是我们班的，你容祖儿是我们班的。
在一的一端维护这种关系，会发现很多udpate。因为班级不知道会有多少学生。
就是说，由班级（一的端）主动记住这种关系
就如记人的名字一样，就如让姚明来记我们十三亿的人，这个关系要由姚来维护，
他要主动来记，把十三亿人的名字全部记下来。这肯定比较困难。因为由他一个人来更新，来记。
实际上，这种关系在多的一端来维护很容易，就如让我们记住姚明的名字很容易一样的。这是在一的端维护关系的一个缺点。另一个缺点是后面说的，如果在Student.hbm.xml映射文件中，将classesid字段设置为非空的话，则保存时会出错。
update t_student set classid=? where id=?
update t_student set classid=? where id=?
2.2执行结果数据库显示：
mysql> select * from t_classes;
+----+--------+
| id | name |
+----+--------+
| 1 | 尚学堂 |
+----+--------+
1 row in set (0.00 sec)
mysql> select * from t_student;
+----+--------+--------
| id | name |classesid
+----+--------+-------
| 1 | 菜10 | 1
+----+--------+-------
| 2 | 容祖儿 | 1
+----+--------+-------
1 row in set (0.00 sec)
2.3 我们现在分析一下数据库的结构，如这个测试方法，我们是先保存学生对象集合的。可是这时，这个学生对象里面只有名字与id，却没有classesid .可是表字段里是有classesid字段的。是在映射的时候加进去的。
可是如我们的测试方法，还是可以正确执行，班级里面可以加进去两个学生。这是为什么呢？
原因是，我们的classesid字段是可以为空的。
也就是说，我们先把学生保存进去，可是这时 classesid 字段是没有值的。等到保存Classes时，再更新这个字段，将班级id值更新(update)上去。
如果我们在此Students.hbm.xml文件加上这样一条，让 classesid字段不能为空，再执行这个方法时，在存储时就会失败了，因为clssesid字段在保存时必须要值，不然就存不进去了。
注：当修改完Students.hbm.xml文件时，要重新执行ExportDB.class文件，因为这里数据库中的表结构发生改变了。所以要重新生成表。
十三、测试加载
public void testLoad1(){
Session session=null;
try{
session=HibernateUtils.getSession();
Classes classes=(Classes)session.load(Classes.class,1);
Set students=classes.getStudents();
for(Iterator iter=students.iterator();iter.hasNext();){
Student student=(Student)iter.next();
System.out.println("https://www.sodocs.net/doc/7b3105109.html,="+student.getName()); }
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
public void testLoad2(){
Session session=null;
try{
session=HibernateUtils.getSession();
session.beginTransaction();
//注：load与get只能根据主键加载，根据别的字段是不可以的。 //第一个参数是相应的类
Classes classes=(Classes)session.load(Classes.class, 1); System.out.println("https://www.sodocs.net/doc/7b3105109.html,="+classes.getName());
//拿出班级的学生，它是一个集合，然后一个一个输出学生名字。 Set
for(Iterator
iter=students.iterator();iter.hasNext();){
Student student=iter.next();
System.out.println("https://www.sodocs.net/doc/7b3105109.html,="+student.getName()); }
session.getTransaction().rollback();
}catch(Exception e){
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
执行后SQL语句为：
先根据id到班级里面来查询
select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?
班级查上来后，就可以把班级的学生查询上来。因为班级维护了一指向多的关系，所以它要找到这个关系字段，把班级的id拿来，然后它到t_student这张表中，找维护两个表关系的字段，就是classesid=这个班级的学生，把它一个一个的拿上来，它会自动地把这些学生放到学生集合里面。
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=?
再回想一下一对多，查询用户时，也可以把组加上来。之所以可以这样，是因为我们配置了关系，如果没有在映射文件里面配置这种关系，则hibernate就不会给我们加上来了。
十四、readme.txt文件
hibernate 一对多关联映射。（单向日葵 Classed----->Student) 一对多关联映射利用了多对一关联映射原理。
多对一关联映射，在多的一端加入一个外键，指向一的一端。但是它维护的关系是多指向一的。
一对多关联映射，在多的一端加入一个外键，指向一的一端。但是它维护的关系是一指向多的。
也就是说，一对多与多对一映射策略是一样的，只不过站的角度不同。
因为是在一的一端维护的关系（为什么知道是在一的一端维护的关系呢？
因为我们将关系的配置写到一的一端就是Classes.hbm.xml文件里面了。
缺点：在一端维护关系的缺点：
*如果将t_student表里的classesid字段设置为非空，则无法保存
*因为在一的一端维护的，所以刚开始建立时，学生是不知道她是哪个班级的。
所以一的一端要发出多余的update语句。
因为不是在student这一端维护关系（就像我没有记住你的电话号，所以找不到你），
所以student不知道自己是哪个班的。所以需要发出多余的update语句来更新关系。
基于以上的缺点，所以一对多关联映射通常要做成双向的。就可以克服这些缺点了。双向的返过来就是多对一。
为什么要做成双向的，最大的考虑，是将关系交给多的一端来维护，不让一的一端来做了。
就像不能让姚明记住十三亿人的名字一样，我们记住姚的就可以了。
Hibernate配置文件的DTD
Hibernate中有两个配置文件 映射文件Xxx.hbm.xml 映射文件的的文件头DTD文件内容：
配置文件hibernate.cfg.xml 配置文件的文件头DTD文件内容： org.hibernate.dialect.MySQLDialect
Hibernate练习题
Hibernate&EJB考试试题 1、下面关于Hibernate说法正确的是（）（选择两项） A）Hibernate是ORM的一种实现方式 B）Hibernate不要JDBC的支持 C）属于控制层 D）属于数据持久层 2、下面关于ORM的说法错误的是（)（选择两项） A）对象关系映射，让现实中的对象同数据库的表产生映射（类与表产生映射） B）对象关系映射，让类同表产生关系 C）对象关系映射，让类同记录产生关系（类的实例与记录（表中的一行数据）产生关系） D）对象关系映射，让类中的属性同表中的列产生关系 3、下面关于Hibernate中Session的说法正确的是（）（选择两项） A）Session是轻量级的，可以随意的创建和销毁 B）Session是重量级的，不能随意的创建和销毁 C）Session是线程安全的 D）Session不是线程安全的 4、在Hibernate中，以下（）不属于session的方法 A、close（） B. open() C. update() D. delete() 5、下面关于Hibernate中load和get方法说法正确的是（） A）这两个方法是一样的，没有任何的区别 B）这两个方法不一样，load先找缓存，再找数据库
C）这两个方法不一样，get先找缓存，再找数据库 D）以上说法都不对 注：load()和get()都是先找缓存，再找数据库。 不同点是在检索时： load()是延迟检索，先返回代理对象，访问对象时在发出sql命令Get()是立即检索，直接发出sql命令，返回对象 6、在Hibernate中修改对象的说话错误的是（） A）只能利用update方法来做修改 B）可以利用saveOrUpdate方法来做修改 C）可以利用HQL语句来做修改 D）不能利用HQL语句来修改 7、下面关于Hibernate中Transaction的使用说法正确的是（）(选择两项) A）Transaction是可有可无的 B）Transaction在做查询的时候是可有可无的 C）Transaction在做修改的时候是可有可无的 D）Transaction在做修改的时候是必须的 8、使用Hibernate技术实现数据持久化时，下面（）内容不在 Hibernate配置文件中配置(选择一项) A) 数据库连接信息 B) 数据库类型（dialect） C) show_sql参数 D) 数据库表和实体的映射信息
持续集成测试
一、概念引入 持续集成是一种软件开发实践，即团队开发成员经常集成它们的工作，通常每个成员每天至少集成一次，也就意味着每天可能会发生多次集成。每次集成都通过自动化的构建（包括编译，发布，自动化测试)来验证，从而尽快地发现集成错误。许多团队发现这个过程可以大大减少集成的问题，让团队能够更快的开发内聚的软件。 在敏捷开发中，有一个很重要的实践叫做持续集成。而什么是持续集成呢？简单来说，持续集成是频繁、持续的在多个团队成员的工作中进行集成，并且给与反馈。一个典型的持续集成周期包括以下几个步骤： 1.持续集成服务器不断从版本控制服务器上检查代码状态，看代码是否有 更新。 2.如果发现代码有最新的提交，那么就从版本控制服务器下载最新的代码。 3.等代码完全更新以后，调用自动化编译脚本，进行代码编译。 4.运行所有的自动化测试。 5.进行代码分析。 6.产生可执行的软件，能够提供给测试人员进行测试。 测试是持续集成流程中重要的一环，也是区别去传统的软件开发流程中的一个重要的标志。为什么要有持续集成测试呢？ 每天，程序开发人员将各自开发的代码上传到配置管理工具（如SVN、VSS）中，而配置管理工具会记录下谁在什么时间上传了什么代码文件。随后，持续集成工具会定期（可以是几个小时、半天，或者一天，由使用者自己定义）向配置管理工具询问，从上一周期到现在是否有代码上传。如果有，则下载到持续集成工具中进行集成。之后，持续集成工具会调用构建工具代码编译、自动化测试，以及执行静态代码检查。如果这几项工作执行成功，则打包复制到应用服务器（如Weblogic）上执行重新发布，并形成代码检查与测试等报告；如果执行失败，则及时通过邮件通知管理者，并记录相关日志。 配置管理工具 毫无疑问，配置管理工具对持续集成工具来说是绝顶重要的，它是所有最新代码的来源。持续集成工具会定期向配置管理工具询问代码是否有更新。只有有了更新，持续集成工具才会去完成后续的工作，否则就没有了意义。目前在Java开发项目中，最主流的无疑是Subversion（简称SVN）。SVN是对CVS的升级，它通过插件的形式被集成到开发工具中，并且提供了更加方便的上传下载操作，使开发人员最厌恶的上传下载操作变得简便。SVN的另一个巨大贡献是改变了VSS 那样的串行修改模式。众所周之，VSS的版本管理思路就是串行修改模式，即对于同一个文件只能一个人修改，其他人不能修改。这样的模式对应大规模团队开发来说无疑是非常蹩脚的。SVN改变了这种模式，同一个文件可以多人并行操作，但同时SVN又提供了强大的版本冲突处理机制，当并行操作的多人各自提交版本时，通过版本冲突处理机制可以顺利的合并版本，使最终形成统一版本。
Hibernate3.6(开发必看)
1.Java对象持久化概述 1.1.应用程序的分层体系结构 1.1.1.基于B/S的典型三层架构 说明： 1，展现层：提供与用户交互的界面。 2，业务逻辑层：实现各种业务逻辑。 3，数据访问层：负责存放和管理应用程序的持久化业务数据。 1.1. 2.数据访问层与Hibernate在Java应用程序中的 角色 数据访问层（持久化层）封装了数据访问的细节，为业务逻辑层提供了面向对象的API。完善的持久化层应该达到的目标： 1，代码重用性高，可完成所有的数据访问操作。 2，如果需要的话，能够支持多种数据库平台。 3，具有相对独立性，当持久化层变化时，不会影响上层实现。 在数据访问层（持久化层）中可以使用Hibernate框架以实现要求，如下图所示：
1.2.软件模型 1.2.1.各种模型的说明 概念模型： 模拟问题域中的真实实体。描述每个实体的概念和属性及实体间关系。不描述实体行为。实体间的关系有一对一、一对多和多对多。。 关系数据模型： 在概念模型的基础上建立起来的，用于描述这些关系数据的静态结构。有以下内容组成：1，若干表 2，表的所有索引 3，视图 4，触发器 5，表与表之间的参照完整性
域模型： 在软件的分析阶段创建概念模型，在软件设计阶段创建域模型。 组成部分： 1，具有状态和行为的域对象。 2，域对象之间的关联。 域对象(domain object)： 构成域模型的基本元素就是域对象。对真实世界的实体的软件抽象，也叫做业务对象（Business Object，BO）。域对象可代表业务领域中的人、地点、事物或概念。 域对象分为以下几种: 1，实体域对象：通常是指业务领域中的名词。（plain old java object，简单Java 对象）。 2，过程域对象：应用中的业务逻辑或流程。依赖于实体域对象，业务领域中的动词。如发出订单、登陆等。 3，事件域对象：应用中的一些事件（警告、异常）。 1.2.2.域对象间的关系 关联： 类间的引用关系。以属性定义的方式表现。
hibernate面试题
1.Hibernate工作原理及为什么要用？ 原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Sesssion 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用： 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。 2．Hibernate是如何延迟加载? 1. Hibernate2延迟加载实现：a)实体对象b)集合（Collection） 2. Hibernate3 提供了属性的延迟加载功能 当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。 3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、 4．说下Hibernate的缓存机制 1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存 2. 二级缓存： a) 应用及缓存 b) 分布式缓存 条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据 c) 第三方缓存的实现
JAVA复试问题答案
（一） JAVA复试的问题整理 1 Hibernate 的优化流程是如何实现的，流程是怎么样？ 1.尽量使用many-to-one，避免使用单向one-to-many 2.灵活使用单向one-to-many 3.不用一对一，使用多对一代替一对一 4.配置对象缓存，不使用集合缓存 5.一对多使用Bag 多对一使用Set 6.继承使用显示多态 HQL:from object polymorphism="exlicit" 避免查处所有对象 7.消除大表，使用二级缓存 2 Struts1与Struts2的区别？ 在Action 实现类方面的对比：Struts 1 要求Action 类继承一个抽象基类；Struts 1 的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action 类可以实现一个Action 接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts2 提供一ActionSupport 基类去实现常用的接口。即使 Action 接口不是必须实现的，只有一个包含execute 方法的POJO 类都可以用作 Struts 2 的Action 。 线程模式方面的对比：Struts 1 Action 是单例模式并且必须是线程安全的，因为仅有Action 的一个实例来处理所有的请求。单例策略限制了Struts 1 Action 能做的事，并且要在开发时特别小心。Action 资源必须是线程安全的或同步的；Struts 2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。 Servlet 依赖方面的对比：Struts 1 Action 依赖于 Servlet API，因为Struts 1 Action 的execute 方法中有HttpServletRequest 和HttpServletResponse 方法。Struts 2 Action 不再依赖于 Servlet API，从而允许Action 脱离Web 容器运行，从而降低了测试Action 的难度。当然，如果Action 需要直接访问HttpServletRequest 和HttpServletResponse 参数，Struts 2 Action 仍然可以访问它们。但是，大部分时候，Action 都无需直接访问HttpServetRequest 和HttpServletResponse，从而给开发者更多灵活的选择。 可测性方面的对比：测试Struts 1 Action 的一个主要问题是execute 方法依赖于Servlet API，这使得Action 的测试要依赖于Web 容器。为了脱离Web 容器测试 Struts1
用MyEclipse如何自动生成hibernate的.hbm.xml文件
用MyEclipse如何自动生成hibernate的.hbm.xml文件(2010-07-29 17:36:01) 今天在网上看到很多人都不知道怎么用MyEclipse自动生成hibernate的.hbm.xml文件。我甚至看到有位兄弟竟然自己写出那个格式的文件来。首先我不得不佩服那位兄弟的记忆力。可是我这边有更直接的方法希望能对那些入门级别的人一点帮助！ 在hibernate中，每个数据表对应的其实是一个实体类，每个实体类有一个对应的hbm.xml 配置文件和你匹配，myeclipse中其实有个MyEclipse Database Explorer视图，它提供了myeclipse与数据库直接连接的内置窗口，并且通过此窗口可以生成hibernate的mapping文件。 1.在项目上点击右键选择MyEclipse选项，为应用增加Hibernate特性. 2.在出现的配置窗口中，选中“Add Hibernate 2.1 libraries to project?”，然后设定存放Hibernate 库文件的目录为：/WEB-INF/lib 目录，默认会选择创建一个新的Hibernate配置文件hibernate.cfg.xml。 3.点击下一步，进入Hibernate数据库连接配置界面，在Connection Profile选项中直接选择在MyEclipse Database Explorer中配置的vipdata选项，然后就会自动生成其他的配置，可以选择“Copy JDBC Driver and add to classpath”,这样就会将JDBC驱动拷贝到WEB-INF/lib目录中。： 4.点击下一步，来创建Hibernate的SessionFactory类，这是一个简单的集中管理Hibernate 会话的工厂类，填写类的全名称。 5.点击完成，然后MyEclipse就会将Hibernate相关的jar包拷贝到lib目录下，同时会生成Hibernate的配置文件：hibernate.cfg.xml，和SessionFactory类。 现在要利用MyEclipse Database Explorer视图中的工具来生成Hibernate的映射文件。切换到MyEclipse Database Explorer视图，在表vipdata上点击右键，选择Create Hibernate Mapping.
Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结
Hibernate（6）——一对多和多对多关联关系映射（xml和注解）总结 涉及的知识点总结如下： ?One to Many 映射关系 o多对一单向外键关联(XML/Annotation) o一对多单向外键关联(XML/Annotation) o懒加载和积极加载 o一对多双向外键关联(XML/Annotation) ?Many to Many 映射关系 o多对多单向外键关联(XML/Annotation) o多对多双向外键关联(XML/Annotation) o set的inverse元素详解 ?问题小结 ?关联关系的优缺点 多对一单向外键关联关系 注意多对一关联是多方持有一方的引用。看一个例子，去淘宝购物，那么一个淘宝用户可以对应多个购物订单，如图所示： 多的一方是Orders，持有一方的引用，也就是Users，而在Users中无需作任何定义，从订单到用户的关系是单向多对一关联。对应数据库就是： 还有比如说学生和班级的关系，多个学生可以属于同一个班级，这就是从学生到班级也是典型的单向多对一关系，看代码实现： 基于注解的多对一单向外键关联： 单向多对一关联中，多方需要持有一方的引用，那么多方（学生类）需要额外配置，需要对持有的一方引用使用注解@ManyToOne (cascade={CascadeType.ALL}, fetch=FetchType.EAGER)，设置为级联操作和饥渴的抓取策略，@JoinColumn(name="cid")，而一方（教室类）无需做任何多方的定义。 注意；多方必须保留一个不带参数的构造器！ import ; import ; import ; //班级类,在多对一关系中属于一的方，不持有其他多余的配置，反而是被多方持有
如何根据hibernate的实体类和实体类配置文件生成数据库的表
网络地址： 主题：如何根据hibernate的实体类和实体类配置文件生成数据库的表 内容部分 [c-sharp]view plaincopyprint? 1. 4.
HQL 查询
Hibernate提供了强大的查询系统，使用Hibernate有多种查询方法可以选择：可以使用Hibernate的HQL查询，也可以使用条件查询，甚至可以使用原生的SQL 查询语句。其中HQL查询时Hibernate配置的功能强大的查询语句。HQL是非常有意识的被设计为完全面向对象的查询，它可以理解如继承、多态和关联之类的概念。 一、HQL查询 HQL的语法和SQL很相似，但是HQL是一种面向对象的查询语句，它的操作对象是类、实例、属性等，而SQL的操作对象是数据表、列等数据库对象。 由于HQL是完全面向对象的查询语句，因此可以支持继承、多态等特性。 HQL查询依赖于Query类，每一个Query实例对应一个查询对象，它的执行是通过Session的createQuery()方法来获得的。 执行HQL查询的步骤： 1、获得Hibernate Session对象 2、编写HQL语句 3、调用Session的createQuery方法创建查询对象 4、如果HQL语句包含参数，则调用Query的setXxx方法为参数赋值 5、调用Query对象的list等方法返回查询结果。 实例： 上面的程序先编写HQL语句后，使用Session的createQuery(hql)方法创建一个Query，Query对象使用setXxx方法为HQL语句的参数赋值，最后调用list()方法返回查询的全部结果。 在这里Query对象可以连续多次调用setXxx方法为HQL参数赋值。这是因为Hibernate Query的setXxx方法的返回值为Query本身，因此程序创建Query后，可以直接多次调用setXxx方法为HQL语句的参数赋值。
hibernate关系映射注解配置
1. Hibernate Annotation关系映射有下面几种类型： 1)一对一外键关联映射（单向） 2)一对一外键关联映射（双向） 3)一对一主键关联映射（不重要，有需要看下文档即可） 在实际中很少用，使用注解@PrimaryKeyJoinColumn 意思是说，我的主键去参考另外一张表中的主键，作为我的主键，但是在我测试使用 注解一对一主键关联映射，在生成表的时候，数据库中并没有生成关联，使用XML 映射可以生成。Annotation注解一对一主键关联映，有些bug。不过没空去研究它。 因为在实际开发中一对一很少用。在实际开发中我机会没有用过，主键关联就更少了 4)多对一关联映射（单向） 5)一对多关联映射（单向） 6)一对多关联映射（双向） 7)多对多关联映射（单向） 8)多对多关联映射（双向） 2.介绍各种映射用法 1）一对一外键关联映射（单向）Husband ---> Wife public class Husband{ private Wife wife; @OneToOne(cascade=CascadeType.ALL) @JoinColumn(name="wife_id",unique=true) public Wife getWife(){…} … } public class Wife{ } 一对一外键关联，使用@OneToOne，并设置了级联操作 @JoinColum设置了外键的名称为wife_id（数据库字段名），如果不设置，则默认为另一类的属性名+ _id 外键的值是唯一的(unique)，不可重复，与另一类的主键一致 2）一对一外键关联映射（双向）Husband <---> Wife public class Husband{ private Wife wife; @OneToOne(cascade=CascadeType.ALL) @JoinColumn(name="wife_id",unique=true) public Wife getWife(){…} ... } public class Wife{ private Husband husband; @OneToOne(mappedBy="wife",cascade=CascadeType.ALL) public Husband getHusband(){…} ... } 一对一双向关联关系，使用@OneToOne 注意：需要加上mappedBy="wife"，如果不加上的话，Wife也会生成一个外键（husband_id）。mappedby="wife"需要指向与他关联对象的一个属性(即Husband类里面的wife属性)，这里的会在Husband表里面生成个外键wife_id字段，而Wife表里则不会生成。这里Husband作为维护端即主
Java应用数据库：Hibernate对多表关联查询
执行救济竞合的实务把握 周玉和彭长林所谓执行救济竞合，是指执行当事人、利害关系人或案外人，就具体执行案件的同一执行行为或执行标的，各自以不同的途径、方式及理由等提出异议，交由人民法院审查裁决的情形。慧眼辨析和准确把握执行救济竞合，对于及时、准确审查处理执行争议，提高执行效率，保护执行当事人、利害关系人、案外人合法权益具有积极意义。笔者现侧重从实务的角度，针对执行救济不同路径的竞合情形，就如何在实务中把握谈些心得。 执行实践中执行救济竞合情形，常见的有各不同主体的执行异议救济竞合、利害关系人程序异议与案外人实体异议竞合、消极执行与执行异议及执行监督救济竞合、执行异议与案外人异议及执行监督救济竞合四种情形。对执行救济竞合情形的不同处理，将在后续救济途径、救济时效、救济功能上产生不同的法律后果。因此，在司法实务中应当明晰梳辨、认真把握，针对不同情形作出不同处理。具体可从四个方面审查把关： 一、把好立案受理关 原则上对所有执行当事人、利害关系人、案外人的异议、执行复议、案外人异议之诉等，均应予以受理。但对同一主体就同一执行事项所提出的异议，则只能选择其中最恰当情形予以立案;如果当事人、利害关系人、案外人已行使异议权、复议权、申请更换执行法院权、诉权以资救济，则无必要启动执行监督立案程序。反之，则应当启动执行监督立案程序予以执行监督。 对于立案受理这一环节，还应注意：一是审查基本要件，防止恶意异议。基本要件包括异议主体身份资料，如公民个人的居民身份证或户口簿、法人的机构代码证等;异议书使用书面形式提出，并由异议人签名盖章;相应的基本证据材料，如执行法院的具体执行行为法律文
书、执行行为所违反的法律条文、对执行标的权属凭证或相应权利证明等。三个基本情况不能同时提供的，一般不予立案受理。二是审查提起异议、复议或诉讼期间。对执行异议要求在执行程序结束前提出;对执行程序已经结束的，不能再作执行异议立案。对所遭受的损害，异议人可通过提起损害赔偿之诉或返还不当得利之诉或者要求执行法院予以国家赔偿;对申请变更执行法院，只能向上一级法院提出，但需适度控制，一般限于被执行人有财产可供执行或有条件执行的案件，且需执行期间满六个月以上(这里的六个月应当剔除公告期间、鉴定评估、异议审查等期间;对裁定不服向上一级法院申请复议期间为十日内，执行当事人、案外人向执行法院提起的许可执行之诉、执行标的异议之诉、分配方案异议之诉，为收到裁定或通知之日起十五日内。 二、把好审查定性关 首先，对执行异议及复议，主要审查执行行为是否违反了法律规定和司法解释，即审查执行行为的合法性。执行行为的范围主要包括四个方面：执行法院采取的执行措施、强制执行时应当遵守的程序、强制执行中作出的某些法律文书(包括应发出而未发出相应的法律文书，应发出但发出了错误的法律文书，不应发出而发出了某种法律文书等等，如进行民事搜查时未出示搜查令等、其他侵害当事人、利害关系人合法权益的执行行为(如违法追加、变更被执行人等。上述情形往往相互交织在一起，难以截然分开。 还应当明确，对于新民事诉讼法所规定的对被执行人限制出境、在征信系统记录、在媒体公布不履行义务信息，应当作为一种执行行为对待，对其异议应按执行异议、复议程序审查。 其次，对案外人异议，主要审查案外人对执行标的物有无“所有权或者是其他阻止标的物转让、交付的权利”，即是否有足以排除强制执行的权利。这种权利不一定都是物权，主要包括所有权、用益物权、担保物权、占有、孳息收取权、债权、依法保全的标的物等。
利用轻量对象关系映射技术Hibernate提高开发效率
利用轻量对象关系映射技术Hibernate提高开发效率 Enhancing Development Efficiency with Hibernate a Lightweight Object/Relational Mapping Technology 谢挺 周维民 （上海大学机电工程与自动化学院，上海 200072） 摘 要 Hibernate是一种轻量对象关系映射技术。文章通过实例，介绍了Hibernate的一些关键特性，并阐述了该技术的一些局限性。 关键词 Hibernate 对象关系映射企业级JavaBeans 持久化 Abstract Hibernate is a lightweight Object/Relational Mapping(ORM) technology. Some key features of Hibernate are illustrated, and some limits of this technology are expounded. Keywords Hibernate Object/Relational Mapping (ORM) EJB Permanence 0 引言 随着internet的发展，应用服务程序已经从集中式、C/S模式过渡到B/S、分布式模式；无论是用户或是供应商都迫切希望缩短开发周期、提高开发效率，Hibernate应运而生。 1 Hibernate简介 Hibernate是一个面向Java环境的对象/关系数据库映射工具。对象/关系数据库映射(Object/Relational Mapping , ORM)这个术语表示一种技术，用来把对象模型表示的对象映射到基于SQL的关系模型中去。 Hibernate不仅提高Java类到数据库的映射，还提供数据查询和获取数据的方法。Hibernate在英语中的意思是“冬眠”，顾名思义它使得商务逻辑的开发和数据库最大程度地分离，可以大幅度减少开发时人工使用SQL和JDBC处理数据的时间。Hibernate的目标是解放开发者通常与数据持久化相关的编程任务的95％。对于那些在基于Java的中间层应用中，它们实现面向对象的业务模型和商业逻辑的应用，Hibernate是很有用的。 图1是Hibernate的体系结构图，从图中可以Array看到，系统为3层B/S模式，应用程序在客户端运 行将持久化的对象交由Hibernate。Hibernate通过 properties属性设置和XML Mapping实现商务逻 辑，调用和存储低层数据库后将返回的结果送给 客户端。 Hibernate对每一种数据库都有对应的 Dialect进行操作优化,从而提高它在各种情况 下的效率。目前,它的版本为3.0、支持的数据 库有Oracle、DB2、MySQL、PostgreSQL、Sybase,Interbase、Pointbase、Microsoft SQL Server、
关于SSH框架发展
关于SSH框架发展 SSH 为 Secure Shell 的缩写，由 IETF 的网络工作小组（Network Working Group）所制定；SSH 为建立在应用层和传输层基础上的安全协议。SSH 是目前较可靠，专为远程登录会话和其他网络服务提供安全性的协议。利用 SSH 协议可以有效防止远程管理过程中的信息泄露问题。S S H最初是U N I X系统上的一个程序，后来又迅速扩展到其他操作平台。S S H在正确使用时可弥补网络中的漏洞。S S H客户端适用于多种平台。几乎所有U N I X平台—包括H P - U X、L i n u x、A I X、S o l a r i s、Digital UNIX、I r i x，以及其他平台—都可运行SSH。 传统的网络服务程序，如：ftp、pop和telnet在本质上都是不安全的，因为它们在网络上用明文传送口令和数据，别有用心的人非常容易就可以截获这些口令和数据。而且，这些服务程序的安全验证方式也是有其弱点的，就是很容易受到“中间人”（man-in-the-middle）这种方式的攻击。所谓“中间人”的攻击方式，就是“中间人”冒充真正的服务器接收你的传给服务器的数据，然后再冒充你把数据传给真正的服务器。服务器和你之间的数据传送被“中间人”一转手做了手脚之后，就会出现很严重的问题。通过使用SSH，你可以把所有传输的数据进行加密，这样"中间人"这种攻击方式就不可能实现了，而且也能够防止DNS欺骗和IP欺骗。使用SSH，还有一个额外的好处就是传输的数据是经过压缩的，所以可以加快传输的速度。SSH有很多功能，它既可以代替Telnet，又可以为FTP、PoP、甚至为PPP提供一个安全的"通道"。 Java2企业版为中间件领域思想的统一上发挥了很大的作用。比如，J2EE为分布式事务管理、目录服务和消息服务提供了一套标准的编程接口。J2EE的基础——Java2标准版(J2SE) ，成功地为Java提供了一套访问关系数据库的标准。 但是，就像本文中“J2EE缺乏对编程的支持”提到的一样，J2EE这个平台没有能够提供一个令人满意的应用程序编程模型（application programming model）。Sun 公司和一些大的应用服务器供应商都想用开发工具来降低J2EE开发的复杂性，但是这些工具没有其他的JAVA 开发工具优秀，后者有先进的重构工具，和.NET平台相比，J2EE 的工具支持显得很逊色。 很多J2EE开发工具自动产生的代码像这些工具本身同样复杂。在开源社区很多小型J2EE开发者选择了另外一种开发方式——一些可以降低J2EE开发难度的开发框架,较为流行的比如： Struts, Hibernate, 和 Spring Framework，他们当今很多J2EE项目种扮演着重要角色。
Nhibernate一对多级联保存_双向映射
一对多关系示例，Base_Order和Base_OrderDetail是一对多的关系，通过Base_Order.OrderId和Base_O rderDetail.OrderId关联： 实体Order代码： [Class(Table = "BASE_Order")] public class Order : Common.BaseEntity { private IList _childList; public Order() { _childList = new ArrayList(); } ///
Hibernate映射解决问题
Hibernate映射解决问题 做Hibernate映射已经做了五天了,期间遇到了不少错误,有的时候错误很细小,很难发现.现在就来总结一下,常见的错误,有的也是在网上搜了看到的! 第一种问题:Could not execute JDBC batch update 网上说有两种可能: 1.因为Hibernate Tools（或者Eclipse本身的Database Explorer）生成*.hbn.xml工具中包含有catalog="***"（*表示数据库名称）这样的属性,将该属性删除就可以了 2.估计是你的列名里面有关键字的原因吧，命名列的时候不要单独使用date,ID...这种关键字 但是,我觉得他写得不完全啦!我遇到的就不是两种原因,而是List映射时,对应表的索引项没有设成主键,所以就出错了.虽然找了蛮长时间的.同样, 它也会出现Duplicate entry '1' for key 1的错误啦! 第二种问题(归纳下): 1．Caused by: org.dom4j.DocumentException: Invalid byte 2 of 2-byte UTF-8 sequence. Nested exception: Invalid byte 2 of 2-byte UTF-8 sequence. 如果出现这行错误说明你的XML配置文件有不规范的字符，检查下。 2．net.sf.hibernate.MappingException: Error reading resource: hibernate/Hello_Bean.hbm.xml 如果出现这行错误说明你的hibernate的XML配置文件有错 3．net.sf.hibernate.MappingException: Resource: hibernate/Hello_Bean.hbm.xml not found 如果出现这行错误说明hibernate的XML配置文件没有找到，你应该把XML文件放在与你的类文件同个目录下,一般跟同名的java持久化类放在一起，也就是跟Hello_Bean.class类文件一起。4．net.sf.hibernate.PropertyNotFoundException: Could not find a setter for property name in class hibernate.Hello_Bean 如果出现这行错误说明你的xml文件里设置的字段名name的值与Hello_Bean.Java类里的getXXX 或setXXX方法不一致。 5．net.sf.hibernate.HibernateException: JDBC Driver class not found: org.gjt.mm.mysql.Driver：没有找到数据库驱动程序 6．The database return no natively generate indentity value。主键没有添加增量 7．net.sf.hibernate.PropertyValueException:not-null property references a null or transient value:com.pack.Rordercontent. 异常产生原因：Rordercontent对象的非空属性Rordertable引用了一个临时对象。 8．net.sf.hibernate.TransientobjectException:objiect references an unsaved transient instance –save the transient instance before flushing: com.pack.Rordertable 持久化对象的某个属性引用了一个临时对象Rordertable https://www.sodocs.net/doc/7b3105109.html,.sf.hibernate.MappingException
相关文档
- 第三章Hibernate对象关系映射
- Hibernate的关联映射
- Hibernate中的继承关系的映射实现
- Hibernate中OneToMany映射讲解
- Hibernate(6)—— 一对多和多对多关联关系映射(xml和注解)总结
- Hibernate一对一映射配置详解
- Hibernate映射关联关系
- hibernate关系映射总结
- hibernate映射关系学习笔记
- hibernate的继承映射(Inheritance Mapping)
- hibernate映射文件自动生成
- Hibernate练习题
- 利用轻量对象关系映射技术Hibernate提高开发效率
- Hibernate之one-to-one主键关联映射
- hibernate--java数据类型和各种数据库类型的映射关系图
- Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结
- Hibernate 映射关联关系
- Hibernate(JPA)多对多(ManyToMany)关联映射不完美之处
- Hibernate映射文件
- hibernate关系映射注解配置