j2ee开发之hibernate框架学习笔记

hibernate框架技术重点学习笔记

1.针对不同的数据库，有不同的数据库实现类，使其符号对应的数据库？

mysqlDaoImpl oracleDaoImpl ... ...

2.对象和表记录的转换存在着转换问题->orm,对象和关系的一种映射

3.框架：解决一种问题的方案集合！

4..配置文件

Xxx.cfg.xml 主配置文件

xxx.hbm.xml映射文件：

映射基础

普通属性

主键

集合属性

关联关系：一对多多对一多对多一对一

继承结构

5.其他特性：数据库连接池懒加载二级缓存一级缓存

6.hibernnate中主要的API:

configuration :配置对象

Configure()

Configure(String resource)//读取指定位置处的配置文件

AddResource(String Resource)//导入指定位置的配置文件

addClass(Class class) //导入与指定类在同一个包中的以类名为前缀，后缀为.hbm.xml的映射文件

buildSessionFactory：session工厂

sessionFactory：session 工厂

openSession//打开session

getCurrentSession//得到当前的session

Close()//关闭session

session对象：

Save(object) update(object) delete() createQuery() createCriteria()

Transaction事务

Commit() rollback()

Query：查询

List() 查询一个结果集合

uniqueResult() 查询一个唯一的结果只有一个结果就返回没有就返回null 多个就抛异常

7.hibernate.cfg.xml的配置文件：

基础6项：方言+jdbcurl+驱动类+用户名+密码+导入映射文件

<!--

~ Hibernate, Relational Persistence for Idiomatic Java

~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.

~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.

-->

<!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="connection.url">jdbc:mysql://127.0.0.1:3306/myhibernate</property>

<property name="connection.driver_class">com.mysql.jdbc.Driver</property>

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

</session-factory>

</hibernate-configuration>

8.对象名.hbm.xml文件：

对象和数据库表的对应关系

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="domain">

</id>

</class>

</hibernate-mapping>

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

Name属性：对象的属性名

Type属性：如果不写会自动检测，为了避免歧义会写。

可以写java中类的全名java.lang.String

Hibernate中string

Column:对应表中的列名，如果没有的话，对应属性名

Length:长度属性：如果不写，默认为255，varchar有。

9.自动建表技术：

在配置文件中加入<property name=”hbm2ddl.auto”>create</property>

Create:先删除，再创建

Update:如果表不存在就创建，不一样就进行更新，一样，就不做.

Create-drop:初始化时建表，sessionFactory执行close(),删除表。

Validate:验证表结构是否一致，如果不一致，就抛异常。

10.主键生成策略：

Identity sequence hilo native assigned uuid foreigns

Identify：使用数据库自己的主键的生成策略。

11.映射：

在自动建表的情况下，利用set list map集合关联数据表

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="ysDao">

</id>

</set>

<list-index column="idx"></list-index>

</list>

</class>

</hibernate-mapping>

12.维护关联关系：

一对多/多对一内涵：

修改和设置外键的值

多对多内涵：

就是在中间表中修改和删除记录。

13.casade：级联

默认为none，代表不级联，是指操作对象时，对关联的对象也做相同的操作，

可以设为save-update delete all none.

14.单向关联：多项关联：

15.临时状态

与数据库没有对应，和session没有关联

一般是新new出的对象

16.持久化状态

再session的管理之中，最终会有对应的数据库记录

对对象的修改会同步到数据库中。

18.游离状态

数据库中有对应的记录，但对象不在session的管理内。

19.

Update：把游离状态转换为持久状态

SaveOrUpdate:把临时或者游离状态转换为持久状态

Delete: 把持久或者游离状态转换为删除状态

Get: 持久化状态

Load: 持久化

20.

Session.refresh();刷新session缓存,重新去select下

21.

在hibernate.cfg.xml配置：

数据库隔离级别：

读未提交：1 0001

读已提交：2 0010

可重复读：4 0100

串行化： 8 1000

22.

单向关联：

单向一对多单向多对一单向多对多

在单向一对一的关联关系中，只能做从有外键方到无外键方的单向的关联。

维护关系时，必须从有外键方去设置关系。

23.

hibernate检索对象的方式：

Get()方法

OID方法 session.get()/session.load()

HQL检索方法，使用面向对象hql检索方法

QBC:使用query by criteria api检索对象，分装了基于字符串形式的查询语句。

24.使用hql语句进行查询

特点：

1）与sql语句相似

2）sql查询表和表中的列，hql查询对象和对象的属性

3）Hql关键字不去区分大小写，类名和属性名是区分大小写的

4）Select 可以省略不写

25.

//hql简单查询：

Hql=”select * from baoming.User”;

//是否写全限定名，是由实体类的映射文件中，auto-import决定的，默认为true,表示不用显式写包名，为false时，必须查询实体类的全限定名。

Hql=”FROM baoming.User”;

//执行查询

Query query = session.createQuery(hql);

List list = query.list();

//显示结果

for(Object obj:list){

System.out.prinltn(obj);

}

//使用别名

Hql=”FROM employee as e”;

//加入条件

Hql=”FROM employee e where e.id<10 AND e.id>5”;

//加入排序条件,按照name进行降序排序

Hql=”FROM employee e where e.id<10 ORDER BY e.name DESC”;

//先按照第一个进行排序，相同按照第二个排序

Hql=”FROM employee e where e.id<10 ORDER BY e.name DESC，id ASC”;

//查询某个列,查询name和id

Hql=”select e.name e.id from employee e”;

//通过new 方法，将查询出的属性作为对象的构造参数

Hql=”select new Employee(e.id,e.name) from employee e”;

//输出时：

List list=Session.createQuery(HQl);

For(Object obj ：list){

If(obj.getClass().isArray()){

Sop(Array.toString((Object[]) obj)_;

}else{

Syso(obj);

}

//执行分页查询

Query query= session.createQuery(“FROM Employee”).

query.setFirstResult(0);

Query.setMaxResults(10);

List list = query.list();

//需要查询的结果唯一时，没有查询到的结果就null,有多个就报错，一个就正常返回

Employee employee = (Employee)query.uniqueResult();

//hql高级查询

26.聚集函数：

Count() max() min() avg() sum()

//数目

Hql=”select count(*) from Employee”;

Long result = session.createQuery(Hql).uniqueResult;

//最大值

Hql=”select max(id) from Employee”;

//最小值

Hql=”select min(id) from Employee”;

//分组查询,按照名字来分组，查询的是名字和该组下的id数目值

Hql=”select e.name,COUNT(e.id) FROM Employee e where e.id<9 GROUP BY e.name”;

注意：

在查询过程中，聚合语句要比having子句优先执行，比where子句后执行。

Where 是具体来进行分组的，having 是对分组后的结果进行过滤的，比如控制分组中，内容大于1条才显示等。

例如：

Hql=”select e.name,COUNT(e.id) FROM Employee e where e.id<9 GROUP 27.级联查询，有外键关系。

//基本sql语句

employee表中有departmentId外键属性列，使用on查询条件指定查询范围

inner内部连接：都有记录才查询

Select e.id,e.name,d.name FROM employee e join department d on e.departmentId=d.id;

left连接：以左边为准

Right连接：以右边为准

//hql语句,进行连接查询

Select e.id,e.name,e.department.name from Employee e;

//查询时设置参数

使用？占位

如：Hql=”FROM Employee e where id=?”;

List list=session.createQuery(hql).setParameter(0,5).list();

设置第一个参数的值为5，第一个参数索引为0

如：Hql=”FROM Employee e where id between ? And ?”;

List list=session.createQuery(hql).setParameter(0,5).setParameter(1,10).list();

查询id位于5到10之间的

使用变量名

当id值是多个的时候，利用设置参数列表，第一个参数为变量名，第二个参数为id的变量集合

Hql=”FROM Employee e where id IN(:ids)”;

List list = session.createQuery(hql).setParameterList(“ids”,new Object[]{1,2,3,4,5}).list();

27.使用update和delete

Int result=session.createQuery(“UPDATE Employee e SET e.name =? Where e.id>10”).setParameter(0,”xjq”).executeUpdate();

执行更新和删除的语句，设置第一个？占位符为xjq,并执行更新。

返回一个int型的结果，表示影响了多少行。

注意：update和delete不去去通知缓存的，当更新数据库了，但是如果这个时候去直接查询的话，查的是session中的值，所以必须去更新obj对象，再去查询！

刷新要查询的对象：Session.refresh(obj);

28.回顾总结：

1）一对一的关联关系映射（外键+唯一性约束）

基于外键的关联映射

有外键方：

<many-to-one name=”obj” class=”...” column=”...” unique=”true”>

</many-to-one>

无外键方：

<one-to-one name=”...” class=”...” property-ref=”obj”>

</one-to-one>

基于主键的映射

有外键方：

<one-to-one></one-to-one>

无外键方：

<one-to-one></one-to-one>

2）hql查询对象，属性，写的时候全部为类名和属性名

关键字不区分大小写，类名和属性名区分大小写。

语法顺序：

SELECT 别名/属性名/表达式

FROM 实体 AS 别名

Where 过滤条件

Group by 分组条件

Having 分组后结果的查询条件

Order by 排序条件

29.懒加载：

不是在执行获取操作时马上去生成sql语句，而是在真正需要时才去查询数据库生成sql语句

级别：类级别

属性级别

<many-to-one>

<one-to-one>

理解：对于一定会用到的就直接去全部加载，对于可能不会用到的就去懒加载。
对应于load方法，在真正需要时才去查数据库

Lazy属性：默认为true

True:在第一次使用时就去加载，在真正去查get时才去执行真正的select语句

False:立即加载，在获取本对象时就去加载

Extra:增强的懒加载策略

懒加载异常：就是将要查询的东西放在了session关闭之后，session已经关闭了，将不会去重新查数据库

解决方案：

1）调整查询语句的位置,让session真正加载后再去关闭

2）Hibernate.initialize(obj);先去初始化对象

30.缓存机制：

一级缓存：session中的缓存

二级缓存：sessionFactory中的缓存，不经常被更新的，又是常用的。省市联动的情况。

使用二级缓存（应用级别的缓存）：

在主配置文件中：

<property name=”cache.provider_class”>指定缓存提供商 </property>

//指定要缓存的实体类,对其使用的操作读写，全限定名

<class-cache usage=”read-write” class=”包名.Employee”>

//指定要缓存的集合,对其使用的操作读写，全限定名

<collection-cache usage=”read-write” collection=”包名.实体类.集合名”>

注意：

只有使用oid时，即get load 方法时才会去使用一级和二级缓存，

对于queryList()查询方式则不会使用从缓存中取，但是会将查询结果放在缓存中。

带着热忱学技术，带着耐心做技术，带着分享去交流，带着微笑探我们的程序人生！