1、hibernate的开发流程
创建项目——>基本框架示意图——>引入hibernate 开发包——> 开发hibernate (有3中方法)——>开发domain对象和对象关系映射文件——>手动配置hibernate.cfg.xml文件
注意：hibernate可以用在JavaSE项目中，也可以用在JavaEE项目中；但是Struts只能用在JavaEE项目中（因为Struts是web框架）
（1） 创建一个项目
（2）画出一个简单项目框架示意图
（3）引入hibernate 开发包 (从网上下载google hibernate http://www.hibernate.org),完后我们
（4） 开发hibernate 有三种方法（开发顺序）
我们使用第二种开发项目
创建employe 表.
create table employee(
id number primary key,
name varchar2(64) not null,
email varchar2(64) not null,
hiredate date not null)
创建一个序列，将来用于主键的自增长 :
--创建一个序列
create sequence emp_seq
start with 1
increment by 1
minvalue 1
nomaxvalue
nocycle
nocache
（5） 开发domain对象和对象关系映射文件
对象关系映射文件： 作用是用于指定 domain对象和表的映射关系. ,该文件的取名有规范:domain对象.hbm.xml,一般我们放在 和domain对象同一个文件夹下(包下)
我们的Employee.hbml.xml配置文件 ：
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/HibernateMapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mappingpackage="com.hsp.domain">
<classname="Employee" table="employee">
<!--id元素用于指定主键属性-->
<idname="id" column="id"type="java.lang.Integer">
<!--该元素用于指定主键值生成策略hilonative increment sequence uuid -->
<generatorclass="sequence">
<paramname="sequence">emp_seq</param>
</generator>
</id>
<!--对其它属性还有配置-->
<propertyname="name" type="java.lang.String">
<columnname="name" not-null="false" />
</property>
<propertyname="email" type="java.lang.String" >
<columnname="email" not-null="false"/>
</property>
<propertyname="hiredate" type="java.util.Date">
<columnname="hiredate" not-null="false" />
</property>
</class>
</hibernate-mapping>
（6）手动配置我们的hibernate.cfg.xml文件，该文件用于配置 连接的数据库的类型，driver,,用户名，密码 ,url ....同时管理 对象关系映射文件 ,该文件的名称，我们一般不修改hibernate.cfg.xml配置文件
<?xml version="1.0"encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!--hibernate 设计者，给我们提供了一写常用的配置 -->
<!--配置使用的driver-->
<propertyname="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<propertyname="connection.username">scott</property>
<propertyname="connection.password">tiger</property>
<propertyname="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:orclhsp</property>
<!--配置dialect方言,明确告诉hibernate连接是哪种数据库 -->
<propertyname="dialect">org.hibernate.dialect.OracleDialect</property>
<!--显示出对于sql -->
<propertyname="show_sql">true</property>
<!--指定管理的对象映射文件-->
<mappingresource="com/hsp/domain/Employee.hbm.xml"/>
</session-factory>
</hibernate-configuration>
（7） 测试文件TestMain.java
package com.hsp.view;
import com.hsp.util.*;
import java.util.Date;
import org.hibernate.Session;import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.*;
import com.hsp.domain.Employee;
public class TestMain {
/**
* @param args
*/
publicstatic void main(String[] args) {
//查询[load]->hql语句(hibernate query language)
}
publicstatic void delEmp() {
//删除
//获取一个session
Sessionsession=MySessionFactory.getSessionFactory().openSession();
Transactionts=session.beginTransaction();
//删除1.先获取该雇员，然后删除
Employeeemp=(Employee) session.load(Employee.class, 3);
session.delete(emp);
ts.commit();
session.close();
}
publicstatic void updateEmp() {
//TODO Auto-generated method stub
//修改用户
//获取一个会话
Sessionsession=MySessionFactory.getSessionFactory().openSession();
Transactionts=session.beginTransaction();
//修改用户1. 获取要修改的用户，2.修改
//load是通过主键属性，获取该对象实例.<--->表的记录对应
Employeeemp=(Employee) session.load(Employee.class, 3);
emp.setName("韩顺平8");//update...
emp.setEmail("abc@sohu.com");
ts.commit();
session.close();
}
publicstatic void addEmployee() {
//我们使用hibernate完成crud操作[这里我们只见对象，不见表]
//现在我们不是用service ,直接测试.
//1。创建Configuration,该对象用于读取hibernate.cfg.xml,并完成初始化
Configurationconfiguration=new Configuration().configure();
//2.创建SessoinFactory[这是一个会话工厂，是一个重量级的对象]
SessionFactorysessionFactory=configuration.buildSessionFactory();
//3.创建Sessoin 相当于jdbc Connection[ serveltHttpSession ,也不是 jspsession]
Sessionsession=sessionFactory.openSession();
//4.对hiberate而言，要求程序员，在进行 增加，删除，修改的时候使用事务提交，
Transactiontransaction = session.beginTransaction();
//添加一个雇员
Employeeemployee=new Employee();
employee.setName("shunping");
employee.setEmail("shunping@sohu.com");
employee.setHiredate(newDate());
//insert.............
//保存
session.save(employee);//saveemployee就是持久化该对象 (把对象保存到了数据库中称为一条记录)
//==>insertinto ....[被hiberante封装]
//提交
transaction.commit();
session.close();
}
}
2、hibernate运行原理首先，应用程序先调用Configration类，该类读取hibernate的配置文件及映射文件中的信息（如果我们使用注解的话则不需要读取映射文件），并使用这些信息生成一个SessionFactory对象。接着，从SessionFacctory生成一个Session对象，并用Session对象生成Transaction对象。通过Session对象的get()、sava()、update()、delete()和saveOrupdate()等方法对PO进行加载，保存，更新，删除等操作；在查询的情况下，可通过Session对象生成一个Query对象，然后利用Query对象执行查询操作。如果没有异常，Transaction对象将提交这些操作结果到数据库中，否则会回滚事务。
http://blog.csdn.net/xiaoyaoyulinger/article/details/52263848
1.通过Configuration config = new Configuration().configure();//读取并解析hibernate.cfg.xml配置文件
2.由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>读取并解析映射信息
3.通过SessionFactory sf = config.buildSessionFactory();//创建SessionFactory
4.Session session = sf.openSession();//打开Sesssion
5.Transaction tx = session.beginTransaction();//创建并启动事务Transation
6.persistent operate操作数据，持久化操作
7.tx.commit();//提交事务
8.关闭Session
9.关闭SesstionFactory
Hibernate是如何延迟加载?get与load的区别
1. 对于Hibernate get方法，Hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查询数据库，数据 库中没有就返回null。这个相对比较简单，也没有太大的争议。主要要说明的一点就是在这个版本(bibernate3.2以上)中get方法也会查找二级缓存！
2. Hibernate load方法加载实体对象的时候，根据映射文件上类级别的lazy属性的配置(默认为true)，分情况讨论：
(1)若为true,则首先在Session缓存中查找，看看该id对应的对象是否存在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为实体类的子类，由CGLIB动态生成)。等到具体使用该对象(除获取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一个ObjectNotFoundException。
(2)若为false,就跟Hibernateget方法查找顺序一样，只是最终若没发现符合条件的记录，则会抛出一个ObjectNotFoundException。
这里get和load有两个重要区别:
如果未能发现符合条件的记录，Hibernate get方法返回null，而load方法会抛出一个ObjectNotFoundException。
load方法可返回没有加载实体数据的代 理类实例，而get方法永远返回有实体数据的对象。
(对于load和get方法返回类型：好多书中都说：“get方法永远只返回实体类”，实际上并不正 确，get方法如果在session缓存中找到了该id对应的对象，如果刚好该对象前面是被代理过的，如被load方法使用过，或者被其他关联对象延迟加 载过，那么返回的还是原先的代理对象，而不是实体类对象，如果该代理对象还没有加载实体数据（就是id以外的其他属性数据），那么它会查询二级缓存或者数 据库来加载数据，但是返回的还是代理对象，只不过已经加载了实体数据。)
总之对于get和load的根本区别，一句话，hibernate对于 load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于get方 法，hibernate一定要获取到真实的数据，否则返回null。
Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、
说下Hibernate的缓存机制：
Hibernate缓存的作用：
Hibernate是一个持久层框架，经常访问物理数据库，为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据
Hibernate缓存分类：
Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存
Hibernate一级缓存又称为“Session的缓存”，它是内置的，意思就是说，只要你使用hibernate就必须使用session缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。在第一级缓存中，持久化类的每个实例都具有唯一的OID。
Hibernate二级缓存又称为“SessionFactory的缓存”，由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的，是一个可配置的插件，在默认情况下，SessionFactory不会启用这个插件。
什么样的数据适合存放到第二级缓存中？
1 很少被修改的数据
2 不是很重要的数据，允许出现偶尔并发的数据
3 不会被并发访问的数据
4 常量数据
不适合存放到第二级缓存的数据？
1经常被修改的数据
2 .绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发
3 与其他应用共享的数据。
Hibernate查找对象如何应用缓存？
当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；如果都查不到，再查询数据库，把结果按照ID放入到缓存
删除、更新、增加数据的时候，同时更新缓存
Hibernate管理缓存实例
无论何时，我们在管理Hibernate缓存（Managing the caches）时，当你给save()、update()或saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。
当随后flush()方法被调用时，对象的状态会和数据库取得同步。 如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。
Hibernate的查询方式
Sql、Criteria,object comptosition
Hql：
1、 属性查询
2、 参数查询、命名参数查询
3、 关联查询
4、 分页查询
5、 统计函数
如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少，表关联不要怕多，有二级缓存撑腰
http://www.cnblogs.com/dashi/p/3597969.html
1864
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
