Hibernate基本CRUD

1 hibernate 框架介绍

冬眠：开发的代码基本不变。

1.1回顾jdbc

Java提供的标准的数据访问的API

作用：完成应用程序java程序中的数据和db中的数据进行交换。

工作过程：

A 加载驱动

B建立连接

C定义sql,发生sql语句

D执行sql语句获得执行结果

E处理返回结果

F关闭资源

1.2 ORM对象关系映射

将大象保存数据库？

JAVA：

1 定义大象类

2定义类的属性

3创建对象

DB:

1 创建表

2定义表中的字段

3 插入记录（一行）

将大象保存到java程序？

ORM:

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

类----表

类属性----表中的字段

对象----数据库的记录

1.3hibernate实现机制

Src:hibernate.cfg.xml

描述数据的操作环境

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

2 Hello Hhibernate

2.1 新建java项目

导入jar包

2.2 建立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">1111</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="org/guangsoft/pojo/Pet.hbm.xml" />
     </session-factory>
 </hibernate-configuration> 

2.3建立java类（实体类）

建立pojo类

 package org.guangsoft.pojo;
 /***
  *
  * 定义宠物的pojo类：简单的java类
  *
  * ***/
 public class Pet
 {
     private Integer pid;
     private String pname;
     private String ptype;
     private String color;
     public Integer getPid()
     {
         return pid;
     }
     public void setPid(Integer pid)
     {
         this.pid = pid;
     }
     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;
     }
 }

2.4 建立pojo的映射文件

必须和pojo类放入同一个包中。

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <!-- 描述java中的类和数据库的表映射关系 package:指定pojo所在的包 -->
 <hibernate-mapping package="org.guangsoft.pojo">
     <!-- 描述类和表的关系 -->
     <class name="Pet" table="t_pet">
         <!-- 描述java对象的标识和数据库中的主键的对应关系 name:属性名 column:数据库的列表 type:属性的数据类型 -->
         <id name="pid" column="pid" type="java.lang.Integer">
             <!-- native:pid这一列在数据库中管理方式： 如:mysql 会自动使pid自增 oracle:会为该列产生一个序列 -->
             <generator class="native"></generator>
         </id>
         <!-- 其他属性：简单属性 name:属性名 column:数据库的列表 type:属性的数据类型 -->
         <property name="pname" column="pname" type="java.lang.String"></property>
         <property name="ptype" column="ptype" type="java.lang.String"></property>
         <property name="color" column="color" type="java.lang.String"></property>
     </class>
 </hibernate-mapping>

2.5使用Hibernate的API

建立测试类，访问数据库

 package org.guangsoft.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提交事务
         tr.commit();
         //8释放资源
         session.close();
     }
 } 

3 hibernate的基本操作（curd）

3.1 准备工作

建立项目，加入jar

建立hibernate.cfg.xml

建立pojo类和对应的映射文件

3.2 定义Dao接口

 package org.guangsoft.dao;
 import java.util.List;
 import org.guangsoft.pojo.Student;
 /***
  *
  * 学生表的crud操作定义
  *
  * ***/
 public interface StudentDao
 {
     // 添加学生信息
     public void saveStudent(Student stu);
     // 删除学生信息
     public void deleteStudent(Student stu);
     // 修改学生信息
     public void updateStudent(Student stu);
     // 单条查询
     public Student selStudentBySno(Integer sno);
     // 查询所有学生信息
     public List<Student> selStudentAll();
 }

3.3建立接口的实现类

 package org.guangsoft.dao.impl;
 import java.util.List;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.guangsogt.dao.StudentDao;
 import org.guangsoft.pojo.Student;
 public class StudentDaoImpl implements StudentDao
 {
     /**
      *
      * 通过静态代码块加载配置文件
      *
      * ****/
     static SessionFactory sf = null;
     static
     {
         // 1 创建Configuration对象，用来加载hibernate的配置文件
         Configuration cfg = new Configuration();
         // 2加载配置文件
         cfg.configure("hibernate.cfg.xml");
         // 3通过cfg构造一个会话工厂对象
         sf = cfg.buildSessionFactory();
     }
     @Override
     public void saveStudent(Student stu)
     {
         // TODO Auto-generated method stub
         // 获得数据库的会话对象
         Session session = sf.openSession();
         // 打开事务操作
         Transaction tr = session.beginTransaction();
         // 添加数据
         session.save(stu);
         // 提交事务
         tr.commit();
         // 关闭资源
         session.close();
     }
     @Override
     public void deleteStudent(Student stu)
     {
         // TODO Auto-generated method stub
         //
         Session session = sf.openSession();
         //
         Transaction tr = session.beginTransaction();
         //
         session.delete(stu);
         //
         tr.commit();
         //
         session.close();
     }
     @Override
     public void updateStudent(Student stu)
     {
         // TODO Auto-generated method stub
         //
         Session session = sf.openSession();
         //
         Transaction tr = session.beginTransaction();
         //
         session.update(stu);
         /***
          *
          * 如果传入的对象的唯一标识是null，那对数据库进行保存操作
          *
          * 如果传入的对象的唯一标识不是null，会进行更新操作，如果不存在
          *
          * **/
         // session.saveOrUpdate(stu);
         //
         tr.commit();
         //
         session.close();
     }
     /**
      *
      * 单条查询
      *
      * ***/
     @Override
     public Student selStudentBySno(Integer sno)
     {
         // TODO Auto-generated method stub
         // 1 session
         Session session = sf.openSession();
         // 2 查询操作事务是可以不需要的
         // 3查询操作：参数1：需要查询的类对应的clas文件 参数2：查询条件（唯一标识）
         Object obj = session.get(Student.class, sno);
         return (Student) obj;
     }
     /*** 多条查询 ***/
     @Override
     public List<Student> selStudentAll()
     {
         // TODO Auto-generated method stub
         // 1 session
         Session session = sf.openSession();
         // 2(通过hibernate提供的查询语句进行查询)
         String hql = "from Student";
         // 3执行hql语句
         return session.createQuery(hql).list();
     }
 }

3.4 建立测试类

测试基本的crud操作

 package org.guangsoft.test;
 import java.util.List;
 import org.junit.Before;
 import org.junit.Test;
 import org.guangsoft.dao.StudentDao;
 import org.guangsoft.dao.impl.StudentDaoImpl;
 import org.guangsoft.pojo.Student;
 public class TestCrud
 {
     // 声明Dao变量
     StudentDao dao;
     /***
      *
      * init方法在所有加@Test注解的方法执行之前，会自动执行。
      *
      * ***/
     @Before
     public void init()
     {
         dao = new StudentDaoImpl();
     }
     /**
      *
      * 测试增加学生的功能
      *
      * ***/
     @Test
     public void testSaveStudent()
     {
         Student stu = new Student();
         stu.setSname("王岐山");
         stu.setAddress("中南海");
         stu.setBirthday("1956-10-10");
         dao.saveStudent(stu);
     }
     /***
      *
      *
      *
      * 测试更新功能
      *
      * ***/
     @Test
     public void testUpdateStudent()
     {
         Student stu = new Student();
         // 如果给定的id在数据库没有对应的记录，抛出异常
         stu.setSno(14);
         stu.setSname("特朗普");
         stu.setAddress("白宫");
         stu.setBirthday("1990-10-10");
         dao.updateStudent(stu);
     }
     /***
      *
      * 进行单条查询
      *
      * ***/
     @Test
     public void testSelectStudentBySno()
     {
         Student s = dao.selStudentBySno(4);
         System.out.println("-----" + s.getSno() + "\t" + s.getSname() + "\t"
                 + s.getAddress() + "\t" + s.getBirthday());
     }
     /***
      *
      * 测试多条查询
      *
      * ***/
     @Test
     public void testSelectStudentAll()
     {
         List<Student> list = dao.selStudentAll();
         for (Student s : list)
         {
             System.out.println("-----" + s.getSno() + "\t" + s.getSname()
                     + "\t" + s.getAddress() + "\t" + s.getBirthday());
         }
     }
     /***
      *
      * 测试删除
      *
      * **/
     @Test
     public void testDeleteStudent()
     {
         // 创建了对象，自己封装了id属性的值
         /*
          * Student stu = new Student();
          *
          * stu.setSno(4);
          */
         // 删除之前，先进行查询操作
         Student stu = dao.selStudentBySno(3);
         dao.deleteStudent(stu);
     }
 } 

4 crud操作总结

总结API:对象

Configuration ：加载hibernate的配置文件。

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

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

Transaction:事务控制对象

Session方法

BeginTransaction()  开始事务

Save()

saveOrUpdate()

delete()

update()

get()/load();

Query q = createQuery()

q.list()

//session.createSQLQuery(arg0)

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