hibernate总结笔录e

一 ORM：ORM<object relation mapping>关系数据库.


1.1：产生的原因：对象数据库的不同步.


ORM是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。
简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，
将java程序中的对象自动持久化到关系数据库中。
本质上就是将数据从一种形式转换到另外一种形式.
 
1.2  常见ORM框架
   1.Hibernate
灵活的设计，优秀的性能，齐全的文档
   2.Entity Bean（ejb）
重量级，成本高，开发周期长，学习曲线非常陡
   3.IBATIS  apache子项目
SQL-MAPPING，相对于hibernate的完全面向对象，IBATIS更加灵活。
但需要的代码量更大，而且需要直接编写SQL语句。
   4.TOPLink  (收费) 
   5.JDO  java-data-object

 二 hibernate

    1 什么是Hibernate
    Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的
    使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合
   ，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，
   完成数据持久化的重任

     与ibatis的比较
                             IBATIS                                             HIBERNATE
    ORM类型                  半自动                                                      一站式全自动
    映射关系               实体类和SQL语句                                               实体类和数据库
    学习门槛                 容易                                                         3倍于IBATIS
    SQL 的 优化           方便,进行细粒度的优化                                       1 一般情况下，HIBERNATE 会把所有的字段都SELECT 2 UPDATE一般也是更新所有字段
    开发效率             IBATIS要求开发者编写具体的SQL 语句                            HIBERNATE会自动生成SQL 语句
    数据库移植           标准SQL方便移植  如果用到具体的数据库sql则 不方便移植       移植方便

    2 Hibernate的核心类和接口：
   <1>Configuration
负责管理Hibernate的配置信息，这些配置信息都是从配置文件 hibernate.cfg.xml或者
Hibernate.properties读取的，当然也可以自定义文件名称，只要在实例化Configuration
的时候指定具体的路径就可以了
   <2>SessionFactory
Configuration的实例会根据当前的配置信息，构造SessionFactory实例。
SessionFactory是线程安全的，一般情况下一个应用中一个数据库共享一个SessionFactory实例。
   <3>Session
一般的持久化方法（CRUD）都是通过Session来调用的，Session是非线程安全的
   <4>Transaction
事务管理
   <5>Query
查询的接口


   3 Hibernate的原理及步骤


1. 读取并解析配置文件 
//采用默认的hibernate.cfg.xml来启动一个Configuration的实例
例：Configuration configuration=new Configuration().configure();
//如要修改默认配置文件名 当然你可以选择不修改
Configuration configuration=new Configuration().configure(new File("src/xxx.xml"));
2. 读取并解析映射信息，创建SessionFactory
例：SessionFactory  sessionFactory = configuration.buildSessionFactory();
3. 打开Session实例(它是线程不安全的，是共享同一个session，所以要ThreadLocal模式来控制)
例：Session session = sessionFactory.openSession();
4. 创建事务Transaction
例：Transaction transaction = (Transaction) session.beginTransaction();
5. CRUD操作(执行数据操作 CRUD 增删查改)
例： 增加
    session.save(pojo对象);
    增加或者修改
    session.saveOrOpdate(pojo对象)//当修改时候,id不存在将被抛出异常
                     删除
                     session.delete(pojo对象)
    //根据主键加载
                    p1=(Person)session.load(pojo类.class, 主键值);


6. 提交事务
例：transaction.commit();
7. 关闭Session实例及SessionFactory
例：   session.close();
              sessionFactory.close();
// 获取session
Session session = this.getHibernateTemplate().getSessionFactory().getCurrentSession();


   示例一个Hibernate的流程操作：


ORM  对象关系映射  O---pojo   R---创建数据库的表   M---person.hbm.xml
1首先导入所有的包，2建立一张表并且建立属性和它对应的pojo(javaBean)，3然后在src下面建立tableName.hbm.xml来映射表与pojo的关系，
<?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE hibernate-mapping
PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!--将"pojo" 映射到表 table="demo"-->
<class name="包.pojo类名" table="表名">
<!-- name是pojo属性 column是映射的表字段 、若不写表示默认相同  -->
<id name="id" column="id">
   <generator class="identity"/>
</id>
<property name="name"/>
<property name="age"/>
   </class>
</hibernate-mapping>


4 在src下面建立 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>
<!-- Database connection settings  连接数据库-->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/j2ee</property>
<property name="connection.username">root</property>
<property name="connection.password">123456</property>
<!-- JDBC connection pool (use the built-in) 连接数 -->
<property name="connection.pool_size">5</property>
<!-- SQL dialect 映射到mysql-->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 是否显示生成的sql语句-->
<property name="show_sql">true</property>
<!--  可以从对象生成 表 也可以从表生成对象
      它包含4个属性:
create : 会根据你的model类来生成表,但是每次运行都会删除上一次的表,重新生成表,哪怕2次没有任何改变
create-drop : 根据model类生成表,但是sessionFactory一关闭,表就自动删除
update : 最常用的属性，也根据model类生成表,即使表结构改变了,表中的行仍然存在,不会删除以前的行
validate : 只会和数据库中的表进行比较,不会创建新表,但是会插入新值
-->
<property name="hbm2ddl.auto">update</property>
      <!---   hibernate  mapping  将上面的映射表放到的hibernate的xml  -->
<mapping resource="person.hbm.xml"/>
</session-factory>
</hibernate-configuration>


    5 客户端使用
public class Client {
   public static void main(String[] args) {
      //读取配置文件
      Configuration configuration = new Configuration().configure();
      //创建Session
      SessionFactory  sessionFactory = configuration.buildSessionFactory();
      //打开Session
      Session    session = sessionFactory.openSession();
      //获取事物
      Transaction tx = session.beginTransaction();
      修改 删除 增加
                        //增加


                        session.saveOrUpdate(pojo对象)//增加或修改pojo
                        session.delete(pojo对象)//删除
                        p1=(Person)session.load(Person.class, 2);


      //提交事物
      tx.commit();
   {color:black}}
}
        演示 1增加 2 修改 3   删除 4  根据主键查询 5查询 6事务


     4.Session的管理
   Session是Hibernate运作的中心，对象的生命周期、事务的管理、数据库的存取，都与 Session息息相关，
   就如同在编写JDBC时需关心Connection的管理，以有效的方法创建、利用与回收Connection，以减少资源的消耗，
   增加系统执行效能一样，有效的Session管理，也是Hibernate应用时需关注的焦点。
   　
   Session是由SessionFactory所创建， SessionFactory是线程安全的（Thread-Safe），您可以让多个
   线程同时存取SessionFactory而不会有数据共享的问题，然而Session则不是设计为线程安全的，所以试图让
   多个线程共享一个 Session，将会发生数据共享而发生混乱的问题。 　
   在各种Session 管理方案中， ThreadLocal 模式得到了大量使用。ThreadLocal 是Java中一种较为特殊的
   线程绑定机制。通过ThreadLocal存取的数据，总是与当前线程相关，也就是说，JVM 为每个运行的线程，
   绑定了私有的本地实例存取空间，从而为多线程环境常出现的并发访问问题提供了一种隔离机制。
   首先，我们需要知道，SessionFactory负责创建Session，SessionFactory是线程安全的，多个并发线程
   可以同时访问一个SessionFactory 并从中获取Session 实例。而Session并非线程安全，也就是说，如果
   多个线程同时使 用一个Session实例进行数据存取，则将会导致Session 数据存取逻辑混乱
     
         ThreadLocal例子


public class HibernateUtil
{


   public static final SessionFactory sessionFactory;
   static
{
try
{
   //采用默认的hibernate.cfg.xml来启动一个Configuration的实例
Configuration configuration=new Configuration().configure();
//由Configuration的实例来创建一个SessionFactory实例
   sessionFactory = configuration.buildSessionFactory();
}
catch (Throwable ex)
{
   // Make sure you log the exception, as it might be swallowed
   System.err.println("Initial SessionFactory creation failed." + ex);
   throw new ExceptionInInitializerError(ex);
}
   }
   //ThreadLocal并不是线程本地化的实现,而是线程局部变量。也就是说每个使用该变量的线程都必须为
//该变量提供一个副本,每个线程改变该变量的值仅仅是改变该副本的值,而不会影响其他线程的该变量
//的值.
//ThreadLocal是隔离多个线程的数据共享，不存在多个线程之间共享资源,因此不再需要对线程同步    
public static final ThreadLocal session = new ThreadLocal();
   public static Session currentSession() throws HibernateException
{
Session s = (Session) session.get();
//如果该线程还没有Session,则创建一个新的Session
if (s == null)
{
   s = sessionFactory.openSession();
   //将获得的Session变量存储在ThreadLocal变量session里
   session.set(s);
}
return s;
   }


   public static void closeSession() throws HibernateException {
Session s = (Session) session.get();
if (s != null)
   s.close();
session.set(null);
   }
}
    5   Hibernate三种查询方式 1 hql 2 qbc《qbe  --- query by example》 3 sql
  1.hql    
           1.1 冒号法
    Session session = this.getHibernateTemplate().getSessionFactory().getCurrentSession();
session.beginTransaction();
    Query query=session.createQuery(" from Person p where name=:xxx");//from后面跟的是PO对象名，而不是表名 面向对象。