小白学框架 —— JAVA框架之Hibernate_herb java

Java框架 —— Hibernate 学习笔记

1 Hello Hibernate

使用JDBC做数据库相关功能开发会做很多重复性的工作，比如创建连接，关闭连接，把字段逐一映射到属性中。 Hibernate把这一切都封装起来了，使得数据库访问变得轻松而简单，代码也更加容易维护。

这里要利用hibernate实现往数据库插入一条数据：
1 很重要的一点就是要在java项目中导入hibernate相应的jar包;
2 然后在数据库中创建好数据库和数据表格，这里创建的是一个test库，product_表格；
3 接着在Java项目中定义实体类 Product 用于映射数据库中的表product_；
在Product所在的包下 新建一个配置文件Product.hbm.xml， 用于映射Product类对应数据库中的product_表；
4 在src目录下创建 hibernate.cfg.xml配置访问数据库要用到的驱动，url，账号密码等等；

准备好配置文件之后，就可以编写测试类进行测试，这里放上测试类代码

package com.how2java.test;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

import com.how2java.pojo.Product;
/**
 * 
 * hibernate的基本步骤是：
	1. 获取SessionFactory 
	2. 通过SessionFactory 获取一个Session
	3. 在Session基础上开启一个事务
	4. 通过调用Session的save方法把对象保存到数据库
	5. 提交事务
	6. 关闭Session
	7. 关闭SessionFactory
 *
 */

public class TestHibernate {
	public static void main(String[] args) {
		
		SessionFactory sf = new Configuration().configure().buildSessionFactory();
		
		Session s = sf.openSession();
		s.beginTransaction();
		
		for (int i = 0; i < 10; i++) {
            Product p = new Product();
            p.setName("iphone"+i);
            p.setPrice(i);
            s.save(p);         
        }
		
		s.getTransaction().commit();
		s.close();
		sf.close();
 	}

}
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

实现效果如下图：

2 Hibernate 对象状态

实体类对象在Hibernate中有3种状态
分别是瞬时，持久和脱管

1 瞬时 指的是没有和hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，这个对象也就消失了
2 持久 指得是一个对象和hibernate发生联系，有对应的session,并且在数据库中有对应的一条记录
3 脱管 指的是一个对象虽然在数据库中有对应的一条记录，但是它所对应的session已经关闭了

演示3种状态代码：

package com.how2java.test;
  
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
import com.how2java.pojo.Product;
  
public class TestHibernate {
    /**
     * @param args
     */
    public static void main(String[] args) {
  
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
  
        Session s = sf.openSession();
        s.beginTransaction();
        Product p = new Product();
        p.setName("p1");
        System.out.println("此时p是瞬时状态");
        s.save(p);
        System.out.println("此时p是持久状态");
        s.getTransaction().commit();
        s.close();
        System.out.println("此时p是脱管状态");
        sf.close();
    }
  
}
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

3 Hibernate 各类概念

1. 事务
   Hibernate的任何对数据有改动的操作，都应该被放在事务里面.
   在事务中的多个操作行为，要么都成功，要么都失败

2. 延迟加载
   hibernate中的延迟加载(lazyload)分属性的延迟加载和关系的延迟加载

   属性的延迟加载:
   当使用load的方式来获取对象的时候，只有访问了这个对象的属性，hibernate才会到数据库中进行查询。否则不会访问数据库

   延迟加载又叫lazyload，在one-many many-many的时候都可以使用关系的延迟加载

3. 级联
   什么是级联？ 简单的说，没有配置级联的时候，删除分类，其对应的产品不会被删除。 但是如果配置了恰当的级联，那么删除分类的时候，其对应的产品都会被删除掉。
   级联有4种类型：
   all：所有操作都执行级联操作；
   none：所有操作都不执行级联操作；
   delete：删除时执行级联操作；
   save-update：保存和更新时执行级联操作；
   级联通常用在one-many和many-to-many上，几乎不用在many-one上。

4. 缓存
   hibernate默认是开启一级缓存的，一级缓存存放在session上，二级缓存是在SessionFactory上

5. 分页查询
   使用Criteria进行分页查询
   这里附上分页查询代码
   Oracle,Mysql,NoSQL还是DB2，分页查询的代码写法都是一样的

package com.how2java.test;
  
import java.util.List;
 
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
 
import com.how2java.pojo.Product;
  
public class TestHibernate {
    public static void main(String[] args) {
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
  
        Session s = sf.openSession();
        s.beginTransaction();
  
        String name = "iphone";
          
        Criteria c= s.createCriteria(Product.class);
        c.add(Restrictions.like("name", "%"+name+"%"));
        c.setFirstResult(2);  // 表示从第3条数据开始
        c.setMaxResults(5);   // 表示一共查询5条数据
         
        List<Product> ps = c.list();
        for (Product p : ps) {
            System.out.println(p.getName());
             
        }
          
        s.getTransaction().commit();
        s.close();
        sf.close();
    }
}
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

6. 获取对象方式
   通过id获取Product对象有两种方式，分别是get和load
   他们的区别分别在于 ：延迟加载 和对于id不存在的时候的处理

   关于延迟加载：
   load方式是延迟加载，只有属性被访问的时候才会调用sql语句；
   get方式是非延迟加载，无论后面的代码是否会访问到属性，马上执行sql语句

   关于对id不存在的时候的处理
   例如，都通过id=500去获取对象，（但这个id在数据库中并不存在）
   1） get方式会返回null
   2） load方式会抛出异常

7. 两种session获取方式
   Hibernate有两种方式获得session,分别是：
   openSession和getCurrentSession
   他们的区别在于
   1）获取的是否是同一个session对象
   openSession每次都会得到一个新的Session对象
   getCurrentSession在同一个线程中，每次都是获取相同的Session对象，但是在不同的线程中获取的是不同的Session对象
   2） 事务提交的必要性
   openSession只有在增加，删除，修改的时候需要事务，查询时不需要的
   getCurrentSession是所有操作都必须放在事务中进行，并且提交事务后，session就自动关闭，不能够再进行关闭

8. 乐观锁
   Hibernate使用乐观锁来处理脏数据问题

   1. 假设数据库中产品的价格是10000，version是10
   2. session1,session2分别获取了该对象
   3. 都修改了对象的价格
   4. session1试图保存到数据库，检测version依旧=10，成功保存，并把version修改为11
   5. session2试图保存到数据库，检测version=11，说明该数据已经被其他人动过了。 保存失败，抛出异常
      

仅作为个人学习记录，持续更新。。。。。

最后，本人是在一个不错的Java学习网站中学习的这部分内容，站长主张的是先运行看效果，增强学习信心，再进一步讲解每一步的原理，感觉对Java新手很是友好，链接放在这啦，推荐给大家哦~~
https://how2j.cn/p/5266