hibernate:ormapping 对象关系映射
jdbc:面向sql语句
hibernate:面向对象
jdbc缺点:
1、写sql语句比较繁琐
2、把sql语句的操作封装成面向对象的操作比较麻烦
3、关闭资源的操作特别繁琐
4、查询的操作代码太多(冗余太多)
5、没有做到数据的缓存(向数据库频繁的要数据,性能很差)
6、sql语句的移植性太差(存储过程、触发器)
jdbc优点:
1、有连接池,所以获取connection的速度更快了
2、最低层的数据库的操作
hibernate:
优点:
1、面向对象的操作
2、关闭资源操作很简单
3、查询变得很简单了
4、一级缓存、二级缓存、查询缓存
5、移植性很好
缺点:
1、sql语句是由hibernate内部生成的,如果要对sql语句做优化,几乎不能
2、如果一张表中的数据集达到千万级别,hibernate不适合
总结:hibernate适合一些中小型的项目开发
hibernate学习
1、完成crud
2、一对多、多对多的关系怎么样转变成hibernate的面向对象的操作
3、hibernate的hql语句:类似于sql语句
4、性能的问题
1、延迟加载
2、数据缓存
3、抓取策略
5、二级缓存(不是重点,面试重点)
hibernate的组成部分:
1、持久化类
2、映射文件:描述了表到类的映射关系
3、hibernate的配置文件:用于产生链接的
1、导包
2、写bean
3、导入配置文件 bean名.hbm.xml(详细看源文件)
<hibernate-mapping>
<!--
class是用来描述一个持久化类
name属性就是累的全名
table表明如果不写,默认就是类名
catalog数据库的名称 一般不写
-->
<class name="" table="" catalog="">
<!--
id代表标示符属性
name为属性呢的名称 提示来自于属性
column表中的列名 默认就是属性的名称
length指的是数据中的类型长度,如果不写,默认最大长度
<id name="pid" column="pid" length="5" [type=""]>
<!--
generator 主键的产生机制
-->
<generator class="increment"></generator>
</id>
<property name="pname" length="20" [type=""]></property>
<property name="sex" length="5" [type=""]></property>
</class>
4、导入hibernate.cfg.xml并配置
5、类实现
1、加载解析配置文件
默认方法:Configuration configuration = new Configuration();
configuration.configure()-->configure("/hibernate.cfg.xml");-->配置文件放在src下
按名称:Configuration configuration = new Configuration();
configuration.configure("")-->configure(String path);
2、连接数据库,动态生成表
configuration.buildSessionFactory
SessionFactory:
1、一个SessionFactory只能连接一个数据库
2、配置文件的信息、映射文件的信息会存到sessionFactory中
3、sessionFactory是一个重量级类
4、sessionFactory是一个单例类
5、sessionFactory是线程安全的
3、sessionFactory.optionSession 打开session
4、session.beginTransaction
1、打开事务
2、完成cud的操作
3、commit()
1、添加数据save
Person person = new Person();
person.setPname("老方");
person.setPsex("不详");
session.save(person);
2、更新数据update
*先把数据提取出来
*修改
*更新update
session.get(要取的表,主键的属性值)
Person person = (Person)session.get(Person.class, 1L);
person.setPsex("纯爷们");
session.update(person);
3、删除数据delete
//Person person = (Person)session.get(Person.class, 1L);// Person person = new Person();
//person.setPid(1L);
session.delete(person);
4、查询createQuery
List<Person> personList = session.createQuery("from Person").list();
for(Person person:personList){
}
字段类型的映射
hibernate java类型 sql类型
integer java.lang.Integer int/number
long java.lang.Long long/number
配置的时候写java类型,映射快
详细java类型和hibernate类型对比参照: http://blog.csdn.net/kuyuyingzi/article/details/10012367
id生成器
1、increment,主键类型是数字,不自动增加,由hibernate(先获取max,再加1)自动增加
注意:increment时,不能手动设置id,否则会报错
2、identity,主键类型是数字,由sql自动增加,因此效率比increment高
用increment优点,删除后,id没有断片
3、uuid,企业里面一般用这个
*主键类型是字符串
*由hibernate生成
4、assigned手动指定主键值
持久化状态
1、Person person = new Person();
2、person.setPname("laofng");
3、perso.setPsex("sdf");
4、session.save(person);
5、transaction.commit();
6、session.close();
1,2,3person对象时临时状态的对象
4、person由临时状态转化成持久化状态
5、person也是持久化状态,数据库中相对应的值了
6、session关闭,hibernate与数据库通信断开,变成脱管状态
总结:持久化状态:与数据库有关联和交互,脱管状态,有过交互但停了
session.save(person),如果是新对象则执行insert,如果是更新操作则执行update
session.evict(person)将对象从session中移除,变成脱管状态
session.update(person)变成持久化状态,如果同一个对象进行多个更新,则只更新最近的一个
session.clear()把session中的所有对象全部清空了
注意:
session.save,update,get方法都可以把一个对象变成持久化状态,并都能产生一个副本
如果没有上述方法,session.commit的时候,hibernate会比较session中的副本中的值,不一样才与数据库发生相应交互
hibernate的多表:
一对多:
<set name="students" cascade="save-update" inverse="false">
<key>
<!-- 外键-->
<column name="cid"></column>
</key>
<!-- -->
<one-to-many class="..student"/>
</set>
另一方是多对一,应配置<!-- 引入外键 -->
<many-to-one name="classes" class="..." column="cid" cascade="save-update"></many-to-one>
类配置文件:
<!--
cascade(默认为none)级联:在保存或者更新一个对象的时候保存或者更新级联对象
即session.save(classs)时级联保存set<student>
inverse(默认为false):表示对关系的不维护
true 不维护关系
false 维护关系
default false
表示class是否维护class与student的关系
-->
<set name="students" cascade="save-update" inverse="false">
<key>
<!-- 用来描述class和student的关系-->
<column name="cid"></column>
</key>
<!-- -->
<one-to-many class="..student"/>
</set>
总结:
1、一对多的单项关联,维护关系指的就是发出update语句
2、维护关系的操作,如果update cid=null肯定就是解除关系的操作
如果update cid=4就是建立关系或者更改关系
3、在维护关系的代码中,是通过classes维护关系的,所以应该看classes.hbm.xml文件
4、级联指的是对象和对象之间的操作与关系无关,inverse指的是对象和关系之间的操作与对象无关
多对多:
多对多谁维护关系,效率都一样,都要对第三种表进行操作
多对多维护关系体现在:
1、建立关系指的是在第三张表中插入一行数据
2、解除关系指的是在第三张表中删除一行数据
3、更新数据
执行update语句
先删除,后增加
<set name="students" table="student_course" cascade="save-update">
<key>
<column name="cid"></column>
</key>
<many-to-many class="" column="sid">
</set>
总结:一对多和多对多
1、两边都是可以连通的
2、inverse和cascade
inverse指的是对象与关系的操作(对象与外键的操作)
cascade指的是对象与对象之间的操作(与外键没有关系)
一班默认情况下:
一对多
多的一方维护效率比较高
维护关系指的是发出update语句
update set 关系=null 解除关系
update set 关系=值 建立关系
多对多
哪一方维护都行
维护关系
建立关系:在关系表中插入一行数据 insert
解除关系:在关系表中删除数据 delete
更新关系:在关系表中先删除后增加
3、在客户端session.save/update操作谁,看谁的映射文件
4、在写客户端代码的时候,一定要考虑这几个方面的因素
1、当session执行save/update方法的时候,是否发生对象的关联
2、当session执行save/update方法的时候,是否维护关系
3、发生级联的时候,什么情况下对于级联对象执行save/update操作
4、客户端代码中持久化对象的转换状态:临时状态-持久化
hib ernate性能的提高 :延迟加载、抓取策略、缓存、内连接-外连接
延迟加载:关键词load
懒加载lazy:要配合session.load方法使用
true(默认)
alse
extra;用count/sum/avg等函数计算数值的时候,这个时候并不需要查
1、概念:该加载时加载
2、类型
类的延迟加载
类的基本属性
1、classes = session.load("");
当classes.getCname()、setCname()的时候才发出sql语句
2、<class lazy="false">,取消session.load()的延迟加载
经典错误:
classes = session.load("");
session.close();
classes.getCname();发生no session错误
集合的延迟加载
在关联对象时集合的情况
一对多 多对多
1、students = classes.getStudents();并没有发出sql语句
for(Student student:students){}才发出sql语句
2、<set lazy="false"> 取消集合的延迟加载,获取的时候就发出sql语句
单端关联的延迟加载
通过多的一方加载一的一方的策略
<many-to-one>中lazy的值有
false
proxy 延迟加载
no-proxy
通过多的一方加载一的一方,就一条数据,保持默认值就可以了,不会特别影响效率
抓取策略:关键词createQuery
根据一个对象提取关联对象的策略
抓取策略的情况:
集合的提取
<set fetch="">
fetch
"join"外连接 left outer join
"subselect"子查询:查询效率最高 select+“batch-size"==subselect
后面可跟:session.createQuery("from classes where cid in(1,2)");
"select"默认的
batch-size: 一次性查询出集合的数量
根据多的 一段加载一的一端
说明:
1、如果把雪球分析翻译成sql语句,sql语句存在子查询,这个时候,首选子查询
2、如果没有子查询,但是想把数据一次性的提取出来,这个时候选择”join"
3、如果没有子查询,但是不想把数据一次性提取出来,这个时候选择默认“select”
抓取策略和懒加载结合:结合面试重点内容
lazy fetch sql
true/extra join 采用左外连接,lazy不起作用
false join 采用左外连接
true/extra select 先加载一的一段,再加载多的一端,多的一端在迭代时候加载
false select 在session.get方法时,把集合加载出来了,但是发出两条sql
false select 在session.createQuery时,就已经发出sql语句
session:
1、session的产生方式
2、session的缓存
3、session与实务的关系
openSession:每次执行该方法都会新建一个session;
getCurrentSession的执行过程
1、先从当前线程中查找session
2、如果找到,则直接使用,如果偶找不到执行第三步
3、当事务提交transaction.commit,getCurrestSession中的session会自动关闭
4、需要配置<property name="current_session_context_class">thread</property>(可以通过界面配置)
5、所有的操作必须在事务环境下进行
优点:安全性、自动关闭session
session缓存:一级缓存 私有缓存
1、缓存的生命周期
生命周期开始:当session打开的时候
生命周期结束:session.close(),session为当前线程,则程序执行完以后session自动关闭,缓存结束
2、缓存中数据的安全性
如果是当前线程打开session,session本身在threadLocal中,所以session中的数据时安全的(其他线程访问不到)
3、数据怎么样放入到一级缓存中的
当执行session.get、load、save、update方法时,把对象放入到了一级缓存中
4、怎么样从一级缓存中取出数据
session.get、load取数据
5、怎么样把缓存中的数据同步到数据库中
transaction.commit其实默认执行session.flush
session.flush该语句包含作用:
1、save/update数据
2、有关系,更新关系
3、有级联,更新级联操作
一般配合session.clear()使用
6、怎么样把数据库中的数据同步到缓存中
session.refresh()只能把一个数据同步到缓存中
7、怎么样把一个对象从缓存中移除
session.evict(Object obj)
8、怎么样清空缓存中所有的数据
session.clear();
二级缓存
1、缓存的生命周期
sessionFactory级别:当hibernate容器启动的时候,二级缓存就有了
2、缓存中数据的安全性
*sessionFactory线程安全的
3、二级缓存存在的意义
*提高查询速度
*如果数据更新特别频繁,不适合做二级缓存
*一些重要的数据不能放到二级缓存中
*存放到二级缓存中的数据是不经常改变的,所以hibernate3以上的版本相对于一级缓存,有一些区别:
二级缓存并不建议清除(把一个对象清除获取把所有的对象清除)
*二级缓存分为类的二级缓存和集合的二级缓存,用法一样
4、hibernate本身没有二级缓存,是借助第三方框架来实现的(面试亮点)
5、二级缓存默认是关闭的
6、二级缓存配置
二级缓存的提供商
<property name="cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
开启二级缓存
<property name="cache.use_second_level_cache">true</property>
类级别的二级缓存:usage读取策略
1、在hibernate.cfg.xml<class-cache usage="read-write" class="..'/> 我用着不行哪
2、一般在相应对的映射文件中配置<class name="..">
<cache usage="read-only"/>
不配置就不会放到二级缓存
7、如果利用二级缓存
session.get、session.load方法:把数据拿出来,存到一级缓存和二级缓存
8、当二级缓存中的数据量比较大事,hibernate提供了一种机制,可以在内存缓存一部分数据,另一部分存在磁盘上
ehcache.xml
将缓存放到磁盘的配置文件,必须放在src目录下
需要修改的项目
<diskStore path=""/>
<defaultCache
maxElementsInMemory="12"
maxElementsOnDisk="10000000"
查询缓存:
*查询缓存是建立在二级缓存基础之上的
*查询缓存默认也不是开启的
*打开查询缓存
<property name="cache.use_query_cache">true</property>
*在程序中的用法
Query query= session.createQuery("from Classes")
query.setCacheable(true);//开启查询缓存
query.list();//把数据写入到查询缓存中
query = session.createQuery("from Classes")
query.setCacheable(true);//开启查询缓存
query.list();//从查询缓存中取数据
二级缓存:针对ID的查询缓存
查询缓存:针对数据的查询
session.createQuery("from Classes").list()
session.createQuery().list()与session.createQuery().iterator()方法的区别(面试点)
list:利用查询缓存,不利用一级缓存和二级缓存
iterator:n+1查询
利用一级缓存、二级缓存,不利用查询缓存
hql语句(重点):得到合适的结果集,单表查询尽量用select,多表用fetch
*语法规则:
from持久化类 where 属性
sql语句中的函数count,avg,sum等在hal语句中都适合
order by,group by,having,子查询,in等在hql语句中都适合
投影查询:只查询某些属性
*单表的查询
*select X X from 表,取出来的元素是Object
*如果要求select查出来的是对象元素:select new com.....(类的路径)Classes(X,X) from 表
该中查询方法,要求bean中要有有参构造函数,而且查询的参数个数与构造函数个数一致
*from 表取出来的元素是对象
总结:
1、如果页面上的字段和数据库中的字段的个数差不多,直接”from 持久化类“
2、如果页面上的字段和数据库中的字段相差很多,则利用到构造函数的查询
3、如果是第一种情况,查询出来的Object[]中的顺序和select后的顺序保持一致
迫切内连接:fetct规范取出去的数据
from Student s inner join fetch s.classes c
from Classes c inner join fetch c.students s
from Classes c left outer join fetch c.students s
外连接:可以在条件不成立的时候,仍然可以包含某些不成立的记录
左外连接: 在条件不成立的时候,等号左边的表仍然被包含 left outer join
右外连接: 在条件不成立的时候,等号右边的表仍然被包含 right outer join
总结:无论是内连接还是左外连接,如果查询出来的结构和持久化的结构保持一致,要在join后面加fetch
需求:查询表一的一部分和表二的一部分
需要建一个bean来接收
select new com.....(类的路径)Classes(c.X,s.X) from Classes c inner join c.students s
*关联表的查询
一对多
多对多
一对多和多对多的结合(难点)
关键:找核心表(能同时联系其他的表),表的设计要用星型设计
最终的目的:好取数据
from Student s inner join fetch s.classes inner join fetch s.course
问题:因为内连接用的是笛卡尔积,有重复数据
解决:利用hashset不重复元素原理
Set<Studnet>students = new HashSet<Student>(StudentList);
studentList = new ArrayList<Student>(Students);
jdbc:面向sql语句
hibernate:面向对象
jdbc缺点:
1、写sql语句比较繁琐
2、把sql语句的操作封装成面向对象的操作比较麻烦
3、关闭资源的操作特别繁琐
4、查询的操作代码太多(冗余太多)
5、没有做到数据的缓存(向数据库频繁的要数据,性能很差)
6、sql语句的移植性太差(存储过程、触发器)
jdbc优点:
1、有连接池,所以获取connection的速度更快了
2、最低层的数据库的操作
hibernate:
优点:
1、面向对象的操作
2、关闭资源操作很简单
3、查询变得很简单了
4、一级缓存、二级缓存、查询缓存
5、移植性很好
缺点:
1、sql语句是由hibernate内部生成的,如果要对sql语句做优化,几乎不能
2、如果一张表中的数据集达到千万级别,hibernate不适合
总结:hibernate适合一些中小型的项目开发
hibernate学习
1、完成crud
2、一对多、多对多的关系怎么样转变成hibernate的面向对象的操作
3、hibernate的hql语句:类似于sql语句
4、性能的问题
1、延迟加载
2、数据缓存
3、抓取策略
5、二级缓存(不是重点,面试重点)
hibernate的组成部分:
1、持久化类
2、映射文件:描述了表到类的映射关系
3、hibernate的配置文件:用于产生链接的
4、客户端
*.hbm.xml(映射文件)
建立表到类的映射
1、表明和类名映射
2、表里字段的名称和类中属性的名称映射
3、表里的字段类型和类中的属性类型映射
1、导包
2、写bean
3、导入配置文件 bean名.hbm.xml(详细看源文件)
<hibernate-mapping>
<!--
class是用来描述一个持久化类
name属性就是累的全名
table表明如果不写,默认就是类名
catalog数据库的名称 一般不写
-->
<class name="" table="" catalog="">
<!--
id代表标示符属性
name为属性呢的名称 提示来自于属性
column表中的列名 默认就是属性的名称
length指的是数据中的类型长度,如果不写,默认最大长度
<id name="pid" column="pid" length="5" [type=""]>
<!--
generator 主键的产生机制
-->
<generator class="increment"></generator>
</id>
<property name="pname" length="20" [type=""]></property>
<property name="sex" length="5" [type=""]></property>
</class>
4、导入hibernate.cfg.xml并配置
5、类实现
1、加载解析配置文件
默认方法:Configuration configuration = new Configuration();
configuration.configure()-->configure("/hibernate.cfg.xml");-->配置文件放在src下
按名称:Configuration configuration = new Configuration();
configuration.configure("")-->configure(String path);
2、连接数据库,动态生成表
configuration.buildSessionFactory
SessionFactory:
1、一个SessionFactory只能连接一个数据库
2、配置文件的信息、映射文件的信息会存到sessionFactory中
3、sessionFactory是一个重量级类
4、sessionFactory是一个单例类
5、sessionFactory是线程安全的
3、sessionFactory.optionSession 打开session
4、session.beginTransaction
1、打开事务
2、完成cud的操作
3、commit()
5、关闭session.close();数据库链路断开
1、添加数据save
Person person = new Person();
person.setPname("老方");
person.setPsex("不详");
session.save(person);
2、更新数据update
*先把数据提取出来
*修改
*更新update
session.get(要取的表,主键的属性值)
Person person = (Person)session.get(Person.class, 1L);
person.setPsex("纯爷们");
session.update(person);
3、删除数据delete
//Person person = (Person)session.get(Person.class, 1L);// Person person = new Person();
//person.setPid(1L);
session.delete(person);
4、查询createQuery
List<Person> personList = session.createQuery("from Person").list();
for(Person person:personList){
}
字段类型的映射
hibernate java类型 sql类型
integer java.lang.Integer int/number
long java.lang.Long long/number
配置的时候写java类型,映射快
详细java类型和hibernate类型对比参照: http://blog.csdn.net/kuyuyingzi/article/details/10012367
id生成器
1、increment,主键类型是数字,不自动增加,由hibernate(先获取max,再加1)自动增加
注意:increment时,不能手动设置id,否则会报错
2、identity,主键类型是数字,由sql自动增加,因此效率比increment高
用increment优点,删除后,id没有断片
3、uuid,企业里面一般用这个
*主键类型是字符串
*由hibernate生成
4、assigned手动指定主键值
持久化状态
1、Person person = new Person();
2、person.setPname("laofng");
3、perso.setPsex("sdf");
4、session.save(person);
5、transaction.commit();
6、session.close();
1,2,3person对象时临时状态的对象
4、person由临时状态转化成持久化状态
5、person也是持久化状态,数据库中相对应的值了
6、session关闭,hibernate与数据库通信断开,变成脱管状态
总结:持久化状态:与数据库有关联和交互,脱管状态,有过交互但停了
session.save(person),如果是新对象则执行insert,如果是更新操作则执行update
session.evict(person)将对象从session中移除,变成脱管状态
session.update(person)变成持久化状态,如果同一个对象进行多个更新,则只更新最近的一个
session.clear()把session中的所有对象全部清空了
注意:
session.save,update,get方法都可以把一个对象变成持久化状态,并都能产生一个副本
如果没有上述方法,session.commit的时候,hibernate会比较session中的副本中的值,不一样才与数据库发生相应交互
hibernate的多表:
一对多:
<set name="students" cascade="save-update" inverse="false">
<key>
<!-- 外键-->
<column name="cid"></column>
</key>
<!-- -->
<one-to-many class="..student"/>
</set>
另一方是多对一,应配置<!-- 引入外键 -->
<many-to-one name="classes" class="..." column="cid" cascade="save-update"></many-to-one>
类配置文件:
<!--
cascade(默认为none)级联:在保存或者更新一个对象的时候保存或者更新级联对象
即session.save(classs)时级联保存set<student>
inverse(默认为false):表示对关系的不维护
true 不维护关系
false 维护关系
default false
表示class是否维护class与student的关系
-->
<set name="students" cascade="save-update" inverse="false">
<key>
<!-- 用来描述class和student的关系-->
<column name="cid"></column>
</key>
<!-- -->
<one-to-many class="..student"/>
</set>
总结:
1、一对多的单项关联,维护关系指的就是发出update语句
2、维护关系的操作,如果update cid=null肯定就是解除关系的操作
如果update cid=4就是建立关系或者更改关系
3、在维护关系的代码中,是通过classes维护关系的,所以应该看classes.hbm.xml文件
4、级联指的是对象和对象之间的操作与关系无关,inverse指的是对象和关系之间的操作与对象无关
多对多:
多对多谁维护关系,效率都一样,都要对第三种表进行操作
多对多维护关系体现在:
1、建立关系指的是在第三张表中插入一行数据
2、解除关系指的是在第三张表中删除一行数据
3、更新数据
执行update语句
先删除,后增加
<set name="students" table="student_course" cascade="save-update">
<key>
<column name="cid"></column>
</key>
<many-to-many class="" column="sid">
</set>
总结:一对多和多对多
1、两边都是可以连通的
2、inverse和cascade
inverse指的是对象与关系的操作(对象与外键的操作)
cascade指的是对象与对象之间的操作(与外键没有关系)
一班默认情况下:
一对多
多的一方维护效率比较高
维护关系指的是发出update语句
update set 关系=null 解除关系
update set 关系=值 建立关系
多对多
哪一方维护都行
维护关系
建立关系:在关系表中插入一行数据 insert
解除关系:在关系表中删除数据 delete
更新关系:在关系表中先删除后增加
3、在客户端session.save/update操作谁,看谁的映射文件
4、在写客户端代码的时候,一定要考虑这几个方面的因素
1、当session执行save/update方法的时候,是否发生对象的关联
2、当session执行save/update方法的时候,是否维护关系
3、发生级联的时候,什么情况下对于级联对象执行save/update操作
4、客户端代码中持久化对象的转换状态:临时状态-持久化
hib ernate性能的提高 :延迟加载、抓取策略、缓存、内连接-外连接
延迟加载:关键词load
懒加载lazy:要配合session.load方法使用
true(默认)
alse
extra;用count/sum/avg等函数计算数值的时候,这个时候并不需要查
1、概念:该加载时加载
2、类型
类的延迟加载
类的基本属性
1、classes = session.load("");
当classes.getCname()、setCname()的时候才发出sql语句
2、<class lazy="false">,取消session.load()的延迟加载
经典错误:
classes = session.load("");
session.close();
classes.getCname();发生no session错误
集合的延迟加载
在关联对象时集合的情况
一对多 多对多
1、students = classes.getStudents();并没有发出sql语句
for(Student student:students){}才发出sql语句
2、<set lazy="false"> 取消集合的延迟加载,获取的时候就发出sql语句
单端关联的延迟加载
通过多的一方加载一的一方的策略
<many-to-one>中lazy的值有
false
proxy 延迟加载
no-proxy
通过多的一方加载一的一方,就一条数据,保持默认值就可以了,不会特别影响效率
抓取策略:关键词createQuery
根据一个对象提取关联对象的策略
抓取策略的情况:
集合的提取
<set fetch="">
fetch
"join"外连接 left outer join
"subselect"子查询:查询效率最高 select+“batch-size"==subselect
后面可跟:session.createQuery("from classes where cid in(1,2)");
"select"默认的
batch-size: 一次性查询出集合的数量
根据多的 一段加载一的一端
说明:
1、如果把雪球分析翻译成sql语句,sql语句存在子查询,这个时候,首选子查询
2、如果没有子查询,但是想把数据一次性的提取出来,这个时候选择”join"
3、如果没有子查询,但是不想把数据一次性提取出来,这个时候选择默认“select”
抓取策略和懒加载结合:结合面试重点内容
lazy fetch sql
true/extra join 采用左外连接,lazy不起作用
false join 采用左外连接
true/extra select 先加载一的一段,再加载多的一端,多的一端在迭代时候加载
false select 在session.get方法时,把集合加载出来了,但是发出两条sql
false select 在session.createQuery时,就已经发出sql语句
session:
1、session的产生方式
2、session的缓存
3、session与实务的关系
openSession:每次执行该方法都会新建一个session;
getCurrentSession的执行过程
1、先从当前线程中查找session
2、如果找到,则直接使用,如果偶找不到执行第三步
3、当事务提交transaction.commit,getCurrestSession中的session会自动关闭
4、需要配置<property name="current_session_context_class">thread</property>(可以通过界面配置)
5、所有的操作必须在事务环境下进行
优点:安全性、自动关闭session
session缓存:一级缓存 私有缓存
1、缓存的生命周期
生命周期开始:当session打开的时候
生命周期结束:session.close(),session为当前线程,则程序执行完以后session自动关闭,缓存结束
2、缓存中数据的安全性
如果是当前线程打开session,session本身在threadLocal中,所以session中的数据时安全的(其他线程访问不到)
3、数据怎么样放入到一级缓存中的
当执行session.get、load、save、update方法时,把对象放入到了一级缓存中
4、怎么样从一级缓存中取出数据
session.get、load取数据
5、怎么样把缓存中的数据同步到数据库中
transaction.commit其实默认执行session.flush
session.flush该语句包含作用:
1、save/update数据
2、有关系,更新关系
3、有级联,更新级联操作
一般配合session.clear()使用
6、怎么样把数据库中的数据同步到缓存中
session.refresh()只能把一个数据同步到缓存中
7、怎么样把一个对象从缓存中移除
session.evict(Object obj)
8、怎么样清空缓存中所有的数据
session.clear();
二级缓存
1、缓存的生命周期
sessionFactory级别:当hibernate容器启动的时候,二级缓存就有了
2、缓存中数据的安全性
*sessionFactory线程安全的
3、二级缓存存在的意义
*提高查询速度
*如果数据更新特别频繁,不适合做二级缓存
*一些重要的数据不能放到二级缓存中
*存放到二级缓存中的数据是不经常改变的,所以hibernate3以上的版本相对于一级缓存,有一些区别:
二级缓存并不建议清除(把一个对象清除获取把所有的对象清除)
*二级缓存分为类的二级缓存和集合的二级缓存,用法一样
4、hibernate本身没有二级缓存,是借助第三方框架来实现的(面试亮点)
5、二级缓存默认是关闭的
6、二级缓存配置
二级缓存的提供商
<property name="cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
开启二级缓存
<property name="cache.use_second_level_cache">true</property>
类级别的二级缓存:usage读取策略
1、在hibernate.cfg.xml<class-cache usage="read-write" class="..'/> 我用着不行哪
2、一般在相应对的映射文件中配置<class name="..">
<cache usage="read-only"/>
不配置就不会放到二级缓存
7、如果利用二级缓存
session.get、session.load方法:把数据拿出来,存到一级缓存和二级缓存
8、当二级缓存中的数据量比较大事,hibernate提供了一种机制,可以在内存缓存一部分数据,另一部分存在磁盘上
ehcache.xml
将缓存放到磁盘的配置文件,必须放在src目录下
需要修改的项目
<diskStore path=""/>
<defaultCache
maxElementsInMemory="12"
maxElementsOnDisk="10000000"
查询缓存:
*查询缓存是建立在二级缓存基础之上的
*查询缓存默认也不是开启的
*打开查询缓存
<property name="cache.use_query_cache">true</property>
*在程序中的用法
Query query= session.createQuery("from Classes")
query.setCacheable(true);//开启查询缓存
query.list();//把数据写入到查询缓存中
query = session.createQuery("from Classes")
query.setCacheable(true);//开启查询缓存
query.list();//从查询缓存中取数据
二级缓存:针对ID的查询缓存
查询缓存:针对数据的查询
session.createQuery("from Classes").list()
session.createQuery().list()与session.createQuery().iterator()方法的区别(面试点)
list:利用查询缓存,不利用一级缓存和二级缓存
iterator:n+1查询
利用一级缓存、二级缓存,不利用查询缓存
hql语句(重点):得到合适的结果集,单表查询尽量用select,多表用fetch
*语法规则:
from持久化类 where 属性
sql语句中的函数count,avg,sum等在hal语句中都适合
order by,group by,having,子查询,in等在hql语句中都适合
投影查询:只查询某些属性
*单表的查询
*select X X from 表,取出来的元素是Object
*如果要求select查出来的是对象元素:select new com.....(类的路径)Classes(X,X) from 表
该中查询方法,要求bean中要有有参构造函数,而且查询的参数个数与构造函数个数一致
*from 表取出来的元素是对象
总结:
1、如果页面上的字段和数据库中的字段的个数差不多,直接”from 持久化类“
2、如果页面上的字段和数据库中的字段相差很多,则利用到构造函数的查询
3、如果是第一种情况,查询出来的Object[]中的顺序和select后的顺序保持一致
迫切内连接:fetct规范取出去的数据
from Student s inner join fetch s.classes c
from Classes c inner join fetch c.students s
from Classes c left outer join fetch c.students s
外连接:可以在条件不成立的时候,仍然可以包含某些不成立的记录
左外连接: 在条件不成立的时候,等号左边的表仍然被包含 left outer join
右外连接: 在条件不成立的时候,等号右边的表仍然被包含 right outer join
总结:无论是内连接还是左外连接,如果查询出来的结构和持久化的结构保持一致,要在join后面加fetch
需求:查询表一的一部分和表二的一部分
需要建一个bean来接收
select new com.....(类的路径)Classes(c.X,s.X) from Classes c inner join c.students s
*关联表的查询
一对多
多对多
一对多和多对多的结合(难点)
关键:找核心表(能同时联系其他的表),表的设计要用星型设计
最终的目的:好取数据
from Student s inner join fetch s.classes inner join fetch s.course
问题:因为内连接用的是笛卡尔积,有重复数据
解决:利用hashset不重复元素原理
Set<Studnet>students = new HashSet<Student>(StudentList);
studentList = new ArrayList<Student>(Students);
附录:
小细节1:Hibernate 中 HQL问号与冒号的区别:
在网上搜资料,得到的答案是基本相同,既然是基本相同并不是完全相同,所以肯定有区别。
目前发现的区别就是用了 ? 则用变量的序号来赋值,从0 开始。
如果用了:变量名的则用变量名来赋值。