二、框架学习 （一）Hibernate框架学习 （2）Hibernate概念和api使用

目录

          1 实体类编写规则

         2 hibernate主键生成策略

         3 实体类操作

                   (1)crud操作

                   (2)实体类对象状态

         4 hibernate的一级缓存

         5 hibernate的事务操作

                   (1)事务代码规则写法

         6 hibernate其他的api(查询)

正文

实体类编写规则

         1 实体类里面属性是私有的

         2 私有属性使用公开的set和get方法操作。

         3 要求实体类有属性作为唯一值(一般使用id值)

         4 实体类属性建议不使用基本数据类型,使用基本数据类型对应的包装类

                   (1)八个基本数据类型对应的包装类

                            int-integer

                            char- Character

                            其他的都是首字母大写比如 double- Double.

                   (2)比如表示学生的分数,假如 int score;

                            比如学生得了0分, int score=0:

                            如果表示学生没有参加考试, int score=0;不能准确表示学生是否参加考试

                            解决:使用包装类可以了, Integer score=0,表示学生得了0分,

                            表示学生没有参加考试, Integer score=null;

Hibernate主键生成策略

         1 hibernate要求实体类里面有一个属性作为唯一值,对应表主键,主键可以不同生成策略

         2 hibernate主键生成策略有很多的值

         

         3 在 class属性里面有很多值

                   (1) native: 根据使用的数据库帮选择哪个值

                   (2) uuid: 之前web阶段写代码生成uuid值, hibernate帮我们生成uuid

　　

　　4 演示生成策略值 uuid

                   (1)使用uid生成策略,实体类id属性类型必须字符串类型

　　　　　　

                   (2)配置部分写出uuid值

　　　　　　

　　　　　　

　　　　　　

实体类操作

对实体类的crud操作

添加操作

　　　　　　1 调用session里面的save方法实现

　　　　　　

    @Test
    public void  testAdd(){
//        第一步 加载hibernate核心配置文件
        //在hibernate里面封装了对象
//        Configuration cfg = new Configuration();
//        cfg.configure();
        
        
//        第二步创建 Sessionfactory对象
        //读取hibernate核心配置文件内容，创建ssssionFactory
        //在过程中，根据映射关系，在配置数据库里面把表创建了
//        SessionFactory sessionFactory = cfg.buildSessionFactory();
        
        
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        
//        第三步使用 Sessionfactory创建 session对象
        //类似于连接
        Session session = sessionFactory.openSession();
        
//        第四步开启事务
        Transaction tx = session.beginTransaction();
        
//        第五步写具体逻辑crud操作
        //添加功能
        User user=new User();
        user.setUsername("小马");
        user.setPassword("1314520");
        user.setAddress("美国");
        //调用session的方法实现添加
        session.save(user);
        
        
//        第六步提交事务
        tx.commit();
//        tx.rollback();
        
        
//        第七步关闭资源
        session.close();
        sessionFactory.close();
    }

根据id查询

　　　　　　1 调用session里面的get方法实现

    @Test
    public void testGet(){
        //1 调用工具类得到sessionFactory
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        //2 获取session
        Session session=sessionFactory.openSession();
        //3 开启事务
        Transaction tx=session.beginTransaction();
        //4 根据id查询
        //第一个参数：实体类的class
        //第二个参数：id值
        User user=session.get(User.class, "402880a460fd0bef0160fd0bf04c0000");
        System.out.println(user);
        //5 提交事务
        tx.commit();
        //6 关闭
        session.close();
        sessionFactory.close();
    }

修改操作

　　　　1 首先查询，修改值

　　　　　　（1）根据id查询，返回对象

　　　　　　（2）修改值，更新数据库

　　　　

    @Test
    public void testUpdate(){
        //1 调用工具类得到sessionFactory
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        //2 获取session
        Session session=sessionFactory.openSession();
        //3 开启事务
        Transaction tx=session.beginTransaction();
        //4 根据id查询
        //第一个参数：实体类的class
        //第二个参数：id值
        User user=session.get(User.class, "402880a460fd0bef0160fd0bf04c0000");
        user.setAddress("china");
        session.update(user);
        //5 提交事务
        tx.commit();
        //6 关闭
        session.close();
        sessionFactory.close();
    }

删除操作

　　　　　　1 调用session里面的delete方法实现

    @Test
    public void testDelete(){
        //1 调用工具类得到sessionFactory
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        //2 获取session
        Session session=sessionFactory.openSession();
        //3 开启事务
        Transaction tx=session.beginTransaction();
        //4 删除操作
        //第一种 根据id查询对象
        User user=session.get(User.class, "402880a460fd0bef0160fd0bf04c0000");
        session.delete(user);
        
        
        //第二种
//        User user=new User();
//        user.setUid("402880a460fd0bef0160fd0bf04c0000");
//        session.delete(user);
        
        
        //5 提交事务
        tx.commit();
        //6 关闭
        session.close();
        sessionFactory.close();
    }

实体类对象状态(概念)

         1 实体类状态有三种

                   (1)瞬时态:对里面没有id值,对象与 session没有关联

　　　　　　

                   (2)持久态:对象里面有id值，对象与session有关联

　　　　　　

                   (3)托管态:对象有id值，对象与session没有关联

　　　　　　

         2演示操作实体类对象的方法

                   (1) saveOrUpdate方法:实现添加、实现修改

　　@Test
    public void testSaveOrUpdate(){
        //1 调用工具类得到sessionFactory
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        //2 获取session
        Session session=sessionFactory.openSession();
        //3 开启事务
        Transaction tx=session.beginTransaction();
        //保存或者更新
        User user=new User();
        user.setUsername("jack");
        user.setPassword("520");
        user.setAddress("朝鲜");
        
        
        //实体类对象是瞬时态，做添加
        session.saveOrUpdate(user);
        
        User u=session.get(User.class, "402880a460fd0c830160fd0c846f0000");
        u.setUsername("lili");
        //实体类对象状态是托管态，做修改
        session.saveOrUpdate(u);
        
        
        //5 提交事务
        tx.commit();
        //6 关闭
        session.close();
        sessionFactory.close();
    }

Hibernate的一级缓存

         什么是缓存

                   1 数据存到数据库里面,数据库本身是文件系统,使用流方式操作文件效率不是很高。

                            (1)把数据存到内存里面,不需要使用流方式,可以直接读取内存中数据

                            (2)把数据放到内存中,提供读取效率

　　Hibernate缓存

                   1 hibernate框架中提供很多优化方式, hibernate的缓存就是一个优化方式

                   2 hibernate缓存特点:

                            第一类 hibernate的一级缓存

                                     (1) hibernate的一级缓存默认打开的

                                     (2) hibernate的一级缓存使用范围,是 session范围,从 session创建到session关闭范围

                                     (3) hibernate的一级缓存中,存储数据必须持久态数据

                            第二类 hibernate的二级缓存

                                     (1)目前已经不使用了,替代技术 redis

                                     (2)二级缓存默认不是打开的,需要配置

                                     (3)二级缓存使用范围,是sessionFactory范围

         验证一级缓存存在

                   1 验证方式

                            (1)首先根据 uid=402880a460fd0c830160fd0c846f0000 查询,返回对象

                            (2)其次再根据 uid=402880a460fd0c830160fd0c846f0000 查询,返回对象

    @Test
    public void testCache(){
        //1 调用工具类得到sessionFactory
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
        //2 获取session
        Session session=sessionFactory.openSession();
        //3 开启事务
        Transaction tx=session.beginTransaction();
        //保存或者更新
        User user=session.get(User.class, "402880a460fd0c830160fd0c846f0000");
        System.out.println(user);
        
        user=session.get(User.class, "402880a460fd0c830160fd0c846f0000");
        System.out.println(user);
        
        
        //5 提交事务
        tx.commit();
        //6 关闭
        session.close();
        sessionFactory.close();
    }

                   第一步执行get方法之后,发送sql语句查询数据

                   第二个执行get方法之后,没有发送sql语句,查询一级缓存内容

Hibernate 一级缓存执行过程

　　　　

Hibernate 一级缓存特性

　　　　1 持久态自动更新数据库

　　　　

Hibernate事务操作

         事务相关概念

                   1 什么是事务

                   2 事务特性

                   3 不考虑隔离性产生问题

                            (1)脏读

                            (2)不可重复读

                            (3)虚读

                   4 设置事务隔离级别

                            (1)mysq默认隔离级别 repeatable read

         Hibernate事务代码规范写法。

                   1 代码结构

                   try{

                            开启事务

                            提交事务

                   }catch(){

                            回滚事务

                   }Finally{

                            关闭

                  }

    //事务规范代码
    @Test
    public void testTx(){
        SessionFactory sessionFactory=null;
        Session session=null;
        Transaction tx=null;
        try{
            sessionFactory = HibernateUtils.getSessionFactory();
            session=sessionFactory.openSession();
            //开启事务
            tx=session.beginTransaction();
            //添加
            User user=new User();
            user.setUsername("小马");
            user.setPassword("255");
            user.setAddress("美国");
            
            
            session.save(user);
            
            
            
            // 提交事务
            tx.commit();
        }catch(Exception e){
            tx.rollback();
        }finally{
            // 关闭
            session.close();
            sessionFactory.close();
        }
    }

Hibernate绑定 session

                   1 session类似于jdbc的 connection,之前web阶段学过 threadLocal

                   2 帮实现与本地线程绑定 session

                   3 获取与本地线程 session

                            (1) 在 hibernate核心配置文件中配置

　　　　　　　　

                            (2) 调用 sessionfactory里面的方法得到（工具类中）

 　　　　　　　　

　　　　　　　　

    @Test
    public void testTx(){
        Session session=null;
        Transaction tx=null;
        try{
            session=HibernateUtils.getSession();
            //开启事务
            tx=session.beginTransaction();
            //添加
            User user=new User();
            user.setUsername("小马");
            user.setPassword("255");
            user.setAddress("美国");
            
            
            session.save(user);
            
            
            
            // 提交事务
            tx.commit();
        }catch(Exception e){
            tx.rollback();
        }finally{
            // 关闭
            session.close();
        }
    }

　　　　　　4  获取与本地线程绑定session时候 ，关闭session报错，不需要手动关闭session

Hibernate的api使用

　　　　Query对象

                   1使用 query对象,不需要写sqL语句,但是写hq语句

                            (1) hql: hibernate query language, hibernate提供查询语言,这个hql语句和普通sql语句很相似

                            (2) hql和sql语句区别:

                                     使用sql操作表和表字段

                                     使用hql操作实体类和属性

                   2查询所有 hql语句:

                            (1) from实体类名称

                   3 Query对象使用

                            (1) 创建 Query对象

                            (2) 调用 query对象里面的方法得到结果

    @Test
    public void testQuery(){
        Session session=null;
        Transaction tx=null;
        try{
            session=HibernateUtils.getSession();
            //开启事务
            tx=session.beginTransaction();
            
            
//            (1) 创建 Query对象
            Query query=session.createQuery("from User");
            
            
//          (2) 调用 query对象里面的方法得到结果
            List<User> list=query.list();
            for (User user : list) {
                System.out.println(user);
            }
            
            // 提交事务
            tx.commit();
        }catch(Exception e){
            tx.rollback();
        }finally{
            // 关闭
//            session.close();
        }
    }

　　　　Criteria对象

　　　　　　1 使用这个对象查询操作,但是使用这个对象时候,不需要写语句,直接调用方法实现

　　　　　　　　(1) 创建 criteria对象

                            (2) 调用 criteria对象里面的方法得到结果

    @Test
    public void testCriteria(){
        Session session=null;
        Transaction tx=null;
        try{
            session=HibernateUtils.getSession();
            //开启事务
            tx=session.beginTransaction();
            
            
//            (1) 创建 Criteria对象
            Criteria criteria=session.createCriteria(User.class);
            
            
//          (2) 调用 Criteria对象里面的方法得到结果
            List<User> list=criteria.list();
            for (User user : list) {
                System.out.println(user);
            }
            
            // 提交事务
            tx.commit();
        }catch(Exception e){
            tx.rollback();
        }finally{
            // 关闭
//            session.close();
        }
    }

　　　　SQLQuery对象

　　　　　　1 使用hibernate的时候，调用底层sql实现

　　　　　　　　(1) 创建对象

                            (2) 调用对象里面的方法得到结果

　　　　　　返回的list集合，每部分是数组

　　　　　　解决：返回list中每部分是对象形式

    @Test
    public void testSQLQuery(){
        Session session=null;
        Transaction tx=null;
        try{
            session=HibernateUtils.getSession();
            //开启事务
            tx=session.beginTransaction();
            
            
//            (1) 创建 SQLQuery对象 
            SQLQuery sqlquery=session.createSQLQuery("select * from t_user");
            
            //返回的list中每部分是对象形式
            sqlquery.addEntity(User.class);
            
            
            //调用 SQLQuery对象里面的方法得到结果
            List<User> list=sqlquery.list();
            for (User user : list) {
                System.out.println(user);
            }
            
            
//          (2) 调用 SQLQuery对象里面的方法得到结果
//            List<Object[]> list=sqlquery.list();
//            
//            for (Object[] objects : list) {
//                System.out.println(Arrays.toString(objects));
//            }
            
            // 提交事务
            tx.commit();
        }catch(Exception e){
            tx.rollback();
        }finally{
            // 关闭
//            session.close();
        }
    }