Hibernate的学习笔记

阳光穿透心脏的1/2处 2022-08-07 13:46 94阅读 0赞

1.框架        框架(Framework)是一个提供了可重用的公共结构的半成品  
2.使用框架的优势  
        1.不用考虑公共的问题  
        2.可以专心与业务逻辑,保证核心业务逻辑的开发质量  
        3.结构统一,便于开发和维护  
        4.框架集成了前人的经验.可以帮助新手写出稳定,性能优良企鹅结构完美的高质量程序  
3.数据化持久    ORM(Object Relational Mapping)    对象/关系映射  
    1.概念    数据持久化是将内存中的数据模型转换为存储模型或是将存储模型转换为内存数据模型的统称  
4.hibernate框架的   优点  
        1.Hibernate功能强大.是java应用和关系型数据库的桥梁.与其它的操作数据库方式比较.极大提交了开发的效率,降低维护成本  
        2.Hibernate支持许多面向对象的特征  
        3.可移植性好  
        4.框架开源免费  
           缺点  
        1.不适合以数据位中心大量使用存储过程的应用  
        2.大规模的批量插入,修改和删除  
5.hibernate的部署  
    1.下载所需要的jar包  
    2.部署jar包  
    3.创建hibernate配置文件hibernate.cfg.xml  
        <!DOCTYPE hibernate-configuration PUBLIC  
      
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
      
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  
  
        <hibernate-configuration>  
      
            <session-factory>  
                <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>  
                  <property name="connection.driver\_class">oracle.jdbc.driver.OracleDriver</property>  
                <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>  
                <property name="connection.username">scott</property>  
                <property name="connection.password">13717013727</property>  
                <property name="show\_sql">true</property>  
                <property name="current\_session\_context\_class">thread</property>          
                <mapping resource="org/hibernate/test/legacy/Simple.hbm.xml"/>  
            </session-factory>  
  
        </hibernate-configuration>  
    4.创建持久化类和映射文件dept.hbm.xml  
        <?xml version="1.0" encoding="UTF-8"?>  
        <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >  
        <hibernate-mapping>  
        <class name="cn.entity.Dept" table="dept">  
            <id name="deptNo" type="java.lang.Integer" column="deptNo">  
                <generator class="sequence">    //identity     标识列的自增长  
                                //increment    主键的自增长  
                                //assigned    自定义  
                                //native    自动选择      
                                //sequence    序列  
                    <param name="sequence">sequence\_id</param>  
                </generator>  
            </id>  
            <property name="deptName" type="java.lang.String" column="dName"></property>  
            <property name="location" type="java.lang.String" column="loc"></property>  
        </class>  
        </hibernate-mapping>  
    5.读取并解析配置文件.创建Configuration对象  
        Configuration cf=new Configuration().configure();  
    6.读取并解析映射信息,创建SessionFactory对象  
        SessionFactory sf=cf.buildSessionFactory();  
    7.创建Session信息  
        Session ss=sf.openSession();            //Session ss=sf.getCurrentSession();使用该方式创建,前面必须在配置文件中注明<property name="current\_session\_context\_class">thread</property>    且session不需要开启和关闭  
    8.开始事务  
        Transaction ts=ss.beginTransaction();  
    9.数据库操作  
        Object object=ss.save(Object object);                    //添加操作  
        ss.delete(ss.get(ClasName.class,no));                    //删除操作  
        ss.update(Object object);    ss.load(ClassName.class,no);        //修改操作  
        ss.get(ClassName.class,no);    ss.load(ClassName.class,no);        //查询操作  
    10.结束事务  
        ts.commit();        //提交事务  
        ts.rollback();        //回滚事务  
    11.关闭session  
        ss.close();  
6.Hibernate中java对象的三种状态  
    1.瞬时状态<Transient>---------->>>持久状态 save(); saveOrUpdate();-------->>>瞬时状态 delete();  
    2.持久状态<Persistent>--------->>>游离状态 evict();clear();close();------->>>持久状态 update();saveOrUpdate();  
    3.游离状态<Detached>----------->>>瞬时状态 delete();  
7.HQL实用技术(Hibernate Query Language)  
    1.实现数据的分页查询  
        1.使用聚合函数sum()获得总记录数count;  
        2.计算总页数    (count-1)/pageSize+1;  
        3.实现分页查询      
            Query query=session.createQuery(HQL);  
            query.setFirstResult((pageIndex-1)\*pageSize);  
            query.setMaxResults(pageSize);  
            List<T> list=query.list();        //获得分页查询的结果集  
  
    2.Hibernate的检索方式  
        1.对象导航图  
        2.OID检索  
        3.HQL检索  
        4.QBC检索  
        5.原生态查询  
8.Hibernate关联映射  
    class Emp\{                    class Dept\{  
        private int id;                    private int id;  
        private String name;                private String name;  
        private Dept dept;                private Set<Emp> set=new HashSet<Emp>();  
    \}                        \}  
    1.单向的多对一关联映射    Emp.hbm.xml  
        <many-to-one name="dept" class="cn.hb.entity.Dept" column="DEPTNO">  
        </many-to-one>  
    2.双向的一对多关联映射    Demp.hbm.xml        //当为List的时候可以选用<bag></bag>  
        <set name="set" inverse="true/false" cascade="save-update/delete/all" order-by="name desc/asc">  
            <key column="deptno"></key>  
            <one-to-many class="cn.hb.entity.Emp"></one-to-many>  
        </set>  
\---------------------------------------------------------------------------------  
    class Student\{                                class Teacher\{  
        private int id;                                private int id;  
        private String name;                            private String name;  
        private Set<Teacher> teacher=new HashSet<Teacher>();            private Set<Student> student=new HashSet<Student>();  
    \}                                    \}  
    3.单向的多对多关联映射    Student.hbm.xml  
        <set name="teacher" table="Interval" cascade="save-update">  
            <key column="StuId"></key>  
            <many-to-many class="cn.hb.entity.Teacher" column="TeachId"></many-to-many>  
        </set>  
    4.双向的多对多关联映射    Teacher.hbm.xml  
        <set name="student" table="Interval" cascade="save-update" inverse="true">  
            <key column="TeachId"></key>  
            <many-to-many class="cn.hb.entity.Student" column="StuId"></many-to-many>  
        </set>              
\---------------------------------------------------------------------------------  
    class User\{                                class Info\{  
        private int userId;                            private int infoId;  
        private String username;                        private String name;  
        private String password;                        private String card;  
        private Info info;                            private User user;  
    \}  
    5.一对一外键关联映射    Info.hbm.xml                                \}  
        <many-to-one name="user" class="cn.hb.entity.User" column="USERS\_ID" unique="true"></many-to-one>  
                User.hbm.xml  
        <one-to-one name="info" class="cn.hb.entity.Info" property-ref="user"></one-to-one>  
    6.一对一主键关联映射    Info.hbm.xml  
        <one-to-one name="user" class="cn.hb.entity.User"></one-to-one>  
                User.hbm.xml  
        <id name="id" type="java.lang.Integer" column="ID">  
            <generator class="foreign">  
                <param name="property">user</param>  
            </generator>  
        </id>  
        <one-to-one name="info" class="cn.hb.entity.Info" constrained="true"></one-to-one>  
\----------------------------------------------------------------------------------  
    class Address\{                                class Info\{  
        private String province;                        private int id;  
        private String city;                            private String name;  
        private String district;                        private Address address;  
        private String street;                        \}  
        private Info info;  
    \}                                      
    7.组件的映射    Info.hbm.xml  
        <component name="address" class="cn.hb.entity.Address">  
            <parent name="info"></parent>  
            <property name="province" type="java.lang.String" column="province"></property>  
            <property name="city" type="java.lang.String" column="city"></property>  
            <property name="district" type="java.lang.String" column="district"></property>  
            <property name="street" type="java.lang.String" column="street"></property>  
        </component>  
    8.组件类的特征:  
        1.该类没有OID.在数据库中没有对应的表,不需要单独创建类的映射文件  
        2.不能单独持久化该组件类的对象.该对象的生命周期依赖于主表的生命周期  
        3.其它持久化类不允许关联组件类,而组件类可以关联其它持久类  
9.Hibernate的缓存  
    1.Hibernate的缓存一般分为三大类  
        1.一级缓存        位于Session内的缓存即一级缓存.位于缓存中的对象称为持久对象.和数据库中的记录相对应  
            1.该缓存的作用  
                1.减少访问数据库的频率  
                2.保证数据库中的记录和缓存中的相应对象同步  
            2.管理该缓存的方法  
                1.evict(Object obj);            //从缓存中清除指定的持久化对象  
                2.clear();                //清除缓存中的所有的持久化对象  
        2.二级缓存        位于进程和集群范围内的缓存.可以被所有的Sessin共享.其生命周期和SessionFactory一样     是可配置的插件  
            1.配置二级缓存的步骤  
                1.选择合适的缓存插件,配置配置文件    ehcache.xml  
                    <cache name="samplecache"    //缓存的名称  
                    maxElementsInMemory="1000"    //缓存可存放的对象的最大目录  
                    eternal="true"            //是否过期  
                    timeToIdleSeconds="0"        //允许对象空闲状态的最大时间  
                    timeToLiveSeconds="0"        //允许对象存在于缓存中的最大时间  
                    overflowToDisk="false"        //是否将溢出的对象写在基于硬盘的缓存中  
                    />  
                2.开启缓存  
                    <property name="cache.use\_second\_level\_cache">true</property>  
                    <property name="generate\_statistics">true</property>        //打开二级缓存的统计  
                3.指定缓存商品的提供商  
                    <property name="hibernate.cache.provider\_class">org.hibernate.cache.EhcacheProvider</property>  
                4.指定二级缓存的持久化类  
                    <class name="" table="">  
                        <cache usage="" region="" include=""/>  
                    </class>  
            2.二级缓存的适用场合  
                1.很少修改的数据  
                2.不是很关键的数据,能容忍短时间内独到过期的数据  
                3.不会在多个应用之间共享的数据  
                4.应用参考的常量数据  
                  
        3.查询缓存  
                <property name="cache.use\_query7\_cache">true</property>  
    2.缓存的作用范围可以分为三类  
        1.事务范围          
        2.进程范围  
        3.集群范围  
    3.List()和Iterate()的区别  
        1.List()将查询的结果保存到二级缓存.但是不会使用二级缓存  
        2.Iterate()将查询的结果保存到二级缓存.当再次查询时优先使用二级缓存  
10.批量处理数据  
        1.使用HQL进行批量操作  
            1.批量插入数据        insert into Entity select property from Entity where...  
            2.批量删除数据        update Entity set property=value  
            3.批量修改数据        delete Entity  
        2.使用JDBC API批量操作  
        3.使用Session批量操作  
11.Hibernate数据的操作技巧  
    1.聚合函数      
        1.count();        统计记录的条数  
        2.sum();        求和  
        3.min();        求最小值  
        4.max();        求最大值  
        5.avg();        求平均值  
    2.分组查询  
        1.group by        对条件进行分组  
        2.having        对结果进行再次筛选  
    3.子查询  
        1.关键字    all    子查询语句返回所有的记录  
                any/som    子查询返回任意一条记录  
                in/=any    在这之间的任意一条记录  
                exists    子查询语句至少返回一条记录  
        2.操作集合的函数和属性  
                size()/size            获取集合中元素的数目  
                minIndex()/minIndex        对于建立了索引的集合.获得最小索引的  
                maxIndex()/maxIndex        对于建立了索引的集合,获得最大的索引  
                minElement()/minElement        对于包含基本类型元素的集合.获得集合中值最小的元素  
                maxElement()/maxElement        对于包含基本类型元素的集合,获得集合中值最大的元素  
                elements()            获得集合中的所有元素  
        3.命名查询  
                <query name="getInfo">  
                    <!\[CDATA\[  
                        from Dept  
                    \]\]  
                </query>  
                <sql-query name="getInfo">  
                    <return alias="d" class="cn.hb.entity.Dept"/>  
                    <return-join alias="e" property="d.empx " />  
                    <!\[CDATA\[  
                        select d.\*,e.\* from DEPT d inner join EMP e where d.deptno=e.deptno  
                    \]\]  
                </sql-query>  
        4.CLOB和BLOB类型数据的使用  
            1.java数据类型        Oracle数据类型  
                byte\[\]        BLOB  
                String        CLOB  
                java.sql.Blob    BLOB  
                java.sql.Clob    CLOB  
            2.java数据类型文件的添加和读取  
                //读取字节流文件  
                InputStream inputStream=this.getClass().getResourceAsStream("/BigObject.txt");  
                //创建字节数组  
                byte\[\] bt=new byte\[inputStream.available()\];  
                //对象初始化  
                BigObject bigObject=new BigObject();  
                bigObject.setTclob("个人简介");            //为CLOB对象的内容写入  
                bigObject.setTblob(bt);                //为BLOB对象的内容写入  
                //保存提交  
                ss.save(bigObject);  
                ts.commit();  
    ------------------------------------------------------------------------  
                OutputStream outputStream=new FileOutputStream("BigObject\_back.txt",true);  
                outputStream.write(bigObject.getTblob());    //对BOLB文件的输出  
                System.out.println(bigOnject.getTclob());    //对CLOB内容的输出  
            3.oracle数据类型时文件的添加和读取  
                //读取字节流文件  
                InputStream inputStream=this.getClass().getResourceAsStream("/BigObject.txt");  
                //创建字节数组  
                byte\[\] bt=new byte\[inputStream.available()\];  
                //对象初始化  
                BigObject bigObject=new BigObject();  
                bigObject.setTclob(Hibernate.createClob("个人简介"));            //为CLOB对象的内容写入  
                bigObject.setTblob(Hibernate.createBolb(bt));                //为BLOB对象的内容写入  
                //保存提交  
                ss.save(bigObject);  
                ts.commit();  
    -----------------------------------------------------------------------  
                Reader reader=litleObject.getTclob().getCharacterStream();            //字符流的读取  
                InputStream inputStream=litleObject.getTblob().getBinaryStream();        //字节输入流的读取  
                OutputStream outputStream=new FileOutputStream("LitleObject\_back.txt",true);    //创建输出流  
                int length=0;  
                char\[\] ch=new char\[1024\];  
                while((length=reader.read(ch))!=-1)\{  
                    System.out.println(new String(ch,0,length));  
                \}  
                while((length=inputStream.read())!=-1)\{  
                    outputStream.write(length);  
                \}  
11.Criteria查询接口的使用  
        1.等于            Restrictions.eq("dName","销售部");  
        2.不等于        Restrictions.ne("dName","销售部");  
        3.小于            Restrictions.lt("sal",1000);  
        4.大于            Restrictions.gt("sal",1000);  
        5.大于等于        Restrictions.ge("sal",1000);  
        6.小于等于        Restrictions.le("sal",1000);  
        7.等于空值        Restrictions.isNull("sal");  
        8.非空值        Restrictions.isNotNull("sal");      
        9.等于列表中的某个字    Restrictions.in("dName",Collection value/Object\[\] object);  
        10.不等于列表中的任意值    Restrictions.not(Restrictions.in("dName",Collection value/Object\[\] object))  
        11.之间            Restrictions.between("sal",1000,2000);  
        12.不在之间        Restrictions.not(Restrictions.between("sal",1000,2000));  
        13.模糊查询        Restrictions.like("dName","%m%");                        //模糊查询  
                    Restrictions.like("dName","m",MatchMode.START/END/ANYWHERE/EXACT);        //模糊查询  
                    Restrictions.ilike("dName","%m%");                        //忽略大小写的模糊查询  
                    Restrictions.ilike("dName","m",MatchMode.START/END/ANYWHERE/EXACT);        //忽略大小写的模糊查询  
        14.逻辑与        Restrictions.and(Restrictions.eq("dName","销售部"),Restrictions.eq("loc","BEIJING"););  
        15.逻辑或        Restrictions.or(Restrictions.eq("dName","销售部"),Restrictions.eq("loc","BEIJING"););  
        16.逻辑非        Restrictions.not(Restrictions.eq("dName","销售部"));        //部门不是销售部的记录  
        17.集合为空        Restrictions.isEmpty("emp");  
        18.集合非空        Restrictions.isNotEmpty("emp");  
        19.条件的集合        Restrictions.conjunction().add(Restrictions.eq("dName","销售部"));  
        20.满足其中的一条    Restrictions.disjunction().add(Restrictions.eq("dName","销售部"));  
        21.忽略大小写        .ignoreCase();  
        22.排序            .addOrder(Order.asc("sal"));  
        23.分页            .setFirstResult(0).setMaxResults(5);  
        24.查询唯一对象        .uniqueResult();  
        25.连接查询        .createCriteria("emp","e");            //.createAlias("emp","e");  
        26.左外连接的设置    .setFetchMode("emp",FetchMode.JOIN);  
        27.单值投影        .setProjection(Property.forName("dName"));  
        28.多值投影        .setProjection(Projections.projectionList().add(Property.forName("eName")).add(Property.forName("sal")));  
        29.Projections常用的方法  
            1.分组        Projections.groupProperty("loc");  
            2.统计记录数    Projections.rowCount();  
            3.统计平均值    Projections.avg("sal")  
            4.统计最大值    Projections.max("sal");  
            5.统计最小值    Projections.min("sal");  
            6.统计求和    Projections.sum("sal");  
            7.统计字段非空    Projections.count("sal");  
        30.DetachedCriteria常用的方法  
            1.离线查找    一般用于查询条件由用户构造.把条件封装成对象返回持久化层  
                DetachedCriteria detachedCriteria=DetachedCriteria.forClass(Dept.class).createCriteria("emp","e").add(Restrictions.eq("e.eName"),"张三");  
                在持久化层.进行对象的调用  
                Session ss=new Configuration().confige().openSession();  
                List<Dept> list=detachedCriteria.getExcuteableCriteria(session).list();  
            2.条件查找  
                DetachedCriteria detachedCriteria=DetachedCriteria.forClass(Emp.class)  
                                .setProjection(Projections.groupProperty("eName")).setProjection(Property.forName("sal").avg());  
                List<Emp> list=ss.createCriteria(Emp.class).add(Property.forName("sal").gt(detachedCriteria)).list();  
12.继承映射  
    1.两个有继承关系的对象存放于一张表  
        1.create table person (id,name,age,job,sal,type)  
        2.class person\{id,name,age\}    class emp\{job,sal\}  
            <class discriminator-value="person">  
                <id></id>  
                <property></property>  
                <discriminator type="String" column="type"><discriminator>            //辨别者列  
                subclass discriminator-value="emp">  
                    <property></property>  
                </subclass>  
            </class>  
    2.两个有继承关系的对象存放于两张表.存在主键引用  
        1.create table person (id,name,age)        create table emp(id,job,sal)  
        2.class person\{id,name,age\}    class emp\{job,sal\}  
            <class>  
                <id></id>  
                <property></property>  
                <joined-subclass>  
                    <key column></key>  
                    <property></property>  
                </joined-subclass>  
            </class>  
    3.两个有基础更关系的对象,存放于两张表,两张表有继承关系  
        1.create table person (id,name,age)        create table emp(id,name,age,job,sal)  
        2.class person\{id,name,age\}    class emp\{job,sal\}  
            <class>  
                <id></id>  
                <property></property>  
                <union-subclass>  
                    <key column></key>  
                    <property></property>  
                </union-subclass>  
            </class>  
13.事务隔离级别  
    1.并发事务可能出现的情况  
        1.出现丢失更新  
        2.出现脏读  
        3.出现虚读  
        4.出现重复度            //  
        5.出现第二类丢失更新  
    2.解决并发事务  
        1.串行化  
        2.可重复度  
        3.可读已提交  
        4.可读未提交