Hibernate（一）

1.Hibernate介绍

hibernate3.6: hibernate公司的产品.

hibernate4.3.8: jboss公司的产品.

2.作用

能让程序员以面向对象的方式来操作数据库，从而简化持久层的开发。

它底层可以跨数据库. (程序人员开发项目不用关心项目用得是什么数据库).

ORM: Object Relation Mapping 对象关系映射.

Object : 对象指得是面向对象的编程语言.

Relation: 关系指得是关系型数据库.

Mapping : 面向对象的编程语言与关系型数据库之间的映射.

3.ORM

ORM思想：它是用来解决面向对象的编程语言与关系型数据库之间的映射.ORM它是一种思想,不是具体的框架.

       ORM框架：Hibernate4、TopLink、JDO等.

　　ORM的映射思想：

　　　　类对应表

　　　　对象对应一条数据

　　　　属性对应列名

4.JPA

　　JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。

JPA 与 ORM之间的关系：JPA是sun公司根据ORM思想制订出来的持久化层的规范. (有一套持久化的api)

JPA的实现商：Hibernate4、TopLink、JDO等.

由于JPA出现的时间比Hibernate4晚，学习Hibernate框架时，既要学习Hiberante框架，又要学习JPA.

尽量面向jpa编程，到时底层的ORM框架就可以自由切换.

JDBC: Java DataBase Connection java数据库连接的规范.

JDBC它是sun为各个数据库厂商制订的连接数据库的规范.(有一套连接数据的api，这些api都是接口).

5.核心类

Configuration 配置

   专门负责加载全局的配置文件，产生SessionFactory.

ServiceRegistry 注册

SessionFactory 会话工厂

    它是当前数据库在内存中镜像。一个SessionFactory对应一个数据库，所以SessionFactory只能有一个，当应用一启动就获取SessionFactory,当应用关闭时才关闭SessionFactory.

       它是线程安全的.

       它是创建Session的工厂。

       它底层封装了数据源(连接池)。

       它还有一个可选的二级缓存. (默认是关闭的).

Session 会话

    它是应用程序与持久层进行交互的单线程对象。

       它是线程不安全。

       它存活的时间比较短.(因为它底层封装得是Connection，用完就要关闭).

       它是事务工厂.

       有一个必须开启的一级缓存. (一级缓存永远都是开启的).

Transaction 事务

       JDBC事务(局部事务) : 只能对一个数据库中的表做事务. (web容器) tomcat jetty

       JTA事务(全局事务、分布式事务) : 可以对多个数据库中的表做事务.(EJB容器)

              WebSphere(IBM)、WebLogic(Oracle)、JBoss(jboss)

ConnectionProvider : 数据库连接的提供者

       一般指得是数据源DataSource(连接池).

6.基本使用

注解方式：

新建项目

A.导包

向项目导入以下包：（官网下载的Hibernate项目的lib文件夹下）

B.配置文件src/hibernate.cfg.xml

在官网下载的Hibernate项目中搜索hibernate.cfg.xml，拷贝一个配置文件到src根目录下。

 

<!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>
        <!-- 配置数据库方言，告诉Hibernate4我们用得是什么样的数据库 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <!-- 配置显示SQL语句 -->
        <property name="hibernate.show_sql">true</property>        
        <!-- 配置格式化SQL语句 -->
        <property name="hibernate.format_sql">true</property>    
        <!-- 是否自动建表-->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 配置连接数据库的驱动类 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 配置连接数据库的URL (创建数据库) -->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate?useUnicode=true&amp;characterEncoding=utf8</property>
        <!-- 配置连接数据库的用户名 -->
        <property name="hibernate.connection.username">root</property>
        <!-- 配置连接数据库的密码 -->
        <property name="hibernate.connection.password">root</property>
        <!-- 配置c3p0连接池中最大连接数 -->
        <property name="hibernate.c3p0.max_size">10</property>
        <!-- 配置c3p0连接池中最小连接数 -->
        <property name="hibernate.c3p0.min_size">3</property>
        <!-- 配置持久化类  class是注解方式-->
        <mapping class="com.rong.entity.User"/>
    </session-factory>
</hibernate-configuration>

C.编写实体类

package com.rong.entity;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    private int id;
    private String name;
    private int age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
    
}

D.测试

在本地创建数据库名为hibernate的数据库

CREATE DATABASE hibernate CHARSET utf8;

package com.rong.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.junit.Test;

public class HibernateTest {
    @Test
    public void oneTest(){
        //1.获得SessionFacotry
        Configuration configuration=new Configuration()    // 默认会加载src/hibernate.properties属性文件
                                          .configure();// 默认会加载src/hibernate.cfg.xml
        ServiceRegistry serviceRegistry= new StandardServiceRegistryBuilder()
                                        .applySettings(configuration.getProperties())//把配置信息交给注册
                                        .build();
        SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        //2.获得Session
        Session session = sessionFactory.openSession();
        //3.开启事务
        Transaction transaction = session.beginTransaction();
        //在数据库表操作......
        
        //4.提交事务
        transaction.commit();
        //5.关闭资源
        session.close();
        sessionFactory.close();
    }
}

E.查看数据库

数据库的user表被创建

xml配置文件方式：

A.导包

B.配置文件src/hibernate.cfg.xml

在官网下载的Hibernate项目中搜索hibernate.cfg.xml，拷贝一个配置文件到src根目录下。

<!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>
        <!-- 配置数据库方言，告诉Hibernate4我们用得是什么样的数据库 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <!-- 配置显示SQL语句 -->
        <property name="hibernate.show_sql">true</property>        
        <!-- 配置格式化SQL语句 -->
        <property name="hibernate.format_sql">true</property>    
        <!-- 是否自动建表-->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 配置连接数据库的驱动类 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 配置连接数据库的URL (创建数据库) -->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate?useUnicode=true&amp;characterEncoding=utf8</property>
        <!-- 配置连接数据库的用户名 -->
        <property name="hibernate.connection.username">root</property>
        <!-- 配置连接数据库的密码 -->
        <property name="hibernate.connection.password">root</property>
        <!-- 配置c3p0连接池中最大连接数 -->
        <property name="hibernate.c3p0.max_size">10</property>
        <!-- 配置c3p0连接池中最小连接数 -->
        <property name="hibernate.c3p0.min_size">3</property>
        <!-- 配置持久化类  class是注解方式 resource是映射文件方式-->
        <mapping class="com.rong.entity.User"/>
        <mapping resource="com/rong/entity/xml/Student.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

C.编写实体类

package com.rong.entity.xml;

public class Student {
    private int id;
    private String name;
    private int age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
}

D.配置XXX.hbm.xml文件

　　在官网下载的Hibernate项目中搜索*.hbm.xml，拷贝一个配置文件到该实体类的目录下。如：Student类，xml文件名为Student.hbm.xml

<?xml version="1.0"?>
<!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="com.rong.entity.xml.Student" table="student">
        <id name="id" column="id">
            <generator class="native" />
        </id>
        <property name="name" column="name" />
        <property name="age" column="age" />
    </class>
</hibernate-mapping>

E.测试

　　与注解方式一样。

F.查看数据库

7.Hibernate对象状态

瞬态 ： User user = new User(); 我们程序使用，hibernate不认识

持久化状态：交给hibernate认识。

托管状态：又重新交给应用管理了。

A.查看对象状态

package com.rong.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.junit.Test;

import com.rong.entity.User;

public class HibernateTest {
    @Test
    public void oneTest(){
        //1.获得SessionFacotry
        Configuration configuration=new Configuration()    // 默认会加载src/hibernate.properties属性文件
                                          .configure();// 默认会加载src/hibernate.cfg.xml
        ServiceRegistry serviceRegistry= new StandardServiceRegistryBuilder()
                                        .applySettings(configuration.getProperties())//把配置信息交给注册
                                        .build();
        SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        //2.获得Session
        Session session = sessionFactory.openSession();
        //3.开启事务
        Transaction transaction = session.beginTransaction();
        //在数据库表操作......
        User user=new User();//瞬态
        user.setName("rjl");
        //判断Session的一级缓存中是否包含这个对象。false 是瞬态 true是持久化状态
        System.out.println(session.contains(user));//false
        
        session.save(user);//持久化状态
        System.out.println(session.contains(user));//true
        
        session.clear();//脱管状态
        System.out.println(session.contains(user));//false
        //4.提交事务
        transaction.commit();
        //5.关闭资源
        session.close();
        sessionFactory.close();
    }
}

B.对象持久化状态（存储到数据库）

save与persist的区别：

第一个区别

save方法有返回值,它的返回值是主键id

persist方法没有返回值，调用对象的getId();

第二个区别

save方法：它会立即往数据库表中插入数据,马上生成insert语句

persist方法：他会延迟往数据库表中插入数据。跟事务是否开启有关。

注意：在事务开启后执行两个方法做添加都会立即生成sql语句。

package com.rong.test;

import java.io.Serializable;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.junit.Test;

import com.rong.entity.User;

public class HibernateTest {
    @Test
    public void oneTest(){
        //1.获得SessionFacotry
        Configuration configuration=new Configuration()    // 默认会加载src/hibernate.properties属性文件
                                          .configure();// 默认会加载src/hibernate.cfg.xml
        ServiceRegistry serviceRegistry= new StandardServiceRegistryBuilder()
                                        .applySettings(configuration.getProperties())//把配置信息交给注册
                                        .build();
        SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        //2.获得Session
        Session session = sessionFactory.openSession();
        //3.开启事务
        Transaction transaction = session.beginTransaction();
        //在数据库表操作......
        User user=new User();//瞬态
        user.setName("rjl");
        //判断Session的一级缓存中是否包含这个对象。false 是瞬态 true是持久化状态
        System.out.println(session.contains(user));//false
        
/*        user.setId(1);
        Serializable serializable = session.save(user);//持久化状态
        System.out.println(serializable);//save方法返回user的id，返回1
        System.out.println(session.contains(user));//true
*/        
/*        user.setId(2);
        user.setName("kobe");
        session.saveOrUpdate(user);//持久化状态。
                                   //数据库先查询，若不存在该记录id，则插入；否则更新。
        System.out.println(session.contains(user));//true
*/        
/*        user.setId(3);
        session.persist(user);//持久化状态。
        System.out.println(session.contains(user));//true
*/        
        user.setId(4);
        user.setAge(18);
        user.setName("lyr");
        User mergeUser = (User) session.merge(user);
        //user还是瞬态，mergeUser才是持久化状态
        System.out.println(session.contains(user));//false
        System.out.println(session.contains(mergeUser));//true
        
        //4.提交事务
        transaction.commit();
        //5.关闭资源
        session.close();
        sessionFactory.close();
    }
}

C.查询

package com.rong.test;

import java.io.Serializable;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.junit.Test;

import com.rong.entity.User;

public class HibernateTest {
    @Test
    public void oneTest(){
        //1.获得SessionFacotry
        Configuration configuration=new Configuration()    // 默认会加载src/hibernate.properties属性文件
                                          .configure();// 默认会加载src/hibernate.cfg.xml
        ServiceRegistry serviceRegistry= new StandardServiceRegistryBuilder()
                                        .applySettings(configuration.getProperties())//把配置信息交给注册
                                        .build();
        SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        //2.获得Session
        Session session = sessionFactory.openSession();
        //3.开启事务
        Transaction transaction = session.beginTransaction();
        //在数据库表操作......
        
        //get方式通过id获取一条数据
        //立刻发送sql语句查询
        User user1 = (User) session.get(User.class, 3);
        System.out.println(user1);
        
        //load方式通过id获取一条数据
        //load方式延迟加载数据，当使用对象当中的方法或者属性时，就会查询数据库。
        //在使用对象的方法时，必须要保证session没有关闭
        User user2=(User) session.load(User.class, 4);
        System.out.println(user2);
        //4.提交事务
        transaction.commit();
        //5.关闭资源
        session.close();
        sessionFactory.close();
    }
}

D.更新

package com.rong.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.junit.Test;

import com.rong.entity.User;

public class HibernateTest {
    @Test
    public void oneTest(){
        //1.获得SessionFacotry
        Configuration configuration=new Configuration()    // 默认会加载src/hibernate.properties属性文件
                                          .configure();// 默认会加载src/hibernate.cfg.xml
        ServiceRegistry serviceRegistry= new StandardServiceRegistryBuilder()
                                        .applySettings(configuration.getProperties())//把配置信息交给注册
                                        .build();
        SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        //2.获得Session
        Session session = sessionFactory.openSession();
        //3.开启事务
        Transaction transaction = session.beginTransaction();
        //在数据库表操作......
        
        //在持久化状态下，直接修改对象的属性，就会发送update语句更新数据库
        //建议采用此种方式
        User user1=(User)session.get(User.class, 3);//持久化状态
        //user1.setName("rong");
        user1.setAge(16);
        
        //在瞬态状态下更新数据库数据，注意：一定要全部赋值，否则其它属性会为变为默认值。
        User user2=new User();//瞬态
        user2.setId(4);
        user2.setAge(20);
        session.saveOrUpdate(user2);//持久化状态
        //session.update(user2);//持久化状态
        //4.提交事务
        transaction.commit();
        //5.关闭资源
        session.close();
        sessionFactory.close();
    }
}

E.删除

package com.rong.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.junit.Test;

import com.rong.entity.User;

public class HibernateTest {
    @Test
    public void oneTest(){
        //1.获得SessionFacotry
        Configuration configuration=new Configuration()    // 默认会加载src/hibernate.properties属性文件
                                          .configure();// 默认会加载src/hibernate.cfg.xml
        ServiceRegistry serviceRegistry= new StandardServiceRegistryBuilder()
                                        .applySettings(configuration.getProperties())//把配置信息交给注册
                                        .build();
        SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        //2.获得Session
        Session session = sessionFactory.openSession();
        //3.开启事务
        Transaction transaction = session.beginTransaction();
        //在数据库表操作......
        
        //在持久化状态下 直接删除
        User user1=(User) session.get(User.class, 4);//持久化状态
        session.delete(user1);
        
        //在瞬态状态下删除
        User user2=new User();
        user2.setId(0);
        session.delete(user2);
        //4.提交事务
        transaction.commit();
        //5.关闭资源
        session.close();
        sessionFactory.close();
    }
}