hibernate复习第一天

 

课程大纲：
    1、 ORM原理
          Hibernate的结构
    2、 基数映射
    3、 对象状态
    4、 继承映射，组件映射，集合映射
    5、 HQL查询

一、ORM原理
    1、对象持久化的概念
    2、对象持久化手段、对比
    3、hibernate结构
   
  1、为什么要对象持久化？
    1)、内存是易逝的；掉电等物理原因；对象会丢失；如：将文件保存到硬盘上就是对象持久化；
    2)、为了使用大规模的查询和检索；功能上的原因；
     (为了在网络间传输；对象串行化，保存到别的地方；也是持久化)
    持久设备: 硬盘、光盘
   
  2、持久化的手段：
    1)、对象序列化；
                              适合于少量的对象进行暂时的持久化和网路传输对象；
                              简单，变成二进制的流通过网络传输；
                              对二进制文件不能做大规模的检索；
                              RMI：远程方法调用；传参数和对象，通过网络，序列化；
           不符合企业级应用：大量的长期的，并且需要查询和检索；
                                         只能辅助；业务对象不做传输，数据一般都存在服务器中；
    2)、对象通过JDBC保存到数据库中；
                             JDBC可以单独作为持久层；执行效率高；
                             可以存海量的数据并且查询和检索；
                             但是开发效率和维护效率低；
                             代码量大，占到1/3，或50％；
                             难度大；
    3)、EJB 实体Bean；
                             通过容器和数据库保持一致；
                             EJB出来时没有经过调查，就直接用到了企业中了；
                             一个Bean只能对一个表，并且不能去继承；
                             不是完全面向对象的；需要部署到容器中，开发效率也不高；
                             配置很难，初级程序员没法做；
                             EJB的长处在分布式事务上；
                             3.0中不做持久化了，实体Bean变成了POJO类；
    4)、采用ORM框架；
                             开源组织；
                             把JDBC重复的代码组件化；
                             最有名的就是Hibernate；
                             把JDBC封装；
    5)、对象数据库，不太成熟；在检索方面不如关系数据库；
  
  3、hibernate结构
  
    1) ORM：(Object-Relation Mapping)
        a. 分析对象和表之间的映射关系；
                  类对应表；
                  属性对应字段；
        b. 写jdbc代码；            
       
        映射－－Hibernate－－JDBC－－数据库
       
        POJO：Plain Old  Java Object  又普通又古老的java对象；
                    相对于EJB的实体Bean；
   2) hibernate结构：
                                         映射关系 (人脑 ---> 文件)
                                              |
                                         Hibernate  (api) —— new app(持久层)
                                              | 产生         
            PO(持久化对象)  ---> JDBC   --->   R(数据库表) 
              (业务层)                    |(jdbc api)
                                          (old app 持久层)
                   
    Hibernate和JDBC结构比较：
                         JDBC：                     Hibernate：
  1业务层：          PO；                           PO；               要持久化的对象；
  2                        R；                             R；               
  3持久层：         jdbc app；                hibernate app； 
  4                                                       映射文件；        类和表的对应关系；
                     
   学习重点：
             映射文件的编写；
             hibernate api；
             学不会变的东西；来掌握变化的东西；
 二、Hibernate  api          
     1、
         Session：save(object);//可以存任何类型的对象；根据xml文件动态产生jdbc；
                          主要api，线程不安全，轻量级的；多个线程不要用同一个；
                  两种使用方法：
                  一个事务一个session，用完关闭；这种用的多；
                  一个view一个；在jsp打开session，在
                              请求打开，经过中间层，持久层，响应再关闭；有点不符合面向对象的概念；
                              这种用的少；
            SessionFactory：线程安全的，重量级的对象；一个应用程序里有一个就行；
                                     是session的工厂；读映射文件；
            Transaction：通过session获得，session是Transaction的工厂；
                                 tran.commit();=connection.commit();
                                 connection也在session里；
            Configuration：读配置文件；连接数据库的信息；
                                   SessionFactory由它造出来的；
    
     2、配置环境：
    
     1)  加载 hibernate jar包；
     2)  配置dtd ，本地读；  
     Window－－preference---web and  xml ---xml catalog ---add
    
     URI：dtd文件的路径   
     key type:  URI 
     key:-//Hibernate/Hibernate Configuration DTD 3.0//EN // dtd的PUBLIC名称；
 
三、Hibernate 应用程序：
     1、PO、表;
     2、类、xxx.hbm.xml;   hibernate.cfg.xml;
     3、test (api);
  
 1)   hibernate.cfg.xml:必须出现：必须叫这个名字；
         数据库连接信息；
         方言；
         映射文件的位置；
     <hibernate-configuration> //根节点
 <session-factory>
  <property name="show_sql">true</property>  <!-- 显示sql -->
  <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>//驱动
  <property name="connection.url">jdbc:oracle:thin:@192.168.0.20:1521:tarena</property>//url
  <property name="connection.username">openlab</property>//用户名
  <property name="connection.password">open123</property>//密码
  <property name="connection.isolation">2</property> //事务隔离级别，防止脏读：1,2,4,8;默认
  <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>//方言，用的是什么种类的数据库和其版本；
  <!-- 指定映射文件的位置；存数据时要来找这个映射文件；这是包的路径，不能用. ; 是相对路径；-->
  <mapping resource="com/haige/biz/Student.hbm.xml"/>  
 </session-factory>
    </hibernate-configuration>  
   
  2)    基本映射： xxx.hbm.xml   可以自己起名；
   
    <hibernate-mapping package="com.haige.biz">  //根节点，所在包；
 <class name="Student" table="T_STUDENT"> //一般一个映射文件写一个class, 类－表
  <id name="sid" column="sid">  //第一个必须是id;属性中有一个特殊的属性，对象id，唯一标识；
   <generator class="hilo"> //generator生成机制hilo算法，不是我们给定义的；class是类别；hilo是一种机制的名字；
    <param name="table">t_hilo</param>
    <param name="column">hi</param>
   </generator>
   <!--
   <generator class="sequence">
    <param name="sequence">stu_seq</param>
   </generator>
   -->
  </id>
   <property name="name" column="name" /> //属性名和字段名一样就不用写column了，小心和关键字冲突；
   <property name="age" column="age" />
   <property name="stuId" column="studentid" />
 </class>
    </hibernate-mapping>
   
    1、PO
         com.公司名.项目名.层名.组成部分
         com.langna.bank.biz.entity
         Account {
                 private  Long  aid;//构造方法不要给这个属性值； Hibernate 使用的包装类；将基本类型转成包装类；
                 private String actNo;
                 private String owner;
                 private double balance;    
         }
   2、建表
        drop table ln_hilo;
        drop table ln_account;
        CREATE TABLE ln_HILO(HI NUMBER(20));
        INSERT INTO ln_HILO VALUES(1);
        create table ln_account(
         aid number(20) primary key,
         actNo varchar(100) not null,
         owner  varchar(20) not null,
         balance number(20,2)
        );
   3、写测试类：
         //1. 准备SessionFactory
  Configuration config = new Configuration();//读xml的配置文件
  config.configure();
  SessionFactory sf = config.buildSessionFactory();
        //2.准备Session和Transaction;Hibernate中的所有操作都必须在事务中进行；
  Session s = sf.openSession();
  Transaction tran = s.beginTransaction();
  //3.准备PO
  Account a=new Account("10001","langna",1000);
  try {
   s.save(a);
   tran.commit();
   s.close();
   }catch (HibernateException e) {
   e.printStackTrace();
  }