Hibernate基础

Posted 2020-12-27 kin1492

一、Hibernate是什么

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。简单一句话概括就是持久层的orm框架。

二、ORM框架

ORM全名Object relation mapping即对象关系映射，是指将java中的对象与关系型数据库中的表建立一种映射关系，通过操作java对象就可以来操作数据库。

三、Hibernate的优点

1. hibernate对jdbc访问数据库进行了轻量级封装，大大简化了数据访问层繁琐的重复的代码，并且减少了内存的消耗，加快了运行效率。
2. hibernate是一个基于jdbc的主流持久层框架，是一个优秀的ORM实现，它很大程度简化了DAO层编码工作。
3. Hibernate的性能非常好，映射的灵活性很很出色，从一对多，到多对多的各种复杂关系。它支持很多关系型数据库。
4. 可扩展性强，由于源代码的开源以及API的开放，当本身功能不够用时，可以自行编码进行扩展。

四、Hihbernate的入门

• 下载Hibernate的开发环境  

　　https://sourceforge.net/projects/hibernate/files/hibernate-orm/,选择你需要的版本

　　

• 下载后解压,文件夹目录如下。doucumentation主要放置的主要是开发文档。lib文件夹里面包含一些jar，其中required里面的jar是开发hibernate必须要引入的jar，optional文件夹里面是可选的jar。project是hibernate提供的项目。
• 新建一个Maven项目（使用eclipse把hibernatelib解压文件中必须的jar、jdbc驱动包、日志包log4j-1.2.16.jar 、slf4-api-1.6.1.jar、slf4j-log4j12-1.6.1.jar导入类路径下，使用maven的pom.xml配置如下）

　　

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
      <!-- 添加Hibernate依赖 -->
      <dependency>
          <groupId>org.hibernate</groupId>
          <artifactId>hibernate-core</artifactId>
          <version>5.3.3.Final</version>
      </dependency>
      <dependency>
          <groupId>antlr</groupId>
          <artifactId>antlr</artifactId>
          <version>2.7.7</version>
      </dependency>
      <dependency>
          <groupId>net.bytebuddy </groupId>
          <artifactId>byte-buddy</artifactId>
          <version>1.8.1</version>
      </dependency>
      <dependency>
          <groupId>com.fasterxml</groupId>
          <artifactId>classmate</artifactId>
          <version>1.3.4</version>
      </dependency>
      <dependency>
          <groupId>org.hibernate.common</groupId>
          <artifactId>hibernate-commons-annotations</artifactId>
          <version>5.0.4.Final</version>
      </dependency>
      <dependency>
          <groupId>javax.annotation</groupId>
          <artifactId>javax.annotation-api</artifactId>
          <version>1.2</version>
      </dependency>
      <dependency>
          <groupId>javax.persistence</groupId>
          <artifactId>javax.persistence-api</artifactId>
          <version>2.2</version>
      </dependency>
      <dependency>
          <groupId>dom4j</groupId>
          <artifactId>dom4j</artifactId>
          <version>1.6.1</version>
      </dependency>
      <dependency>
          <groupId>org.jboss.logging</groupId>
          <artifactId>jboss-logging</artifactId>
          <version>3.3.2.Final</version>
      </dependency>
      <dependency>
          <groupId>org.jboss.spec.javax.transaction</groupId>
          <artifactId>jboss-transaction-api_1.2_spec</artifactId>
          <version>1.1.1.Final</version>
      </dependency>


      <!-- 添加Log4J依赖 -->
      <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>1.2.16</version>
      </dependency>
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-log4j12</artifactId>
          <version>1.6.1</version>
      </dependency>
      <dependency>
          <groupId>org.jboss</groupId>
          <artifactId>jandex</artifactId>
          <version>2.0.5.Final</version>
      </dependency>
      <!-- 添加javassist -->
      <dependency>
          <groupId>org.javassist</groupId>
          <artifactId>javassist</artifactId>
          <version>3.23.1-GA</version>
      </dependency>

      <!-- mysql数据库的驱动包 -->
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.6</version>
      </dependency>

•  创建表

create table user
(
  id       int(10)       null,
  username varchar(10)   null,
  password varchar(32)   null,
  account  double(10, 3) null
);

• 创建实体类

public class User {
    
    private Integer user_id;
    private String user_name;
    private String user_pwd;
    private Double user_acc;

    public Integer getUser_id() {
        return user_id;
    }

    public void setUser_id(Integer user_id) {
        this.user_id = user_id;
    }

    public String getUser_name() {
        return user_name;
    }

    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    public String getUser_pwd() {
        return user_pwd;
    }

    public void setUser_pwd(String user_pwd) {
        this.user_pwd = user_pwd;
    }

    public Double getUser_acc() {
        return user_acc;
    }

    public void setUser_acc(Double user_acc) {
        this.user_acc = user_acc;
    }

    @Override
    public String toString() {
        return "User{" +
                "user_id=" + user_id +
                ", user_name=‘" + user_name + ‘‘‘ +
                ", user_pwd=‘" + user_pwd + ‘‘‘ +
                ", user_acc=" + user_acc +
                ‘}‘;
    }
}

• 创建映射文件User.hbm.xml，通过该映射文件建立java实体类和关系型数据库表的关系。这个配置文件可以任意命名。尽量统一命名规范（类名.hbm.xml）。要是不知道映射文件的dtd约束的可以到hibernate-core.final.jar  org.hibernate包中去找。

　　

　　打开映射文件dtd，将dtd粘贴到你的映射文件中

　　

• 映射文件的配置

1. class标签 用来建立java实体类和数据库表的映射关系

              name属性指定类

　　　　table属性指定表（表名和类名相同，table可省略）

　　　　catelog属性指定数据库

　　  2. id标签用来建立类中的属性与表中的主键的对应关系

               name属性指定类中的属性

　　　　column属性指定表中的字段（字段名和属性名 相同，column可以省略）

　　　　length指定表中字段的长度（如果在核心配置文件中配置了自动建表属性，那么字段长度为该属性的值）

　　　　type指定表中字段的类型

　　　3.preoperty标签用来建立类中属性和表中非主键字段的对应关系

　　　　nane属性指定类中的属性名

　　　　column指定表中的字段名

　　　　length长度

              type类型

　          not-null设置表中字段是否允许空

              unique设置表中字段值是否唯一

<?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">
<hibernate-mapping>
    <!--建立类与表的对应-->
<class name="Hibernate.demo.User" table="user">
    <!--类中属性与主键的对应-->
    <id name="user_id" column="id" >
        <generator class="native"/>
    </id>
    <!--普通属性与非主键列对应-->
    <property name="user_name" column="username"/>
    <property name="user_pwd" column="password"/>
    <property name="user_acc" column="account"/>
</class>

</hibernate-mapping>

• 创建hibernate的核心配置文件，要是不知道映射文件的dtd约束的可以到hibernate-core.final.jar  org.hibernate包中去找。核心配置文件需要配置如下内容

1. 必须的配置：

　　　　连接数据库的基本参数

　　　　方言 hibernate支持很多的关系型数据库，但是每种数据库的sql有细微的差别，比如在分页的sql中oracle是多层sql的嵌套，mysql用的是limit,通过该配置让hibernate生成

　　　　对应的sql

          2.可选的配置：

　　　　是否打印sql

　　　　是否将打印的sql格式化

　　　　是否自动建表

　　　3.映射文件的位置

<?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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/django_orm</property>
            <property name="hibernate.connection.username">root</property>
            <property name="hibernate.connection.password">root</property>
            <!--数据库的方言-->
            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
          <!--可选的配置-->
            <!--是否打印sql true打印false不打印-->
            <property name="hibernate.show_sql">true</property>
            <!--是否格式化sql-->
            <property name="hibernate.format_sql">true</property>
            <!--是否自动生成表-->
            <!--<property name="hibernate.hbm2ddl.auto">create</property>   create每次插入记录都会重新创建表-->
            <!--<property name="hibernate.hbm2ddl.auto">create-drop</property>  create-drop每次插入记录重新创建表 插入记录后在删除表，通常在测试中使用-->
            <!--<property name="hibernate.hbm2ddl.auto">update</property>  update每次插入记录，需要更新表结构就更新 -->
            <!--<property name="hibernate.hbm2ddl.auto">validate</property>  每次插入记录进行验证（校验映射和表结构能否对应）-->
          <!--设置映射文件的位置-->
            <mapping resource="Hibernate/demo/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

• 编写测试类

public class HibernateUtils {

    private static SessionFactory sessionFactory = null;

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

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

}

 

public class TestDemo {
    @Test
    //插入数据 session.save
    public void demo1(){
        //加载hibernate核心配置文件
        org.hibernate.cfg.Configuration cfg = new org.hibernate.cfg.Configuration().configure();
        //创建SessionFactory对象，类似jdbc中的连接池
        SessionFactory sessionFactory = cfg.buildSessionFactory();
        //创建session对象，类似jdbc中的连接
        Session session = sessionFactory.openSession();
        //开启事物
        Transaction tx = session.beginTransaction();
        User u = new User();
        u.setUser_name("张三");
        session.save(u);
        //提交事物
        tx.commit();
        //关闭连接
        session.close();
    }

    @Test
    //查找数据 session.get
    public void demo2(){
        Session session = HibernateUtils.getSession();
        Transaction tx = session.beginTransaction();
        User u = session.get(User.class,1);
        System.out.println(u);
        User u2 = session.get(User.class,1);
        System.out.println(u==u2);
        System.out.println(u);
        tx.commit();
        session.close();
    }
    @Test
    //查找数据 session.load
    public void demo3(){
        Session session = HibernateUtils.getSession();
        Transaction tx = session.beginTransaction();
        User u = session.load(User.class,1);

        System.out.println(u);

        User u2 = session.load(User.class,1);
        System.out.println(u==u2);
        tx.commit();
        session.close();
    }

    @Test
    //保存或更新数据 session.saveOrUpdate
    public void saveOrUpdate(){
        Session session = HibernateUtils.getSession();
        Transaction tx = session.beginTransaction();
        User u = new User();
        u.setUser_name("李四");
        session.saveOrUpdate(u);
        tx.commit();
        session.close();
    }
    @Test
    //更新数据 session.update
    public void update2(){
        Session session = HibernateUtils.getSession();
        Transaction tx = session.beginTransaction();
        User u = new User();
        u.setUser_name("lisi");
        u.setUser_id(2);
        session.saveOrUpdate(u);
        tx.commit();
        session.close();
    }

    @Test
    //查询数据
    public void list(){
        Session session = HibernateUtils.getSession();
        Transaction tx = session.beginTransaction();
        //面向对象查询
        Query query = session.createQuery("from User");
        List<User> list = query.list();
        for(User u :list){
            System.out.println(u);
        }
        // sql查询
        SQLQuery sql = session.createSQLQuery("select * from user");

        List<Object[]> objList = sql.list();
        for(Object[] obj :objList){
            System.out.println(Arrays.toString(obj));
        }

    }
}