hibernate第六天

来源：互联网发布：淘宝百信大药房旗舰店编辑：程序博客网时间：2024/06/14 08:43

1 将整个继承关系放在一张表中，为了区分具体的子类信息，表中需要创建一个额外的列
create table paymeny(
  .....
  type varchar2(12)
);
<class name="Payment" table="payment">
  .....
  <discriminitor column="type" type="string">
  <sub-class name="CardPayment" discriminitor-value="card">
   子类属性
  </sub-class>
  <sub-class name="CashPayment" discriminitor-value="cash">
   子类属性
  </sub-class>
</class>
操作方便效率较高多态
冗余浪费空间
2 将父类信息和每个子类信息结合在一起，创建多张具体的表
create table cardpayment(
  父类信息
  信用卡子类信息
)
create table cashpayment(
  父类信息
  现金子类信息
)
<class name="Payment">
  .....

  <union-sub-class name="CardPayment" table="cardpayment">
   子类属性
  </union-sub-class>
  <union-sub-class name="CashPayment" table="cashpayment">
   子类属性
  </union-sub-class>
</class>
操作方便效率较高空间利用率较高
冗余没有多态
3 针对每个具体的对象，创建其对应得表
create table payment(
  父类信息
)
create table cardpayment(
  信用卡子类信息
  外键cardid
)
create table cashpayment(
  现金子类信息
  外键cashid
)
<class name="Payment" table="payment">
  .....

  <joined-sub-class name="CardPayment" table="cardpayment">
   <key column="cardid"></key>
   子类属性
  </joined-sub-class>
  <joined-sub-class name="CashPayment" table="cashpayment">
   <key column="cashid"></key>
   子类属性
  </joined-sub-class>
</class>
多态没有冗余空间利用率较高
操作复杂效率较低

hibernate查询：
1 native sql
  程序员精通sql
  自己控制sql的效率
  查询到的信息只能自己封装
2 hql Student1 ----1 Address
  在sql框架基础之上，面向对象
  from Student;
  select s.name from Student s;
  from Student s where s.age > 20;
  from Student s inner join address a where a.name=...;
3 criteria
  标准面向对象式查询
  session.createCriteria(Student.class);
  session.createCriteria(Student.class)
   .add(Restrictions.gt("age",20));
  session.createCriteria(Student.class)
   .createCriteria("address")
   .add(Restrictions.eq("name","..."));
4 named query
  将sql语句彻底从源代码中提取到映射文件中
  *.hbm.xml
  <hibernate-mapping>
   <class>
    .....
   </class>
   <query name="sql变量名">
    <![CDATA[
     hql语句... ?/:name
    ]]>
   </query>
  </hibernate-mapping>

session.getNamedQuery("sql变量名")

hibernate对数据源的支持：
1 hiebrnate内置数据源，仅用于测试
<property name="connection.username">scott</property>
<property name="connection.url">
  jdbc:oracle:thin:@localhost:1521:sinojava
</property>
<property name="dialect">
  org.hibernate.dialect.Oracle9Dialect
</property>
<property name="connection.password">tiger</property>
<property name="connection.driver_class">
  oracle.jdbc.driver.OracleDriver
</property>

2******* hibernate整合c3p0*******
<property name="connection.username">scott</property>
<property name="connection.url">
  jdbc:oracle:thin:@localhost:1521:sinojava
</property>
<property name="dialect">
  org.hibernate.dialect.Oracle9Dialect
</property>
<property name="connection.password">tiger</property>
<property name="connection.driver_class">
  oracle.jdbc.driver.OracleDriver
</property>

添加以下信息：
<property name="connection.provider_class">
org.hibernate.connection.C3P0ConnectionProvider
</property>
<property name="c3p0.max_size">5</property>
<property name="c3p0.timeout">2000</property>
..........

3 jndi
<property name="connection.username">scott</property>
<property name="connection.url">
  jdbc:oracle:thin:@localhost:1521:sinojava
</property>
<property name="dialect">
  org.hibernate.dialect.Oracle9Dialect
</property>
<property name="connection.password">tiger</property>
<property name="connection.driver_class">
  oracle.jdbc.driver.OracleDriver
</property>

添加以下信息：
<property name="jndi">java:comp/env/userDs</property>

程序中必须手动获取连接，传递给hibernate:
  getSession(){
   Context env = new IntialContext();
   DataSource ds = (DataSource)env.lookup("java:comp/env/userDs");
   Conenction con = ds.getConnection();
   ...
   sessionFactory.openSession(conn);
   ....
  }

hibernate对于分页的支持：
query.setFirstResult(起始位置);
query.setMaxResults(查询条数);
query.list();

锁：
读锁/写锁
表级锁/列级锁

JDBC中的并发控制：
1 数据库
  隔离级别
  TRANSACTION_NONE  0
  TRANSACTION_UNCOMMITED_READ 1
  TRANSACTION_COMMIED_READ 2
  TRANSACTION_REPEATABLE_READ 4
  TRANSANTION_SERIALIZABLE 8
  Connection.setTransactionIsolation(...)

  select **** 【for update】;
2 应用程序
  synchronized
******hibernate对多线程并发的控制：
1 数据库
  隔离级别
  TRANSACTION_NONE  0
  TRANSACTION_UNCOMMITED_READ 1
  TRANSACTION_COMMIED_READ 2
  TRANSACTION_REPEATABLE_READ 4
  TRANSANTION_SERIALIZABLE 8

hibernate.cfg.xml
<property name="connection.isolation">2</property>

  select **** 【for update】;
2 应用程序
  悲观锁：
   认为一定会有两个线程同时访问一个数据
   必须针对操作进行加锁：
    Query q = session.createQuery("from Student s")
    q.setLockMode("s",LokeMode.WRITE);
    LockMode:
     NONE 不加锁
     READ 读锁
     WRITE 写锁
     UPDATE 表级锁 <===> select **** for update;
  乐观锁：
   认为一个线程访问的时候，不一定会并发

      线程1    线程2
    ------------------------------------------------------
    balance=1000
      1000    1000
      1000-600 commit
     400     1000-200 commit
     800

    解决：采用一个标志位控制数据的有效性

    balance     identity 线程1    线程2
    -----------------------------------------------------------------
    1000   1
       1000 1   1000 1
       1000-600 1+1 commit
    400    if(2>1)提交
           1000-200 1+1 commit
        if(2>2)不许提交

    标志位：
     时间戳：

     **版本号：

hibernate缓存机制：
一级缓存：Session对象
  session.get(Class,Serializble)
  session.load(Class,Serializble)

  get/load共性：
   get和load发送的sql语句结构相同
   session--->SessionFactory--->DB
  get/load区别:
   get:
    1 只要调用get方法，则直接发送sql查询
    2 get直接查找信息，找不到则返回null

   load:
    1 调用了load方法，默认不发送sql语句
    直到真正使用该对象时，才发送sql查询
    load方法返回的对象：没用到信息，则返回代理对象
          使用到信息，则返回真正的对象      2 load方法查找不到信息，则报异常         org.hibernate.ObjectNotFoundException

二级缓存：SessionFactory
  1 在hibernate.cfg.xml中添加属性
  --设置二级缓存类
  <property name="cache.provider_class">
   org.hibernate.cache.EhCacheProvider
  </property>二级
  --设置query操作使用缓存，否则是对get/load生效
  <property name="cache.use_query_cache">true</property>

  2 在hbm映射文件中设置使用二级缓存
  <class name="Concur" table="concur_time">
   <cache usage="read-only|read-write"/>
   ...
  </class>

  3 如果使用query语句查询，并且想使用二级缓存
   Query.setCacheable(true);
   Query.list....

hibernate对象状态及session的各个方法：
transient 临时对象
detached 游离对象
persist 持久化对象

  Configuration cfg = new Configuration().configure();
  SessionFactory sf = cfg.buildSessionFactory();
  Session session = sf.openSession();
  Transaction tx = session.beginTransaction();  内存 session  DB

  Concur c = new Concur("hehe");    有没有  没有===transient
  ----------------------------------------------------------------------------------------------
  session.save(c);

  tx.commit();      有有  有 ===persist
  ----------------------------------------------------------------------------------------------
  session.close();     有没有  有 ===detched
  ----------------------------------------------------------------------------------------------

1 hibernate环境搭建
2 hibernate操作步骤
3 1-1 1-m
4 继承关系的处理3种方式
5 乐观锁
6 hbm配置文件
7 session的常用方法
8 hql/criteria
9 数据源-c3p0
10 id生成策略-native(sequence,identity,hilo)-uuid.hex