您的位置：首页 > 其它

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

2018-01-16 16:25 537 查看

正文

实体类编写规则

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框架学习 （2）Hibernate概念和api使用

目录

正文

实体类编写规则

Hibernate主键生成策略

实体类操作

对实体类的crud操作

添加操作

根据id查询

修改操作

删除操作

实体类对象状态(概念)

Hibernate的一级缓存

什么是缓存

Hibernate缓存

验证一级缓存存在

Hibernate 一级缓存执行过程

Hibernate 一级缓存特性

Hibernate事务操作

事务相关概念

Hibernate事务代码规范写法。

Hibernate绑定 session

Hibernate的api使用

Query对象

Criteria对象

SQLQuery对象

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

　　Hibernate缓存

　　　　Query对象

　　　　Criteria对象

　　　　SQLQuery对象