hibernate复习

使用hibernate之前：
1.准备所需要的架包
2.完成hibernate配置文件(在hibernate.cfg.xml中配置)：
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">
com.microsoft.jdbc.sqlserver.SqlServerDriver
</property>

<property name="connection.url">
jdbc:microsoft://localhost:1433;DataBase=" "
</property>

<property name="connection.username">
sa
</property>

<property name="connection.password">
123
</property>

<property name="dialect">
org.hibernate.dialect.MySqlDialect
</property>

<mapping resource=" .......hbm.xml">
</session-factory>
</hibernate-configuration>
3.确定实体类实现了serializable接口，
并添加了默认构造方法

使用hibernate:
1.读取配置文件：
Configuration conf = new Configuration().configure();
2.创建SessionFactory
SessionFactory sf = conf.buildSessionFactory();
3.打开Session
Session session = sf.openSession();
4.开始一个事物
Transaction ts = session.beginTranscation();
5.持久化操作
除查询外的其它三种操作
6.提交或回滚事物
ts.commit()---ts.rollBack();
7.关闭session
session.close();









<% @ page language="" import="" contentType="" %>

<property name="connection.driver_class">...</property>
<property name="connection.url">...</property>
<property name="connection.username">...</property>
<property name="connection.password">...</property>
<property name="connection.dialect">...</property>
<property name="connection.show_sql">...</property>
<property name="connection.hbm2ddl.auto">...</property> hibernate mapping to database data language
hbm2ddl:hibernate mapping to database language--- hibernate映射到数据库的语言



hql语句：
Configuration conf = new Configuration().configure();
SessionFactory sf = conf.buildSessionFactory();
Session session = sf.openSession();
Transaction tx = null;
...


Session session = super.gerSession();
String hql = ";;;";
Query query = session.createQuery(hql);
List list = query.list();


Session session = this.getSession();
String hql = "from fwxx fw where fw.zj >=:zj1 and fw.zj <=: zj2";
Query query = session.createQuery(hql);
query.setInteger("zj1",100);
query.setInteger("zj2",200);






二级缓存怎么配置？
1．把hibernate中相应的缓存架包导入项目中，一般用OSCache
2．将oscache的oscache.properties放入classpatch的类路径下面，他的位置和默认的myeclipse自动生成的hibernate.cfg.xml的位置是一样的。
在该文件中可以修改oscache的缓存大小，默认的是1000：
cache.capacity=1000
3．在hibernate的配置文件hibernate.cfg.xml中写入相应的二级缓存
<property name=”cache.provider_class”>
org.hibernate.cache.OSCacheProvider
</property>
3．在hibernate的配置文件hibernate.cfg.xml中写入要应用二级缓存的类及缓存策略
<class-cache class = “cn.itcast..dao.entity.User” usage=”read-only”/>
如果该类以后不需要修改则用readonly，修改则用read-write
4．若不用步骤3在hibernate.cfg.xml中指定缓存可以在实体类的相应配置文件中指定，如在User.hbm.xml中，在id属性的上一行指定：
...
<cache usage=”readonly”>
<id name=”id”><generator class=”native”/></id>
...
5．在hibernate的配置文件中启动缓存查询命令
<property name=”cache.use_query_cache”>true</property>
6．get,load和iterator方法可以按以上配置直接从缓存中读取数据
7．query与criteria由于查询命中率低，所以对他们默认的查询缓存是不支持的。
它们必须在hibernate.cfg.xml中设置查询对象是支持缓存的。
比如query查询要设置Query的对象query支持缓存：query.setCacheable(true)
缓存命中率：比如查询100次数据，有几次数据是从缓存中找到的。


一级缓存可以用evict或clear方法清掉（eict是清理一条缓存，clear是清理全部）
二级缓存可以用evict方法清理

二级缓存配置在hibernate的sessionFactory中
因此当ssh整合时，二级缓存要配置在spring的配置文件中。

ql/sql语句中：
em.getReference(Person.class,personid) 得到的是一个代理的对象，多用在删除时候.
当不存在该对象时会出现一个异常
em.gerfind(Person.class,personid) 得到的是一个实体对象，多用在查询时候.
当不存在该对象时返回null




hibernate：？？？？？？？？？？？？？？？
因为一对多(查询两张表)效率比多对一(查询一张表??)低，实际中并不使用一对多(除非是很少量的数据)，而使用多对一关系。
hibernate 主键生成策略：
<id name="id" type="interger">
<column name="id"> <generator class="identity"/>
</id>
1.identity：
使用数据库提供的主键生成机制，自动为主键赋值,不便于数据库的迁移
2.native
hibernate根据不同的数据库方言自动选择不同的主键生成方式,便于不同数据库之间的移植
3.sequence
oracle数据库使用sequence生成主键
4.uuid
支持大部分数据库，但是占用较大的存储空间
5.increase：
多线程对数据库进行写入时可能会出现相同主键而发生主键冲突。

hibernate中集合类型：
1.set:
<set name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
</set>


2.list:
<list name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
<list-index column="order_id"/>
</list>
or
<bag name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
</bag>


3.map:
<map name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
<map-key type="String" class="name"/>
</map>


4.数组集合:

hibernate中inverse:
hibernate 中关系维护中默认由多的一方维护关系(inverse=”false”)，一得一方不维护(inverse=”true”)。这样减少了update语句也就减少了垃圾sql执行代码，提高了性能。


hibernate配置文件中hibernate.hbm2ddl.auto的值：
create： 先drop表再create (默认)
create-drop：也表示创建，不过在系统关闭之前执行一下drop；
update： 加载hibernate时自动更新数据库结构
validate： 加载hibernate时候自动检查数据库表结构是否发生改变，如果改变就抛出异常，不会更新。


hibernate配置中cascade的值：
none：对任何关系不进行级联(默认)
all: 对所有关系进行级联(即：save-update和delete)
save-update: 在进行save和update操作时进行级联
delete：在进行delete时进行级联
all-delete-orphan：当一个对象在关系图中成为孤儿时，删除该节点


lazy(什么时候抓取数据)的值：
proxy：使用代理(3.0之后有的，默认)
true：是用懒加载
false：不使用懒加载


fetch(什么方式抓取数据)的值：
select：对相关的每张表进行select查询(默认)
join： 对关联的字段查询，效率较高


一对一的时候查主对象不能懒加载(hibernate无法判断相关联的从对象是否存在,若是存在才可以把主对象的外键构造出来，若不存在设为空)，查从对象的时候可以懒加载。
openSessionInView是线程级别session，在线程开启期间保持打开状态，在页面渲染的时候session也是打开的。它会把session和transaction的会话周期延长。造成内存长时间被占用。


hibernate大批量数据的处理：容易造成缓存溢出问题
hibernate3.0之前:是一条记录移交记录的处理:
Session s = null;
try{
s = HibernateUtil.getSession();
Transaction t = s.beginTransaction();
Query q = s.createQuery(“from myUsers”);
List<User> users = q.list();
for(User u：users){
u.setBirthday(new Date());
}……
上面的方法可以这样写：每更新20条记录就将缓存数据写入数据库，同时清空缓存
for(int i=0;i<10000000;i++){
s.save(user);
if(i%20 == 0 ){
s.flush();
s.clear();
}
hibernate3.0之后：通过q.executeUpdate()批量执行，并且每更新一条记录就清空缓存。
Query q1 = s.createQuery(“update myUsers set birthday ：= ….”);
q1.executeUpdate();
t.commit();


hibernate的联合主键:
在联合主键类中必须实现serializable接口并重写equal()方法和hashCode()方法
映射文件中用<composite-id 标签：
<class name="Person">
<composite-id name="unitedKey">
<key-property name="firstName" column="first_name" length="12"/>
<key-property name="lastName" column="last_name" length="12"/>
</composite-id>
<property name="ss" length="12"/>
</class>


枚举：通过<param name="type">12</param>来指定枚举的类型是String，默认是int：
<hibernate-mapping package="com.cn">
<class name="Person" table="[right]" schema="dbo" catalog="crmDatabase">
<id name="id">
<generator class="native" />
</id>
<property name="name" type="java.lang.String"/>
<property name="gender" not-null="true">
<type name="org.hibernate.type.EnumType"><!-- 将type的name是枚举类型 -->
<param name="enumClass">com.cn.Gender</param><!-- 指定映射的Gender类路径 -->
<param name="type">12</param><!-- 12表示指定映射到数据库的类型是String，默认是int类型。此处的值根据枚举类的属性类型来决定 -->
</type>
</property>
</class>
</hibernate-mapping>


继承关系：
1、映射到同一张表：discriminator-value与subclass。sql语句执行效率高(因为执行的sql是在同一张表上)，但是映射有点乱，且子类会出现空的属性。
<hibernate-mapping package="com.cn1">
<class name="Employee" discriminator-value="0">
<id name="id">
<generator class="native" />
</id>
<properties name="name" unique="true"/>
<discriminator column="type" type="String"/>
<subclass name="Seller" discriminator-value="1">
<property name="sell"/>
</subclass>
<subclass name="Skiller" discriminator-value="2">
<property name="skill"/>
</subclass>
</class>
</hibernate-mapping>
2、映射到不同的表：用joined-subclass。子类单独映射到各自的一张表中，然后利用joined-subclass连接起来。sql语句执行效率低，但是各表映射清晰。
<hibernate-mapping package="com.cn2">
<class name="Employee">
<id name="id">
<generator class="native" />
</id>
<properties name="name" unique="true"/>
<joined-subclass name="Seller" table="seller">
<key column="emp_id"/>
<property name="sell"/>
</joined-subclass>
<joined-subclass name="Skiller" table="skiller">
<key column="emp_id"/>
<property name="skill"/>
</joined-subclass>
</class>
</hibernate-mapping>
3、映射到同一张和另外表的结合：结合了第一种和第二种继承映射的优点。执行较快，结构换算清晰。
<hibernate-mapping package="com.cn3">
<class name="Employee" discriminator-value="0">
<id name="id">
<generator class="native" />
</id>
<properties name="name" unique="true"/>
<discriminator column="type" type="String"/>
<subclass name="Seller" discriminator-value="1">
<property name="sell"/>
</subclass>
<subclass name="Skiller">
<join table="skiller">
<key column="emp_id">
<property name="skill"/>
</join>
</subclass>
</class>
</hibernate-mapping>


编写一个hibernate的映射文件内容：
<hibernate-mapping package=”com.cn”>
<class name=”Employee” >
<id name=”id”>
<generator class=”native”>
</id>
<property name=”name”/>
<many-to-one name=”depart” column=”dapart_id”/>
</class>
</hibernate-mapping>