Hibernate框架基本使用

时间：2017-1-16 00:36

——什么是Hibernate

Hibernate是一个开放源代码的关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以使用对象编程思维来操作数据库。

Hibernate可以应用在任何使用JDBC的场景，既可以在Java的客户端程序使用，也可以在Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE框架中取代CMP，完成数据持久化的重任。

Hibernate是轻量级JavaEE应用的持久层解决方案，是一个关系数据库ORM框架：
* ORM（Object Relation Mapping），对象关系映射，就是通过将Java对象映射到数据库表，通过操作Java对象，就可以完成对数据表的操作。

Hiernate提供了对关系型数据库的增删改查操作。

流行数据库框架：
      * JPA（Java Persistence API），JPA通过JDK5.0注解或XML描述对象 - 关系表的映射关系（只有接口规范）
      * Hibernate最流行ORM框架，通过对象 - 关系映射配置，可以完全脱离底层SQL。
      * MyBatis是Apache的一个开源项目iBatis，支持普通SQL查询，存储过程和高级映射的优秀持久层框架。
       * Apache DBUtils、SpringMVC、JDBCTemplate

——为什么学习Hibernate

1、Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码

2、Hibernate是一个基于jdbc的主流持久化框架，是一个优秀的orm实现，它很大程度的简化了dao层编码工作

3、Hibernate使用java的反射机制，而不是字节码增强程序类实现透明性

4、Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系

——Hibernate常用版本

Hibernate3.x版本和Hibernate4.x

Hibernate并没有提供日志的实现，所有可以下载slf4j 和 log4j 开发包，整合Hibernate的日志系统到log4j

——Hibernate的日志记录

日志：程序开发中的一些信息。

通常用System.out.println();打印输出。

但是这种方式不好：
* 如果输出内容比较多，并且项目已经开发完毕，不想使用输出，那么需要修改源代码。

Hibernate中使用slf4j技术。
slf4j并不是记录日志的工具，而是用于服务其它日志的系统。

在企业中最常用的日志记录工具：log4j
log4j才是一个具体的日志记录工具。

Log4J的日志级别:

        * fatal(致命的)
      * error(普通错误)
*   warn(警告)
*   info(信息)
*   debug(调试)
*   trace(堆栈信息).

Log4J的三个组件:

记录器（Loggers）

* 格式：记录器 = 级别, 输出源1 , 输出源2

* log4j.rootLogger=info, stdout

输出源（Appenders）

* log4j.appender.stdout=org.apache.log4j.ConsoleAppender：控制台进行输出.

* log4j.appender.file=org.apache.log4j.FileAppender：向文件进行输出.

布局（Layouts）

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

log4j配置文件：

### direct log messages to stdout ###

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Target=System.err

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###

log4j.appender.file=org.apache.log4j.FileAppender

log4j.appender.file.File=c\:mylog.log

log4j.appender.file.layout=org.apache.log4j.PatternLayout

log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info, stdout, file

示例代码：
public class Log4jDemo {

private Logger logger = Logger.getLogger(this.getClass());

@Test

public void fun() {

logger.fatal("致命错误");

logger.error("普通错误");

logger.warn("警告");

logger.info("普通信息");

logger.debug("调试信息");

logger.trace("堆栈信息");

}

——Hibernate快速入门

1、下载Hibernate的开发工具
下载地址：http://sourceforge.net/projects/hibernate/files/hibernate3/

2、Hibernate框架目录结构
* documentation
      存放Hibernate文档
* lib
      存放Hibernate开发jar包
      > bytecode
          操作字节码的jar包
      > jpa
          Hibernate的实现JPA规范
      > optional
          开发Hibernate的可选jar包
      > required
          开发Hibernate必须jar包
* project
      提供的测试示例工程

3、创建一个工程（Java工程）
1）导入jar包
      * 核心jar包
          解压根目录下：hibernate3.jar
      * 解压目录下：
            lib/required/*.jar
      * 引入JPA规范
            解压目录下：lib/jpa/hibernate-jpa-2.0-api-1.0.1.Final.jar
      * 导入日志记录包：
          log4j.jar
          slf4j.jar
      * 导入数据库驱动

        antlr-2.7.6.jar：
          一个语言转换工具，Hibernate利用它实现HQL到SQL的转换。
        commons-collections-3.1.jar：
      collections Apache 的工具集,用来增强Java对集合的处理能力

dom4j-1.6.1.jar：
dom4j XML 解析器

hibernate-jpa-2.0-api-1.0.1.Final.jar：
JPA 接口开发包

javassist-3.12.0.GA.jar：
代码生成工具, Hibernate用它在运行时扩展 Java类

jta-1.1.jar：
标准的 JAVA 事务（跨数据库）处理接口

slf4j-api-1.6.1.jar：
hibernate使用的一个日志系统

4、创建表（关系型数据库）
create database hibernate3_day01;

use hibernate3_day01;

create table customer(

id int primary key auto_increment,

name varchar(20),

age int

);

5、创建实体类（面向对象）

/**

* 实体类对象

* @author WYC

public class Customer {

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;

}

6、创建ORM的映射

映射文件只要是XML格式文件就可以，名字可以任意。
通常情况下映射文件与实体类在同包下。
名称规范：
实体类名称.hbm.xml

在XML文件中引入约束：
在hibernate3.jar/org.hibernate.hibernate-mapping-3.0.dtd

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

示例代码：
----------------------------------------------------------------------------------------------------------------------------
<?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>

</id>

<!--

type的三种写法

* Java类型：java.lang.String

* Hibernate类型：string

* SQL类型：不能直接使用type属性，需要使用子标签<column>

> <property name=""><column name="" sql-type="varchar(20)"/></property>

通常使用Hibernate类型。

可以不写type，Hibernate会自动完成类型转换

-->

</class>

</hibernate-mapping>

----------------------------------------------------------------------------------------------------------------------------

7、创建Hibernate的核心配置文件
配置Hibernate连接的数据库等信息。

在src下创建一个配置文件：
hibernate.cfg.xml

在XML文件中引入约束：
Hibernate核心包下：/org/hibernate/hibernate-configuration-3.0.dtd

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

示例代码：

----------------------------------------------------------------------------------------------------------------------------

<?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:///hibernate3_day01</property>

<property name=hibernate.connection.password">Admin123</property>

<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

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

              
                <property name="hibernate.connection.autocommit">false</property>

<property name="hibernate.hbm2ddl.auto">update</property>

</session-factory>

</hibernate-configuration>

----------------------------------------------------------------------------------------------------------------------------

8、编写测试
向数据库中插入一条记录。

session.save(Object obj);

示例代码：

import java.util.List;

import org.hibernate.Criteria;

import org.hibernate.Query;

import org.hibernate.SQLQuery;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.criterion.Restrictions;

import org.junit.Test;

/**

* Hibernate入门案例测试

* @author WYC

public class HibernateDemo1 {

@Test

public void fun(){

* 1、使用Hibernate框架加载核心配置文件，获取连接信息。

Configuration config = new Configuration().configure();

* 2、创建连接池SessionFactory，可以获得Session（相当于Connection）

SessionFactory factory = config.buildSessionFactory();

* 3、获得Session对象

Session session = factory.openSession();

* 4、默认情况下事务是不会自动提交的

// 开启事务

Transaction tx = session.beginTransaction();

* 5、业务逻辑操作

// 向数据库中插入一条记录

Customer customer = new Customer();

customer.setName("张三");

customer.setAge(20);

session.save(customer);

* 7、提交事务

tx.commit();

* 8、释放资源

session.close();

factory.close();

}

9、Java - Hibernate - SQL类型对应关系

——Hibernate的CRUD操作

1、插入数据
session.save(customer);

2、根据主键进行查询：
Customer customer = (Customer)session.get(Customer.class, 1);

Customer customer = (Customer)session.load(Customer.class, 1);

示例代码：

public void fun2(){

* 1、加载Hibernate配置文件

* 2、创建SessionFactory

* 3、通过工厂创建Session对象

* 4、开启事务

* 5、逻辑操作

* 6、提交事务

* 7、释放资源

Configuration config = new Configuration().configure();

SessionFactory factory = config.buildSessionFactory();

Session session = factory.openSession();

Transaction tx = session.beginTransaction();

* 根据id进行查询

// get()方法

Customer customer = (Customer)session.get(Customer.class, 1);

// load()方法

// Customer customer = (Customer)session.load(Customer.class, 1);

// System.out.println(customer);

tx.commit();

session.close();

factory.close();

}

get()方法和load()方法的区别：
      1）发送SQL的时间不同
          * load()方法采用了一个延时加载的技术（懒加载），load()方法在调用时并没有发送SQL语句，而是在使用对象属性时才会发送一条SQL语句。
          * get()方法采用的是立即检索，当执行session.get()方法的时候立即发送SQL语句。
          * load()更优化

      2）返回的对象不同
          * load()方法返回的是一个代理对象（javassist包生成），可以通过断点查看。
          * get()方法返回的是真实对象本身。

      3）当查询数据不存在时
          * load()方法会抛出ObjectNotFoundException异常。
          * get()方法会返回null，如果调用方法会出现空指针异常。

3、修改操作

session.update(Object obj)

修改有两种方式：
* 手动创建对象修改
* 先查询再修改

// 修改记录

public void fun3(){

* 1、加载核心配置文件

* 2、创建Session工厂

* 3、通过工厂创建Session对象

* 4、开启事务

* 5、逻辑操作

* 6、提交事务

* 7、释放资源

Configuration config = new Configuration().configure();

SessionFactory factory = config.buildSessionFactory();

Session session = factory.openSession();

Transaction tx = session.beginTransaction();

* 有两种方式可以进行修改

* * 手动创建对象的方式

* * 先查询再修改的方式

// Customer customer = new Customer();

// customer.setId(2);

// customer.setName("李四");

* 当被修改对象不设置age等属性时，则会采用默认值的形式：0

* 所以在定义属性时不要使用基本数据类型，因为基本数据类型的默认值是0

* 而是使用包装类，因为包装类的默认值是null

// session.update(customer);

* 先查询再修改的方式

Customer customer = (Customer)session.get(Customer.class, 2);

customer.setName("王五");

session.update(customer);

tx.commit();

session.close();

factory.close();

}

4、删除记录

session.delete(Object obj)

删除有两种方式：
* 手动创建对象删除
* 先查询再删除

如果想要进行级联删除，则必须先查询再删除。

// 删除操作

public void fun4(){

Configuration config = new Configuration().configure();

SessionFactory factory = config.buildSessionFactory();

Session session = factory.openSession();

Transaction tx = session.beginTransaction();

* 有两种删除方式：

* * 手动创建对象的方式

* * 先查询再删除的方式

// Customer customer = new Customer();

// customer.setId(3);

// session.delete(customer);

Customer customer = (Customer)session.get(Customer.class, 6);

session.delete(customer);

tx.commit();

session.close();

factory.close();

}

——查询操作

1、HQL查询
Hibernate Query Language。
Hibernate的查询语言，只能用于面向对象的查询。

// HQL查询操作

public void fun5(){

Configuration config = new Configuration().configure();

SessionFactory factory = config.buildSessionFactory();

Session session = factory.openSession();

Transaction tx = session.beginTransaction();

// 查询所有客户

// Customer表示一个类，可以不写表名，因为在配置文件中已经完成了映射

// Query query = session.createQuery("from com.wyc.hibernate3.demo1.Customer");

// List<Customer> list = query.list();

// 根据姓名查询客户

// Query query = session.createQuery("from Customer where name = ?");

// setParameter()方法可以不设置值的类型

// query.setParameter(0, "张三");

// List<Customer> list = query.list();

// 为参数起别名

Query query = session.createQuery("from Customer where name = :name");

query.setParameter("name", "张三");

List<Customer> list = query.list();

for(Customer c : list){

System.out.println(c);

}

tx.commit();

session.close();

factory.close();

}

2、QBC查询
Query By Criteria，条件查询。

示例代码：

public void fun6(){

Configuration config = new Configuration().configure();

SessionFactory factory = config.buildSessionFactory();

Session session = factory.openSession();

Transaction tx = session.beginTransaction();

* 使用QBC查询

// Criteria criteria = session.createCriteria(Customer.class);

// List<Customer> list = criteria.list();

* 使用QBC进行条件查询

Criteria criteria = session.createCriteria(Customer.class);

criteria.add(Restrictions.eq("name", "张三"));

List<Customer> list = criteria.list();

for(Customer c : list){

System.out.println(c);

}

tx.commit();

session.close();

factory.close();

}

3、SQL查询

public void fun7(){

Configuration config = new Configuration().configure();

SessionFactory factory = config.buildSessionFactory();

Session session = factory.openSession();

Transaction tx = session.beginTransaction();

* 使用SQL进行查询

// 查询所有记录

// SQLQuery query = session.createSQLQuery("select * from customer");

// // 一个数组表示一条记录

// List<Object[]> list = query.list();

// for(Object[] o : list){

// System.out.println(Arrays.toString(o));

// }

SQLQuery query = session.createSQLQuery("select * from customer");

// 指定封装对象

query.addEntity(Customer.class);

List<Customer> list = query.list();

for(Customer c : list){

System.out.println(c);

}

tx.commit();

session.close();

factory.close();

}

——Hibernate常用配置

1、核心配置
有两种方式进行配置
1）属性文件的配置
      hibernate.properties
      格式：
          key=value
          hibernate.connection.driver_class=com.mysql.jdbc.Driver

      注意：在属性配置文件中无法完成加载映射文件，只能通过手动编码的方式进行加载。
2）XML格式文件配置
      hibernate.cfg.xml

2、配置属性
1）必须属性：
      连接数据库的4个基本参数
          * hibernate.connection.driver_class：数据库驱动程序
          * hibernate.connection.url：数据库URL
          * hibernate.connection.username：数据库用户名
          * hibernate.connection.password：数据库密码

      Hibernate方言：
          * hibernate.dialect：操作数据库方言

2）可选属性：
      hibernate.show_sql：true，会在控制台上输出SQL语句
      hibernate.format_sql：true，格式化控制台输出的SQL语句
      hibernate.connection.autocommit：true，事务是否自动提交
      hibernate.hbm2ddl.auto：
          * create：每次执行时，都会创建一个新的表（如果这个表已经存在，那么将删除该表然后重新创建），一般用于测试。
          * create-drop：每次执行时，都会创建一个新的表，程序执行结束后会将该表删除，一般用于测试，当SessionFactory close()之后才会执行drop操作。
          * update：如果数据库中没有表，则会创建一个新的表，如果该表已存在，会直接使用这个表，当指定字段不存在时，会更新表结构，新添加字段的值默认为null
          * validate：使用原有的表，并且完成校验，校验映射文件中与表配置的字段是否一致，如果不一致，则会报错。

3）映射文件配置
      * 在核心配置文件中配置映射文件：
          <mapping resource="com/wyc/hibernate3/demo1/Customer.hbm.xml" />
      * 需要使用手动编码的方式加载

2、映射文件的配置
主要配置的是ORM，对象和关系表的映射。
1）配置类与表的映射
<class name="com.wyc.hibernate3.demo1.Customer" table="Customer"></class>
      * name：类的完整路径
      * table：表名（可以省略，默认使用类名，不区分大小写，但是类名不能与数据库关键字冲突）

2）配置普通属性与字段的映射
      * <property name="name" column="name" type="string" length="20" />
      * 如果不写length，默认255。
      * type的三个值：
          > Java类型：java.lang.String
          > Hibernate类型：string
          > SQL类型：不能直接使用type属性，需要使用子标签<column>
              <column name="name" sql-type="varchar(20)" />

3）配置唯一标识与主键映射
      * 一个表中只有一个主键
          <id name="类中属性名" column="表中字段名" />
          > 生成策略

      * 复合主键
          必须实现序列化接口
          <composite-id> </composite-id>

4）关联关系

5）命名SQL
      使用的是HQL：
      <query name="findAll">
              from Customer
          </query>

      使用SQL：
          <sql-query name="sqlFindAll">
              select * from Customer
          </sql-query>

——Hibernate核心API

1、Configuration
1）负责管理Hibernate的配置信息，包括如下内容：
      * 加载hibernate.properties和hibernate.cfg.xml
      * 持久化类与数据表的映射关系（*.hbm.xml）

2）创建Configuration的两种方式：
      * 属性文件（hibernate.properties）
          Configuration config = new Configration(); // 手动加载hbm

      * XML文件（hibernate.cfg.xml）
          ConfigURation config = new Configration().configure();
          configure()方法源代码：configure("/hibernate.cfg.xml");
          可以手动指定要加载的XML文件：configure(XML文件名称);

3）加载映射文件
      * 第一种写法：
          configuration.addResource("com/wyc/hibernate3/demo1/Customer.hbm.xml");
      * 第二种写法（要求：映射文件名称要规范，类与映射文件要在同一个包下）
          configuration.addClass(Customer.class);

      通常会将映射文件配置在核心配置文件中，如果要使用properties配置文件，则必须使用这种方法。

2、SessionFactory工厂类
Configuration对象根据当前的配置信息生成SessionFactory对象。
SessionFactory对象中保存了当前数据库配置信息和所有映射关系以及预定义的SQL语句。
SessionFactory对象是线程安全的。
SessionFactory还负责维护Hibernate的二级缓存（Session是一级缓存）。
SessionFactory对象根据数据库信息，维护连接池，创建Session（相当于Connection）对象。

构造SessionFactory很耗费资源，一般情况下一个应用只初始化一个SessionFactory对象。

练习：抽取一个HibernateUtils工具类来提供Session对象。

示例代码：

/**

* Hibernate工具类

* @author WYC

public class HibernateUtils {

private static Configuration config;

private static SessionFactory factory;

static {

config = new Configuration().configure();

factory = config.buildSessionFactory();

}

public static Session openSession(){

return factory.openSession();

}

}

当openSession()方法调用时，就会通过实体类来创建映射的表，前提是在核心配置文件中进行了配置。

3、Session接口
1）相当于JDBC的Connection
2）Session是应用程序与数据库之间交互操作的一个单线程对象，是Hibernate的运作中心。
3）Session是线程不安全的。
4）所有持久化对象必须在Session的管理下才可以进行持久化操作。
5）Session对象有一个一级缓存，显示执行flush之前，所有的持久化操作的数据都换存在Session对象中。
6）持久化类与Session关联起来后就具有了持久化的能力。
7）常用方法：
      *   save()、persist()：增加
          > persist()方法是JPA提供的方法
      *   update()：修改对象
      *   saveOrUpdate()：添加或修改对象
          > 当对象存在时执行修改操作，对象不存在时执行添加操作
      *   delete()：删除对象
      *   get()、load()：根据主键查询对象。
      * createQuery()：创建一个Query接口，编写HQL语句
      * createSQLQuery()：创建一个SQLQuery接口，编写SQL语句
      * createCriteria()：条件查询，会返回一个Criteria接口。

4、Transaction接口
1）代表数据库操作的事务对象
      Transaction transaction = session.beginTransaction();
2）提供事务管理的方法
      * commit()：提交相关联的Session实例
      * rollback()：撤销事务操作
      * wasCommitted()：检察事务是否提交

如果没有开启事务，那么每个Session的操作都相当于一个独立的事务。

5、Query接口
1）Query代表面向对象的一个Hibernate查询操作。
2）session.createQuery()接收的是一个HQL语句。
3）HQL是Hibernate Query Language的缩写，语法很像SQL语法，但是完全面向对象的。
4）使用Query对象步骤：
      * 获得Hibernate Session对象
      * 编写HQL语句
      * 调用session.createQuery()方法创建查询对象
      * 如果HQL语句包含查询条件参数，则调用Query对象的setXxx()方法设置参数
      * 调用Query对象的list()方法，或uniqueResult()方法执行查询
5）Query还包含两个方法，用于控制返回结果
      * setFirstResult(int firstResult)：设置返回结果从第几条开始
      * setMaxResults(int maxResults)：设置本次返回结果记录数
      * 可以使用这两个方法进行分页查询。

HQL入门举例：
      * 以from开头的HQL语句：
            调用list()方法返回List<Customer>，from Customer表示查询Customer表的所有数据。
      * 使用Select关键字：（查询部分对象属性）
          > select name from Customer，返回List<String>
          > select name, age from Customer，返回List<Object[]>
          > select c.name from Customer as c，为Customer实例起别名
      * 使用Where添加条件：
          > from Customer as c where c.age > :age：其中:age是参数
          > from Customer as c where c.age > ?：其中?是参数

6、Criteria接口
1）Criteria接口是Hibernate提供的用于条件查询接口
2）Criteria criteria = session.createCriteria(Customer.class);
3）使用Criteria对象步骤：
      * 获得Hibernate的Session对象
      * 通过Session获得Criteria对象
      * 使用Restrictions的静态方法创建Criteria条件对象
      * 向Criteria对象中添加Criteria查询条件
      * 执行Criteria的list()或uniqueResult()获得结果

——在Hibernate中使用C3P0连接池

1、导入C3P0的jar包

2、在核心配置文件中添加一段配置：

<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>

<!--设定数据库连接的过期时间,以秒为单位,

如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->

——Hibernate持久化对象的配置和操作

1、Hibernate采用普通、传统的Java对象（POJO类），作为持久化类，与数据表进行映射。
2、编写规则：
* 提供一个public的无参构造方法。
* 提供一个标识属性，映射数据表主键字段。
* 所有属性提供public访问控制符的set()/get()方法。
* 标识属性应尽量使用基本数据类型的包装类。
* 不要用final修饰（不能被继承，无法生成代理对象进行优化）
      当无法生成代理对象时，load()方法不会延时加载，会即时打印SQL语句。
3、持久化对象的唯一标识：OID
* Java根据地址区分同一个类的不同对象。
* 关系数据库根据主键区分是否同一条记录
* Hibernate使用OID来建立内存中的对象和数据库记录的对应关系。
* 对象的OID和数据库的表的主键对应，为保证OID的唯一性，应该让Hibernate来为OID赋值。

4、自然主键和代理主键
1）自然主键
      创建一个用户表，用户表中某条记录想要被唯一确定，可以使用身份证号作为主键，身份证号本身就是一个用户的属性，这就叫自然主键。
2）代理主键
      创建一个用户表，用户表中某条记录想要被唯一确定，但没有使用身份证号作为主键，使用一个与用户的任何信息都不相关，只具备标识的作用，这就是代理主键。

尽量使用代理主键。

5、尽量让Hibernate自己维护主键
涉及到主键的生成策略。

——主键的生成策略

1、increment
自动增长，适用于数值类型，而不能使用字符串。
    不是使用数据库的自动增长机制，而是使用Hibernate框架提供的自动增长方式。

* 首先会检查主键的最大值：select max(id) from table
* 然后在最大值的基础上+1
容易出现多线程的问题，不能在集群下使用。

2、identity
自动增长，适用于数值类型，而不能使用字符串。
采用数据库的自动增长的机制。
不适用于Oracle数据库，因为Oracle数据库没有自动增长。

3、sequence
序列，适用于数值类型，而不能使用字符串。
可以应用在Oracle中，MySQL中不能使用。

4、uuid
使用与字符串类型的主键。
使用随机字符串作为主键。

5、native
本地策略。
根据底层数据库自动选择使用identity还是sequence。

6、assigned
Hihernate框架不维护主键，由程序自动生成。

7、foreign
主键来自外表主键。
应用在一对一的关系表中。

——练习

1、搭建Hibernate环境
      > 核心配置文件
      > 映射文件
2、抽取Hibernate工具类
3、CRUD操作

——总结

1、Hibernate框架概述
* 是一个持久层的ORM框架
* ORM：Object Relational Mapping
      > 对象关系映射，将Java中实体对象与关系型数据库中的表建立一种关系，Hibernate中可以通过操作对象的方式，从而操作数据库中的表。
* 常见持久层框架
      > Hibernate
      > MyBatis
      > JPA

2、Hibernate入门
1）下载Hibernate开发包
2）Hibernate开发包目录结构
      * 文档
      * 开发包
          > 操作字节码
          > 必须包
          > 可选包
          > JPA
3）创建一个Java项目，导入相应jar包
4）创建数据库表
5）创建一个实体类
6）映射配置文件
7）核心配置文件
8）测试程序

3、Hibernate的CRUD
1）save()
2）update()
3）delete()
4）get() / load()
      * 区别：
          > get：采用立即检索，马上发送SQL语句。返回的是真实对象。当检索不到数据时会抛出NullPointerException
          > load：采用延迟加载的技术，当真正使用对象的时候，才会发送SQL语句。返回的是代理对象。抛出ObjectNotFoundException

4、Hibernate的配置
* 核心配置
      > 属性文件(properties)
          在src下创建一个hibernate.properties文件
          必须手动加载
      > XML文件
          在src下创建一个hibernate.cfg.xml文件

      必须的配置：
          数据库连接信息
          Hibernate方言

      可选配置：
          显示SQL
          格式化SQL
          hbm2ddl.auto
              create/create-drop/update/validate

映射文件：
            <mapping resource="" />

* 映射配置
      > <class>建立类与表的映射
          name：类的全路径
          table：表名称
      > id
      > property
          name
          column
          type
          length

5、Hibernate核心API
* Configuration
      > 属性文件：
          直接创建
      > XML文件
          new Configuration().configure();

* SessionFactory
      > 维护二级缓存，线程安全的对象
      > 抽取工具类

* Session
      > 维护一级缓存，线程不安全的对象

* Transaction
      > 控制事务
      > 在Hibernate中默认事务不自动提交，每个Session都是一个独立的事务

* Query
* Criteria

6、Hibernate的持久化类的编写
* 无参构造
* 属性提供set() / get()方法
* 属性尽量使用包装类
* 类不要使用final
* 提供唯一标识OID

7、自然主键和代理主键

8、Hibernate主键的生成策略
* increment：线程不安全，不能用于集群
* identity：使用数据库自动增长机制
* sequence：支持序列的数据库，比如Oracle
* uuid
* native：本地策略，根据本地数据库自动选择主键生成策略

Hibernate框架基本使用的更多相关文章

Hibernate框架之Criteria查询和注解（重点☆☆☆☆☆，难点☆☆☆）
写好一篇博客,不是容易的事.原因是:你要给自己以后看的时候,还能看懂,最重要的是当别人看到你的博客文章的时候,也一样很清楚的明白你自己写的东西.其实这也是一种成就感!! 对于每一个知识点,要有必要的解 ...
Hibernate 系列 01 - 框架技术（介绍Hibernate框架的发展由来）
引导目录: Hibernate 系列教程目录本篇导航: 为什么学习框架技术框架的概念主流框架的介绍 1.为什么学习框架技术如何制作一份看上去具有专业水准的PPT文档呢?一个简单的方法就是使用 ...
2.0、Hibernate框架的简单搭建
一.Hibernate:是一个开放源代码的对象关系映射框架,对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句 ...
【Hibernate框架】对象的三种持久化状态
一.综述 hibernate中的对象有三种状态,分别是TransientObjects(瞬时对象).PersistentObjects(持久化对象)和DetachedObjects(托管对象也叫做离线 ...
hibernate框架int和Integer类型区别
hibernate 框架在定义实体时,int类型最好定义为Inttger类型,因为在注入时int是值类型不允许为空.
SSH(Struts2+Spring+Hibernate)框架搭建流程<注解的方式创建Bean>
此篇讲的是MyEclipse9工具提供的支持搭建自加包有代码也是相同:用户登录与注册的例子,表字段只有name,password. SSH,xml方式搭建文章链接地址:http://www.cnblo ...
ECLIPSE/JAVAWEB （二）三大框架之Hibernate框架持续更新中...
(一)发展历史在Struts框架中使用jdbc连接来读写数据库,我们最常见的就是打开数据库连接.使用复杂的sql语句进行读写.关闭连接,获得的数据又需要转换或封装后往外传,这是一个非常繁琐的过程. ...
Hibernate框架简单应用
Hibernate框架简单应用 Hibernate的核心组件在基于MVC设计模式的JAVA WEB应用中,Hibernate可以作为模型层/数据访问层.它通过配置文件(hibernate.proper ...
Hibernate框架(未完待续······)
作为SSH三大框架之一的Hibernate,是用来把程序的Dao层和数据库打交道用的,它封装了JDBC的步骤,是我们对数据库的操作更加简单,更加快捷.利用Hibernate框架我们就可以不再编 ...
Hibernate框架之get和load方法的区别
我们在学习Hibernate框架时,经常会进行修改,删除操作,对于这些操作,我们都应该先加载对象,然后在执行或删除的操作,那么这里Hibernate提供了两种方法按照主键加载对象,也就是我要说的get ...

随机推荐

height设置100%不起作用
详细讲解了原因:http://www.webhek.com/post/css-100-percent-height.html
每天五分钟Go - 变量
变量的声明 1.使用关键词 var 定义,声明后若不赋值,则使用默认值 var 变量名 [变量类型] [=初始值] var a,b,c string var e,f int = 0,1 声明时,如果省 ...
windows上安装python3里没有pip问题，解决办法！
安装python3: 1.下载python:https://www.python.org/downloads/ 2.安装: 3.安装完成进cmd里验证,但发现无pip包所以操作步骤如下: 1.下 ...
Python基础之subprocess
前言 subprocess这个函数很好用,类似于控制台执行,功能很多,今天先介绍subprocess调用exe,并行调用两个或两个以上的exe. Subprocess调用exe 调用exe有几种方式, ...
Vue__npm run build npm run dev
npm run build npm run dev 一.以前一直错的做法以前,git完项目之后就,执行1.npm install 2.npm run build 3.npm run dev.今天ma ...
vant vue 屏幕自适应
手机端 pc端屏幕自适应一.新建 vue.config.js项目目录中没有 vue.config.js 文件,需要手动创建,在根目录中创建 vue.config.js const pxtorem ...
PASS-单组目标值法的样本量计算
临床试验的参数估计中,评价指标有确定的估计目标 ,临床试验目的需通过参数估计(含相应的可信区间估计)的方法证明评价指标不低于目标值时,可根据单组目标值法样本量公式计算. 例:欲证明器械A的诊断准确性非 ...
java小游戏java九宫格
问题来源于吾爱破解https://www.52pojie.cn/thread-1484202-1-1.html 编程目标一:根据下面的"游戏说明",实现该游戏程序,完成响应用户的输 ...
QT常用控件（一）——菜单栏和对话框
引言 QMainWindow 是一个为用户提供主窗口程序的类,包含一个菜单栏(menu bar).多个工具栏(tool bars).多个锚接部件(dock widgets).一个状态栏(status ...
;~ 并发运行的AutoHotkey脚本真机实际测试模板参考20191010.ahk
;~ 并发运行的AutoHotkey脚本真机实际测试模板参考20191010.ahk;~ 2019年10月10日;~ 徐晓亮(aahk6188);~ 操作系统测试环境: Windows 7 专业版 3 ...

Hibernate框架基本使用

Hibernate框架基本使用的更多相关文章

随机推荐

热门专题