Hibernate 干货

一 .hibernate概念：

hibernate应用在javaee 三层框架中的dao层（web 层 --service层--dao层），在dao层实现对数据库的CRUD操作。hibernate是对jdbc的封装，使用hibernate的好处，不需要写jdbc复杂的代码，不需要写sql语句实现。 hibernate是开源的轻量级框架。

版本:hibernate3.x hibernate4.x hibernate5.x 其中4.x不稳定不建议使用

orm: object relational mapping 对象关系映射 hibernate使用的就是orm思想对数据库进行CRUD操作

简单说:让实体类和表进行一一对应关系（实体类名--数据库表名实体类中属性名--表中字段名）

使用配置文件来完成这种对应关系

二.配置文件

hibernate的核心配置文件

    hibernate.cfg.xml hibernate核心配置文件路径：src目录下文件名称固定不变
    <hibernate-configuration> 
        <session-factory> 

            
            <property name= "connection.driver_class" >com.mysql.jdbc.Driver</property>
            <property name= "connection.url" >jdbc:mysql:///hibernate</property>
            <property name= "connection.username" >root</property>
            <property name= "connnection.password" >root</property>

            
            <property name= "show-sql" >true</property>
            <property name= "format-sql" >true</property>
            <property name= "hibernate.hbm2ddl.auto" >ture</property>
            <property name= "dialect" >org.hibernate.dialect.mysqlDialect</property>
            <property name= "hibernate.current_session_context_class" >thread</property>

            
            <mapping resource="cn/ss/entity/User.hbm.xml"/>

hibernate映射配置文件

    hibernate 映射配置文件即实体类的映射文件一般和实体类所在路径在同一个包下
    例如：User.hbm.xml 格式：实体类名+.hbm.xml 固定格式
    
    <hibernate-mapping>
        <class name="cn.ss.entity.User" table="t_user">
            
             <id name="uid" column="uid">
              
                <generator class="native"></generator>
            </id>

            
            <property name="uname" column="uname"></property>
            ... ...
        </class>

主键生成策略：

    increment: 由long int short 类型使用，由hibernate自动递增（每次加1）线程不安全建议测试使用 identity:由DB2 mysql sql server 等数据库支持自增长类型的数据库使用的生成器，要求主键定义为自增长生成器类型
    sequence:由oracle 等数据库支持序列的数据库使用。
    native:当使用native hibernate会自动识别数据库并用对应的主键生成策略从而识别主键生成识别符
    uuid:由hibernate 采用128位uuid算法生成的识别符
    assignied：由java 程序生成的识别符，如果默认id没写generator 属性则默认值位assignied

三 hibernate 核心api使用

Configuration SessionFactory Session Transaction

1.Configuration 读取hibernate核心配置文件用的类

    Configuration cfg = new Configuraion();
    cfg.configure(); //hibernate.cfg.xml 名称固定位置固定在src下才可以读取到

2.SessionFactory 执行过程中创建表，特别消耗资源，建议一个项目只创建一共sesionFactroy对象. 可以创建session

cfg.buildSessionFactory();

写在工具类里面且一个项目只创建一个sessionFactroy 对象的实现代码

    public class HibernateUtils{//hibernate 工具类

        private static Configuration cfg;
        private static Sessionfactory sessionFactory;
        private static Session session;

        static {//在静态代码块中创建可以保证类加载的时候只创建一次，保证唯一性
            cfg = new Configuration();
            sessionFactory = cfg.buildSessionFactory();
        }


        public static SessionFactory getSessionFactory(){
            return sessionFactroy;

        }
        public static Session getSession(){
        //session = sessionFactory.OpenSession(); 线程不安全不建议使用
        return sessionFactory.getCurrentSession();//绑定本地线程且线程安全不需要手动关闭session
        //否则写了会报错 session.close();

        }

    }

3.Session 类相当于jdbc中的connection hibernate中的session是单线程的，所以需要绑定本地线程

然后调用session的方法操作对象

相关方法：

1.获取对象 get(类名.class,主键值）

2.保存save(对象)

3.修改update(对象）saveOrUpdate(对象）

4.删除delete(对象）--注意删除的时候需要先查询出对象才可以删除

4.Transaction 事务类

只有开启事务之后才可以操作session对应的方法

    /**事务开启*/

    Transaction tx = session.beginTransaction();



    /** 提交事务**/

    tx.commit();


    /** 回滚事务**/

    tx.rollback();

事务的特性：原子性一致性隔离性持久性

四 hibermate的对像状态和缓存机制

hibernate对对象由三种状态：

    瞬时态：对象里即没有id 主键值，又没又在session对象中
        User u = new User(); new出来的都是瞬时态对象
        u.setname("wangwu");并里面没有id

    持久态：对象里即有id主键值，又在session的对象中

        持久态对象可以实现立即刷新，不需要save() update（）等
        User u = session.get(User.class,1);
        u.sertname("lisi");

    托管态：对象中有id主键值，但没在session的对象中

        User u = new User();
        u.serid(5); // 对象中有id

hibernate的缓存：

第一种：一级缓存在session 对象中，生命周期同session,是持久态对象自动更新的依据。实现原理：在创建session对象时会同时创建session的一级缓存和一个副本快照区，当session对象调用方法得到持久态对象时首先会到一级缓存中查找是否存在该对象，如果没有就存放到一级缓存中同时复制到副本快照区，当对象修改后，首先到副本区查看对象是否与该对象一致，如果一致则不做修改，如果不一致则实行自动更新操作，把数据更新到数据库中

第二种：二级缓存在sessionFactory对象中,生命周期同sessionFactory，一般很少使用

五 hibernate 表与表之间的关系及级联操作

一对多多对多一对一

一对多

    一对多：客户和联系人的关系一个客户可以有多个联系人但是一个联系人只属于一个客户
    配置文件中操作

    在一的一方
    客户方实体类
    Customer class
    添加联系人Set集合属性
    private Set<LinkMan> setLinkMan = new HashSet<LinkMan>();//无序唯一性

    客户方映射配置文件
    Customer.hbm.xml
    添加set标签
    <set name = "setLinkMan" cascade="save-update,delete" inverse="false" bach-size="10">
    
        <key column = "clid"></key>
        <one-to-many class="cn.ss.entity.LinkMan"/>

     </set>


    在多的一方
    联系人实体类
    LinkMan class
    添加所属客户属性
    private Customer customer;


    联系人映射配置文件
    LinkMan.hbm.xml
    添加many-to-one 标签
    <many-to-one name="customer" class="cn.ss.enetiy.Customer" column="clid"/>


    java代码
    Customer baidu = new Customer();
    baidu.sertname("baidu");
    LinkMan lucy = new Link Man();
    lucy.setname("lucy");
    LinkMna wangcai = new LinkMan();
    wangcai.setname("wangcai');
    baidu.getSetLinkMan().add(lucy);
    baidu.getSetLinkMan().add(wangcai);
    //持久态对象自动更新不需要save() 方法实现了级联保存操作
    级联删除类似

多对多

    多对多：用户的和角色的关系一个用户可以有多个角色，一个角色也可以有多个用户
    配置中间中操作

    在用户方
    用户实体类
    User class
    添加角色类set集合
    private set<Role> setRole = new HashSet<Role>();

    用户映射配置文件
    User.hbm.xml
    添加set标签
    <set name="setRole" table ="user_role" casecade="save-update" inverse="true">
    
        
        <key column= "userid"></key>
        <many-to-many class="cn.ss.entity.Role" column="roleid"/>
    </set>

    角色方
    角色实体类
    Role class
    添加用户set集合
    private Set<Use> setUser = new HashSet<User>();

    角色映射配置文件
    Role.hbm.xml
    添加set标签
    <set name="setUser" table="user_role">
        <key column= "roleid"></key>
        <many-to-many class="cn.ss.entity.User" column="userid"/>
    </set>


    java代码
    User u1 = new User();
    u1.setname("u1");
    User u2 = new User();
    u2.setname("u2");

    Role r1 = new Role();
    r1.setName("r1");
    Role r2 = new Role();
    r2.setName("r2");
    Role r3 = new Role();
    r3.setName("r3");


    u1.getSetRole().add(r1);
    u1.getSetRole().add(r2);
    u2.getSetRole().add(r2);
    u2.getSetRole().add(r3);

    //以下代码可以不写
    session.save(u1);
    session.save(u2);




六 hibernate其他api查询对象

Query Crieator SQLQuery

Query对象使用的是hql语句只操作实体类和属性

    Query对象 --- HQL查询
    //1.hql语句创建
    String hql = "from User"; //from+实体类查询所有

    //2 创建Query对象
    Query query = session.createQuery(hql);

    //3.调用对象方法返回结果
    List <User> list = query.list();


    hql语句：
    1.查询所有 “form User” from+实体类类名
    2.条件查询 "from User where uid = ?" 条件语句where+实体类属性名=? ?是占位符
        需要设置值用query.setParameter(下标从0开始,对应属性值);
        如果多条用 List<User> list = query.list();
        如果唯一值 Object obj = query.uniqueResult(); 注意long型数据
    3.模糊查询 “form User where name like ?”
        ? 占位符值设置：query.setParameter(下标从0开始,“%白%”);
    4.排序查询 “from User Order by uid” //form+实体类名+order by +属性名 asc/desc;
    5.分页查询使用的是query对象的两个方法
        query.setFirstResult(0);//从0开始查
        query.setMaxResults(3);//每页查找3条记录
    6.投影查询 “select uid,unmae from User” //select+属性名1,属性名2 form+实体类名;
        注意投影查询得到的list集合每个对象是Object[] 数组/或object 对象
    7.聚集函数查询 count max min sum avg 等sql函数
        "select count(*) from User" //select +聚集函数+form+实体类名；





HQL多表查询

内链接左外连接右外连接

特有的查询：迫切内链接迫切左外连接（没有迫切右外连接）

    HQL多表查询
    1.内连接
    String hql = "from Customer c inner join c.setLinkMan" ;//用到都是本类中的属性值
    Query query = session.createQuery(hql);
    List<Objec[]> list = query.list();//返回的list集合的每个元素是Object[] 数组

    2.迫切内连接
    迫切内链接和内连接底层实现是一样的
    区别：内链接返回的是list的object[] 数组，但是迫切内连接返回的list 每个元素是对象
    String hql = "from Customer c inner join fetch c.setLinkMan"; //迫切内连接

    3.左外连接
    Sting hql = "from Customer c left outer join c.setLinkMan";

    4.迫切左外连接
    Sting hql = "from Customer c left outer join fetch c.setLinkMan";
    同上特性
    区别：左外链接返回的是list的object[] 数组，但是迫切左外连接返回的list 每个元素是对象

    5.右外连接此处不写了同上


Crieator 对象没有sql hql 等对应的语句查询只有对应对象及方法作为条件进行查询

    Criteria --QBC查询

    //1.创建Criteria对象
    Criteria criteria = session.createCriteria(User.class);//参数位类的字节码对象
    //2.调用criteria对象方法
    List<User> list = criteria.list();
    //3.增强for循环查看
    for(User user : list){
        syso(user.getid()+ user.getname());

    }

    1.查询所有
    criteria.list();
    2.条件查询使用criteria的add()方法参数为对象Restriction(属性名，属性值)
        criteria.add(Restriction.eq("uid",1));

    3.模糊查询
    criteria.add(Restriction.like("uname","%白%")；

    4.排序查询
    criteria.addOrder(Order.asc("uid")); //正序 Order.desc("uname") 倒序

    5.分页查询
    criteria.setFirstResult(0);//从0开始查找
    criteria.setMaxResult(3);//每页3条记录
    开始位置计算公式：（当前页-1）*每页记录

    6.统计查询
    criteria.setProjection(Projection.rowcount);
    Object obj = criteria.uniqueResult();
    Long lobj = (Long)obj;
    int count = lobj.intValue();
    7.离线查询
    Detachedcriteria dc = Detachedcriteria.forClass(User.class);
    Criteria c = dc.getExectableCriteria(session);
    List<User> list = c.list();

SQLQuery 查询

     SQLQuery 查询
    //创建SQLQuery对象
    SQLQuery sq = session.createSQLQuery(sql);//sql 为数据库sql 语句
    //执行对象方法返回结果
    List list = sq.list();//默认返回的list集合是数组形式 Object[]
    //遍历
    for(Object[] obj : list){
        syso(Arrays.toString(obj));

    }

    将结果转换成每个部分是对象
    sqlquery.addEntity(User.class);
    List<User> list = sqlquery.list();
    for(User u : list){

        syso(u);
    }

原文：https://blog.csdn.net/weixin_39209728/article/details/82944775

猜你喜欢