Hibernate框架中简单的CRUD操作_hibernate简单实实现crud

简单回顾：

1、Hibernate的概述

什么是Hibernate？
Hibernate是一个持久层的ORM的框架。

什么是ORM？
ORM：Object Relational Mapping（对象关系映射）。
将java中的一个对象，与关系型数据库中的表建立映射，从而操作对象就可以操作表。

为什么要学习Hibernate？
简化JDBC的开发。
性能好。

---

2、Hibernate的入门

下载Hibernate
了解Hibernate目录结构

创建数据库和表
创建实体类
创建映射文件
创建核心配置文件
编写测试类

---

3、Hibernate的常见配置

映射文件的配置
核心文件的配置：包括必须配置，可选配置，映射加载绑定等。

---

4、Hibernate的API

Configuration
加载配置文件

SessionFactory
内部维护连接池，配置C3P0连接池，自定义工具类。线程安全的。

Session
维护一级缓存，与数据库交互的桥梁。非线程安全的。

Session常用方法：
save (obj);
get(class, id)/load(class, id);
update(obj);
delete(obj);
saveOrUpdate(obj);
createQuery(hql);
createSQLQuery(sql);

Transaction
commit();
rollback();

---

Hibernate中的CRUD操作

因为一个项目中通常只使用一个SessionFactory对象。
故写上工具类方法：

package myutils;

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

public class HibernateUtil {

    public static final Configuration configuration;
    public static final SessionFactory sessionFactory;

    static {
        configuration = new Configuration().configure();
        sessionFactory = configuration.buildSessionFactory();
    }

    public static Session openSession() {
        return sessionFactory.openSession();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

---

注意：增删改查的方法，都是Session对象的方法。

---

1、存储某个对象：save()

测试代码：

package com.pipi.hibernate;

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

// 入门案例
public class Test01 {
    public static void main(String[] args) {

        // 1、加载Hibernate的核心配置文件
        Configuration configuration = new Configuration().configure();

        // 2、创建一个SessionFactory对象，类似于JDBC中的连接池
        SessionFactory sessionFactory = configuration.buildSessionFactory();

        // 3、通过SessionFactory获取到Session对象，类似于JDBC中的Connection
        Session session = sessionFactory.openSession();

        // 4、手动开启事务
        Transaction transaction = session.beginTransaction();

        // 5、准备存储的数据
        User user = new User();
        user.setUsername("赵六");
        user.setPassword("abc123");

        // 6、保存
        session.save(user);

        // 7、事务提交
        transaction.commit();

        // 8、释放资源
        session.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

---

2、查询单个对象：get()，load()

（1）查询功能（2种方法）：
查询指定id的数据
T get(Class c, Serializable id);
T load(Class c, Serializable id);
参数为类字节码，数据的id

（2）get()方法和load()方法的区别？

• get方法：
  采用的是立即加载，执行到这行代码时，会立马发送sql语句去查询。
  查询后返回的是真实对象本身。
  查询一个找不到的对象的时候，返回null。

• load方法：
  采用的是延迟加载（lazy懒加载），执行到这行代码时，不会发送sql语句。
  当真正使用这个对象的时候才会发送sql语句。
  查询后返回的是代理对象，javassist-3.18.1-GA.jar，利用javassist技术产生的代理。
  查询一个找不到的对象的时候，返回ObjectNotFoundException。

测试代码：

package com.pipi.hibernate;

import myutils.HibernateUtil;
import org.hibernate.Session;

public class Test02 {
    public static void main(String[] args) {

        // 获取Session对象
        Session session = HibernateUtil.openSession();

        // 使用get方法查询，如果查询不到，返回null
        User user1 = session.get(User.class, 6);
        System.out.println(user1);  // User{id=6, username='王五', password='abc123'}

        // 使用load方法查询，如果查询不到，将抛出ObjectNotFoundException异常
        User user2 = session.load(User.class, 7);
        System.out.println(user2);  // User{id=7, username='赵六', password='abc123'}

        // 释放资源
        session.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

---

3、修改某个对象：update()

测试代码：

package com.pipi.hibernate;

import myutils.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

// 修改
public class Test03 {
    public static void main(String[] args) {

        // 获取Session对象
        Session session = HibernateUtil.openSession();
        // 开启一个事务
        Transaction transaction = session.beginTransaction();

        // 直接创建对象，再进行修改（不推荐）
        /*User user = new User();
        user.setId(5);
        user.setUsername("李四");
        session.update(user);*/

        // 先查询，再修改（推荐使用）
        User user1 = session.get(User.class, 1);
        if (user1 != null) {
            user1.setUsername("张三");
            session.update(user1);
        }

        // 提交事务
        transaction.commit();
        // 释放资源
        session.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

---

4、删除某个对象：delete()

测试代码：

package com.pipi.hibernate;

import myutils.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

// 删除方法
public class Test04 {
    public static void main(String[] args) {

        Session session = HibernateUtil.openSession();
        Transaction transaction = session.beginTransaction();

        // 直接创建对象，再删除（不推荐）
        /*User user = new User();
        user.setId(8);
        session.delete(user);*/

        // 先查询，再删除（推荐使用）--->级联删除
        User user = session.get(User.class, 7);
        if (user != null) {
            session.delete(user);
        }

        transaction.commit();
        session.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

---

5、保存或更新方法：saveOrUpdate()

测试代码：

package com.pipi.hibernate;

import myutils.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

// 保存或更新
public class Test05 {
    public static void main(String[] args) {

        Session session = HibernateUtil.openSession();
        Transaction transaction = session.beginTransaction();

        // 如果数据库中没有，就保存，有就更新（字段要写全，不然报错，因为有可能是保存，字段要全有）
        User user = new User();
        user.setUsername("zhangsan");
        user.setPassword("abc123");

        session.saveOrUpdate(user);

        transaction.commit();
        session.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

---

6、查询多个对象：hql和sql方式

HQL：Hibernate Query Language，面向对象的查询语言。

测试代码：

package com.pipi.hibernate;

import myutils.HibernateUtil;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;

import java.util.Arrays;
import java.util.List;

// 查询多个对象
public class Test06 {
    public static void main(String[] args) {

        Session session = HibernateUtil.openSession();

        // 接收HQL方式：Hibernate Query Language，面向对象的查询语言
        String hql = "from User";
        Query query1 = session.createQuery(hql);
        // 获取集合，并遍历
        List<User> list1 = query1.list();
        for (User u : list1) {
            System.out.println(u);
        }

        System.out.println("--------------------------------------");

        // 接收SQL方式
        String sql = "select * from t_user";
        SQLQuery query2 = session.createSQLQuery(sql);
        // 获取集合，并遍历，注意：返回值类型变了
        List<Object[]> list2 = query2.list();
        for (Object[] objects : list2) {
            System.out.println(Arrays.toString(objects));
        }

        session.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

---