hibernate3.6-jar包

day1

一. hibernate数据持久化组件

对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库）

1.为什么要持久化:

           a.内存是暂时存储设备,断电后数据易丢失

           b.网络传输无法传输内存中的对象，需要将对象外化

           c.内存中数据查询,组织不方便

           d.内存只能存储少量数据

2.怎样持久化

   a.对象序列化 --> 二进制流

                 合并存储,粒度大,无规律

                 不支持检索

                 只适合少数个别对象的序列化

     b.用JDBC/EJB/ORM 将数据存入数据库

       用JDBC:(Java DB Connection)

       优点:底层开发,控制力强(细); 效率最高; 标准的(SQL)JDBC,有可移植性

       缺点:过于复杂; 代码量大; 可维护性差(代码重用性低);

       用EJB:(Entity Java Bean)

       优点:直接自动生成JDBC代码; 持久对象(PO)的状态由服务器管理; 声明式的事务

       缺点:功能不全(特殊的组件,不能做继承关系); EJB容器是侵入性容器,失去OO的优点; 调试更复杂

       用ORM:（object relation mapping）对象关系映射

       优点:自动生成JDBC(代码量下降); 使用(plain oldest java object---pojo),非侵入型; 提供状态管理; 难度下降,不需要容器

       缺点:由于开源, 文档少; bug多; 技术支持差

      结论: 用java开发-->必须将数据持久化-->用数据库持久化-->须用ORM-->需要用Hibernate

二. Hibernate

      1.POJO类

           plain oldest java object,就是标准的Java Bean。

      2.Hibernate

           Hibernate -->一个可以自动的根据xml完成对象关系映射，并持久化到数据库的开源组件。其底层也是由JDBC实现的。hibernate是通过xml文件的配置，对数据库的底层的方言，以及数据库连接所需的信息，以及连接数据库的驱动。

      hibernate的系统配置文件

           hibernate.cfg.xml -->与数据库建立连接(一般放在项目的根目录下)

           XXXX.hbm.xml-->用来建立类与表之间的映射关系(一般将映射类的xml文件和实体类放在一起)

      3.Hibernate API

      Configuragion   读配置文件(默认名:hibernate.cfg.xml)  (org.hibernate.cfg.Configuration)

       生成SessionFactory:SessionFactory 重量级的对象, 线程安全的  (org.hibernate.SessionFactory),生成Session .

           Session，相当于JDBC中的Connection  (org.hibernate.Session)，轻量级的对象,线程不安全(原则上一个线程一个Session,不要放在并发的环境中)

      生成Transaction

      Transaction    管理事务的对象 (org.hibernate.Transaction)

      Query       查询对象,提供面向对象的查询语言(HQL)

      4.使用hibernate编程步骤

           1，配置环境，加载hibernate的jar文件，以及连接数据库连接使用的jar文件，并配置CLASSPATH环境变量。

           2，写hibernate所需的配置文件，hibernate.cfg.xml ，XXX.hbm.xml

           3，写POJO类

           4，调用hibernate API。

           1)获得Configuration的对象，并调用他的configure()方法来读映射文件和配置文件，使用Configuration对象的buildSessionFactory()方法创建SessionFactory对象

           2)使用SessionFactory对象openSession()方法创建Session对象。

       3）使用Transaction  trans = session.beginTransaction();方法来打开一个事务

         4)使用Session的相应方法来操作数据库，将对象信息持久化到数据库。

         session.delete();

　　　　session.save()

        session.saveOrUpdate()

　　　　session.update()

　　　　session.load();

5）调用trans.Commit()提交事务

6）关闭资源

附: 1.环境配置:

           *** 导入hibernate 库文件 ***

           1、在eclipse中建立一个java工程，如:hbn

           2、在工程hbn的属性--Build Path中选择Add Libraries

           3、在Add Libraries窗口中选择User Library点next按钮

           4、在User Library窗口中点User Libraries ...按钮

           5、在User Libraries窗口中，点new按钮

            6、在New user library窗口中，填写一个User libary name(如:hbnlib,注意不要选择System libary 复选框)，点OK按钮回到User Liberies窗口

           7、在User Liberaries窗口中选择刚刚创建的hbnlib,点Add jars按钮

           8、在打开的文件选择窗口中找到解压好的hibernate的库文件，全部选中，点"打开"按钮，返回User Libraries窗口

           9、在User Libraries窗口中点OK按钮，返回User Library 窗口；再点Finish按钮，结束操作

           b. 驱动

           c. 映射文件/配置文件的模板

           d. Eclips导入2个DTD文件(3.2版本以前的eclipse需要导入)

2. hibernate.cfg.xml的写法

<?xml version='1.0' encoding='utf-8'?>

<!DOCTYPE hibernate-configuration PUBLIC

        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"      "/home/soft01/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

    <property name="connection.driver_class">com.mysql.jdbc.Driver

    </property>  指定数据库的驱动程序

    <property name="connection.url">jdbc:mysql://127.0.0.1:3306/test

    </property>  指定连接数据库的URL

    <property name="connection.username">root

   </property> 联结数据库的用户名，

    <property name="connection.password">1111</property>  密码

    <propertyname="dialect">org.hibernate.dialect.MySQLDialect

</property> 指定数据库使用的方言，本质上就是hibernate  API 中的一个用来标示不同数据库的接口

    <property name="show_sql">true</property>   

         用来在控制台输出hibernate 产生的SQL语句

    <property name="format_sql">true</property> 对SQL语句进行format

    <mapping resource="Student.hbm.xml"/>   对象关系映射文件，可以有多个

</session-factory>

</hibernate-configuration>

3. hibernate的映射类的XXXX.hbm.xml的写法

      <?xml version="1.0"?>

      <!DOCTYPE hibernate-mapping PUBLIC

      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"                 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

      <!-- 建立类于数据库中表的映射关系 -->

      <hibernate-mapping package="com.tarena.biz.entity"><!--映射类所在的包-->

      <!-- 类名和表名的映射 -->

      <class name="Account" table="account_hz">

           <!-- 属性和字段的映射 -->

           <id name="aid" column="aid"><!--主键生成策略-->

           <generator class="hilo"><!—主键产生方式：高低位算法->

                 <param name="table">pk_table</param>

                 <param name="column">id_value</param>

           </generator>

           </id>

           <property name="actNo" column="actNo"></property>

           <property name="balance" column="balance"></property>

           <!--在hibernate中其他类型可以自动识别只有Data类型必须指名-->

      </class>

      </hibernate-mapping>

 4. 创建数据库表结构:

create account_hz(aid number(20) primary key,

                    actNo varchar(50) not null unique,

                      balance number(12,2) not null);

create t_hilo(hi number(20));

insert into t_hilo values(1);//必须事先插入一条记录到表

5. 调用hibernate API

      public class Test {

           public static void main(String[] args) {

                 Account act = null;

           //step1: 创建Configration对象

           Configuration config = new Configuration().configure();

           //step2: 获取SessionFactorye

           SessionFactory sf = config.buildSessionFactory();

           //step3:获取Session和Transaction,进行持久化操作

           Session s = null;

           Transaction tran = null;

           try {

                 s = sf.openSession();

                 tran = s.beginTransaction();//启动事务

                 act = new Account(12345, 2000.00);

                 s.save(act);//将帐户对象持久化

                 tran.commit();//提交事务

           } catch (Exception e) {

           if(tran != null){

           tran.rollback();

           e.printStackTrace();

           } finally{

           if(s!=null) s.close();

           }

      }

}    

三．主键的生成方式：

1：hibernate 负责对主键ID赋值

2：应用程序自己为主键ID赋值（不推荐使用）

3：底层数据库为主键ID赋值

生成主键的具体用法:

1）：increment：（跨平台的）

以递增的方式为代理主键赋值，每次维护的当前实例中取出一个最大值，在最大值的基础之上再进行加法，适合只有单个应用进程访问数据的情况，否则会产生并发冲突问题（主键重复）。并且oid 的类型必须是long ,int ,short类型的。

2）：assigned :由程序员给赋值，（不建议使用）

3）：identity:是由底层的数据库来生成主键，他要求底层数据库支持自动增长，并且把主键定义成自动增长类型的 ，oid 必须是long ,int ,short 类型的。

Oracle 不支持。Mysql 支持

4）：sequence:由底层的数据根据序列来生成主键。oracle ,db2数据库支持，mysql不支持

5）：native:(跨平台的)

由hibernate 自己跟据不同的数据库的主键生成方式，自己选择生成方式（可以跨平台）

6）：hilo :（跨平台的），通过hi/lo算法实现主键的生成机制，但是需要额外的表来保存主键的生成历史。

使用规则： 通用性和安全性：

7）：seqhilo：取得sequence的值，来生成高位，产生id。

但是只能使用于有sequence的数据库（oracle , db2）;

8）：uuid.hex:

用系统时间和ip地址等具有天然唯一性的资源进行计算，生成id，

全球唯一。生成的是一个128位的二进制数。然后把这个二进制数，转化成一个16进制的数（32位），再转化为字符串付给我们的id。那么我们的实体类的oid以及数据库的主键都需要随之改为字符串类型的。

9）：foreign

用于共享主键的时候。（一对一主键关联）；

Day2

一.Util工具类:

public class HbnUtilV1 {

      private static SessionFactory sf;//线程安全的

           static{

           Configuration config = null;

           try {

           config = new Configuration().configure();

                 sf = config.buildSessionFactory();

           } catch (Exception e) {

           e.printStackTrace();

           }

           }

//session轻量级的对象，线程不安全的，

//所以使用的原则是一个线程一个session，

public static Session getSession(){

           Session s = null; 

         if(sf!=null)

           s = sf.openSession();

           return s;

           }

//不用静态语句块的情况下用这个

publicstatic SessionFactory getSessionFactory(){

           if(sf==null||sf.isClosed()){

                 sf=new Configuration().configure().buildSessionFactory();

           }

           returnsf;

      }

public static void close(){

if(sf!=null&!sf.isClosed()){

sf.close();

          }

        }

      }         

二．HQL语句

           Query q = s.createQuery("from Account where actNo=:actNo");

      //from 类名 where 属性名=:shuxingming，其中=:后面的东西相当于//JDBC sql中的?，也是一个占位符，等待你去赋值

                 q.setLong("actNo",12345);//设置属性名,并赋值

      Account a=q.uniqueResult()//获得匹配HQL的唯一对象，如果查询条件不能唯一确定一个对象会抛异常

下面是连起来使用

 hql="from Student s where s.sno>?";

     List list1=s.createQuery(hql).setInteger(0, 300).list();

     for(Student e:(List<Student>)(list1)){

          System.out.println(e.getSno()+":"+e.getName());

     }

Hql="from Student s where s.name like ?";

list = s.createQuery(hql).set</span

 

 

【温馨提示】如果我的整理对您的学习有帮助，可以在方便的情况向我们整理小组的支付宝支付 1毛钱，表示对我们整理小组的支持，谢谢 支付宝帐号：[e-mail]