Hibernate使用快速入门介绍(2)

1. 实体类编写规则
2. hibernate主键生成策略
3. 实体类操作
   (1)crud操作
   (2)实体类对象状态
4. hibernate的一级缓存
5. hibernate的事务操作
   (1)事务代码规则写法
6. hibernate其他api(查询)

---

1.实体类编写规则

1. 实体类里面的属性都是私有的
2. 私有属性使用公开的get/set方法
3. 要求实体类有属性作为唯一值(一般使用id值)
4. 实体属性建议不使用基本数据类型,使用基本数据类型对应的包装类
   (1)8个基本数据类型对应的包装类
   int–Integer
   char–Character
   其他的都是首字母大写 比如 double-Double
   (2)比如 表示学生的分数,假如 int scroe;
   学生考了0分1 int score=0;
   学生没有参加参加考试,int score=0,不能准确表示学生是否参加考试
   解决:使用包装类就可以了,Integer score=0 表示学生得了0分
   表示学生未参加考试,Integer score=null;

hibernate中主键的生成策略

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

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

           
                <generator class="native">generator>

主要记两个
native:底层数据库对自动生成符的能力来选择 identity,sequence,hilo三种生成器中的一种
uuid:之前web阶段生成id值,hibernate帮我们生成uuid值

3.使用uuid

(1)将uid的类型改为String类型
private String uid;

实体类操作

1.实体类的crud操作

添加操作
调用session里面的user方法实现

                   //添加功能
                   User user= new User();
                   user.setUsername("小马");
                   user.setPassword("123");
                   user.setAddress("美国");
                   //调用session的方法实现添加
                   session.save(user);

根据id查询
调用session里面的get方法实现

                    // 4.根据id查询
                    // 调用session里面的get方法
                    // 第一个参数:实体类的class 第二个参数:id值
                    User user = session.get(User.class, 1);
                    System.out.println(user);                                     

修改操作
首先查询,再修改

                    // 4.修改操作
                    // 修改uid=2的username
                    // 4.1根据id查
                    User user = session.get(User.class, 2);
                    // 4.2向返回的user对象里面设置修改之后的值
                    user.setUsername("小红");
                    // 4.3调用session的update方法修改
                    // 执行过程:到session对象里面找到uid的值,根据uid进行修改
                    session.update(user); 

删除操作

                    调用session里面的delete方法实现
                    // 4.删除操作
                        // 第一种:根据id查询对象
                        User user = session.get(User.class, 2);
                        session.delete(user); 
                    //第二种
                        User user3=new User();
                        user3.setUid(3);
                        session.delete(user3);   

注意:在进行修改操作时:
若使用save操作已存在id的记录,则会在后面添加

2.实体类对象状态(概念)

实体类状态有三种
(1)瞬时态:对象里面没有id值,对象与session没有关联

                         User u=new User();
                         u.setUsername("jack");
                         u.setPassword("124");
                         u.setAddress("china");

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

                         User user=session.get(User.class,1); 

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

                         User user=new User();
                         user.setUid(3);         

演示操作实体类对象的方法
(1)saveOrUpture方法:实现添加,实现修改

                        //1.添加操作
                            User user=new User();
                            user.setUsername("jack");
                            user.setPassword("520");
                            user.setAddress("朝鲜");
                            //实体类对象状态是瞬时态,做添加
                            session.saveOrUpdate(user);

                    //2.修改操作
                    User user=new User();
                    user.setUid(6); //托管态
                        user.setUsername("jack");
                        user.setPassword("520");
                        user.setAddress("朝鲜");
                        //实体类对象状态是瞬时态,做修改
                        session.saveOrUpdate(user);

                    User user=session.get(User.class,7);
                    user.setUsername("lilei");
                    //实现类对象状态是持久态,做修改
                    session.saveOrUpdate(user);

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=1 查询,返回对象
                    (2)其次再根据uid=1 查询,返回对象           
                     //1.根据uid=1查询,返回对象
                     //执行第一个get方法是否查询数据库,是否发送sql语句
                     User user1=session.get(User.class,6);
                     //2.在uid=1查询
                     //执行第二个get方法是否查询数据库,是否发送sql语句
                     User user2=session.get(User.class,6);

Hibernate缓存的一般特性

          1.持久态自动更新数据库

                    //1.根据id查询
                    User user=session.get(User.class,7);
                    //2.设置返回对象的值
                    user.setUsername("hanmeimei");                   
                    //3.调用方法实现          
                    //session.update(user);这一句其实不用写也可

2.执行过程(了解)

5.Hibernate事务操作

事务相关概念

1. 什么是事务
2. 事务特性
3. 不考虑隔离性产生问题
   (1)脏读
   (2)不可重复读
   (3)虚读

4. 设置事务的隔离级别
   (1)mysql默认隔离级别repeatable read
   Hibernate事务代码规范写法

             try{
                 开启事务
                 提交事务
             }catch{
                 回滚事务
             }finally{
                 关闭  
             }                                            
   

Hibernate 绑定session

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

       帮实现与本地线程绑定session

       获取与本地线程session
           (1)在hibernate核心配置文件中配置

                  <property name="hibernate.current_session_context_class">threadproperty>

           (2)调用sessionFactory里面的方法得到 

                  // 在util中提供返回与本地线程的session的方法
                    public static Session getSessionobject() {
                        return sessionFactory.getCurrentSession();
                    }

       获取与本地线程绑定session时候,关闭session报错

              org.hibernate.SessionException: Session was already closed //不需要手动关闭

Hibernate的api使用

Query 对象

1.使用query对象,不需要写sql语句,但是要写hql语句

(1)hql:hibernate query language,hibernate提供的查询语言,这个hql语句和普通sql语句很相似
(2)hql和sql语句区别
使用sql操作表和表字段
使用hql操作实体类和属性

2.查询所有hql语句

(1)from 实体类名称

3.Query对象使用

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

                  SessionFactory sessionFactory = null;
                    Session session = null;
                    Transaction tx = null;
                    try {
                        sessionFactory = HibernateUtils.getSessionFactory();
                        session = HibernateUtils.getSessionobject();
                        tx = session.beginTransaction();
                        // 1.创建query对象
                        // 方法里面写hql语句
                        Query query = session.createQuery("from User");
                        // 2.创建query对象里面的方法得到结果
                        List list = query.list();
                        for (User user : list) {
                            System.out.println(user);
                        }
                        // 提交事务
                        tx.commit();
                    } catch (Exception e) {
                        e.printStackTrace();
                        tx.rollback();
                    } finally {
                        session.close();
                        sessionFactory.close();
                    }  

Criteria对象

1.使用这个对象查询操作

2.实现过程

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

                        // 1.创建criteria对象
                        // 方法里面的参数是实体类class
                        Criteria criteria = session.createCriteria(User.class);
                        // 2.调用方法得到结果
                        List list = criteria.list();

                        for (User user : list) {
                            System.out.println(user);
                        }

SQLQuery对象

1.使用hibernate时候,调用底层sql实现

2.实现过程

(1)创建对象
(2)调用对象的方法得到结果

                  //返回list中的部分是数组
                  // 1.创建对象
                        SQLQuery sqlQuery = session.createSQLQuery("select*from t_user");
                        // 调用sqlQuery里面的方法
                        // 返回list集合,默认里面每部分是数组结构
                        List list = sqlQuery.list();
                        for (Object[] objects : list) {
                            for (int i = 0; i < objects.length; i++) {
                                System.out.print(objects[i] + " ");
                            }
                            System.out.println();
                        }
                 返回list中的部分是对象
                     SQLQuery sqlQuery = session.createSQLQuery("select*from t_user");
                     sqlQuery.addEntity(User.class);
                         List user = sqlQuery.list();
                         for (User user2 : user) {
                             System.out.println(user2);
                        }