`

对hibernate的理解

阅读更多

================映射关系设置=====================

  

关系映射:对象之间的对应数量关系

单、双的数据库表是一样的,只是程序中不同

 

1. 1 1:(双向外键关联的意思:在程序中两边都设置对方的引用,但是在数据库中一样的,注意设置 mappedBy属性)


    1.1 
单(主键、外键)

       外键关联:@OneToOne
           
属性:fetchcascade…

            @JoinColumn(name=”wife”)

   1.2  双(主键、外键)

       外键关联:互有引用

           @OneToOne(mappedBy=”wife”)

       规律:凡是双向关联,必设mappedBy

 

 

2. 多对1:(数据库中两张表,并在多的那个表中加上1的外键)
     2.1
单: 
    
在程序中在多方类中增加单方类的引用,并在引用对象的get方法上增加 @Many2One


    2.2
双:
    1)
在多方类(User) 的单方引用的get方法上设置@Many2One

    2) 在单方类(group)的多方类引用哈希表对象的get方法上设置一个主解:
     
@One2Many(mappedBy=”group”)

 

 

3.  1对多:(数据库表中有三张表,还生成了一张中间表(默认当成多对多))
     3.1
单:在单方类中增加多的引用的HashSet<User>
          @One2Many
注解

          @JoinColumn(name=”groupId”)
          Ps:
感觉不太好理解。。。

             

     3.2

 

5.   多对多:
      5.1
单:

    在数据库中增加一张中间关联表,有两个字段:两个表的id,且这两个id构成联合主键、每个id分别为其中一张表的主键作为外键。

       @ManyToMany

 
      5.2 双:

 
 

6.   集合映射:
 

   

7.   继承关系映射:

  

8.    组合映射(不太理解)

     1)除去Wife中主键字段 以及相应的getset方法,去除该类的@Entity的注解

     2)在Husband 类中的getWife()方法上增加 @Embedded 注解

     3) hibernate.ctg.xml中去掉Wifemapping class 标签

 

   

9.       联合主键:


10.   简化问题

       1)  怎么写Annotation

       2)  如何写CRUD

 

 

11.   Hibernate中的级联操作(关联关系中的CRUD
  默认情况下的基本写法:

 

User u = new User();
u.setName(“user”); 
Group g = new Group(“g”); 
g.setName(“g”); 
u.setGroup(g); 
Session session = sessionFactory.getCurrenSession(); Session.beginTrasation(); 
Session.save(g); (g: detached 状态) 
Session.save(u); 
Session.getTransation().commit(); 

 

 


   使用Spring中的机制的写法:直接存user即可

 

 

 

    需要做的是: @ManyToOne( cascade={CascadeType.ALL} )
      @OneToMany(mappedBy=”group” ,cascade = {CascadeType.ALL} )….

      (从多的一方操作比较方便)

 

铁律:

    1. 双向关系在程序中要在多方设置双向关联:

        @ManyToOne( cascade={CascadeType.ALL} ),不然会出错

 

    2. 如果是1对多的双向关系中,需要在单方设置:@OneToMany(mappedBy=” “)

        ALL | MERGE| PERSIST | REFRESH | REMOVE

        ALL: 对于一个对象任何的持久化操作(增删改查)都会级联到另一个对象
        REFRESH

        PERSIST:保存的时候级联

        REMOVE:删除的时候级联


        不设置 cascade属性将不产生任何级联

 

        级联读操作:

        示例程序:

        Session s = sessionFactory.getCurrentSession();

        s.beginTransation();

        //由于@ManyToOne默认会 1 给取出来,不必设//cascade属性

        User u = (User) s.get(User.class , 1); 
        s.getTransation().commit();

@OneToMany
默认不会级联取出其中对象(取出group对象时默认不会将其所有User对象取出)

 

cascade属性只负责cud
fetch
:负责 getload等读取   {FetchType.LAZY, FetchType.EAGER}

 

 

 

l  Eager 加载 lazy 加载的区别:

    eager 加载: 会将需要加载的类(user)以及其关联的对象(group)一起放入内存中。如果session关闭了仍能处理其关联的对象(group)
     lazy 
加载: 只有当要访问关联的对象(user)时,才从数据库中取得。如果session关闭后被关联的对象不在内存中,此时是无法再取得被关联对象(group) 的。

 

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

Load的时候 fetchType LAZYEAGER的区别:
LAZY 先从数据库中取出user对象的信息,再取出group对象的信息


 


级联更新操作

@ManyToOne(cascade = {CascadeType.ALL})

 

 

 

级联删除操作:

l  取消在多方删除对象时级联删除单方对象:

 

 

或者:

 

 

l    在单方级联删除多方: 

1.         一般情况下默认级联删除

2.         取消在单方删除情况下删除多方对象
            利用HQL进行精确控制

 

 

 

 =================几个问题======================================= 

  

1. 什么是SessionFactory 以及 SessionFactory的取得:
     
    1.1 SessionFactory是由Spring容器来管理的、用来创建Session对象的单例类

    1.2 取得SessionFactory对象: 
    
public class SessionFactoryTest{ 
	private static SessionFactory sessionFactroy; 
	public static SessionFactory getSessionFactory(){ 
		sessionFactory = AnnotationConfiguration.configure().buildSessionFactory(); 
		return sessionFactory; 
	} 
} 
 
2. SessionFactory 的 getCurrentSession()方法 和 openSession()方法 的区别:
1) 用途: 界定事务边界(getCurrentSession从上下文中找,如果有就用已有的;如果没有,创建新的session)
2) 用法: 事务提交时是否自动 close session

上下文: 必须配置 current_session_context_class属性的值: jtathread| managed| custom.Class
thread:即在当前线程中获取 session


3. session
    一次数据库会话。
   从session中可以取得一个数据库连接,因此每次新建一个session的同时获得也了一个数据库连接
   session负责实现对数据库的增、删、改、查操作

    API:
       1. beginTransaction() 
       2. getTransaction().commit() 
       3. save(Object object) 三种状态
       5. load()
       6. get()
       7. update()
       8. delete() 参考三种状态
       9. saveOrUpdate()
      10. clear() 
      11. flush()
 
5. hibernate 中三种状态
    transient : 对象没有持久化到数据库中,也没有放到session的缓存中
    persistent : 对象持久化到数据库中了,放到session的缓存中了
    detached: 对象持久化在数据库中,已经不在session的缓存中了,因为session已经关闭了
    三种状态的区分:对象是否在数据库中  对象是否在缓存(session中的hashmap)中

6. 关系映射
    七种关系:参考映射关系设置部分
   



7. 性能优化
hibernate一级缓存、二级缓存和查询缓存简介:

1) 什么是缓存

 

2) 什么是一级缓存,session级别缓存

session缓存:一级缓存

 

 

 

3) 什么是二级缓存,SessionFactory 级别的缓存,可以跨越session存在

二级缓存由第三方提供

二级缓存又称为:SessionFactory级别的缓存(每个应用只有一个SessionFactory




5)
打开二级缓存

l    适合放在二级缓存的对象:

       经常被访问

       不会经常改动

       数量不多

l   打开的步骤:
第一步:hibernate.cfg.xml 设定:

 

    

  第二步:  @Cache注解

    

    

6) load 默认使用二级缓存iterate 默认使用二级缓存

 

7) list 默认往二级缓存加数据但是查询的时候不使用

 

8) 如果要 query用二级缓存,需要打开查询缓存

   重复查询(查询语句)使用的缓存,两个不同的查询不能使用二级缓存

  

   打开二级缓存:

 

 

 

测试代码:

 

 

 

 

 

 

     9)缓存算法


8. O/R Mapping模型:
a) 映射模型
   jpa annotation
   hibernate annotation extension
   hibernate xml
   jpa xml

b) 编程接口
   jpa
   hibernate

c) 数据查询语言
   sql
   hql
   ejbql(jpql)

 

 

 

============= ===重点学习提纲===================================

   

 

Hibernate是目前最流行的开源对象关系映射(ORM)框架。Hibernate采用低侵入式的设计,也即完全采用普通的Java对象(POJO),而不必继承Hibernate的某个基类,或实现Hibernate的某个接口。Hibernate是面向对象的程序设计语言和关系数据库之间的桥梁,Hibernate允许程序开发者采用面向对象的方式来操作关系数据库。


因为我们知道hibernate它能支持透明持久化从这个角度来看它没有侵入性 所谓侵入性它没有侵入hibernate任何的API所以它叫轻量级框架,轻量级框架的好处是没有侵入性 另外的一个好处是为测试带来了好处,测试非常简单 测试就行我们写普通的java应用程序一样不需要什么环境只需要几个jar包就可以了写个main函数一侧就可以了 它没有侵入性和测试非常简单 这是它流行的一个原因。


hibernate的优缺点
优点:1、程序更加面向对象;
2、提高了生产率;
3、方便移植(修改配置文件);
4、无侵入性。
缺点:
1、效率比JDBC略差;
2、不适合批量操作。

3、只能配置一种关联关系



Hibernate有四种查询方案
1、get,load方法,根据id查找对象
2、HQL--hibernate query language(查询对象:Query)
3、Criteria--标准查询语言(查询对象:Criteria,查询条件:Criterion)
4、通过sql来查(查询对象:SQLQuery)

具体

Query/Criteria:

1.Query接口封装了Hibernate强大的对象查询能力,同时也支持数据库的更新操作

2.提供了动态查询的参数绑定功能

3.提供list(),iterator(),scroll()等对象导航方法

4.提供uiqueResult()方法获取单独的对象

5.提供executeUpdate()方法来执行DML语句

6.提供了可移植的分页查询方法

Session:

1、save,presist保存数据,persist在事务外不会产生insert语句。

2、delete,删除对象

3、update,更新对象,如果数据库中没有记录,会出现异常,脱管对象如属性改变需要保存,则调用update方法

4、get,根据ID查,会立刻访问数据库

5、load,根据ID查,(返回的是代理,不会立即访问数据库)

6、saveOrUpdate,merge(根据ID和version的值来确定是否是save或update),调用merge你的对象还是托管的。当不知该对象的状态时可调用该方法

小贴士:瞬时对象id无值,脱管对象有值,hibernate通过该方式判断对象的状态

7、lock(把对象变成持久对象,但不会同步对象的状态)



hibernate的工作原理
1.配置好hibernate的配置文件和与类对应的配置文件后,启动服务器
2.服务器通过实例化Configuration对象,读取hibernate.cfg.xml文件的配置内容,并根据相关的需求建好表或者和表建立好映射关系
3.通过实例化的Configuration对象就可以建立sessionFactory实例,进一步,通过sessionFactory实例可以创建 session对象
4.得到session之后,便可以对数据库进行增删改查操作了,除了比较复杂的全文搜索外,简单的操作都可以通过hibernate封装好的 session内置方法来实现
5.此外,还可以通过事物管理,表的关联来实现较为复杂的数据库设计
优点:hibernate相当于java类和数据库表之间沟通的桥梁,通过这座桥我们就可以做很多事情了




Hibernate 的初始化.
1)创建Configeration类的实例。
它的构造方法:将配置信息(Hibernate config.xml)读入到内存。
一个Configeration 实例代表Hibernate 所有Java类到Sql数据库映射的集合。

2)创建SessionFactory实例
把Configeration 对象中的所有配置信息拷贝到SessionFactory的缓存中。
SessionFactory的实例代表一个数据库存储员源,创建后不再与Configeration 对象关联。

3)调用SessionFactory创建Session的方法
1】用户自行提供JDBC连接。
Connection con=dataSource.getConnection();
Session s=sessionFactory.openSession(con);
2】让SessionFactory提供连接
Session s=sessionFactory.openSession();



状态转换

临时状态 (transient)
1】不处于Session 缓存中
2】数据库中没有对象 录

Java如何进入临时状态
1】通过new语句刚创建一个对象时
2】当调用Session 的delete()方法,从Session 缓存中删除一个对象时。


持久化状态(persisted)
1】处于Session 缓存中
2】持久化对象数据库中有对象记录
3】Session 在特定时刻会保持二者同步

Java如何进入持久化状态
1】Session 的save()把临时-》持久化状态
2】Session 的load(),get()方法返回的对象
3】Session 的find()返回的list集合中存放的对象
4】Session 的update(),saveOrupdate()使游离-》持久化


游离状态(detached)
1】不再位于Session 缓存中
2】游离对象由持久化状态转变而来,数据库中可能还有对应记录。

Java如何进入持久化状态-》游离状态
1】Session 的close()方法
2】Session 的evict()方法,从缓存中删除一个对象。提高性能。少用。



具体如图:










缓存

主要有session缓存(一级缓存)和sessionfactory缓存(内置缓存和外置缓存(也叫二级缓存))

Session的缓存是内置的,不能被卸载,也被称为Hibernate的第一级缓存(Session的一些集合属性包含的数据)。在第一级缓存中,持久化类的每个实例都具有唯一的OID。


SessionFactory的缓存又可以分为两类:

内置缓存(存放SessionFactory对象的一些集合属性包含的数据,SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句,映射元数据是映射文件中数据的拷贝,而预定义SQL语句是在Hibernate初始化阶段根据映射元数据推导出来,SessionFactory的内置缓存是只读的,应用程序不能修改缓存中的映射元数据和预定义SQL语句,因此SessionFactory不需要进行内置缓存与映射文件的同步。)

外置缓存:SessionFactory的外置缓存是一个可配置的插件。在默认情况下,SessionFactory不会启用这个插件。外置缓存的数据是数据库数据的拷贝,外置缓存的介质可以是内存或者硬盘。SessionFactory的外置缓存也被称为Hibernate的第二级缓存。



缓存的范围分为三类。

1 事务范围:缓存只能被当前事务访问。

2 进程范围:缓存被进程内的所有事务共享。

3 集群范围:在集群环境中,缓存被一个机器或者多个机器的进程共享。



持久化层可以提供多种范围的缓存。如果在事务范围的缓存中没有查到相应的数据,还可以到进程范围或集群范围的缓存内查询,如果还是没有查到,那么只有到数据库中查询。事务范围的缓存是持久化层的第一级缓存,通常它是必需的;进程范围或集群范围的缓存是持久化层的第二级缓存,通常是可选的。

在进程范围或集群范围的缓存,即第二级缓存,会出现并发问题。因此可以设定以下四种类型的并发访问策略,每一种策略对应一种事务隔离级别。



事务型、读写型、非严格读写型、只读型

  什么样的数据适合存放到第二级缓存中?

  1 很少被修改的数据

  2 不是很重要的数据,允许出现偶尔并发的数据

  3 不会被并发访问的数据

  4 参考数据

  不适合存放到第二级缓存的数据?

  1 经常被修改的数据

  2 财务数据,绝对不允许出现并发

  3 与其他应用共享的数据。



  Hibernate的二级缓存策略的一般过程如下:

  1) 条件查询的时候,总是发出一条select * from table_name where …. (选择所有字段)这样的SQL语句查询数据库,一次获得所有的数据对象。

  2) 把获得的所有数据对象根据ID放入到第二级缓存中。

  3) 当Hibernate根据ID访问数据对象的时候,首先从Session一级缓存中查;查不到,如果配置了二级缓存,那么从二级缓存中查;查不到,再查询数据库,把结果按照ID放入到缓存。

  4) 删除、更新、增加数据的时候,同时更新缓存。





注意几个关键字的含义

inverse="true"表示此表不维护表之间的关系,由另外的表维护。

inverse属性默认是false的,就是说关系的两端都来维护关系。

false代表由己方来维护关系,true代表由对方来维护关系。在一个关系中,只能由一方来维护关系,否则会出问题(解疑中会讲到);同时也必须由一方来维护关系,否则会出现双方互相推卸责任,谁也不管。



可以这样理解,cascade定义的是关系两端对象到对象的级联关系;而inverse定义的是关系和对象的级联关系。

Cascade属性的可能值有

all: 所有情况下均进行关联操作,即save-update和delete。
none: 所有情况下均不进行关联操作。这是默认值。
save-update: 在执行save/update/saveOrUpdate时进行关联操作。
delete: 在执行delete 时进行关联操作。

all-delete-orphan: 当一个节点在对象图中成为孤儿节点时,删除该节点。比如在一个一对多的关系中,Student包含多个book,当在对象关系中删除一个book时,此book即成为孤儿节点。









主键生成策略

increment,identity,sequence,hilo,native,uuid,foreign,assigned,seqhilo,uuid.hex,uuid.string

 

 

    

面试题:
1.Hibernate有哪几种查询数据的方式

2.load()和get()的区别

3.Hibernate工作原理及为什么要用?

4.Hibernate是如何延迟加载?

5.Hibernate中怎样实现类之间的关系?(如:一对多、多对多的关系)

6. 说下Hibernate的缓存机制

7. Hibernate的查询方式

8. 如何优化Hibernate?

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

1.在数据库中条件查询速度很慢的时候,如何优化?
 
2.在Hibernate中进行多表查询,每个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之对应,如何解决这个问题?
  
3.session.load()和session.get()的区别

4.Session在加载实体对象时,将经过的过程:
 
5.Hibernate的主键生成机制


=====================Hibernate笔试题==========================


(1)一般情况下,关系数据模型与对象模型之间有哪些匹配关系(多选)
A)表对应类
B)记录对应对象
C)表的字段对应类的属性
D)表之间的参考关系对应类之间的依赖关系

(2)以下关于SessionFactory的说法哪些正确?(多选)
A)对于每个数据库事务,应该创建一个SessionFactory对象
B)一个SessionFactory对象对应一个数据库存储源。
C)SessionFactory是重量级的对象,不应该随意创建。如果系统中只有一个数据库存储源,只需要创建一个。
D)SessionFactory的load()方法用于加载持久化对象


(3)Customer类中有一个Set类型的orders属性,用来存放Order订单对象,在Customer.hbm.xml文件中,用哪个元素映射orders属性?
A)<set> B)<one-to-many> C)<many-to-one> D)<property>

(4)<set>元素有一个cascade属性,如果希望Hibernate级联保存集合中的对象,casecade属性应该取什么值?(单选)
A)none
B)save
C)delete
D)save-update


(5)以下哪些属于Session的方法?
A)load()
B)save()
C)delete()
D)update()
E)open()
F)close()

(6)以下程序的打印结果是什么?(单选)

tx = session.beginTransaction();
Customer c1=(Customer)session.load(Customer.class,new Long(1));
Customer c2=(Customer)session.load(Customer.class,new Long(1));
System.out.println(c1==c2);
tx.commit();
session.close();

A)运行出错,抛出异常
B)打印false
C)打印true


(7)以下程序代码对Customer的name属性修改了两次:
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,
new Long(1));
customer.setName(\"Jack\");
customer.setName(\"Mike\");
tx.commit();

执行以上程序,Hibernate需要向数据库提交几条update语句?(单选)
A)0 B)1 C)2 D)3


(8)在持久化层,对象分为哪些状态?(多选)
A)临时状态
B)独立状态
C)游离状态
D)持久化状态


(9)对于以下程序,Customer对象在第几行变为持久化状态?(单选)
Customer customer=new Customer(); //line1
customer.setName(\"Tom\"); //line2
Session session1=sessionFactory.openSession(); //line3
Transaction tx1 = session1.beginTransaction(); //line4
session1.save(customer); //line4
tx1.commit(); //line5
session1.close(); //line6

A) line1 B)line2 C)line3 D)line4 E)line5 F)line6


(10)对于以下程序,Customer对象在第几行变为游离状态?(单选)
Customer customer=new Customer(); //line1
customer.setName(\"Tom\"); //line2
Session session1=sessionFactory.openSession(); //line3
Transaction tx1 = session1.beginTransaction(); //line4
session1.save(customer); //line4
tx1.commit(); //line5
session1.close(); //line6

A) line1 B)line2 C)line3 D)line4 E)line5 F)line6

(11)以下哪一种检索策略利用了外连结查询?(单选)
A)立即检索 B)延迟检索 C)迫切左外连结检索

(12)假设对Customer类的orders集合采用延迟检索策略,编译或运行以下程序,会出现什么情况(单选)
Session session=sessionFactory.openSession();
tx = session.beginTransaction();
Customer customer=(Customer)session.get(Customer.class,new Long(1));
tx.commit();
session.close();
Iterator orderIterator=customer.getOrders().iterator();

A)编译出错 B)编译通过,并正常运行 C)编译通过,但运行时抛出异常

(13)关于HQL与SQL,以下哪些说法正确?(多选)
A)HQL与SQL没什么差别
B)HQL面向对象,而SQL操纵关系数据库
C)在HQL与SQL中,都包含select,insert,update,delete语句
D)HQL仅用于查询数据,不支持insert,update和delete语句

(14)事务隔离级别是由谁实现的?(单选)
A)Java应用程序 B)Hibernate C)数据库系统 D)JDBC驱动程序

(15)悲观锁与乐观锁,哪个具有较好的并发性能?(单选)
A)悲观锁 B)乐观锁

答案:
(1)A,B,C (2)B,C (3)A (4)D (5)A,B,C,D,F (6)C (7)B (8)A,C,D (9)D (10)F (11)C (12)C (13)B,D (14)C (15)B


 

  • 大小: 31.2 KB
  • 大小: 10 KB
  • 大小: 14.2 KB
  • 大小: 8 KB
  • 大小: 6.1 KB
  • 大小: 3.9 KB
  • 大小: 5 KB
  • 大小: 9.6 KB
  • 大小: 3.6 KB
  • 大小: 1.9 KB
分享到:
评论
2 楼 dreamoftch 2012-12-06  
1 楼 quanwsx 2012-03-08  
  

相关推荐

Global site tag (gtag.js) - Google Analytics