hibernate

持久层 框架 hibernate mybatis
orm 框架

1、MAVEN导包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <hibernate.version>4.3.8.Final</hibernate.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.34</version>
    </dependency>
</dependencies>

 

2、建库建表

　　自己写喽

3、创建表的对应类

package com.stevezong.domain;

public class Customer {

    /*
     * CREATE TABLE `cst_customer` ( `cust_id` BIGINT(32) NOT NULL AUTO_INCREMENT
     * COMMENT '客户编号(主键)', `cust_name` VARCHAR(32) NOT NULL COMMENT '客户名称(公司名称)',
     * `cust_source` VARCHAR(32) DEFAULT NULL COMMENT '客户信息来源', `cust_industry`
     * VARCHAR(32) DEFAULT NULL COMMENT '客户所属行业', `cust_level` VARCHAR(32) DEFAULT
     * NULL COMMENT '客户级别', `cust_linkman` VARCHAR(64) DEFAULT NULL COMMENT '联系人',
     * `cust_phone` VARCHAR(64) DEFAULT NULL COMMENT '固定电话', `cust_mobile`
     * VARCHAR(16) DEFAULT NULL COMMENT '移动电话', PRIMARY KEY (`cust_id`) )
     * ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
     */
    private Long cust_id;

    private String cust_name;
    private String cust_source;
    private String cust_industry;
    private String cust_level;
    private String cust_linkman;
    private String cust_phone;
    private String cust_mobile;

    public Long getCust_id() {
        return cust_id;
    }

    public void setCust_id(Long cust_id) {
        this.cust_id = cust_id;
    }

    public String getCust_name() {
        return cust_name;
    }

    public void setCust_name(String cust_name) {
        this.cust_name = cust_name;
    }

    public String getCust_source() {
        return cust_source;
    }

    public void setCust_source(String cust_source) {
        this.cust_source = cust_source;
    }

    public String getCust_industry() {
        return cust_industry;
    }

    public void setCust_industry(String cust_industry) {
        this.cust_industry = cust_industry;
    }

    public String getCust_level() {
        return cust_level;
    }

    public void setCust_level(String cust_level) {
        this.cust_level = cust_level;
    }

    public String getCust_linkman() {
        return cust_linkman;
    }

    public void setCust_linkman(String cust_linkman) {
        this.cust_linkman = cust_linkman;
    }

    public String getCust_phone() {
        return cust_phone;
    }

    public void setCust_phone(String cust_phone) {
        this.cust_phone = cust_phone;
    }

    public String getCust_mobile() {
        return cust_mobile;
    }

    public void setCust_mobile(String cust_mobile) {
        this.cust_mobile = cust_mobile;
    }

    @Override
    public String toString() {
        return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + "]";
    }

}

 

4、编写映射xml文件

<?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">
<!-- 配置表与实体对象的关系 -->
<!-- package属性:填写一个包名.在元素内部凡是需要书写完整类名的属性,可以直接写简答类名了. -->
<hibernate-mapping package="com.stevezong.domain">
    <!-- class元素: 配置实体与表的对应关系的 name: 完整类名 table:数据库表名 -->
    <class name="Customer" table="cst_customer">
        <!-- id元素:配置主键映射的属性 name: 填写主键对应属性名 column(可选): 填写表中的主键列名.默认值:列名会默认使用属性名 
            type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型. 每个类型有三种填法: java类型|hibernate类型|数据库类型 
            not-null(可选):配置该属性(列)是否不能为空. 默认值:false length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度 -->
        <id name="cust_id">
            <!-- generator:主键生成策略(明天讲) -->
            <generator class="native"></generator>
        </id>
        <!-- property元素:除id之外的普通属性映射 name: 填写属性名 column(可选): 填写列名 type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型. 
            每个类型有三种填法: java类型|hibernate类型|数据库类型 not-null(可选):配置该属性(列)是否不能为空. 默认值:false 
            length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度 -->
        <property name="cust_name" column="cust_name">
            <!-- <column name="cust_name" sql-type="varchar" ></column> -->
        </property>
        <property name="cust_source" column="cust_source"></property>
        <property name="cust_industry" column="cust_industry"></property>
        <property name="cust_level" column="cust_level"></property>
        <property name="cust_linkman" column="cust_linkman"></property>
        <property name="cust_phone" column="cust_phone"></property>
        <property name="cust_mobile" column="cust_mobile"></property>
    </class>
</hibernate-mapping>

 

5、编写主配置文件
hibernate.properties 文件中有可用的所有的键值对

<?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>
        <!-- 配置mysql 信息 #hibernate.dialect org.hibernate.dialect.MySQLDialect #hibernate.dialect 
            org.hibernate.dialect.MySQLInnoDBDialect #hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect 
            #hibernate.connection.driver_class com.mysql.jdbc.Driver #hibernate.connection.url 
            jdbc:mysql:///test #hibernate.connection.username gavin #hibernate.connection.password -->
        <!-- 数据库驱动 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 数据库url -->
        <property name="hibernate.connection.url">jdbc:mysql://172.29.12.158:3306/test?useUnicode=true&amp;characterEncoding=utf8</property>
        <!-- 数据库连接用户名 -->
        <property name="hibernate.connection.username">zongxuan</property>
        <!-- 数据库连接密码 -->
        <property name="hibernate.connection.password">zongxuan</property>

        <!-- 数据库方言 不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成. sql99标准: 
            DDL 定义语言 库表的增删改查 DCL 控制语言 事务 权限 DML 操纵语言 增删改查 注意: MYSQL在选择方言时,请选择最短的方言. -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- #hibernate.show_sql true #hibernate.format_sql true -->
        <!-- 将hibernate生成的sql语句打印到控制台 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 将hibernate生成的sql语句格式化(语法缩进) -->
        <property name="hibernate.format_sql">true</property>
        <!-- ## auto schema export 自动导出表结构. 自动建表 #hibernate.hbm2ddl.auto create 
            自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用) #hibernate.hbm2ddl.auto create-drop 
            自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用) #hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据). 
            #hibernate.hbm2ddl.auto validate 校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败. -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 引入orm元数据 路径书写: 填写src下的路径 -->
        <mapping resource="Customer.hbm.xml" />

    </session-factory>

</hibernate-configuration>    

 

6、测试

package t;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import com.stevezong.domain.Customer;

public class TestH {
    @Test
    public void t1() {
        Configuration conf = new Configuration().configure();
        SessionFactory sessionFactry = conf.buildSessionFactory();
        Session session = sessionFactry.openSession();
        Transaction tx = session.beginTransaction();
        Customer c = new Customer();
        c.setCust_name("ICETECH");
        session.save(c);
        tx.commit();
        session.close();
        sessionFactry.close();
    }
}

1、映射文件配置

<!-- 配置表与实体对象的关系 -->
<!-- package属性:填写一个包名.在元素内部凡是需要书写完整类名的属性,可以直接写简答类名了. -->
<hibernate-mapping package="com.stevezong.domain">
    <!-- class元素: 配置实体与表的对应关系的 name: 完整类名 table:数据库表名 -->
    <class name="Customer" table="cst_customer">
        <!-- id元素:配置主键映射的属性 name: 填写主键对应属性名 column(可选): 填写表中的主键列名.默认值:列名会默认使用属性名 
            type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型. 每个类型有三种填法: java类型|hibernate类型|数据库类型 
            not-null(可选):配置该属性(列)是否不能为空. 默认值:false length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度 -->
        <id name="cust_id">
            <!-- generator:主键生成策略 (ps:①assigned：由程序员提供，无类型限制，无法确保唯一性。 ②uuid：由hibernate提供，类型必须是字符型 
                ，能确保唯一性。 ③increment：由hibernate提供，类型必须是数值型，有并发风险。先去数据库表查询表中id最大值：select max(id) 
                from t_user，在该结果的基础上+1。 ⑤sequence：只能用于提供序列支持的数据库，如：oracle。 ⑥native：本地生成策略，依赖数据库特性。） 
                <!-- identity 主键自增 由数据库啦维护至今会，插入时不需要指定主键 -->
            <!-- hilo 高低位算法，主键自增，由hibernate来维护 -->
            -->
            <generator class="native"></generator>
        </id>
        <!-- property元素:除id之外的普通属性映射 name: 填写属性名 column(可选): 填写列名 type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型. 
            每个类型有三种填法: java类型|hibernate类型|数据库类型 not-null(可选):配置该属性(列)是否不能为空. 默认值:false 
            length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度 或者将property中的属性写到column中去，将数据库相关属性单独配置成子元素。 -->
        <property name="cust_name" column="cust_name">
            <!-- <column name="cust_name" sql-type="varchar" ></column> -->
        </property>
        <property name="cust_source" column="cust_source"></property>
        <property name="cust_industry" column="cust_industry"></property>
        <property name="cust_level" column="cust_level"></property>
        <property name="cust_linkman" column="cust_linkman"></property>
        <property name="cust_phone" column="cust_phone"></property>
        <property name="cust_mobile" column="cust_mobile"></property>
    </class>
</hibernate-mapping>

 

2、hibernate 主配置文件

必选

<!-- 数据库驱动 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<!-- 数据库url -->
<property name="hibernate.connection.url">jdbc:mysql://172.29.12.158:3306/test?useUnicode=true&amp;characterEncoding=utf8</property>

<!-- 数据库连接用户名 -->
<property name="hibernate.connection.username">zongxuan</property>

<!-- 数据库连接密码 -->

<property name="hibernate.connection.password">zongxuan</property>
<!-- 数据库方言 不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成. 
sql99标准: 
DDL 定义语言 库表的增删改查 
DCL 控制语言 事务 权限 
DML 操纵语言 增删改查 
注意: MYSQL在选择方言时,请选择最短的方言. 
#hibernate.dialect org.hibernate.dialect.MySQLDialect 默认的 通用语法
#hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect Innodb的 
#hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect    
-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

 

可选

<!-- #hibernate.show_sql true #hibernate.format_sql true -->
<!-- 将hibernate生成的sql语句打印到控制台 -->
<property name="hibernate.show_sql">true</property>

<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<property name="hibernate.format_sql">true</property>

<!-- ## auto schema export 自动导出表结构. 自动建表 
#hibernate.hbm2ddl.auto create 自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用) 
#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用) 
#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据). 
#hibernate.hbm2ddl.auto validate 校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败. 抛出异常
-->
<property name="hibernate.hbm2ddl.auto">update</property>

 

映射文件
路径

<mapping resource="Customer.hbm.xml" />


<?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://172.29.12.158:3306/test?useUnicode=true&amp;characterEncoding=utf8</property>

<property name="hibernate.connection.username">zongxuan</property>

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

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

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

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

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

<mapping resource="Customer.hbm.xml" />

</session-factory>

</hibernate-configuration>

API：
1、Configuration 配置管理类对象
Configuration conf = new Configuration();
配置加载类用于在载主配置 orm元数据加载
>conf.configure();
有四种重载
一般都是用这个空参数的
加载src下的hibernate.cfg.xml 文件
>config.configure(“cn/config/hibernate.cfg.xml”); 加载指定路径下指定名称的主配置文件

config.buildSessionFactory(); 创建session的工厂对象
但是在不同版本的hibernate 获取session工厂的方式不一样了
=========================================================================================
-如果使用的是hibernate4.2之前的版本,那么方法就这么写:

//创建配置对象
Configuration config = new Configuration().configure();
//创建服务注册对象
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
//创建会话工厂对象
sessionFactory = config.buildSessionFactory(serviceRegistry);
//会话对象
session = sessionFactory.openSession();
//开启事务
transaction = session.beginTransaction();

-如果是hibernate4.3之后的版本,那么方法就这么写:
导入包更换:org.hibernate.boot.registry.StandardServiceRegistryBuilder;

//创建配置对象 
Configuration config = new Configuration().configure();
//创建服务注册对象 
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(config .getProperties()).build();
//创建会话工厂对象 
sessionFactory = config.buildSessionFactory(serviceRegistry);
//会话对象 
session = sessionFactory.openSession();
//开启事务 
transaction = session.beginTransaction();

hibernate5之后连上面的包都可以省略了:

//创建配置对象(读取配置文档)
Configuration config = new Configuration().configure();
//创建会话工厂对象
sessionFactory = config.buildSessionFactory();
//会话对象
session = sessionFactory.openSession();
//开启事务
transaction = session.beginTransaction();    

=========================================================================================

2、SessionFactory session的工厂（或者说代表了这个hibernate.cfg.xml配置文件）就一个功能就是创建session对象
sessionfactory 负责保存和使用所有配置信息 消耗内存非常大
属于线程安全的对象设计

SessionFactory buildSessionFactory = configuration.buildSessionFactory();
1. sf.openSession(); 创建一个sesison对象
2. sf.getCurrentSession(); 创建session或取出session对象（这个相对上边功能更强大）获得一个与线程绑定的session对象
3. sf.close（）；关闭工厂方法

 

3、Session
表达hibernate 框架和数据库之间的连接会话 session类 核心对象

4、Transaction 事物对象

Transaction tx = session.getTransaction();
//开启事物并获得操作事物的对象（）一般用这个
Transaction tx = session.beginTransaction();
tx.commit() 提交事务
tx.rollback() 回滚事务

5、增

Customer c = new Customer();
c.setCust_name("ICETECH");
session.save(c);

6、查
通过id

Customer customer = (Customer) session.get(Customer.class, 1l);
System.out.println(customer);

7、改 先查到转成对象 set属性 在updata

Customer customer = (Customer) session.get(Customer.class, 1l);
customer.setCust_name("Stevezong");
session.update(customer);

8、删 先查到 

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

 

hibernate中的实体规则
实体类创建的注意事项
1.持久化类提供无参数构造
2.成员变量私有,提供共有get/set方法访问.需提供属性
3.持久化类中的属性,应尽量使用包装类型
4.持久化类需要提供oid.与数据库中的主键列对应 ***********
5.不要用final修饰class
hibernate使用cglib代理生成代理对象.代理对象是继承被代理对象.如果被final修饰.将无法生成代理.
主键类型
自然主键(少见)
表的业务列中,有某业务列符合,必须有,并且不重复的特征时,该列可以作为主键使用.
代理主键(常见)
表的业务列中,没有某业务列符合,必须有,并且不重复的特征时,创建一个没有业务意义的列作为主键
主键生成策略
代理主键
identity : 主键自增.由数据库来维护主键值.录入时不需要指定主键.
sequence: Oracle中的主键生成策略.
increment(了解): 主键自增.由hibernate来维护.每次插入前会先查询表中id最大值.+1作为新主键值.
hilo(了解): 高低位算法.主键自增.由hibernate来维护.开发时不使用.
native:hilo+sequence+identity 自动三选一策略.
uuid: 产生随机字符串作为主键. 主键类型必须为string 类型.
自然主键
assigned:自然主键生成策略. hibernate不会管理主键值.由开发人员自己录入.


hibernate中的对象状态
对象分为三种状态
瞬时状态
没有id,没有在session缓存中
持久化状态
有id,在session缓存中
游离|托管状态
有id,没有在session缓存中
三种状态的转换图


hibernate进阶-一级缓存
缓存:提高效率.hibernate中的一级缓存也是为了提高操作数据库的效率.
提高效率手段1:提高查询效率
缓存
提高效率手段2:减少不必要的修改语句发送
快照


hibernate中的事务
事务
事务特性
a 原子性
c 一致性
i 隔离性
d 持久性
事务并发问题
1.脏读
2.不可重复度
3.幻|虚读
事务的隔离级别
读未提交- 123
读已提交 - 23
可重复读(mysql默认级别)-3
串行化 - 没有问题
知识点:如何在hibernate中指定数据库的隔离级别
## specify a JDBC isolation level
#hibernate.connection.isolation 4
1,2,4,8
0001 1 读未提交
0010 2 读已提交
0100 4 可重复读
1000 8 串行化
<property name="hibernate.connection.isolation">4</property>

知识点2:在项目中如何管理事务
业务开始之前打开事务,业务执行之后提交事务. 执行过程中出现异常.回滚事务.
在dao层操作数据库需要用到session对象.在service控制事务也是使用session对象完成. 我们要确保dao层和service层使用的使用同一个session对象
在hibernate中,确保使用同一个session的问题,hibernate已经帮我们解决了. 我们开发人员只需要调用sf.getCurrentSession()方法即可获得与当前线程绑定的session对象
注意1: 调用getCurrentSession方法必须配合主配置中的一段配置
<!-- 指定session 与当前线程绑定-->
<property name="current_session_context_class">thread</property>
注意2:通过getCurrentSession方法获得的session对象.当事务提交时,session会自动关闭.不要手动调用close关闭.
crm项目中
Service层

public class CustomerServiceImpl implements CustomerService {
public void save(Customer customer) {
CustomerDao dao = new CustomerDaoImpl();
//在servier 层打开事物
Transaction transaction = HibernateUtils.getCurrentSession().beginTransaction();
try {
dao.save(customer);
} catch (Exception e) {
e.printStackTrace();
//回滚事物
transaction.rollback();
}
//提交事物
transaction.commit();
}
}

Dao层

public class CustomerDaoImpl implements CustomerDao {
public void save(Customer customer) {
//获得session
Session session = HibernateUtils.getCurrentSession();
//保存
session.save(customer);
}
}

hibernate中的批量查询(概述)
HQL查询-hibernate Query Language(多表查询,但不复杂时使用)
Hibernate独家查询语言,属于面向对象的查询语言
String hql = "select * from 对象的完整类名";
基本查询

    @Test
    public void t4() {
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        //输入HQL语句
        String hql = "from com.stevezong.domain.Customer";
        //根据HQL语句创建查询对象
        Query query = session.createQuery(hql);
        //根据查询对象获得查询结果 list 是多个 uniqueResult 单个
        List<Customer> customers = query.list();
        System.out.println(customers);
        //Customer customer = (Customer) query.uniqueResult();
        tx.commit();
        session.close();
    }

    @Test
    public void t4() {
        Session session = HibernateUtils.openSession();
        Transaction tx = session.beginTransaction();
        //输入HQL语句
        String hql = "from com.stevezong.domain.Customer where cust_id=2";
        //根据HQL语句创建查询对象
        Query query = session.createQuery(hql);
        //根据查询对象获得查询结果 list 是多个 uniqueResult 单个
        //List<Customer> customers = query.list();
        //System.out.println(customers);
        Customer customer = (Customer) query.uniqueResult();
        System.out.println(customer);
        tx.commit();
        session.close();
    }

条件查询
?号占位符

@Test
public void t4() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //输入HQL语句
    String hql = "from com.stevezong.domain.Customer where cust_id=?";
    //根据HQL语句创建查询对象
    Query query = session.createQuery(hql);
    //设置参数 index 从0开始 jdbc是从1（注意）
    //query.setLong(0, 2L);
    // 万能 不需要制定类型 自动转换
    query.setParameter(0, 2L);
    //根据查询对象获得查询结果 list 是多个 uniqueResult 单个
    //List<Customer> customers = query.list();
    //System.out.println(customers);
    Customer customer = (Customer) query.uniqueResult();
    System.out.println(customer);
    tx.commit();
    session.close();
}    

 

命名占位符

@Test
public void t4() {
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//输入HQL语句
String hql = "from com.stevezong.domain.Customer where cust_id= :id";
//根据HQL语句创建查询对象
Query query = session.createQuery(hql);
//设置参数 index 从0开始 jdbc是从1（注意）
//query.setLong(0, 2L);
// 万能 不需要制定类型 自动转换
//query.setParameter(0, 2L);
//命名占位符 :名字
query.setParameter("id", 2l);
//根据查询对象获得查询结果 list 是多个 uniqueResult 单个
//List<Customer> customers = query.list();
//System.out.println(customers);
Customer customer = (Customer) query.uniqueResult();
System.out.println(customer);
tx.commit();
session.close();
}

 

分页查询

@Test
public void t4() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //输入HQL语句
    String hql = "from com.stevezong.domain.Customer ";
    //根据HQL语句创建查询对象
    Query query = session.createQuery(hql);
    //设置参数 index 从0开始 jdbc是从1（注意）
    //query.setLong(0, 2L);
    // 万能 不需要制定类型 自动转换
    //query.setParameter(0, 2L);
    //命名占位符 :名字
    //query.setParameter("id", 2l);
    //起始位置 和limit一致
    query.setFirstResult(0);
    //查询多少
    query.setMaxResults(2);
    //根据查询对象获得查询结果 list 是多个 uniqueResult 单个
    List<Customer> customers = query.list();
    System.out.println(customers);
    //Customer customer = (Customer) query.uniqueResult();
    //System.out.println(customer);
    tx.commit();
    session.close();
}

 

Criteria查询(单表条件查询)
Hibernate自创的无语句面向对象查询
基本查询

@Test
public void t5() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //查询所有的customer对象
    Criteria criteria = session.createCriteria(Customer.class);
    //结果为多个
    List<Customer> criterias = criteria.list();
    //结果为1个
    Customer Customer = (Customer) criteria.uniqueResult();
    tx.commit();
    session.close();
}

 

条件查询
> gt
>= ge
< lt
<= le
== eq
!= ne
in in
between and between
like like
is not null isNotNull
is null isNull
or or
and and

@Test
public void t5() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //查询所有的customer对象
    Criteria criteria = session.createCriteria(Customer.class);
    // 添加查询参数 查询cuts_id 为1 的
    criteria.add(Restrictions.eq("cust_id", 2l));
    //结果为多个
    //List<Customer> criterias = criteria.list();
    //结果为1个
    Customer customer = (Customer) criteria.uniqueResult();
    System.out.println(customer);
    tx.commit();
    session.close();
}

分页 查询

@Test
public void t5() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //查询所有的customer对象
    Criteria criteria = session.createCriteria(Customer.class);
    // 添加查询参数 查询cuts_id 为1 的
    //criteria.add(Restrictions.eq("cust_id", 2l));
    //分页查询
    criteria.setFirstResult(0);
    criteria.setMaxResults(2);
    //结果为多个
    List<Customer> criterias = criteria.list();
    System.out.println(criterias);
    //结果为1个
    //Customer customer = (Customer) criteria.uniqueResult();
    //System.out.println(customer);
    tx.commit();
    session.close();
}

设置查询总记录数(聚合函数)

@Test
public void t5() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //查询所有的customer对象
    Criteria criteria = session.createCriteria(Customer.class);
    //设置查询的聚合函数 》》 总行数
    criteria.setProjection(Projections.rowCount());
    Long count = (Long) criteria.uniqueResult();
    System.out.println(count);
    // 添加查询参数 查询cuts_id 为1 的
    //criteria.add(Restrictions.eq("cust_id", 2l));
    //分页查询
    //criteria.setFirstResult(0);
    //criteria.setMaxResults(2);
    //结果为多个
    //List<Customer> criterias = criteria.list();
    //System.out.println(criterias);
    //结果为1个
    //Customer customer = (Customer) criteria.uniqueResult();
    //System.out.println(customer);
    tx.commit();
    session.close();
}

原生SQL查询(复杂的业务查询)
基本查询
返回数组List

@Test
public void t6() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    String sql = "SELECT * FROM cst_customer";
    SQLQuery query = session.createSQLQuery(sql);
    List<Object[]> list= query.list();
    for(Object[] sub: list) {
    System.out.println(Arrays.toString(sub));
    }
    
    tx.commit();
    session.close();
}

返回对象List

@Test
public void t6() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    String sql = "SELECT * FROM cst_customer";
    SQLQuery query = session.createSQLQuery(sql);
    //制定将结果集封装到那个对象中
    query.addEntity(Customer.class);
    List<Customer> list= query.list();
    for(Customer sub: list) {
    System.out.println(sub);
    }
    tx.commit();
    session.close();
}

条件查询

@Test
public void t6() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    String sql = "SELECT * FROM cst_customer WHERE cust_id=?";
    SQLQuery query = session.createSQLQuery(sql);
    query.setParameter(0, 2L);
    //制定将结果集封装到那个对象中
    query.addEntity(Customer.class);
    List<Customer> list= query.list();
    for(Customer sub: list) {
    System.out.println(sub);
    }
    tx.commit();
    session.close();
}

 

分页查询



一对多|多对一
关系表达
表中的表达
表中的表达
实体中的表达
orm元数据中表达
一对多

<!-- 集合 一对多在配置文件中配置 -->
<!-- name属性 集合属性名 -->
<!-- column属性 外键列名 -->
<!-- class属性 与我关联的对象完整类名 -->
<set name="linkMens">
<key column="lkm_cust_id"></key>
<one-to-many class="LinkMan"/>
</set>
多对一
<!-- 多对一 -->
<!-- name属性 引用属性名 -->
<!-- column属性 外键列名 -->
<!-- class属性 与我关联的对象完整类名 -->
<many-to-one name="customer" column="lkm_cust_id" class="Customer"></many-to-one>

操作

@Test
public void t7() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    Customer c = new Customer();
    c.setCust_name("ICETECH");
    
    LinkMan l1 = new LinkMan();
    LinkMan l2 = new LinkMan();
    l1.setLkm_name("z");
    l2.setLkm_name("c");
    
    c.getLinkMens().add(l1);
    c.getLinkMens().add(l2);
    
    l1.setCustomer(c);
    l2.setCustomer(c);
    
    session.save(c);
    session.save(l1);
    session.save(l2);
    
    tx.commit();
    session.close();
}

 

@Test
//增加
public void t8() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    Customer c = (Customer) session.get(Customer.class, 1l);
    LinkMan lm = new LinkMan();
    lm.setLkm_name("w");
    lm.setCustomer(c);
    c.getLinkMens().add(lm);
    session.save(lm);
    tx.commit();
    session.close();
}

@Test
//删除
public void t9() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    Customer c = (Customer) session.get(Customer.class, 1l);
    LinkMan lm = (LinkMan) session.get(LinkMan.class, 3l);
    c.getLinkMens().remove(lm);
    lm.setCustomer(null);
    tx.commit();
    session.close();
}

操作关联属性


进阶操作
级联操作
<!--cascade
save-update 级联保存更新
detele 级联删除
all save-update+delete
-->
在 映射文件的<set name="" cascade="save-update">
结论: 简化操作.一定要用,save-update,不建议使用delete.
关系维护
inverse属性
性能优化 提供关系维护的性能
无论如何放弃，总有一放必须要维护关系
多的一方不能放弃维护关系的 外键字段就在多的一方
在保存时.两方都会维护外键关系.关系维护两次,冗余了.
多余的维护关系语句,显然是客户这一端在维护关系

多对多
关系表达
表中

对象中
orm元数据

<!-- 多对多 -->
<!-- 
name:集合属性名
table: 配置中间表名
key:
column 外键
many-to-many 
class 我与那个类是多对多关系
column 外键 我引用别人的外键列名
-->
<set name="roles" table="sys_user_role">
<key column="user_id"></key>
<many-to-many class="Role" column="role_id"></many-to-many>
</set>

<!-- 在遇到多对多关系，一定要放弃一方维护关系-->
操作
操作关联属性

@Test
//增
public void t11() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    User user = (User) session.get(User.class, 2l);
    Role r =new Role();
    r.setRole_name("CEO");
    user.getRoles().add(r);
    session.save(r);
    tx.commit();
    session.close();
}

@Test
//删
public void t12() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    User user = (User) session.get(User.class, 2l);
    Role r =(Role) session.get(Role.class, 3l);
    r.setRole_name("CEO");
    user.getRoles().remove(r);
    tx.commit();
    session.close();
}

操作进阶
inverse属性

级联属性

HQL 操作

@Test
//排序
public void t13() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //排序
    String sql = "from Customer order by cust_id desc";
    Query query = session.createQuery(sql);
    List<Customer> list = query.list();
    System.out.println(list.size());
    System.out.println(list);
    tx.commit();
    session.close();
}

@Test
//条件
public void t13() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //排序
    //String sql = "from Customer order by cust_id desc";
    //条件1
    //String sql = "from Customer where cust_id=?";
    String sql = "from Customer where cust_id= :id";
    Query query = session.createQuery(sql);
    //条件1
    //query.setParameter(0, 6L);
    query.setParameter("id", 6L);
    List<Customer> list = query.list();
    System.out.println(list.size());
    System.out.println(list);
    tx.commit();
    session.close();
}

@Test
//分页
public void t13() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //排序
    //String sql = "from Customer order by cust_id desc";
    //条件1
    //String sql = "from Customer where cust_id=?";
    //条件2
    //String sql = "from Customer where cust_id= :id";
    //分页
    String sql = "from Customer";
    Query query = session.createQuery(sql);
    //条件1
    //query.setParameter(0, 6L);
    //条件2
    //query.setParameter("id", 6L);
    //分页
    query.setFirstResult(0);
    query.setMaxResults(2);
    List<Customer> list = query.list();
    System.out.println(list.size());
    System.out.println(list);
    tx.commit();
    session.close();
}    

@Test    
//聚合函数
public void t13() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //排序
    //String sql = "from Customer order by cust_id desc";
    //条件1
    //String sql = "from Customer where cust_id=?";
    //条件2
    //String sql = "from Customer where cust_id= :id";
    //分页
    //String sql = "from Customer";
    //统计
    //String sql ="select count(*) from Customer";
    //String sql ="select max(cust_id) from Customer";
    //String sql ="select sum(cust_id) from Customer";
    //String sql ="select avg(cust_id) from Customer";
    String sql ="select min(cust_id) from Customer";
    Query query = session.createQuery(sql);
    //条件1
    //query.setParameter(0, 6L);
    //条件2
    //query.setParameter("id", 6L);
    //分页
    //query.setFirstResult(0);
    //query.setMaxResults(2);
    //统计
    Number number = (Number) query.uniqueResult();
    System.out.println(number);
    //List<Customer> list = query.list();
    //System.out.println(list.size());
    //System.out.println(list);
    tx.commit();
    session.close();
}    

@Test
//投影查询
public void t13() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //投影查询 就是查询属性
    String sql ="select cust_name from Customer";
    Query query = session.createQuery(sql);
    List<String> list = query.list();
    System.out.println(list);
    tx.commit();
    session.close();
}    

@Test
//投影查询
public void t13() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //投影查询 就是查询属性
    //String sql ="select cust_name from Customer";
    String sql ="select cust_id,cust_name from Customer";
    Query query = session.createQuery(sql);
    List<Object[]> list = query.list();
    System.out.println(list);
    tx.commit();
    session.close();
}    

@Test
//投影查询 Customer要有对应的构造器
public void t13() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //投影查询 就是查询属性
    //String sql ="select cust_name from Customer";
    //String sql ="select cust_id,cust_name from Customer";
    String sql ="select new Customer(cust_id,cust_name) from Customer";
    Query query = session.createQuery(sql);
    List<Customer> list = query.list();
    System.out.println(list);
    tx.commit();
    session.close();
    }    


public Customer(Long cust_id, String cust_name) {
    super();
    this.cust_id = cust_id;
    this.cust_name = cust_name;
}    

多表查询

@Test
//连接查询
public void t13() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //投影查询 就是查询属性
    String sql =" from Customer c inner join c.linkMens";
    Query query = session.createQuery(sql);
    List<Object[]> list = query.list();
    for(Object[] sub:list) {
        System.out.println(Arrays.toString(sub));
    }
    tx.commit();
    session.close();
}

 

@Test
//连接查询
public void t13() {
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    //String sql =" from Customer c inner join c.linkMens";
    //迫切内连接
    //迫切就是将内容放到一起
    String sql =" from Customer c inner join fetch c.linkMens";
    Query query = session.createQuery(sql);
    List<Customer> list = query.list();
    for(Customer sub:list) {
        System.out.println(sub);
    }
    tx.commit();
    session.close();
}    

QBC 查询

@Test
//离线查询
public void t13() {
    //web层 组装 sql 将dc 一路向后传到DAO
    DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);
    dc.add(Restrictions.idEq(6L));
    //++++++++++++++++++++++++++++++++++
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();
    Criteria c = dc.getExecutableCriteria(session);
    List list = c.list();
    System.out.println(list);
    tx.commit();
    session.close();
}    

查询优化
类级别查询
get方法:没有任何策略.调用即立即查询数据库加载数据.
load方法: 应用类级别的加载策略

lazy(默认值):true, 查询类时,会返回代理对象.会在使用属性时,根据关联的session查询数据库.加载数据.
lazy:false. load方法会与get方法没有任何区别.调用时即加载数据.
结论:为了提高效率.建议使用延迟加载(懒加载)
注意:使用懒加载时要确保,调用属性加载数据时,session还是打开的.不然会抛出异常

关联级别查询
集合策略

关联属性策略

结论:为了提高效率.fetch的选择上应选择select. lazy的取值应选择 true. 全部使用默认值.
no-session问题解决: 扩大session的作用范围.

批量抓取

转载于:https://www.cnblogs.com/lmdtx/p/9765189.html