Hibernate实现对数据的CRUD

今天主要去看公司的老框架, CRUD用的较多,所以总结一下步骤,以免忘记的时候温习

回顾 JDBC

工作过程：

加载驱动
建立连接
定义sql,发生sql语句
执行sql语句获得执行结果
处理返回结果
关闭资源

ORM对象关系映射

将汽车保存进数据库 ?

定义汽车类
定义类的属性
创建对象

DB 操作的做法

创建表
定义表中的字段
插入记录（一行）

将汽车保存到java程序的做法呢？

ORM:

面向对象的java语言和关系型数据库之间的对应关系

类----表
类属性----表中的字段
对象----数据库的记录

hibernate实现机制

hibernate 框架介绍

Hibernate是一个基于jdbc的开源的持久化框架，是一个优秀的ORM实现，它很大程度的简化了dao层编码工作。Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

在分层结构中处于持久化层，封装对数据库的访问细节，使业务逻辑层更专注于实现业务逻辑。是一个全自动的框架 ,基本的CRUD细节已经实现了

Src:hibernate.cfg.xml

描述数据的操作环境

Hibernate通过对jdbc的封装，以orm对象关系映射为基础，让程序员以完全面向对象的思想，实现对数据库的crud操作。在使用hibernate进行数据库的操作的时候，程序员不需要考虑sql语句的开发

Hello Hhibernate

新建java项目

建立hibernate的主配置文件

在src目录下，建立hibernate.cfg.xml

  <?xml version="1.0" encoding="UTF-8"?>

  <!DOCTYPE hibernate-configuration PUBLIC

      "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

      "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

  <hibernate-configuration>

      <session-factory>

          <!-- 配置数据库的连接信息 -->

          <property name="connection.driver_class">com.mysql.jdbc.Driver</property>

          <!-- jdbc:mysql://localhost:3306/1106 -->

         <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>

         <property name="connection.username">root</property>

         <property name="connection.password">root</property>

         <!-- 配置hibernate操作的数据库对应的方言 hjibernate在操作数据库的过程中，需要将普通话，翻译为特定数据对应的方言sql语句，hibernate开发的应用程序

             可以在不同的数据库上进行移植。 -->

         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

         <!-- 配置数据相关的其他属性 -->

         <!-- hibenrate生产的sql语句是否在控制台进行打印 -->

         <property name="show_sql">true</property>

         <!-- 是否将产生的sql语句进行格式化 -->

         <property name="format_sql">true</property>

         <!-- 配置hibenrate的正向工程： hibernate的反向工程：由数据库中的表，产生java程序中的类 hibenrate的正向工程：由java中的类，产生数据库中对应的表

             upate:如果数据库中存在某个java类对应的表，检查java类中的属性是否和数据库中的表字段一致，如果不一致进行更新 如果数据库中不存在表，会自动创建表。 -->

        <property name="hbm2ddl">update</property>

         <!-- 通过主配置文件，加载pojo的映射文件 -->

         <mapping resource="com/spiritmark/pojo/Pet.hbm.xml" />

     </session-factory>

 </hibernate-configuration>

建立java类（实体类）

package com.bdqn.spiritmar.pojo;

public class Pet {

	private Integer Id;

	private String pname;

	private String ptype;

	private String color;

	public Integer getId() {

		return Id;

	}

	public void setId(Integer id) {

		Id = id;

	}

	public String getPname() {

		return pname;

	}

	public void setPname(String pname) {

		this.pname = pname;

	}

	public String getPtype() {

		return ptype;

	}

	public void setPtype(String ptype) {

		this.ptype = ptype;

	}

	public String getColor() {

		return color;

	}

	public void setColor(String color) {

		this.color = color;

	}

}

 1 <?xml version="1.0" encoding="UTF-8"?>

 2 <!DOCTYPE hibernate-mapping PUBLIC

 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 5 <!-- 描述java中的类和数据库的表映射关系 package:指定pojo所在的包 -->

 6 <hibernate-mapping package="org.spirit.mark.pojo">

 7     <!-- 描述类和表的关系 -->

 8     <class name="Pet" table="t_pet">

 9         <!-- 描述java对象的标识和数据库中的主键的对应关系 name:属性名 column:数据库的列表 type:属性的数据类型 -->

10         <id name="pid" column="pid" type="java.lang.Integer">

11             <!-- native:pid这一列在数据库中管理方式： 如:mysql 会自动使pid自增 oracle:会为该列产生一个序列 -->

12             <generator class="native"></generator>

13         </id>

14         <!-- 其他属性：简单属性 name:属性名 column:数据库的列表 type:属性的数据类型 -->

15         <property name="pname" column="pname" type="java.lang.String"></property>

16         <property name="ptype" column="ptype" type="java.lang.String"></property>

17         <property name="color" column="color" type="java.lang.String"></property>

18     </class>

19 </hibernate-mapping>

使用Hibernate的API

建立测试类，访问数据库

  package com.bdqn.spiritmar.test;

  import java.io.Serializable;

  import org.hibernate.Session;

  import org.hibernate.SessionFactory;

  import org.hibernate.Transaction;

  import org.hibernate.cfg.Configuration;

  import org.junit.Test;

  import org.guangsoft.pojo.Pet;

  public class TestHibernate {

     /***      * 添加一个宠物信息，为模板代码

      * 单元测试：

      * @Test

      * 在定义单元测试方法的时候，方法不能有参数和返回值

      * ***/

    @Test

     public void addPet()

     {

         //1 创建Configuration对象，用来加载hibernate的配置文件

         Configuration  cfg = new Configuration();

         //2加载配置文件

         cfg.configure("hibernate.cfg.xml");

         //3通过cfg构造一个会话工厂对象

         SessionFactory sf=cfg.buildSessionFactory();

         //4获得数据库的会话对象，和数据库的连接

         Session session = sf.openSession();

         //5开始事务

         Transaction tr=session.beginTransaction();

         //6进行数据库的curd操作

        Pet pet = new Pet();

         pet.setPname("特朗普");

         pet.setColor("绿色");

         pet.setPtype("宝马");

               //返回值为当前增加的记录的主键值

         Serializable ser=session.save(pet);

         System.out.println("ser="+ser);7         //7提交事务

         tr.commit();

         //8释放资源

         session.close();

     }

 }

hibernate的基本操作（curd）

建立项目，加入jar
建立hibernate.cfg.xml
建立pojo类和对应的映射文件

定义Dao接口

 1 package com.bdqn.spiritmark.dao;

 2 import java.util.List;

 3 import org.guangsoft.pojo.Student;

 4 /***

 5  *

 6  * 学生表的crud操作定义

 7  *

 8  * ***/

 9 public interface StudentDao

10 {

11     // 添加学生信息

12     public void saveStudent(Student stu);

13     // 删除学生信息

14     public void deleteStudent(Student stu);

15     // 修改学生信息

16     public void updateStudent(Student stu);

17     // 单条查询

18     public Student selStudentBySno(Integer sno);

19     // 查询所有学生信息

20     public List<Student> selStudentAll();

21 }

建立接口的实现类

  1 package com.bdqn.spiritmark.dao.impl;

  2 import java.util.List;

  3 import org.hibernate.Session;

  4 import org.hibernate.SessionFactory;

  5 import org.hibernate.Transaction;

  6 import org.hibernate.cfg.Configuration;

  7 import org.guangsogt.dao.StudentDao;

  8 import org.guangsoft.pojo.Student;

  9 public class StudentDaoImpl implements StudentDao

 10 {

 11     /**

 12      *

 13      * 通过静态代码块加载配置文件

 14      *

 15      * ****/

 16     static SessionFactory sf = null;

 17     static

 18     {

 19         // 1 创建Configuration对象，用来加载hibernate的配置文件

 20         Configuration cfg = new Configuration();

 21         // 2加载配置文件

 22         cfg.configure("hibernate.cfg.xml");

 23         // 3通过cfg构造一个会话工厂对象

 24         sf = cfg.buildSessionFactory();

 25     }

 26     @Override

 27     public void saveStudent(Student stu)

 28     {

 29         // TODO Auto-generated method stub

 30         // 获得数据库的会话对象

 31         Session session = sf.openSession();

 32         // 打开事务操作

 33         Transaction tr = session.beginTransaction();

 34         // 添加数据

 35         session.save(stu);

 36         // 提交事务

 37         tr.commit();

 38         // 关闭资源

 39         session.close();

 40     }

 41     @Override

 42     public void deleteStudent(Student stu)

 43     {

 44         // TODO Auto-generated method stub

 45         // 1

 46         Session session = sf.openSession();

 47         // 2

 48         Transaction tr = session.beginTransaction();

 49         // 3

 50         session.delete(stu);

 51         // 4

 52         tr.commit();

 53         // 5

 54         session.close();

 55     }

 56     @Override

 57     public void updateStudent(Student stu)

 58     {

 59         // TODO Auto-generated method stub

 60         // 1

 61         Session session = sf.openSession();

 62         // 2

 63         Transaction tr = session.beginTransaction();

 64         // 3

 65         session.update(stu);

 66         /***

 67          *

 68          * 如果传入的对象的唯一标识是null，那对数据库进行保存操作

 69          *

 70          * 如果传入的对象的唯一标识不是null，会进行更新操作，如果不存在

 71          *

 72          * **/

 73         // session.saveOrUpdate(stu);

 74         // 4

 75         tr.commit();

 76         // 5

 77         session.close();

 78     }

 79     /**

 80      *

 81      * 单条查询

 82      *

 83      * ***/

 84     @Override

 85     public Student selStudentBySno(Integer sno)

 86     {

 87         // TODO Auto-generated method stub

 88         // 1 session

 89         Session session = sf.openSession();

 90         // 2 查询操作事务是可以不需要的

 91         // 3查询操作：参数1：需要查询的类对应的clas文件 参数2：查询条件（唯一标识）

 92         Object obj = session.get(Student.class, sno);

 93         return (Student) obj;

 94     }

 95     /*** 多条查询 ***/

 96     @Override

 97     public List<Student> selStudentAll()

 98     {

 99         // TODO Auto-generated method stub

100         // 1 session

101         Session session = sf.openSession();

102         // 2(通过hibernate提供的查询语句进行查询)

103         String hql = "from Student";

104         // 3执行hql语句

105         return session.createQuery(hql).list();

106     }

107 }

建立测试类

 1 package com.bdqn.spiritmarktest;

 2 import java.util.List;

 3 import org.junit.Before;

 4 import org.junit.Test;

 5 import com.spirit.mark.dao.StudentDao;

 6 import com.spirit.mark.impl.StudentDaoImpl;

 7 import com.spirit.mark.pojo.Student;

 8 public class TestCrud

 9 {

10     // 声明Dao变量

11     StudentDao dao;

12     /***

13      *

14      * init方法在所有加@Test注解的方法执行之前，会自动执行。

15      *

16      * ***/

17     @Before

18     public void init()

19     {

20         dao = new StudentDaoImpl();

21     }

22     /**

23      *

24      * 测试增加学生的功能

25      *

26      * ***/

27     @Test

28     public void testSaveStudent()

29     {

30         Student stu = new Student();

31         stu.setSname("王岐山");

32         stu.setAddress("中南海");

33         stu.setBirthday("1956-10-10");

34         dao.saveStudent(stu);

35     }

36     /***

37      *

38      *

39      *

40      * 测试更新功能

41      *

42      * ***/

43     @Test

44     public void testUpdateStudent()

45     {

46         Student stu = new Student();

47         // 如果给定的id在数据库没有对应的记录，抛出异常

48         stu.setSno(19);

49         stu.setSname("迪迦");

50         stu.setAddress("光之国");

51         stu.setBirthday("1999-10-10");

52         dao.updateStudent(stu);

53     }

54     /***

55      *

56      * 进行单条查询

57      *

58      * ***/

59     @Test

60     public void testSelectStudentBySno()

61     {

62         Student s = dao.selStudentBySno(4);

63         System.out.println("-----" + s.getSno() + "\t" + s.getSname() + "\t"

64                 + s.getAddress() + "\t" + s.getBirthday());

65     }

66     /***

67      *

68      * 测试多条查询

69      *

70      * ***/

71     @Test

72     public void testSelectStudentAll()

73     {

74         List<Student> list = dao.selStudentAll();

75         for (Student s : list)

76         {

77             System.out.println("-----" + s.getSno() + "\t" + s.getSname()

78                     + "\t" + s.getAddress() + "\t" + s.getBirthday());

79         }

80     }

81     /***

82      *

83      * 测试删除

84      *

85      * **/

86     @Test

87     public void testDeleteStudent()

88     {

89         // 创建了对象，自己封装了id属性的值

90         /*

91          * Student stu = new Student();

92          *

93          * stu.setSno(4);

94          */

95         // 删除之前，先进行查询操作

96         Student stu = dao.selStudentBySno(3);

97         dao.deleteStudent(stu);

98     }

99 }

crud操作总结

Configuration ：加载hibernate的配置文件。

SessionFactory:会话工厂，在实际的程序也只存在一个对象。

Session:用来操作数据库的会话对象，产生事务对象

Transaction:事务控制对象

Session方法

       BeginTransaction()  开始事务

```
   Save()
```
```
      saveOrUpdate()
```
```
     delete()
```
- ```
   update()
```

      get()/load();

```
  Query q = createQuery()
```
```
 q.list()
```

Query:执行数据库的查询操作，负责执行HQL语句