27、第一个class实例

学习目标：

1、搭建Hibernate环境

2、理解Hibernate的运行流程

3、能正确运行Hibernate的第一个例子

学习过程：

hibernate既然是多数据库进行封装，所有我们就先建立一个数据库，我们可以直接使用面向对象的思想设计操作数据库，所有这里暂时需要建立表了

1、引入依赖包

必须要引入的是hibernate的核心依赖，这里我们使用的是mysql的数据库，所有我们还必须把mysql的驱动包也导入进去。pom.xml的依赖如下：

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.2.12.Final</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.35</version>
</dependency>

2、新建一个类Employee。这个类和数据库的表具有映射关系，也就是一个非常简单一个pojo。包含一些基本属性和对应的get/set方法而已，代码如：

public class Employee implements Serializable{
    private int empId;//>> emp_id
    private String employeeName;//employee_name
    private Date birthday;
    private Double weight;
    private Boolean gender;
    public int getEmpId() {
        return empId;
    }

    public void setEmpId(int empId) {
        this.empId = empId;
    }

    public String getEmployeeName() {
        return employeeName;
    }

    public void setEmployeeName(String employeeName) {
        this.employeeName = employeeName;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Double getWeight() {
        return weight;
    }

    public void setWeight(Double weight) {
        this.weight = weight;
    }

    public Boolean getGender() {
        return gender;
    }

    public void setGender(Boolean gender) {
        this.gender = gender;
    }
}

3、建立一个映射文件。在和Employee类中建立一个对应的映射文件Employee.hbm.xml，所谓的映射文件就是该对象和数据库中表的对应关系，以及类属性和表字段的对应关系，这个映射文件比较简单。代码如下：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <!-- 表和类之间的映射关系 -->
    <class name="com.javadayup.stuorm.Employee" table="employee" catalog="hibernate">
        <!-- id -->
        <id name="empId" column="emp_id">
            <generator class="native"></generator>
        </id>
        <property name="employeeName"  type="java.lang.String">
           <column name="employee_name"></column>
        </property>
        <property name="birthday" column="birthday" type="java.util.Date"></property>
        <property name="weight" column="weight" type="java.lang.Double"></property>
        <property name="gender" column="gender" type="java.lang.Boolean"></property>
    </class>
</hibernate-mapping>

4、建立一个hibernate的总配置文件。在src目录下建立一个hibernate.cfg.xml文件，这个文件就是hibernate的连接数据库的信息和维护所有的映射文件，既然hibernate是对数据库进行封装，那么我们第一步当然就是要定义连接数据库的基本信息。这里需要配置的还有方言，是否使用缓存已经导入所有的映射文件等等，具体可见下面的代码注释，代码如下：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <!-- 数据库的连接信息 -->
    <session-factory>
        <!-- 基本信息 -->
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123456</property>
        <!-- SQL 方言 -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 连接池配置 -->
        <property name="connection.pool_size">1</property>
        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>
        <!-- 是否使用缓存 -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
        <!-- 是否显示sql的语句 开发=true 生产=false -->
        <property name="show_sql">true</property>
        <!-- 它包含4个属性: create : 会根据你的model类来生成表,但是每次运行都会删除上一次的表,重新生成表,哪怕2次没有任何改变 
            测试使用 create-drop : 根据model类生成表,但是sessionFactory一关闭,表就自动删除 测试使用 update : 最常用的属性，也根据model类生成表,即使表结构改变了,表中的行仍然存在,不会删除以前的行 
            生产 validate : 只会和数据库中的表进行比较,不会创建新表,但是会插入新值 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 导入映射文件 -->
        <mapping resource="Employee.hbm.xml" />
    </session-factory>
</hibernate-configuration>

5、建立一个帮助类。因为每一次对数据库的连接，都需要建立一个session，所有这里就封装一个帮助类。

public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();
    private static SessionFactory buildSessionFactory() {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            return new Configuration().configure().buildSessionFactory();
        }
        catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

6、新建一个EmployeeDao，实现对数据库的基本的增删改查操作。代码如下：

public class EmployeeDao {
    public void add(Employee employee) {
        // 通过sessionFactory建立一个与数据库的回话 》》 connection
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        // 开启一个事务
        session.beginTransaction();
        // 操作数据库 直接操作对象 持久化
        session.save(employee);
        // 提交事物
        session.getTransaction().commit();
    }
    // employee id 必须要有值
    public void del(Employee employee) {
        // 通过sessionFactory建立一个与数据库的回话 》》 connection
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        // 开启一个事务
        session.beginTransaction();
        // 操作数据库 直接操作对象 持久化
        session.delete(employee);
        // 提交事物
        session.getTransaction().commit();
    }

    // id 必须要有值
    public void update(Employee employee) {
        // 通过sessionFactory建立一个与数据库的回话 》》 connection
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        // 开启一个事务
        session.beginTransaction();
        // 操作数据库 直接操作对象 持久化
        session.update(employee);
        // 提交事物
        session.getTransaction().commit();
    }
    // id 必须要有值
    public Employee getById(int id) {
        // 通过sessionFactory建立一个与数据库的回话 》》 connection
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        // 开启一个事务
        session.beginTransaction();
        // 操作数据库  inser into 
        Employee employee= (Employee)session.get(Employee.class, id);
        // 提交事物
        session.getTransaction().commit();
        return employee;
    }
    public static void main(String[] args) {
        EmployeeDao employeeDao=new EmployeeDao();
        Employee employee=new Employee();
        employee.setBirthday(new Date());
        employee.setEmployeeName("刘保");
        employee.setGender(true);
        employee.setWeight(1.2D);
        employeeDao.add(employee);
       // Employee employee=employeeDao.getById(1);
       // employee.setEmployeeName("刘");
        //employeeDao.update(employee);
      //  employeeDao.del(employee);
        //System.out.println(employee.getEmployeeName());
    }
}

   可以看到，java代码中对数据库的操作，不需要操作具体的那一张表，我们操作的是Employee对象，至于对Employee对象操作如何转换为数据库对应的表的操作，就是hibernate做的事情了，hibernate就是封装这一块的内容。作为hibernate的入门例子，这个例子稍微复杂了一点，不过也是一个很好的入门。以后会深入的讲解细节内容，现在大概有个了解就可以了。