Hibernate（三）对数据库进行增删改查

重要的接口
1.SessionFactory接口 :针对单个数据库映射关系经过编译后的内存镜像。封装了我们在configuration里封装的连接信息信息，它在内存中就会生成一个内存映射，主要用来创建Session接口，此接口创建比较耗时，和一级缓存有关系，因此将其写在静态块中。
2.Session接口 :表示应用程序与持久储存层之间交互操作的一个单线程对象，此对象生存期很短,其隐藏了JDBC连接，也是Transaction的工厂。和二级缓存有关，含有操作数据库的增删改查方法，它的底层隐式封装了我们在JDBC中的Connection对象。
3.Transaction :应用程序用来指定原子操作单元范围的对象， 它通过抽象具体处理数据操作时的事务接口。主要用来做数据库的事务。
4.Query接口:提供的查询接口，并且查询的是类，而不是表，是执行的面相对象的查询语言(HQL)。
5.Configuraciton类：主要获得Hibernate提供的配置文件中配置连接数据的配置信息。

简单操作的实例

在之前对象关系映射的基础上

1.修改连接数据库的配置文件，在文件中添加下面两行代码，这两行代码可以在使得运行后在控制台显示标准的sql语句，便于我们了解真正的实现过程。

<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>

2.修改hibernate类的描述文件，将主键的生成方式改为uuid

<generator class="uuid" ></generator>

3.修改实体类，将id的类型改为String类型，创建无参和两个带参的构造函数，一个包含了所有的成员变量，在修改数据时使用，一个不包含id，在增加数据时使用。

import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = 1L;
private String id;// javaBean的标识
private String userName;
private String passWord;
private String createTime;
private String endTime;
public User(String id, String userName, String passWord, String createTime,String endTime) {
super();
this.id = id;
this.userName = userName;
this.passWord = passWord;
this.createTime = createTime;
this.endTime = endTime;
    }
public User(String userName, String passWord, String createTime,
            String endTime) {
super();
this.userName = userName;
this.passWord = passWord;
this.createTime = createTime;
this.endTime = endTime;
    }
public User() {
super();
// TODO Auto-generated constructor stub
    }
public String getId() {
return id;
    }
public void setId(String id) {
this.id = id;
    }
public String getUserName() {
return userName;
    }
public void setUserName(String userName) {
this.userName = userName;
    }
public String getPassWord() {
return passWord;
    }
public void setPassWord(String passWord) {
this.passWord = passWord;
    }
public String getCreateTime() {
return createTime;
    }
public void setCreateTime(String createTime) {
this.createTime = createTime;
    }
public String getEndTime() {
return endTime;
    }
public void setEndTime(String endTime) {
this.endTime = endTime;
    }
}

4.新建一个工具包并在其中新建一个工具类，用来获得SessionFactory和
session。

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

public class HibernateUntil {
private static SessionFactory sessionFactory=null;
static{
try {
            Configuration con=new Configuration().configure();
//实例化sessionFactory
            sessionFactory=con.buildSessionFactory();
        } catch (Exception e) {
            e.printStackTrace();
        }   
    }
//获得session
public static Session getSession(){
return sessionFactory.openSession();
    }
//关闭session
public static void closeSession(Session session){
if(session!=null){
            session.close();
        }
    }
}

5.新建一个dao包并在其中创建UserDao类（主要写数据的操作方法），在操作方法中，增加删除修改相类似，返回值都是void，操作的步骤，得到session，开启事务，执行相应的sql,完成提交事务，出现错误回滚事务，最终关闭session，查询方法的返回值是list，它不需要开启事务，操作步骤得到session，获得Query，传入sql，值得注意的是Hibernate的查询是面向类的，所以此时传入的是类的全映射名，执行相应方法，关闭session。

package com.pre.dao;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import com.pre.entity.User;
import com.pre.until.HibernateUntil;
public class UserDao {
    public static void saveUser(User user){
        Session session=HibernateUntil.getSession();
        //获得操作数据库的事务，Hibernate的事务需要手动处理
        try {
            session.beginTransaction().begin();
            session.save(user);
            session.beginTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.beginTransaction().rollback();
        }finally{
            HibernateUntil.closeSession(session);
        }   
    }
    public static void delUser(User user){
        Session session=HibernateUntil.getSession();
        //获得操作数据库的事务，Hibernate的事务需要手动处理
        try {
            session.beginTransaction().begin();
            session.delete(user);
            session.beginTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.beginTransaction().rollback();
        }finally{
            HibernateUntil.closeSession(session);
        }   
    }
    public static void updateUser(User user){
        Session session=HibernateUntil.getSession();
        //获得操作数据库的事务，Hibernate的事务需要手动处理
        try {
            session.beginTransaction().begin();
            session.update(user);
            session.beginTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.beginTransaction().rollback();
        }finally{
            HibernateUntil.closeSession(session);
        }   
    }
    public static List<User> selectUser(){
        Session session=HibernateUntil.getSession();
        List<User> user=null;
        try {
            Query query=session.createQuery("from com.pre.entity.User");
            user=query.list();
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            HibernateUntil.closeSession(session);
        }
        return user;
    }
}

6.书写测试类，此时的测试类中主要包含的是返回值为void的几个测试类，和main方法，main方法中主要是创建一个测试类，以及调用其中的方法。

package com.pre.mapper;
import java.util.List;
import com.pre.dao.UserDao;
import com.pre.entity.User;
public class Test {
public void testSave(){
        UserDao.saveUser(new User("娃娃1", "12345", "2017-07-31", "2019-09-09"));
    }
public void testDel(){
        User user=new User();
        user.setId("402880fd5d9927bf015d9927c0290001");
        UserDao.delUser(user);
    }
public void testUpdate(){
        UserDao.updateUser(new User("402880fd5d992c87015d992c88460001","张三", "5678", "2017-07-31", "2019-09-09"));
    }
public void testSelect(){
        List<User> user=UserDao.selectUser();
for (User us : user) {
            System.out.println(us.getId()+us.getUserName());
        }
    }
public static void main(String[] args) {
        Test test=new Test();
//test.testSave();
//test.testDel();
//test.testUpdate();
        test.testSelect();
    }
}

7.各个操作的注意点以及执行结果
增加：需要传入一个新创建的User类的实例，在执行的结果中可以看到id是一个32位的字符串，且每次生成的不同。

删除：此时需要用无参的构造函数创建一个新的User类的实例，并设置其id值，用来标识要删除那一条数据。

修改：此时需要创建一个新的User类的实例，其中的id是自己想要修改数据的id值，其它属性是修改后的值。

查询：需要创建一个list用来存放查找的结果，并遍历输出查询的结果。