框架学习 Hibernate框架学习 Hibernate概念和api使用

Posted 秋心无波

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了框架学习 Hibernate框架学习 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方法实现

      

 1     @Test
 2     public void  testAdd(){
 3 //        第一步 加载hibernate核心配置文件
 4         //在hibernate里面封装了对象
 5 //        Configuration cfg = new Configuration();
 6 //        cfg.configure();
 7         
 8         
 9 //        第二步创建 Sessionfactory对象
10         //读取hibernate核心配置文件内容,创建ssssionFactory
11         //在过程中,根据映射关系,在配置数据库里面把表创建了
12 //        SessionFactory sessionFactory = cfg.buildSessionFactory();
13         
14         
15         SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
16         
17 //        第三步使用 Sessionfactory创建 session对象
18         //类似于连接
19         Session session = sessionFactory.openSession();
20         
21 //        第四步开启事务
22         Transaction tx = session.beginTransaction();
23         
24 //        第五步写具体逻辑crud操作
25         //添加功能
26         User user=new User();
27         user.setUsername("小马");
28         user.setPassword("1314520");
29         user.setAddress("美国");
30         //调用session的方法实现添加
31         session.save(user);
32         
33         
34 //        第六步提交事务
35         tx.commit();
36 //        tx.rollback();
37         
38         
39 //        第七步关闭资源
40         session.close();
41         sessionFactory.close();
42     }

根据id查询

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

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

修改操作

    1 首先查询,修改值

      (1)根据id查询,返回对象

      (2)修改值,更新数据库

    

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

 

删除操作

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

 1     @Test
 2     public void testDelete(){
 3         //1 调用工具类得到sessionFactory
 4         SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
 5         //2 获取session
 6         Session session=sessionFactory.openSession();
 7         //3 开启事务
 8         Transaction tx=session.beginTransaction();
 9         //4 删除操作
10         //第一种 根据id查询对象
11         User user=session.get(User.class, "402880a460fd0bef0160fd0bf04c0000");
12         session.delete(user);
13         
14         
15         //第二种
16 //        User user=new User();
17 //        user.setUid("402880a460fd0bef0160fd0bf04c0000");
18 //        session.delete(user);
19         
20         
21         //5 提交事务
22         tx.commit();
23         //6 关闭
24         session.close();
25         sessionFactory.close();
26     }

 

 

实体类对象状态(概念)

         1 实体类状态有三种

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

      

 

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

      

 

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

      

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

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

 1   @Test
 2     public void testSaveOrUpdate(){
 3         //1 调用工具类得到sessionFactory
 4         SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
 5         //2 获取session
 6         Session session=sessionFactory.openSession();
 7         //3 开启事务
 8         Transaction tx=session.beginTransaction();
 9         //保存或者更新
10         User user=new User();
11         user.setUsername("jack");
12         user.setPassword("520");
13         user.setAddress("朝鲜");
14         
15         
16         //实体类对象是瞬时态,做添加
17         session.saveOrUpdate(user);
18         
19         User u=session.get(User.class, "402880a460fd0c830160fd0c846f0000");
20         u.setUsername("lili");
21         //实体类对象状态是托管态,做修改
22         session.saveOrUpdate(u);
23         
24         
25         //5 提交事务
26         tx.commit();
27         //6 关闭
28         session.close();
29         sessionFactory.close();
30     }

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 查询,返回对象

 1     @Test
 2     public void testCache(){
 3         //1 调用工具类得到sessionFactory
 4         SessionFactory sessionFactory = HibernateUtils.getSessionFactory();
 5         //2 获取session
 6         Session session=sessionFactory.openSession();
 7         //3 开启事务
 8         Transaction tx=session.beginTransaction();
 9         //保存或者更新
10         User user=session.get(User.class, "402880a460fd0c830160fd0c846f0000");
11         System.out.println(user);
12         
13         user=session.get(User.class, "402880a460fd0c830160fd0c846f0000");
14         System.out.println(user);
15         
16         
17         //5 提交事务
18         tx.commit();
19         //6 关闭
20         session.close();
21         sessionFactory.close();
22     }

 

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

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

 

Hibernate 一级缓存执行过程

    

Hibernate 一级缓存特性

    1 持久态自动更新数据库

    

 

Hibernate事务操作

         事务相关概念

                   1 什么是事务

                   2 事务特性

                   3 不考虑隔离性产生问题

                            (1)脏读

                            (2)不可重复读

                            (3)虚读

                   4 设置事务隔离级别

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

         Hibernate事务代码规范写法。

                   1 代码结构

                   try{

                            开启事务

                            提交事务

                   }catch(){

                            回滚事务

                   }Finally{

                            关闭

                  }

 

 1     //事务规范代码
 2     @Test
 3     public void testTx(){
 4         SessionFactory sessionFactory=null;
 5         Session session=null;
 6         Transaction tx=null;
 7         try{
 8             sessionFactory = HibernateUtils.getSessionFactory();
 9             session=sessionFactory.openSession();
10             //开启事务
11             tx=session.beginTransaction();
12             //添加
13             User user=new User();
14             user.setUsername("小马");
15             user.setPassword("255");
16             user.setAddress("美国");
17             
18             
19             session.save(user);
20             
21             
22             
23             // 提交事务
24             tx.commit();
25         }catch(Exception e){
26             tx.rollback();
27         }finally{
28             // 关闭
29             session.close();
30             sessionFactory.close();
31         }
32     }

 

Hibernate绑定 session

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

 

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

 

                   3 获取与本地线程 session

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

        

 

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

         

        

 1     @Test
 2     public void testTx(){
 3         Session session=null;
 4         Transaction tx=null;
 5         try{
 6             session=HibernateUtils.getSession();
 7             //开启事务
 8             tx=session.beginTransaction();
 9             //添加
10             User user=new User();
11             user.setUsername("小马");
12             user.setPassword("255");
13             user.setAddress("美国");
14             
15             
16             session.save(user);
17             
18             
19             
20             // 提交事务
21             tx.commit();
22         }catch(Exception e){
23             tx.rollback();
24         }finally{
25             // 关闭
26             session.close();
27         }
28     }

      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对象里面的方法得到结果

 1     @Test
 2     public void testQuery(){
 3         Session session=null;
 4         Transaction tx=null;
 5         try{
 6             session=HibernateUtils.getSession();
 7             //开启事务
 8             tx=session.beginTransaction();
 9             
10             
11 //            (1) 创建 Query对象
12             Query query=session.createQuery("from User");
13             
14             
15 //          (2) 调用 query对象里面的方法得到结果
16             List<User> list=query.list();
17             for (User user : list) {
18                 System.out.println(user);
19             }
20             
21             // 提交事务
22             tx.commit();
23         }catch(Exception e){
24             tx.rollback();
25         }finally{
26             // 关闭
27 //            session.close();
28         }
29     }

 

    Criteria对象

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

        (1) 创建 criteria对象

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

 1     @Test
 2     public void testCriteria(){
 3         Session session=null;
 4         Transaction tx=null;
 5         try{
 6             session=HibernateUtils.getSession();
 7             //开启事务
 8             tx=session.beginTransaction();
 9             
10             
11 //            (1) 创建 Criteria对象
12             Criteria criteria=session.createCriteria(User.class);
13             
14             
15 //          (2) 调用 Criteria对象里面的方法得到结果
16             List<User> list=criteria.list();
17             for (User user : list) {
18                 System.out.println(user);
19             }
20             
21             // 提交事务
22             tx.commit();
23         }catch(Exception e){
24             tx.rollback();
25         }finally{
26             // 关闭
27 //            session.close();
28         }
29     }

 

    SQLQuery对象

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

        (1) 创建对象

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

 

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

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

 

 1     @Test
 2     public void testSQLQuery(){
 3         Session session=null;
 4         Transaction tx=null;
 5         try{
 6             session=HibernateUtils.getSession();
 7             //开启事务
 8             tx=session.beginTransaction();
 9             
10             
11 //            (1) 创建 SQLQuery对象 
12             SQLQuery sqlquery=session.createSQLQuery("select * from t_user");
13             
14             //返回的list中每部分是对象形式
15             sqlquery.addEntity(User.class);
16             
17             
18             //调用 SQLQuery对象里面的方法得到结果
19             List<User> list=sqlquery.list();
20             for (User user : list) {
21                 System.out.println(user);
22             }
23             
24             
25 //          (2) 调用 SQLQuery对象里面的方法得到结果
26 //            List<Object[]> list=sqlquery.list();
27 //            
28 //            for (Object[] objects : list) {
29 //                System.out.println(Arrays.toString(objects));
30 //            }
31             
32             // 提交事务
33             tx.commit();
34         }catch(Exception e){
35             tx.rollback();
36         }finally{
37             // 关闭
38 //            session.close();
39         }
40     }

 

以上是关于框架学习 Hibernate框架学习 Hibernate概念和api使用的主要内容,如果未能解决你的问题,请参考以下文章

JAVA框架之Hibernate框架的学习步骤

框架学习 Hibernate框架学习 Hibernate概念和api使用

框架学习笔记之Hibernate

Hibernate框架学习——入门

Hibernate框架学习笔记

Hibernate框架学习1