Hibernate基础学习2

Hibernate基础学习2

测试hibernate的一级缓存，事务以及查询语句

 

1）Hibernate相关概念

hibernate的一级缓存
1）缓存是为了提高该框架对数据库的查询速度
2）一级缓存是将获取的结果放到了session中，再次查询直接从缓存中获取（提高查询效率）
3）缓存进阶之快照：将获取的一份结果放到session中，一份放到快照中，当修改时，对比快照与缓存，
如果数据没有发生变化，直接结束修改（避免不必要的修改）

hibernate的事务
在业务开始之前打开事务，在业务结束时提交事务，如果出现异常则回滚事务

1）事务的4大特性
A:原子性(Atomicity)
       事务是数据库的逻辑工作单位，事务中包括的诸操作要么全做，要么全不做。
B:一致性(Consistency)
       事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
C:隔离性(Isolation)
      一个事务的执行不能被其他事务干扰。
D:持续性/永久性(Durability)
      一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。

2）事务并发存在的问题
1.丢失更新：撤消一个事务时，把其它事务已提交的更新的数据覆盖了。
2.脏读：一个事务读到另一个事务未提交的更新数据。
3.幻读：一个事务执行两次查询，但第二次查询比第一次查询多出了一些数据行。
4.不可重复读：一个事务两次读同一行数据，可是这两次读到的数据不一样。

3）事务的隔离级别（处理事务并发问题）
1.Read uncommitted（读未提交）
顾名思义，就是一个事务可以读取另一个未提交事务的数据。

事例：老板要给程序员发工资，程序员的工资是3.6万/月。但是发工资时老板不小心按错了数字，
按成3.9万/月，该钱已经打到程序员的户口，但是事务还没有提交，就在这时，程序员去查看自己这个月的工资，
发现比往常多了3千元，以为涨工资了非常高兴。但是老板及时发现了不对，马上回滚差点就提交了的事务，
将数字改成3.6万再提交。

分析：实际程序员这个月的工资还是3.6万，但是程序员看到的是3.9万。他看到的是老板还没提交事务时的数据。这就是脏读。

那怎么解决脏读呢？Read committed！读提交，能解决脏读问题。

2.Read committed（读提交）
顾名思义，就是一个事务要等另一个事务提交后才能读取数据。

事例：程序员拿着信用卡去享受生活（卡里当然是只有3.6万），当他买单时（程序员事务开启），
收费系统事先检测到他的卡里有3.6万，就在这个时候！！程序员的妻子要把钱全部转出充当家用，并提交。
当收费系统准备扣款时，再检测卡里的金额，发现已经没钱了（第二次检测金额当然要等待妻子转出金额事务提交完）。
程序员就会很郁闷，明明卡里是有钱的…

分析：这就是读提交，若有事务对数据进行更新（UPDATE）操作时，读操作事务要等待这个更新操作事务提交后
才能读取数据，可以解决脏读问题。但在这个事例中，出现了一个事务范围内两个相同的查询却返回了不同数据，
这就是不可重复读。

那怎么解决可能的不可重复读问题？Repeatable read ！

3.Repeatable read（重复读）
就是在开始读取数据（事务开启）时，不再允许修改操作

事例：程序员拿着信用卡去享受生活（卡里当然是只有3.6万），当他买单时（事务开启，不允许其他事务的UPDATE修改操作），
收费系统事先检测到他的卡里有3.6万。这个时候他的妻子不能转出金额了。接下来收费系统就可以扣款了。

分析：重复读可以解决不可重复读问题。写到这里，应该明白的一点就是，不可重复读对应的是修改，即UPDATE操作。
但是可能还会有幻读问题。因为幻读问题对应的是插入INSERT操作，而不是UPDATE操作。

什么时候会出现幻读？

事例：程序员某一天去消费，花了2千元，然后他的妻子去查看他今天的消费记录（全表扫描FTS，妻子事务开启），
看到确实是花了2千元，就在这个时候，程序员花了1万买了一部电脑，即新增INSERT了一条消费记录，并提交。
当妻子打印程序员的消费记录清单时（妻子事务提交），发现花了1.2万元，似乎出现了幻觉，这就是幻读。

那怎么解决幻读问题？Serializable！

4.Serializable（序列化，串行化：排队执行）
Serializable 是最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。
但是这种事务隔离级别效率低下，比较耗数据库性能，一般不使用。

2）在主配置文件中添加如下配置对事务进行管理

?
1
2
3
4
5
6
7
8
9
10
<!-- 指定hibernate操作数据库时的隔离级别
            #hibernate.connection.isolation 1|2|4|8
            0001    1    读未提交
            0010    2    读已提交
            0100    4    可重复读
            1000    8    串行化
         -->
        <property name="hibernate.connection.isolation">4</property>
        <!-- 指定session与当前线程绑定，事务中确保使用同一个session -->
        <property name="hibernate.current_session_context_class">thread</property>

 

3）测试对象的3种状态

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package com.hibernate.test;
 
import com.hibernate.domain.Customer;
import com.hibernate.utils.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
 
/**
 * @author: XDZY
 * @date: 2018/11/15 11:41
 * @description: 测试hibernate框架
 */
public class HibernateTest {
    /**
     * 添加客户信息
     */
    @Test
    public void addTest() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        //对象的3种状态体现（状态之间的转换）
        //瞬时状态：没有ID，没有与session关联
        Customer customer = new Customer();
        customer.setCust_name("xdzy");
        //持久化状态：有ID，与session有关联
        session.save(customer);
 
        /*******************************************************/
 
        tx.commit();
        //游离|托管状态，有ID，与sesssion无关联
        session.close();
    }
 
    /**
     * 删除客户信息
     */
    @Test
    public void deleteTest() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        //获取ID为1的客户
        Customer customer = session.get(Customer.class, 30L);
        //删除
        session.delete(customer);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 修改客户信息
     */
    @Test
    public void updateTest() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        Customer customer = session.get(Customer.class, 6L);
        customer.setCust_name("xdzy");
        session.update(customer);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 查询客户信息
     */
    @Test
    public void selectTest() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        Customer customer = session.get(Customer.class, 6L);
        System.out.println(customer);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
}

 

4）测试事务中获取session的方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.hibernate.test;
 
import com.hibernate.utils.HibernateUtils;
import org.hibernate.Session;
import org.junit.Test;
 
/**
 * @author: XDZY
 * @date: 2018/11/16 10:00
 * @description: 测试事务中获取session的方法
 */
public class HibernateTest2 {
    /**
     * 获取绑定的session是同一个，可以确保事务使用同一个session
     * 用该方法获取事务提交后会自动关闭，所以事务提交之后不能手动关闭，会引发异常
     */
    @Test
    public void test() {
        Session session = HibernateUtils.getCurrentSession();
        Session session1 = HibernateUtils.getCurrentSession();
        System.out.println(session == session1);
    }
 
    /**
     * 获取新的session
     */
    @Test
    public void test1() {
        Session session = HibernateUtils.openSession();
        Session session1 = HibernateUtils.openSession();
        System.out.println(session == session1);
    }
}

 

5）测试HQL语句

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
package com.hibernate.test;
 
import com.hibernate.domain.Customer;
import com.hibernate.utils.HibernateUtils;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
 
import java.util.List;
 
/**
 * @author: XDZY
 * @date: 2018/11/16 10:26
 * @description: 测试HQL语句（hibernate独有的面向对象的语法）（适合不复杂的多表查询）
 * HQL语句不能出现数据库相关字段，而是类的属性或类的名称
 */
public class HibernateTest3 {
    /**
     * 查询所有
     */
    @Test
    public void test() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        //1）书写HQL语句
        String hql = "from Customer";
        //2）创建查询对象
        Query query = session.createQuery(hql);
        //3）执行查询
        List<Customer> list = query.list();
 
        System.out.println(list);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 指定查询
     */
    @Test
    public void test1() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        //1）书写HQL语句
        String hql = "from Customer where cust_id=6";
        //2）创建查询对象
        Query query = session.createQuery(hql);
        //3）执行查询
        Customer customer = (Customer) query.uniqueResult();
 
        System.out.println(customer);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 占位符
     */
    @Test
    public void test2() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        //1）书写HQL语句
        String hql = "from Customer where cust_id=?";
        //2）创建查询对象
        Query query = session.createQuery(hql);
        //3）设置参数
        //query.setLong(0,6L);
        query.setParameter(0, 6L);
        //4）执行查询
        Customer customer = (Customer) query.uniqueResult();
 
        System.out.println(customer);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 命名占位符
     */
    @Test
    public void test3() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        //1）书写HQL语句
        String hql = "from Customer where cust_id= :cust_id";
        //2）创建查询对象
        Query query = session.createQuery(hql);
        //3）设置参数
        //query.setLong(0,6L);
        query.setParameter("cust_id", 6L);
        //4）执行查询
        Customer customer = (Customer) query.uniqueResult();
 
        System.out.println(customer);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 分页查询所有
     */
    @Test
    public void test4() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        //1）书写HQL语句
        String hql = "from Customer";
        //2）创建查询对象
        Query query = session.createQuery(hql);
        //3）设置分页条件(从0开始查询1条)
        query.setFirstResult(0);
        query.setMaxResults(1);
        //4）执行查询
        List<Customer> list = query.list();
 
        System.out.println(list);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
}

 

6）测试Criteria语句

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package com.hibernate.test;
 
import com.hibernate.domain.Customer;
import com.hibernate.utils.HibernateUtils;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
 
import java.util.List;
 
/**
 * @author: XDZY
 * @date: 2018/11/16 10:26
 * @description: 测试criteria语句（hibernate独有的无语句的完全面向对象的查询语法）（适合单表查询）
 * > (gt)
 * >= (ge)
 * < (lt)
 * <= (le)
 * == (eq)
 * != (ne)
 * in (in)
 * between and (between)
 * like (like)
 * is not null (isNotNull)
 * is null (isNull)
 * or (or)
 * and (and)
 */
public class HibernateTest4 {
    /**
     * 查询所有
     */
    @Test
    public void test() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        Criteria criteria = session.createCriteria(Customer.class);
        List list = criteria.list();
        System.out.println(list);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 指定查询
     */
    @Test
    public void test1() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.add(Restrictions.eq("cust_id", 6L));
        Customer customer = (Customer) criteria.uniqueResult();
        System.out.println(customer);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 分页查询所有
     */
    @Test
    public void test2() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.setFirstResult(0);
        criteria.setMaxResults(1);
        List list = criteria.list();
        System.out.println(list);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 查询总记录数，分页总行数
     */
    @Test
    public void test3() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        Criteria criteria = session.createCriteria(Customer.class);
        criteria.setProjection(Projections.rowCount());
        Long count = (Long) criteria.uniqueResult();
        System.out.println(count);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
}

 

7）测试原生SQL语句

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package com.hibernate.test;
 
import com.hibernate.domain.Customer;
import com.hibernate.utils.HibernateUtils;
import org.hibernate.*;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;
 
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
 
/**
 * @author: XDZY
 * @date: 2018/11/16 10:26
 * @description: 测试原生SQL语句查询（适合复杂多表查询）
 */
public class HibernateTest5 {
    /**
     * 查询所有
     */
    @Test
    public void test() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        String sql = "select * from cst_customer";
        SQLQuery query = session.createSQLQuery(sql);
        List<Object[]> list = query.list();
        for (Object[] customers : list) {
            System.out.println(Arrays.toString(customers));
        }
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 查询所有并且封装到对象
     */
    @Test
    public void test1() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        String sql = "select * from cst_customer";
        SQLQuery query = session.createSQLQuery(sql);
        query.addEntity(Customer.class);
        List<Customer> list = query.list();
        System.out.println(list);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 占位符
     */
    @Test
    public void test2() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        String sql = "select * from cst_customer where cust_id=?";
        SQLQuery query = session.createSQLQuery(sql);
        query.setParameter(0, 6L);
        query.addEntity(Customer.class);
        Customer customer = (Customer) query.uniqueResult();
        System.out.println(customer);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
 
    /**
     * 分页查询
     */
    @Test
    public void test3() {
        //创建Session对象
        Session session = HibernateUtils.openSession();
        //开启事务并获取事务对象
        Transaction tx = session.beginTransaction();
 
        /********************* 数据库操作 **********************/
 
        String sql = "select * from cst_customer limit ?,?";
        SQLQuery query = session.createSQLQuery(sql);
        query.setParameter(0, 0);
        query.setParameter(1, 1);
        query.addEntity(Customer.class);
        List<Customer> list = query.list();
        System.out.println(list);
 
        /*******************************************************/
 
        tx.commit();
        session.close();
    }
}

 

posted @   肖德子裕  阅读(158)  评论(0)  编辑  收藏  举报
编辑推荐：
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 记一次.NET内存居高不下排查解决与启示
阅读排行：
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
点击右上角即可分享
微信分享提示