day1
一. hibernate数据持久化组件
对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库）
1.为什么要持久化:
a.内存是暂时存储设备,断电后数据易丢失
b.网络传输无法传输内存中的对象，需要将对象外化
c.内存中数据查询,组织不方便
d.内存只能存储少量数据
2.怎样持久化
a.对象序列化--> 二进制流,合并存储,粒度大,无规律,不支持检索
只适合少数个别对象的序列化
b.用JDBC/EJB/ORM 将数据存入数据库用JDBC:(Java DB Connection)
优点:底层开发,控制力强(细); 效率最高; 标准的(SQL)JDBC,有可移植性缺点:过于复杂; 代码量大; 可维护性差(代码重用性低);
用EJB:(Entity Java Bean)
优点:直接自动生成JDBC代码; 持久对象(PO)的状态由服务器管理; 声明式的事务
缺点:功能不全(特殊的组件,不能做继承关系); EJB容器是侵入性容器,失去OO的优点; 调试更复杂用ORM:（object relation mapping）对象关系映射
优点:自动生成JDBC(代码量下降); 使用(plain oldest java object---pojo),非侵入型; 提供状态管理; 难度下降,不需要容器
缺点:由于开源, 文档少; bug多; 技术支持差
结论: 用java开发-->必须将数据持久化-->用数据库持久化-->须用ORM-->需要用Hibernate
二. Hibernate
1.POJO类
plain oldest java object,就是标准的Java Bean。
2.Hibernate
Hibernate -->一个可以自动的根据xml完成对象关系映射，并持久化到数据库的开源组件。其底层也是由JDBC实现的。hibernate是通过xml文件的配置，对数据库的底层的方言，以及数据库连接所需的信息，以及连接数据库的驱动。
hibernate的系统配置文件
hibernate.cfg.xml -->与数据库建立连接(一般放在项目的根目录下)
XXXX.hbm.xml-->用来建立类与表之间的映射关系(一般将映射类的xml文件和实体类放在一起)
3.Hibernate API
Configuragion 读配置文件(默认名:hibernate.cfg.xml) (org.hibernate.cfg.Configuration)
生成SessionFactory:SessionFactory 重量级的对象, 线程安全的
(org.hibernate.SessionFactory),生成Session .
Session，相当于JDBC中的Connection (org.hibernate.Session)，轻量级的对象,线程不安全(原则上一个线程一个Session,不要放在并发的环境中)
生成Transaction
Transaction 管理事务的对象(org.hibernate.Transaction)
Query 查询对象,提供面向对象的查询语言(HQL)
4.使用hibernate编程步骤
1，配置环境，加载hibernate的jar文件，以及连接数据库连接使用的jar文件，并配置CLASSPATH环境变量。
2，写hibernate所需的配置文件，hibernate.cfg.xml ，XXX.hbm.xml
3，写POJO类
4，调用hibernate API。
1)使用Configuration对象的buildSessionFactory()方法创建SessionFactory对象
2)使用SessionFactory对象openSession()方法创建Session对象。
3)使用Session的相应方法来操作数据库，将对象信息持久化到数据库。
5. HQL语句
Query q = s.createQuery("from Account where actNo=:actNo");
//from 类名where 属性名=:shuxingming
q.setLong("actNo",12345);//设置属性名,并赋值
q.uniqueResult()//获得匹配HQL的唯一属性
附: 1.环境配置:
a. 类库
*** 导入hibernate 库文件***
1、在eclipse中建立一个java工程，如:hbn
2、在工程hbn的属性--Build Path中选择Add Libraries
3、在Add Libraries窗口中选择User Library点next按钮
4、在User Library窗口中点User Libraries ...按钮
5、在User Libraries窗口中，点new按钮
6、在New user library窗口中，填写一个User libary name(如:hbnlib,注意不要选择System libary 复选框)，点OK按钮回到User Liberies窗口
7、在User Liberaries窗口中选择刚刚创建的hbnlib,点Add jars按钮
8、在打开的文件选择窗口中找到解压好的hibernate的库文件，全部选中，点"打开"按钮，返回User Libraries窗口
9、在User Libraries窗口中点OK按钮，返回User Library 窗口；再点Finish按钮，结束操作
b. 驱动
c. 映射文件/配置文件的模板
d. Eclips导入2个DTD文件
*** 导入hibernate 库文件***
1、在eclipse中建立一个java工程，如:hbn
2、在工程hbn的属性--Build Path中选择Add Libraries
3、在Add Libraries窗口中选择User Library点next按钮
4、在User Library窗口中点User Libraries ...按钮
5、在User Libraries窗口中，点new按钮
6、在New user library窗口中，填写一个User libary name(如:hbnlib,注意不要选择System libary 复选框)，点OK按钮回到User Liberies窗口
7、在User Liberaries窗口中选择刚刚创建的hbnlib,点Add jars按钮
8、在打开的文件选择窗口中找到解压好的hibernate的库文件，全部选中，点"打开"按钮，返回User Libraries窗口
9、在User Libraries窗口中点OK按钮，返回User Library 窗口；再点Finish按钮，结束操作
2. hibernate.cfg.xml的写法
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"https://www.doczj.com/doc/8a9855328.html,/hibernate-configuration-3.0.dtd">
3. hibernate的映射类的XXXX.hbm.xml的写法
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://www.doczj.com/doc/8a9855328.html,/hibernate-mapping-3.0.dtd">
pk_table
id_value
4. 创建数据库表结构:
create account_hz(aid number(20) primary key,actNo varchar(50) not null unique,balance number(12,2) not null);create t_hilo(hi number(20));insert into t_hilo values(1);//必须事先插入一条记录到表
5. 调用hibernate API
public class Test {
public static void main(String[] args) {
Account act = null;
//step1: 创建Configration对象
Configuration config = new Configuration().configure();
//step2: 获取SessionFactorye
SessionFactory sf = config.buildSessionFactory();
//step3:获取Session和Transaction,进行持久化操作
Session s = null;
Transaction tran = null;
try {
s = sf.openSession();
tran = s.beginTransaction();//启动事务
act = new Account(12345, 2000.00);
s.save(act);//将帐户对象持久化
https://www.doczj.com/doc/8a9855328.html,mit();//提交事务
} catch (Exception e) {
if(tran != null){
tran.rollback();
e.printStackTrace();
} finally{
if(s!=null) s.close();
}
}
}
6.Util工具类:
public class HbnUtilV1 {
private static SessionFactory sf;
static{
Configuration config = null;
try {
config = new Configuration().configure();
sf = config.buildSessionFactory();
} catch (Exception e) {
e.printStackTrace();
}
}
public static Session getSession(){
Session s = null;
if(sf!=null)
s = sf.openSession();
return s;
}
}
day3
一. one-to-many
1. one端set标签的设置
注:inverse="true"就是在设置如果在内存中的修改或添加了这个集合中的某一个或某几个对
象他不会将全部集合的信息同步到数据库，而是只将集合中被修改的对象重新同步到数据
库。
2. many端
二.状态
1. 持久对象的状态-->PO外在的状态(OOAD中对象的状态-->PO内在的状态)
Transient 暂时状态: po 和Session无关,数据库中也无该记录
Persistent 持久状态: po 和Session有关,数据库中有该记录
Detached 游离/脱管态:po和Session无关,数据库中有该记录
注:和Session关系,即Session中有该对象的副本和该对象的引用
持久化对象: 即就是在数据库中存有其相对应数据的对象，并且在内存中也有这个对象，内
部状态和外部状态同步, 这个对象在Session的管理范围内,也就是调用Session.save()方法同
步到数据库的对象。
临时对象: 即在内存中刚刚创建(new)的对象，还没有同步到数据库，或者是调用
Session.delete(),数据库中信息被删除了的对象。
游离对象: 也就是在数据库中有和该对象向对应的纪录，并且在内存中的也存在该对象，但
是不在Session的管理范围之内，如在Session关闭之后，就成了游离对象，就不会在将其
改变同步到数据库中.
内在状态-->外在化? 是-->持久态--否-->暂态
(类属性) (表记录) --是-->Session同步?否-->游离态
2. 状态转换: _|_-->close( save() / saveOrUpdate() close()/clear()/evict()
Transient--------------------->Persistent----------------------->Detached
(临时态)<---------------------(持久态)<----------------------- (游离态)
delete() update()/saveOrUpdate()/lock()
三. 级联操作cascade
cascade属性是设置级联操作的也就是在操作一端的数据如果影响到多端数据时会进行级联
操作.
1. none: 就是只对本对象进行操作,不使用级联操作，默认级联是none。
2. save-update: 也就是只有对象保存操作（持久化操作）或者是持久化对象的更新操作，才会级联操作关联对象（子对象）,one2many关系中多的那一方会使用;
3. delete: 对持久化对象的删除操作时会进行级联操作关联对象（子对象）。
4. all: 对持久化对象的所有操作都会级联操作关联对象（子对象）。
5. all-delete-orphan: 在多端进行删除操作时，会在多端表中留下null空纪录，设置了级联操作为delete之会将表中表示关联的外键id置成null，不会将这条纪录也删除掉，而把级联设置成delete-orphan就不会留有空纪录，而是级联的把相关纪录删除掉。(级别最深) cascade="save-update,delete-orphan"
四. 批量更新(Batch update)
1. session.flush()和session.clear()联合使用
2. batch-size: 这个属性写在set标签中，代表批量加载，也就是在加载一端的集合属性时会一次加载指定的数量的对象，而不是默认的一个一个的加载，会提高效率，批量加载只能用于延迟加载和立即加载策略，也就是（lazy="true"或者lazy="false"）。
注: lazy="true" 延迟加载，所谓的延迟加载，就是对一端的集合属性的加载策略，就是在不使用到集合中的对象的数据就不会真正的加载集合中的对象数据，而是家在一个代理对象就相当于的一个空的容器。这也就是会出现LazyInitializationException异常，也就是没有初始化这个代理的集合对象，在事先查询到了集合中的对象就会初始化这个对象，如果Session 没有关闭就会在查询加载集合中的对象信息，如果提前关闭了Session，当使用集合中的对象信息时就会有这个异常。
五. Hibernate控制的事务(ACID,atomicity consistency isolation durability)事务保证原子操作的不可分，也就是操作的同时成功或同时失败。
Transaction tran=session.beginTranaction();//....事务操作
https://www.doczj.com/doc/8a9855328.html,mit();
tran.rollback();
以上是事务对象的方法，来实现对事务的支持。
六、hibernate的事务隔离级别
hibernate的事务隔离级别和JDBC中大致相同。
设置时要在hibernate.cfg.xml配置
1，读未提交的数据（Read uncommitted isolation）
2，读已提交的数据（Read committed isolation）
4，可重复读级别（Repeatable read isolation）
8，可串行化级别（Serializable isolation）
七、hibernate的锁（悲观锁，乐观锁）
1. 悲观锁: 是由数据库本身所实现的，会对数据库中的数据进行锁定，也就是锁行,在同一时间内只能有一个读写数据操作。
LockMode.UPGRADE,修改锁，在get()方法中加上这个设置作为第三个参数。LockMode.NONE 无锁机制
LockMode.READ 读取锁(JDBC中的for update)
LockMode.WRITE 写入锁，不能在程序中直接使用
例如:tran = s.beginTransaction();
user = (User)s.get(User.class , userid , LockMode.UPGRADE);
user.setName("new name");
https://www.doczj.com/doc/8a9855328.html,mit();
还可以使用Session.lock() Query.setLockMode() Criteria.setLockMode()方法来设置锁
2. 乐观锁: 也就是通过对记录加上某些信息来解决并发访问的问题。
解决冲突的手段: 加上版本versionNo
if(read_versionNo=versionNo) write versionNo++ else do it again
一. many-tomany(以学生选课为例)
1.Student.hbm.xml文件的设置
2.Course.hbm.xml文件的设置
lazy="false">
在Student实体类中要设置Student与Course的关联:
public void registerCourse(Course c) {
courses.add(c);
c.getStudents().add(this);
}
3.注: hibernate的实现方式是通过中间表(ying_enrollment),间接实现了多对多关系，实际上也是将多对多拆分
成两个双向的一对多关系。
Hibernate知识点小记
1.cascade
cascade属性是设置级联操作的也就是在操作一端的数据如果影响到多端数据时会进行级联操作，一对一的时候直接写在标签上，其他的要写在set标签上
cascade="none|save-update|all|all-delete-orphan"
none 就是不使用级联操作，默认级联是none。
save-update 也就是只有对象保存操作（持久化操作）或者是持久化对象的更新操作，才会级联操作关联对象（子对象）。
all-delete-orphan，在多端进行删除操作时，会再多端表中留下null空纪录，设置了级联操作为delete之会将表中表示关联的外键id置成null，
不会将这条纪录也删除掉，而把级联设置成delete-orphan就不会留有空纪录，而是级联的把相关纪录删除掉。
2.inverse
inverse="true"就是在设置如果在内存中的修改或添加了这个集合中的某一个或某几个对象他不会将全部集合的信息同步到数据库，而是只将集合中被修改的对象重新同步到数据库
https://www.doczj.com/doc/8a9855328.html,zy
lazy=―true‖
延迟加载，所谓的延迟加载，就是对一端的集合属性的加载策略，就是在不使用到集合中的对象的数据就不会真正的加载集合中的对象数据，而是家在一个代理对象就相当于的一个空的容器。这也就是会出现LazyInitializationException异常，也就是没有初始化这个代理的集合对象，在事先查询到了集合中的对象就会初始化这个对象，如果Session没有关闭就会在查询加载集合中的对象信息，如果提前关闭了Session，当使用集合中的对象信息时就会有这个异常。
4.fetch
fetch=―join‖，这就是使用了预先抓取策略，也就是针对关联的对象的加载策略，在使用到关联对象的信息时会再发送sql语句，如果不使用fetch=―join‖，就会不使用表连接而是先查出一端的关联id再一条一条的发送sql语句查询到关联对象信息，使用了fetch=―join‖就会使用表连接将关联对象信息直接查寻出来的。fetch=―lazy‖这个是默认的设置。
二. inherit_mapping
建表策略(以Account CheckAccount DebitAccount 类为例)
（1）只为具体类建表只为具体类建表，使用于不使用多态的情况下，具体类之间没有继承关系时适用需要针对每个类写映射配置文件，就和普通的单表映射的xml文件相同。也可以使用一个xml文件来进行映射，可以通过写union-subclass标签来表现其关系这里不能使用id生成策略中的native，而是要指定特定的生成策略。
例：
table="t_check_account">
table="t_debit_account">
（2）每个类建一个表每个类建一个表，可以有效减少数据的冗余，减少字段，查询效率不很高。正对每个类建一个表，只要写一个配置文件来进行类的映射即可映射文件中的子类可以使用join-subclass标签来表示，并且引用父类的主键作为共享主键，就是不需要指定id 生成策略
例：
table="ying_check_account">
table="ying_debit_account">
（3）所有类建一个表所有类只建一个表，查寻效率比较高，但是会产生很多空间浪费，当子类中有非空约束,就不大适用了，这是对于子类可以使用subclass标签表示。
例:
discriminator-value="c">
discriminator-value="d">
注: 不考虑多态时，最好是用只针对具体类建表(2个表)，而考虑多态时尽量使用所有类建一个表，
只有当子类中的属性过多是才考虑每个类建一个表的策略。
（4）三种策略的比较:(详见孙卫琴主编的精通Hibernate一书P424)如果不需要支持多态查询和多态关联,可以采用每个具体类对应一个表如果需要持多态查询和多态关联,并且子类包含的属性很多,可以采用所有类对应一个表如果需要持多态查询和多态关联,并且子类包含的属性很多,可以采用每个类对应一个表
day5
一. 组件映射:
把持久类换成非持久类保存在数据库中;一个类如果有一个独立的oid,则该类是一个持久类,否则是一个组件.
目的: 简化操作
适应情况:
两个类之间具有组合(或强度较小的聚合)关系
组合/聚合
PO类(整体)<------------->组件类(部分)
1:1/1:m
组件映射(1:1)
集合映射(1:m)组件是退化的PO;oid消失组件映射是退化的基数映射只要有可能,就要用组件映射
例如:(以Account Address类为例,只需要写一个Account.hbm.xml)
public class Account {
private Long aid;
private long actNo;
private double balance;
private Address address;
}
二. 集合映射
1.集合比较
集合顺序重复
Set 无否
List 有能
Map 有key(否)
bag 无能
1、set映射
关联对象的属性除了外键之外，只有1、2个属性，那么就可以使用set映射
使用了set标签的element元素，不用创建关联对象就可以实现单向一对多的关联关系public class Room implements Serializable{
private int id;
private String roomNumber;
private Set
private Set
}
2、map映射
非常有用的一种集合映射
public class Room implements Serializable{
private int id;
private String roomNumber;
private Map
private Map
}
3.list映射
public class Quiz {
private Long oid;
private String quizNo;
private List answers = new ArrayList();
}
4.bag映射
public class Lab {
private Long oid;
private int labNo;
private List records = new ArrayList();
}
三、HQL
1、query
(1) session.createQuery("from User");
session.createCriteria(User.class);
(2)查询的分页显示
query.setFirstResult(0);
query.setMaxResult(10);
(a) MySql
select * from student where limite ?,?
(b) Oracle
select * from (select row_.* ,rownum rownum_
from (select student0_.id as id0_,
from student student0_) row)
where rownum_ <= ?
and rownum_ > ?
(3)在配置文件中的query
from User u where https://www.doczj.com/doc/8a9855328.html,like :name
]]>
session.getNamedQuery("findByName").setString("name",name);
from User; 返回对象数组，不可以强转
select u from User u; 返回对象集合，对于集合中的每个元素都可以强转成User对象
2、Dynamic query
public Collection findStudents(Student student){
StringBuffer sb = new StringBuffer("select student from Student student where student.id>-1 ");--- student.id>-1 永远为真，再添加条件的时候都用and即可，避免判断用where还是and
if(student.getName() != null)
sb.append("and https://www.doczj.com/doc/8a9855328.html,=:name");
if(student.getBirthday() != null)
sb.append("and student.birthday=:birthday");
if(student.getEmail() != null)
sb.append("and student.email=:email");
……
}
3、QBE
属性多时，效率高，语句少
忽略主键、version、关系（查询当前对象）
与QBC结合，弥补id查询
Example.excludeProperty("param"); --- 查询时忽略某个属性
Hibernate常见的问题总结
问：升级Hibernate 3后在导入hbm映射文件时为什么非常非常慢
原先在Hibernate 2中，程序的速度是非常快的。当环境顺利从Hibernate 2升级到Hibernate 3后，发布时在Tomcat的控制台中发现：Hibernate 3装载hbm映射文件时非常慢，差不多10秒钟才能装载一个hbm文件。
答：通过在Hibernate的源代码中设置断点，可以发现执行效率低下的代码在
org.hibernate.cfg.Configuration文件中的第240行：
addInputStream( new FileInputStream( xmlFile ) );而addInputStream函数中又包含：
org.dom4j.Document doc = xmlHelper.createSAXReader( "XML InputStream", errors, entityResolver ).read( new InputSource( xmlInputStream ) );
跟踪org.hibernate.util.XMLHelper中的函数createSAXReader可以得出结论，问题的症结出在这一条语句：org.dom4j.Document doc = xmlHelper.createSAXReader（）可以判断这是在XML文件装载初始化时发生的错误，仔细检查XML文件，可以发现这是XML的第一行声明dtd的错误，因为以前使用的是Hibernate 2，所以hbm文件的dtd指向的是版本2，而升级Hibernate 3后，没有把老的hbm映射文件换成版本3。在更换为3版本后，此问题得到解决。
问：为什么Hibernate 3中的HQL无法查询汉字
使用同样的代码和配置文件，在Hibernate 2上完全没有问题，在Hibernate 3中，使用如下HQL查询，无法得到正确的结果集：
String hql = "from story where title like '%汉字%'";
Query q = session.createQuery(hql);
但用下面的HQL查询，却可以得到正确结果集：
String hql = " from story where title like '%english%'";
Query q = session.createQuery(hql);
答：如果采用的是拼接HQL的方式，从Hibernate 2升级到Hibernate 3确实会出现汉字乱码问题。在控制台中可以看到，SQL的汉字部分变成了乱码：
[DEBUG] 2005-08-14 14:33:58 org.hibernate.SQL - "select story0_.content from story as story0_ where story0_.title like '%&–°é—&&?¨& ?'
在Hibernate中，查询时应尽量使用占位符的写法（如下），这样既可以避免乱码问题，又可以避免潜在的SQL注入攻击：
getHibernate().find("from story where title like ? ", "%汉字%")
问：Hibernate 3中如何获得库表所有字段的名称
答：可以使用以下的程序获得。
Configuration conf = new Configuration();
conf.configure();
Iterator iter = conf.getTableMappings();
while ( iter.hasNext() ) {
Table table = ( Table ) iter.next();
System.out.println(table.getName());
Iterator ics = table.getColumnIterator();
while (ics.hasNext()){
Column col = (Column) ics.next();
System.out.println(col.getName());
}
｝
问：错误代码：ObjectNotFoundException: No row with the given identifier exists
答：在以下几种情况下，该错误可能会发生。
当试图使用session.load()方法装载一个未被代理的对象，或者访问一个超出范围的代理对象时。
当装载一个未被正确取得的映射时。
当未被外键约束的外键字段中含有非法值时。
检查装载使用的主键Id，并验证外键关系，以确定数据库中已经存在相应的约束关系。坚持“在一个Session中只处理一个事务”的原则。因为当在单一Session中使用多个事务时很容易犯错。尤其注意，在一个HibernateException已经抛出后不要再操作Session。
问：错误代码：InvalidObjectException: Could not find a SessionFactory named: null
答：这个错误在以下几种情况下经常发生。
试图序列化一个已经失效的Hibernate Session，然后在另外一个虚拟机中进行反序列化。
类装载器被重置，例如在未重启的application server或者Web container中重新部署程序。在使用Tomcat时会经常遇到这个问题，这是因为application server中一般使用JNDI
来存储SessionFactory，而在Tomcat或其他一些Web容器中，则是通过在context重载时，关闭HttpSession序列化来实现的。这种实现方式会引起这个错误发生。
问：错误代码：org.hibernate.HibernateException: CGLIB Enhancement failed:
问：为什么在Hibernate中添加、删除、修改一个对象或Collection，但是数据库中实际上没有任何变化
答：这个问题经常会困扰初学者。这是因为如果没有使用Hibernate的自动事务处理，则必需显式的提交事务，操作才会在数据库中执行。
问：为什么保存一个父对象，而它的关联对象没有自动储存到数据库里
答：关联对象必需显式的调用session.save()（或session.persist()），或者在关联的映射文件中加入cascade="all"或cascade="save-update"（或cascade="persist"）才能够自动关联执行。问：no bean specialed.出错了，jsp页面报错。
原因是html:select 标签中option bean is null/.
Set不能加同一实体
在保存数据的时候循环添加一PO数据到Set,居然最后Set的size()为1。各实体设置不同数据啊，只是没Id.
原因是这个PO以前自己实现了Comparable .只比较Id,HibernateSystemException: SQL insert,update or delete failed
hibernate级联保存或更新时可能会出这个错误
原因是由于子实体的主键设置了不符合保存更新的数据.
No persister for错误
这个错误说的是no persister for https://www.doczj.com/doc/8a9855328.html,ng.Integer;映射文件未添加肯定不是这个问题了。那只有映射文件出错。锁定了关联的id;PO里面写的关联ID，而建表看不出问题。而且映射文件里面基本上看不出来。出现No persister for错误后一般是3个情况：
1 hbm.xml文件特殊类未制定类型。
2 cfg.xml文件未添加类的hbm.xml文件名。
3 PO和hbm类映射不匹配。
https://www.doczj.com/doc/8a9855328.html,zyInitializationException: Failed to lazily initialize a collection - no session or session was closed
Lazy为truesession关闭后调用延迟加载属性．在session关闭之前如果调用该属性，会加载．或者是使用Hibernate.Initalize();
BigDecimal对象属性映射出错
这个问题是不小心造成的.属性映射应该加上length="2"指定2位小数,或者几位小数,小数位数在0-19之间
property value with CGLIB 错误
比较常见的hibernate错误了.当PO属性为原始类型(int,double...)时,数据库纪录为null,调PO 时由于这些属性必须有值而出现错误.把属性值设置为对象属性解决.
hibernate出错
在configure.buildSessionFactory()时java.nullpointException.
在eclipse里没问题，但部署在tomcat里就出问题了，
是由于包冲突了,还有个可能就是configure(path),path不对,是由于eclipse的class loader和tomcat不同，在tomcat里，不能有两个一样一起加载.eclipse里却是指定jar的。
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配置文件有不规范的字符，检查下。
net.sf.hibernate.MappingException: Error reading resource: hibernate/Hello_Bean.hbm.xml
如果出现这行错误说明你的hibernate的XML配置文件有错\r
net.sf.hibernate.MappingException: Resource: hibernate/Hello_Bean.hbm.xml not found
如果出现这行错误说明hibernate的XML配置文件没有找到，你应该把XML文件放在与你的类文件同个目录下,本文中是放在hibernate\classes\hibernate\目录下，也就是跟
Hello_Bean.class类文件一起。
net.sf.hibernate.PropertyNotFoundException: Could not find a setter for property name in class hibernate.Hello_Bean
如果出现这行错误说明你的xml文件里设置的字段名name的值与Hello_Bean.java类里的getXXX或setXXX方法不一致。
net.sf.hibernate.HibernateException: JDBC Driver class not found: org.gjt.mm.mysql.Driver
如果出现这行错误说明你的MYSQL驱动没有加进JB库里或者不在CLASSPATH里。hibernate面试的问题，请大家指教！
表中有两个外键为了不用复合主键的方法，如果实现这两个外键非空+唯一？配置文件应该如何配置？
我想了想思路，就是ID然后加上两个外键里面做一些限制，但是配置文件就不知如何写了，请大家指教呢！
[Hibernate题目] Hibernate如何获取指定主键id的某对象，请举例，并进行可能的优劣比较。[Hibernate题目]判断题：使用save/persist一个对象时，便立即向数据库发送执行insert sql 语句？
Hibernate组测试题
(1)一般情况下，关系数据模型与对象模型之间有哪些匹配关系（多选）
A)表对应类
B)记录对应对象
C)表的字段对应类的属性
D)表之间的参考关系对应类之间的依赖关系-----------关联吧
(2)以下关于SessionFactory的说法哪些正确？（多选）
A)对于每个数据库事务，应该创建一个SessionFactory对象
B)一个SessionFactory对象对应一个数据库存储源。
C)SessionFactory是重量级的对象，不应该随意创建。如果系统中只有一个数据库存储源，只需要创建一个。
D)SessionFactory的load()方法用于加载持久化对象
(3)Customer类中有一个Set类型的orders属性，用来存放Order订单对象，在Customer.hbm.xml文件中，用哪个元素映射orders属性？
A)
(4)
A)none
B)save
C)delete
D)save-update
(5)以下哪些属于Session的方法？
A)load()
B)save()
C)delete()
D)update()
E)open()--------------不是
F)close()
(6)以下程序的打印结果是什么？（单选）
tx = session.beginTransaction();
Customer c1=(Customer)session.load(Customer.class,new Long(1));
Customer c2=(Customer)session.load(Customer.class,new Long(1));
System.out.println(c1==c2);
https://www.doczj.com/doc/8a9855328.html,mit();
session.close();
A)运行出错，抛出异常
B)打印false
C)打印true--------主键相同，与java不同
(7)以下程序代码对Customer的name属性修改了两次：
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,
new Long(1));
customer.setName(\"Jack\");
customer.setName(\"Mike\");
https://www.doczj.com/doc/8a9855328.html,mit();
执行以上程序，Hibernate需要向数据库提交几条update语句？（单选）
A)0 B)1 C)2 D)3
(8)在持久化层，对象分为哪些状态？（多选）
A)临时状态-----------------EJB3.0没有这个状态
B)独立状态
C)游离状态
D)持久化状态
(9)对于以下程序，Customer对象在第几行变为持久化状态？（单选）
Customer customer=new Customer(); //line1
customer.setName(\"Tom\"); //line2
Session session1=sessionFactory.openSession(); //line3
Transaction tx1 = session1.beginTransaction(); //line4
session1.save(customer); //line4
https://www.doczj.com/doc/8a9855328.html,mit(); //line5
session1.close(); //line6
A) line1 B)line2 C)line3 D)line4 E)line5 F)line6
(10)对于以下程序，Customer对象在第几行变为游离状态？（单选）
Customer customer=new Customer(); //line1
customer.setName(\"Tom\"); //line2
Session session1=sessionFactory.openSession(); //line3
Transaction tx1 = session1.beginTransaction(); //line4
session1.save(customer); //line4
https://www.doczj.com/doc/8a9855328.html,mit(); //line5
session1.close(); //line6
A) line1 B)line2 C)line3 D)line4 E)line5 F)line6
(11)以下哪一种检索策略利用了外连结查询？（单选）
A)立即检索B)延迟检索C)迫切左外连结检索
(12)假设对Customer类的orders集合采用延迟检索策略，编译或运行以下程序，会出现什么情况（单选）
Session session=sessionFactory.openSession();
tx = session.beginTransaction();
Customer customer=(Customer)session.get(Customer.class,new Long(1));
https://www.doczj.com/doc/8a9855328.html,mit();
session.close();
Iterator orderIterator=customer.getOrders().iterator();
A)编译出错B)编译通过，并正常运行C)编译通过，但运行时抛出异常
(13)关于HQL与SQL，以下哪些说法正确？（多选）
A)HQL与SQL没什么差别
B)HQL面向对象，而SQL操纵关系数据库
C)在HQL与SQL中，都包含select,insert,update,delete语句
D)HQL仅用于查询数据，不支持insert,update和delete语句
(14)事务隔离级别是由谁实现的？（单选）
A)Java应用程序B)Hibernate C)数据库系统D)JDBC驱动程序
(15)悲观锁与乐观锁，哪个具有较好的并发性能？（单选）
A)悲观锁B)乐观锁
(16)以下哪个Hibernate主键生成策略是实现主键按数值顺序递增的？
A) increment
B) identity
C) sequence
D) native
()下列关于Mysql的描述有错误的一项是哪项？
A) Mysql是一个多用户、多线程的SQL数据库
B) Mysql是一个客户机/服务器结构的应用
C) Mysql是可运行在大多数的Linux平台上
D) Mysql不是开源的
答案：
(1)A,B,C (2)B,C (3)A (4)D (5)A,B,C,D,F (6)C (7)B (8)A,C,D (9)D (10)F (11)C
(12)C (13)B,D (14)C (15)B （16）A（17）D
二、简答题
1、什么是ORM？
2、解释数据持久化的好处？
3、Hibernate 有哪5 个核心接口？它们的作用分别是什么？
4、在wim中哪个包对hibernate进行了封装，在pojo包中包含了哪些内容？
5、回答以下问题
1）在hibernate 中，在配置文件呈标题一对多，多对多的标签是什么？
2）Hibernate 的二级缓存是什么？
3）Hibernate 是如何处理事务的?
6、编写一个Hibernate 的测试文件Test.Java（用代码写出大概流程）
7、完成对hibernate.cfg.xml的配置，连接本地的MYSQL数据库
要求如下：数据库名是WISH，要求能在控制台显示sql语句，Parent.hbm.xml文件在于hibernate.cfg.xml文件同一个目录下的example文件夹下，MYSQL的用户名是：System 密码：Manager 。
8、写出相应的SQL语句
表message有如下字段
id 文章id
title 文章标题
hits 点击量
（1）创建表message
（2）插入如下两条信息
1，hero，100；
2，cat，200
（3）查询点击量为100的文章标题
（4）删除文章名为cat的文章
二、简答题
1、什么是ORM？
答：对象关系映射（Object—Relational Mapping，简称ORM）是一种为了解决
面向对象与面向关系数据库存在的互不匹配的现象的技术；简单的说，ORM 是通
过使用描述对象和数据库之间映射的元数据，将java 程序中的对象自动持久化
到关系数据库中；本质上就是将数据从一种形式转换到另外一种形式。
2、解释数据持久化的好处？
答：数据库的读写是一个很耗费时间和资源的操作，当大量用户同时直接访问数据库的时候，效率将非常低，如果将数据持久化就不需要每次从数据库读取数据，直接在内存中对数据进行操作，这样就节约了数据库资源，而且加快了系统的反映速度。
3、Hibernate 有哪5 个核心接口？它们的作用分别是什么？
答：Configuration 接口：配置Hibernate，根据其启动hibernate，创建SessionFactory 对象；SessionFactory 接口：初始化Hibernate，充当数据存储源的代理，创建session 对象，sessionFactory 是线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级、二级缓存；
Session 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，避免多个线程共享同一个session，是轻量级、一级缓存；
Transaction 接口：管理事务；
Query 和Criteria 接口：执行数据库的查询。
4、在wim中哪个包对hibernate进行了封装，在pojo包中包含了哪些内容？
答：在WIM中用DAO包对Hibernate进行了封装，pojo包中包含了持久类和映射文件
5、回答以下问题
1）在hibernate 中，在配置文件呈标题一对多，多对多的标签是什么；
2）Hibernate 的二级缓存是什么；
3）Hibernate 是如何处理事务的；
答：1）一对多的标签为
2）sessionFactory 的缓存为hibernate 的二级缓存；
3）Hibernate 的事务实际上是底层的JDBC Transaction 的封装或者是JTA
Transaction 的封装；默认情况下使用JDBC Transaction。
6、Hibernate 的应用过程
答：//首先获得SessionFactory 的对象
SessionFactory sessionFactory = new Configuration().configure().
buildSessionFactory();
//然后获得session 的对象
Session session = sessionFactory.openSession();
//其次获得Transaction 的对象
Transaction tx = session.beginTransaction();
//执行相关的数据库操作:增,删,改,查
session.save(user); //增加, user 是User 类的对象
session.delete(user); //删除
session.update(user); //更新
Query query = session.createQuery(“from User”); //查询
List list = query.list();
//提交事务
https://www.doczj.com/doc/8a9855328.html,mit();
//如果有异常,我们还要作事务的回滚,恢复到操作之前
tx.rollback();
//最后还要关闭session,释放资源
session.close();
7、完成对hibernate.cfg.xml的配置，连接本地的MYSQL数据库。
要求如下：
数据库名是WISH，要求能在控制台显示sql语句，Parent.hbm.xml文件在与hibernate.cfg.xm 文件同一个目录下的example文件夹下，MYSQL的用户名是：System 密码：Manager 。
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/WISH
System
Manager
8、写出相应的SQL语句
（1）建表
create table message
(
id bigint auto_increment not null primary key,
title char(10) not null,
hits bigint
);
（2）插入信息
Insert into message values (1,‖hero‖,100), (2,‖cat‖,200);
（3）查询点击率为100的文章标题
Select title from message where hits=100；
（4）删除文章名为cat的文章
Delete from message where title= ―cat‖;
Hibernate对多表关联查询
一、Hibernate简介Hibernate是一个JDO工具。它的工作原理是通过文件（一般有两种：xml文件和properties文件）把值对象和数据库表之间建立起一个映射关系。这样，我们只需要通过操作这些值对象和Hibernate提供的一些基本类，就可以达到使用数据库的目的。例如，使用Hibernate的查询，可以直接返回包含某个值对象的列表（List），而不必向传统的JDBC访问方式一样把结果集的数据逐个装载到一个值对象中，为编码工作节约了大