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.sequence    oracle数据库使用sequence生成主键
3.identity    MySQL和SQL Server使用，但不便于数据库的迁移
2.native    根据不同的数据库方言自动选择不同的主键生成方式,便于不同数据库之间的移植
4.uuid        支持大部分数据库，但是占用较大的存储空

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>