搜档网
当前位置:搜档网 › hibernate学习笔记

hibernate学习笔记

hibernate学习笔记
hibernate学习笔记

1、#第一个hibernate项目

1、新建java项目

2、创建User Library,加入如下jar

* HIBERNA TE_HOME/hibernate3.jar * HIBERNA TE_HOME/lib/*.jar * MySql jdbc驱动

3、创建hibernate配置文件hibernate.cfg.xml,为了便于调试最好加入log4j配置文件

4、定义实体类

5、定义User类的映射文件User.hbm.xml

6、将User.hbml.xml文件加入到hibernate.cfg.xml文件中

7、编写hbm2ddl工具类,将实体类生成数据库表

8、开发客户端

为了方便跟踪sql执行,在hibernate.cfg.xml文件中加入 true

2、#测试实体对象的生命周期

junit简介:

* 编写测试类xxxTest,需要继承TestCase

* 编写单元测试方法,测试方法必须以test开头,测试方法不能含有参数和返回值,如:public void testHello1() {}

* 最好单元测试的代码单独建立一个目录

了解Hibernate中CRUD操作

了解get和load的区别?

* get不支持lazy,load支持lazy

* 采用get加载数据,如果没有匹配的数据,返回null,而load则抛出异常

transient状态的特征?

* 在数据库中没有与之匹配的数据

* 没有纳入session的管理

persistent状态的特征?

* persistent状态的对象在数据库中有与之匹配的数据

* 纳入了session的管理

* 在清理缓存(脏数据检查)的时候,会和数据库同步

detached状态的特征?

* 在数据库中有与之匹配的数据

* 没有纳入session的管理

3、hibernate基本映射

实体类---表

实体类中的普通属性---表字段

采用标签映射成数据库表,通过标签将普通属性映射成表字段

所谓普通属性指不包括自定义类、集合和数组等

注意:如果实体类和实体类中的属性和sql中的关键字重复,必须采用table或column重新命名

实体类的设计原则:

* 实现一个默认的(即无参数的)构造方法(constructor)

* 提供一个标识属性(identifier property)(可选)

* 使用非final的类(可选)

* 为持久化字段声明访问器(accessors)

主键生成策略:

uuid、native和assigned

sessionfactory接口

4、hibernate多对一关联映射

关联映射的本质:

* 将关联关系映射到数据库,所谓的关联关系是对象模型在内存中的一个或多个引用

会在多的一端加入一个外键,指向一的一端,这个外键是由

中的column属性定义的,如果忽略了这个属性那么默认的外键与实体的属性一致

标签的定义示例:

*

理解级联的含义?* 是对象的连锁操作:cascade

5、hibernate一对一主键关联映射(单向关联Person---->IdCard)

一对一主键关联映射:让两个实体对象的id保持相同,这样可以避免多余的字段被创建

具体映射:

idCard

6、ibernate一对一主键关联映射(双向关联Person<---->IdCard)

需要在idcard映射文件中加入标签指向person,指示hibernate如何加载person 默认根据主键加载

7、hibernate一对一唯一外键关联映射(单向关联Person---->IdCard)

一对唯一外键关联映射是多对一关联映射的特例

可以采用标签,指定多的一端的unique=true,这样就限制了多的一端的多重性为一

通过这种手段映射一对一唯一外键关联

8、hibernate一对一唯一外键关联映射(双向关联Person<---->IdCard)

一对一唯一外键关联双向,需要在另一端(idcard),添加标签,指示hibernate 如何加载

其关联对象,默认根据主键加载person,外键关联映射中,因为两个实体采用的是person 的外键维护的关系,

所以不能指定主键加载person,而要根据person的外键加载,所以采用如下映射方式:

9、hibernate多对多关联映射(单向User---->Role)

具体映射方式:

10、hibernate多对多关联映射(双向User<---->Role)

映射方法:

table属性值必须和单向关联中的table属性值一致

中column属性值要与单向关联中的标签中的column属性值一致

中的column属性值要与单向关联中标签的column属性值一致

11、hibernate多对一关联映射

关联映射的本质:

* 将关联关系映射到数据库,所谓的关联关系是对象模型在内存中的一个或多个引用

会在多的一端加入一个外键,指向一的一端,这个外键是由 中的column属性定义的,如果忽略了这个属性那么默认的外键与实体的属性一致

标签的定义示例:

*

理解级联的含义?

* 是对象的连锁操作

12、session flush测试:

session flush方法主要做了两件事:

* 清理缓存

* 执行sql

session在什么情况下执行flush

* 默认在事务提交时

* 显示的调用flush

* 在执行查询前,如:iterate

13、lazy

hibernate lazy策略可以使用在:

* 标签上,可以取值:true/false

* 标签上,可以取值:true/false需要类增强工具

* 标签上,可以取值:true/false/extra

* 单端关联上,可以取值:false/proxy/noproxy

lazy概念:

只有真正使用该对象时,才会创建,对于hibernate而言,正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效

标签上的lazy特性只对普通属性起作用

hibernate在集合上的lazy策略,可以取值:true/false/extra

标签上的lazy不会影响到集合上的lazy特性

hibernate在单端关联上的lazy策略,可以取值:false/proxy/noproxy

标签上的lazy不会影响到单端关联上的lazy特性

14、每棵继承树映射成一张表

(1)、理解如何映射

因为类继承树肯定是对应多个类,要把多个类的信息存放在一张表中,必须有某种机制来区分哪些记录是属于哪个类的。

这种机制就是,在表中添加一个字段,用这个字段的值来进行区分。用hibernate实现这种策略的时候,有如下步骤:

父类用普通的标签定义

在父类中定义一个discriminator,即指定这个区分的字段的名称和类型

如:

子类使用标签定义,在定义subclass的时候,需要注意如下几点:

Subclass标签的name属性是子类的全路径名

在Subclass标签中,用discriminator-value属性来标明本子类的discriminator字段(用来区分不同类的字段)

的值Subclass标签,既可以被class标签所包含(这种包含关系正是表明了类之间的继承关系),也可以与class标

签平行。当subclass标签的定义与class标签平行的时候,需要在subclass标签中,添加extends属性,里面的值

是父类的全路径名称。子类的其它属性,像普通类一样,定义在subclass标签的内部。

(2)、理解如何存储

存储的时候hibernate会自动将鉴别字段值插入到数据库中,在加载数据的时候,hibernate能根据这个鉴别值

正确的加载对象

多态查询:在hibernate加载数据的时候能鉴别出正真的类型(instanceOf)

get支持多态查询

load只有在lazy=false,才支持多态查询

hql支持多态查询

15、每个子类映射成一张表

(1)、理解如何映射

这种策略是使用joined-subclass标签来定义子类的。父类、子类,每个类都对应一张数据库表。

在父类对应的数据库表中,实际上会存储所有的记录,包括父类和子类的记录;在子类对应的数据库表中,

这个表只定义了子类中所特有的属性映射的字段。子类与父类,通过相同的主键值来关联。实现这种策略的时候,

有如下步骤:

父类用普通的标签定义即可

父类不再需要定义discriminator字段

子类用标签定义,在定义joined-subclass的时候,需要注意如下几点:Joined-subclass标签的name属性是子类的全路径名

Joined-subclass标签需要包含一个key标签,这个标签指定了子类和父类之间是通过哪个字段来关联的。

如:,这里的column,实际上就是父类的主键对应的映射字段名称。

Joined-subclass标签,既可以被class标签所包含(这种包含关系正是表明了类之间的继承关系),

也可以与class标签平行。当Joined-subclass标签的定义与class标签平行的时候,需要在Joined-subclass

标签中,添加extends属性,里面的值是父类的全路径名称。子类的其它属性,像普通类一样,定义在joined-subclass标签的内部。

16、每个具体类映射成一张表

(1)、理解如何映射

这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表,而且这个表的信息是完备的,

即包含了所有从父类继承下来的属性映射的字段(这就是它跟joined-subclass的不同之处,

joined-subclass定义的子类的表,只包含子类特有属性映射的字段)。实现这种策略的时候,有如下步骤:

父类用普通标签定义即可

子类用标签定义,在定义union-subclass的时候,需要注意如下几点:Union-subclass标签不再需要包含key标签(与joined-subclass不同)

Union-subclass标签,既可以被class标签所包含(这种包含关系正是表明了类之间的继承关系),

也可以与class标签平行。当Union-subclass标签的定义与class标签平行的时候,需要在Union-subclass

标签中,添加extends属性,里面的值是父类的全路径名称。子类的其它属性,像普通类一样,

定义在Union-subclass标签的内部。这个时候,虽然在union-subclass里面定义的只有子类的属性,

但是因为它继承了父类,所以,不需要定义其它的属性,在映射到数据库表的时候,依然包含了父类的所

有属性的映射字段。

注意:在保存对象的时候id是不能重复的(不能使用自增生成主键)

17、component映射

在hibernate中,component是某个实体的逻辑组成部分,它与实体的根本区别是没有oid,component可以成为是值对象(DDD)

采用component映射的好处:它实现了对象模型的细粒度划分,层次会更分明,复用率会更高

复合(联合)主键映射

通常将复合主键相关的属性,单独放到一个类中

* 此类必须实现序列化接口

* 覆写hashcode和equals方法

18、悲观锁乐观锁

悲观锁的实现,通常依赖于数据库机制,在整个过程中将数据锁定,其它任何用户都不能读取或修改.

大多数基于数据版本记录机制(version)实现,一般是在数据库表中加入一个version字段读取数据时将版本号一同读出,之后更新数据时版本号加一,如果提交数据时版本号小于或等于数据表中

的版本号,则认为数据是过期的,否则给予更新。

19、hibernate查询语言hql

在hql中关键字不区分大小写,但是属性和类名区分大小写

<1>、简单属性查询【重要】

* 单一属性查询,返回结果集属性列表,元素类型和实体类中相应的属性类型一致* 多个属性查询,返回的集合元素是对象数组,数组元素的类型和对应的属性在实体类中的类型一致

数组的长度取决与select中属性的个数

* 如果认为返回数组不够对象化,可以采用hql动态实例化Student对象

参见:SimplePropertyQueryTest.java

<2>、实体对象查询【重要】

* N + 1问题,在默认情况下,使用query.iterate查询,有可以能出现N+1问题

所谓的N+1是在查询的时候发出了N+1条sql语句

1: 首先发出一条查询对象id列表的sql

N: 根据id列表到缓存中查询,如果缓存中不存在与之匹配的数据,那么会根据id 发出相应的sql语句

* list和iterate的区别?

* list每次都会发出sql语句,list会向缓存中放入数据,而不利用缓存中的数据

* iterate:在默认情况下iterate利用缓存数据,但如果缓存中不存在数据有可以能出现N+1问题

参见:SimpleObjectQueryTest1.java/SimpleObjectQueryTest2.java

<3>、条件查询【重要】

* 可以采用拼字符串的方式传递参数

* 可以采用?来传递参数(索引从0开始)

* 可以采用:参数名来传递参数

* 如果传递多个参数,可以采用setParamterList方法

* 在hql中可以使用数据库的函数,如:date_format

参见:SimpleConditionQueryTest.java

<4>、hibernate也支持直接使用sql进行查询

参见:SqlQueryTest.java

<5>、外置命名查询

* 在映射文件中采用标签来定义hql

* 在程序中采用session.getNamedQuery()方法得到hql查询串

参见:Student.hbm.xml、NameQueryTest.java

<6>、查询过滤器

* 在映射文件中定义过滤器参数

* 在类的映射中使用这些参数

* 在程序中启用过滤器

参见:Student.hbm.xml、FilterQueryTest.java

<7>、分页查询【重要】

* setFirstResult(),从0开始

* setMaxResults,每页显示多少条数据

参见:PageQueryTest.java

<8>、对象导航查询,在hql中采用. 进行导航【重要】

参见:ObjectNavQueryTest.java

<9>、连接查询【重要】

* 内连

* 外连接(左连接/右连接)

参见:JoinQueryTest.java

<10>、统计查询【重要】

参见:StatQueryTest.java

<11>、DML风格的操作(尽量少用,因为和缓存不同步)

参见:DMLQueryTest.java

20、hibernate一级缓存

一级缓存很短和session的生命周期一致,一级缓存也叫session级的缓存或事务级缓存

那些方法支持一级缓存:

* get()

* load()

* iterate(查询实体对象)

如何管理一级缓存:

* session.clear(),session.evict()

如何避免一次性大量的实体数据入库导致内存溢出

* 先flush,再clear

如果数据量特别大,考虑采用jdbc实现,如果jdbc也不能满足要求可以考虑采用数据本身的特定导入工具

21、hibernate二级缓存

二级缓存也称进程级的缓存或SessionFactory级的缓存,二级缓存可以被所有的session共享二级缓存的生命周期和SessionFactory的生命周期一致,SessionFactory可以管理二级缓存

二级缓存的配置和使用:

* 将echcache.xml文件拷贝到src下

* 开启二级缓存,修改hibernate.cfg.xml文件

true * 指定缓存产品提供商,修改hibernate.cfg.xml文件

name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider * 指定那些实体类使用二级缓存(两种方法)

* 在映射文件中采用标签

* 在hibernate.cfg.xml文件中,采用标签

二级缓存是缓存实体对象的

了解一级缓存和二级缓存的交互

22、hibernate查询缓存

查询缓存是针对普通属性结果集的缓存

对实体对象的结果集只缓存id

查询缓存的生命周期,当前关联的表发生修改,那么查询缓存生命周期结束

查询缓存的配置和使用:

* 在hibernate.cfg.xml文件中启用查询缓存,如:

true

* 在程序中必须手动启用查询缓存,如:

query.setCacheable(true);

23、hibernate抓取策略(单端代理的批量抓取)

保持默认,同fetch="select",如:

fetch="select",另外发送一条select语句抓取当前对象关联实体或集合

hibernate抓取策略(单端代理的批量抓取)

设置fetch="join",如:

fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合

此时lazy会失效

hibernate抓取策略(集合代理的批量抓取)

保持默认,同fetch="select",如:

fetch="select",另外发送一条select语句抓取当前对象关联实体或集合

hibernate抓取策略(集合代理的批量抓取)

设置fetch="join",如:

fetch="join",hibernate会通过select语句使用外连接来加载其关联实体或集合

此时lazy会失效

hibernate抓取策略(集合代理的批量抓取)

设置fetch="subselect",如:

fetch="subselect",另外发送一条select语句抓取在前面查询到的所有实体对象的关联集合hibernate抓取策略,,batch-szie在上的应用

batch-size属性,可以批量加载实体类,参见:Classes.hbm.xml

hibernate抓取策略,batch-szie在集合上的应用

batch-size属性,可以批量加载实体类,参见:Classes.hbm.xml

spring4.x + hibernate4.x 配置详解

spring4.x + hibernate4.x 配置详解 关于spring和hibernate的使用以及特征等等,在此不再啰嗦,相信大家也都知道,或者去搜索一下即可。 本篇博文的内容主要是我最近整理的关于spring4.x 和hibernate 4.x 相关配置和使用方式,当然spring3.x以及hibernate4.x也可以借鉴。 首先是配置文件web.xml 增加以下代码即可 contextConfigLocation classpath*:/applicationContext.xml org.springframework.web.context.ContextLoaderListener 然后建立 applicationContext.xml 文件,src下。文件内容如下,注释我尽量写的很详细

配置文件hibernate.cfg.xml 配置文件的文件头DTD文件内容: org.hibernate.dialect.MySQLDialect com.mysql.jdbc.Driver jdbc:mysql://localhost/minmin?characterEncoding=gb2312 root minmin true create

Hibernate练习题

Hibernate&EJB考试试题 1、下面关于Hibernate说法正确的是()(选择两项) A)Hibernate是ORM的一种实现方式 B)Hibernate不要JDBC的支持 C)属于控制层 D)属于数据持久层 2、下面关于ORM的说法错误的是()(选择两项) A)对象关系映射,让现实中的对象同数据库的表产生映射(类与表产生映射) B)对象关系映射,让类同表产生关系 C)对象关系映射,让类同记录产生关系(类的实例与记录(表中的一行数据)产生关系) D)对象关系映射,让类中的属性同表中的列产生关系 3、下面关于Hibernate中Session的说法正确的是()(选择两项) A)Session是轻量级的,可以随意的创建和销毁 B)Session是重量级的,不能随意的创建和销毁 C)Session是线程安全的 D)Session不是线程安全的 4、在Hibernate中,以下()不属于session的方法 A、close() B. open() C. update() D. delete() 5、下面关于Hibernate中load和get方法说法正确的是() A)这两个方法是一样的,没有任何的区别 B)这两个方法不一样,load先找缓存,再找数据库

C)这两个方法不一样,get先找缓存,再找数据库 D)以上说法都不对 注:load()和get()都是先找缓存,再找数据库。 不同点是在检索时: load()是延迟检索,先返回代理对象,访问对象时在发出sql命令Get()是立即检索,直接发出sql命令,返回对象 6、在Hibernate中修改对象的说话错误的是() A)只能利用update方法来做修改 B)可以利用saveOrUpdate方法来做修改 C)可以利用HQL语句来做修改 D)不能利用HQL语句来修改 7、下面关于Hibernate中Transaction的使用说法正确的是()(选择两项) A)Transaction是可有可无的 B)Transaction在做查询的时候是可有可无的 C)Transaction在做修改的时候是可有可无的 D)Transaction在做修改的时候是必须的 8、使用Hibernate技术实现数据持久化时,下面()内容不在 Hibernate配置文件中配置(选择一项) A) 数据库连接信息 B) 数据库类型(dialect) C) show_sql参数 D) 数据库表和实体的映射信息

hibernate架构图

.Hibernate 架构图 Hibernate 是一个开放源代码的对象关系映射框架,它对JDBC 进行了非常轻量级的对象封装,使得Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate 可以应用在任何使用JDBC 的场合,既可以在Java 的客户端程序使用,也可以在Servlet/JSP 的Web 应用中使用,最具革命意义的是,Hibernate 可以在应用EJB 的J2EE 架构中取代CMP ,完成数据持久化的重任。 Hibernate 的核心接口一共有5 个,分别为:Session 、SessionFactory、Transaction 、Query 和Configuration 。这5 个核心接口在任何开发中都会用到。通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。下面对这五个核心接口分别加以介绍。 ·Session 接口:Session 接口负责执行被持久化对象的CRUD 操作(CRUD 的任务是完成与数据库的交流,包含了很多常见的SQL 语句。) 。但需要注意的是Session 对象是非线程安全的。同时,Hibernate 的session 不同于JSP 应用中的HttpSession 。这里当使用session 这个术语时,其实指的是Hibernate 中的session ,而以后会将HttpSesion 对象称为用户session 。 ·SessionFactory 接口:SessionFactory 接口负责初始化Hibernate 。它充当数据存储源的代理,并负责创建Session 对象。这里用到了工厂模式。需要注意的是SessionFactory 并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory 就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory 。

Hibernate学习入门教程

Hibernate学习入门教程 开发环境搭建 [日期:2015-08-11] 来源:Linux社区作者:doctorJoe [字体:大中小] 其实一两个月前就在了解Hibernate方面的知识了,但一直以来,都没有好好的总结,而且一直使用的是myeclipse,感觉有些傻瓜式的操作就可以搭建起Hibernate的开发环境,但这样一点都不好,没有理解到Hibernate到底是怎么配置的,所以你今天特使用Eclipse来一步一步搭建Hibernate的开发环境,下面,正式进入正题。 在Hibernate中开启日志https://www.sodocs.net/doc/094722482.html,/Linux/2015-07/120499.htm Hibernate+JUnit测试实体类生成数据库表https://www.sodocs.net/doc/094722482.html,/Linux/2015-07/120161. htm Hibernate整体理解https://www.sodocs.net/doc/094722482.html,/Linux/2014-07/104405.htm Hibernate的映射机制https://www.sodocs.net/doc/094722482.html,/Linux/2014-12/110265.htm 新建一个web项目,名字就随便吧,你喜欢什么名字就什么吧,这是我的截图。

引入hibernate的依赖jar包,我使用的是hibernate-release-4.3.10.Final,下载好后解压,打开压缩包下的lib目录下的require文件夹,这是hibernate的所以来的必须的jar包,接下来,在刚才新建的项目里新建一个libs文件夹,将刚才的所说的jar包copy进去,另外,由于我们需要连接MySQL数据库以及使用JUnit测试,将所需的mysql-connector-java-5.0.8-bin.jar和junit-4.5.jar两个jar包引用进去,关于这些jar包,可以在网上搜索。接下来,就是把这些jar 包添加到编译环境中去,选中libs下的jar包,右击选择Build Path –>Add to Build Path,这样就把依赖jar包成功添加进去了。 继续往下,我们需要配置最重要的hibernate配置文件hibernate.cfg.xml以及进行日志处理的log4j.properties属性文件:打开上一步解压后的hibernate文件夹,打开project—>etc文件夹,将该文件夹下的hibernate.cfg.xml和log4j.properties文件拷贝到项目的src文件夹下,打开hibernate.cfg.xml文件,将session-factory标签中的内容替换成如下的内容: org.hibernate.dialect.MySQLDialect com.mysql.jdbc.Driver jdbc:mysql:///hibernatedemo root yzp140103 这样就配置好了。 接下来,要做的就是做开发测试了:在项目的src目录下新建一个实体类包com.joe.entity,在该包下新建一个实体类Student,代码如下: package com.joe.entity; import java.io.Serializable;

Hibernate3.6(开发必看)

1.Java对象持久化概述 1.1.应用程序的分层体系结构 1.1.1.基于B/S的典型三层架构 说明: 1,展现层:提供与用户交互的界面。 2,业务逻辑层:实现各种业务逻辑。 3,数据访问层:负责存放和管理应用程序的持久化业务数据。 1.1. 2.数据访问层与Hibernate在Java应用程序中的 角色 数据访问层(持久化层)封装了数据访问的细节,为业务逻辑层提供了面向对象的API。完善的持久化层应该达到的目标: 1,代码重用性高,可完成所有的数据访问操作。 2,如果需要的话,能够支持多种数据库平台。 3,具有相对独立性,当持久化层变化时,不会影响上层实现。 在数据访问层(持久化层)中可以使用Hibernate框架以实现要求,如下图所示:

1.2.软件模型 1.2.1.各种模型的说明 概念模型: 模拟问题域中的真实实体。描述每个实体的概念和属性及实体间关系。不描述实体行为。实体间的关系有一对一、一对多和多对多。。 关系数据模型: 在概念模型的基础上建立起来的,用于描述这些关系数据的静态结构。有以下内容组成:1,若干表 2,表的所有索引 3,视图 4,触发器 5,表与表之间的参照完整性

域模型: 在软件的分析阶段创建概念模型,在软件设计阶段创建域模型。 组成部分: 1,具有状态和行为的域对象。 2,域对象之间的关联。 域对象(domain object): 构成域模型的基本元素就是域对象。对真实世界的实体的软件抽象,也叫做业务对象(Business Object,BO)。域对象可代表业务领域中的人、地点、事物或概念。 域对象分为以下几种: 1,实体域对象:通常是指业务领域中的名词。(plain old java object,简单Java 对象)。 2,过程域对象:应用中的业务逻辑或流程。依赖于实体域对象,业务领域中的动词。如发出订单、登陆等。 3,事件域对象:应用中的一些事件(警告、异常)。 1.2.2.域对象间的关系 关联: 类间的引用关系。以属性定义的方式表现。

springmvc框架搭建之xml配置说明(spring4+hibernate4)

SpringMVC框架搭建说明 Spring4.1.4 + hibernate4.3.8 1、web.xml配置 程序运行时从web.xml开始,加载顺序为:context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet 如下为web.xml的配置说明 bmymis2 contextConfigLocation classpath:applicationContext-*.xml org.springframework.web.context.ContextLoaderListener encodingFilter org.springframework.web.filter.CharacterEncodingFilter encoding UTF-8 forceEncoding true springServlet org.springframework.web.servlet.DispatcherServlet

整合SSH三大框架介绍

一.在MyEclipse里先建立一个Web project 的项目,选最新版本的java ee。 二.添加struts2框架支持 1.引入struts2必须得几个jar包,放在WebRoot->WEB-INF->lib 目录下。 2.将WEB应用部署到tomcat服务器上:找到tomacat的安装目录Tomcat6.x\apache-tomcat-6.0.33\conf,打开其中的server.xml文件,在文件末尾上面加入例如 这样的句子,其中path的值为你需要访问网站的上下文,docBase的值为该web项目的WebRoot所在的目录,最后一个readloadable最好选true。 3.在WebRoot->WEB-INF->web.xml中加入struts2的过滤

器将部署好的应用纳入到struts2的管辖范围类,具体代码如下 struts2 org.apache.struts2.dispatcher.ng.filter.StrutsPre pareAndExecuteFilter struts2 /* 4.在web项目的src目录下,建一个struts.xml文件,这里是处理struts整个流程的文件。在其中加入 上面的name随便取,extends绝对不能变。 5.这样以后,启动tomcat服务器看看能不能正常启动,如果正常启动后,在浏览器上访问,http://localhost/上下文/index.jsp看能不能进入,若能进入则表示struts2的框架已经成功加到web项目中了,可以开始下一步了。

用MyEclipse如何自动生成hibernate的.hbm.xml文件

用MyEclipse如何自动生成hibernate的.hbm.xml文件(2010-07-29 17:36:01) 今天在网上看到很多人都不知道怎么用MyEclipse自动生成hibernate的.hbm.xml文件。我甚至看到有位兄弟竟然自己写出那个格式的文件来。首先我不得不佩服那位兄弟的记忆力。可是我这边有更直接的方法希望能对那些入门级别的人一点帮助! 在hibernate中,每个数据表对应的其实是一个实体类,每个实体类有一个对应的hbm.xml 配置文件和你匹配,myeclipse中其实有个MyEclipse Database Explorer视图,它提供了myeclipse与数据库直接连接的内置窗口,并且通过此窗口可以生成hibernate的mapping文件。 1.在项目上点击右键选择MyEclipse选项,为应用增加Hibernate特性. 2.在出现的配置窗口中,选中“Add Hibernate 2.1 libraries to project?”,然后设定存放Hibernate 库文件的目录为:/WEB-INF/lib 目录,默认会选择创建一个新的Hibernate配置文件hibernate.cfg.xml。 3.点击下一步,进入Hibernate数据库连接配置界面,在Connection Profile选项中直接选择在MyEclipse Database Explorer中配置的vipdata选项,然后就会自动生成其他的配置,可以选择“Copy JDBC Driver and add to classpath”,这样就会将JDBC驱动拷贝到WEB-INF/lib目录中。: 4.点击下一步,来创建Hibernate的SessionFactory类,这是一个简单的集中管理Hibernate 会话的工厂类,填写类的全名称。 5.点击完成,然后MyEclipse就会将Hibernate相关的jar包拷贝到lib目录下,同时会生成Hibernate的配置文件:hibernate.cfg.xml,和SessionFactory类。 现在要利用MyEclipse Database Explorer视图中的工具来生成Hibernate的映射文件。切换到MyEclipse Database Explorer视图,在表vipdata上点击右键,选择Create Hibernate Mapping.

Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结

Hibernate(6)——一对多和多对多关联关系映射(xml和注解)总结 涉及的知识点总结如下: ?One to Many 映射关系 o多对一单向外键关联(XML/Annotation) o一对多单向外键关联(XML/Annotation) o懒加载和积极加载 o一对多双向外键关联(XML/Annotation) ?Many to Many 映射关系 o多对多单向外键关联(XML/Annotation) o多对多双向外键关联(XML/Annotation) o set的inverse元素详解 ?问题小结 ?关联关系的优缺点 多对一单向外键关联关系 注意多对一关联是多方持有一方的引用。看一个例子,去淘宝购物,那么一个淘宝用户可以对应多个购物订单,如图所示: 多的一方是Orders,持有一方的引用,也就是Users,而在Users中无需作任何定义,从订单到用户的关系是单向多对一关联。对应数据库就是: 还有比如说学生和班级的关系,多个学生可以属于同一个班级,这就是从学生到班级也是典型的单向多对一关系,看代码实现: 基于注解的多对一单向外键关联: 单向多对一关联中,多方需要持有一方的引用,那么多方(学生类)需要额外配置,需要对持有的一方引用使用注解@ManyToOne (cascade={CascadeType.ALL}, fetch=FetchType.EAGER),设置为级联操作和饥渴的抓取策略,@JoinColumn(name="cid"),而一方(教室类)无需做任何多方的定义。 注意;多方必须保留一个不带参数的构造器! import ; import ; import ; //班级类,在多对一关系中属于一的方,不持有其他多余的配置,反而是被多方持有

hibernate框架必问的面试题

108.为什么要使用 hibernate? hibernate 是对 jdbc 的封装,大大简化了数据访问层的繁琐的重复性代码。 hibernate 是一个优秀的 ORM 实现,很多程度上简化了 DAO 层的编码功能。 可以很方便的进行数据库的移植工作。 提供了缓存机制,是程序执行更改的高效。 109.什么是 ORM 框架? ORM(Object Relation Mapping)对象关系映射,是把数据库中的关系数据映射成为程序中的对象。 使用 ORM 的优点:提高了开发效率降低了开发成本、开发更简单更对象化、可移植更强。 115.hibernate 中如何在控制台查看打印的 SQL 语句? 在 Config 里面把 hibernate. show_SQL 设置为 true 就可以。但不建议开启,开启之后会降低程序的运行效率。 116.hibernate 有几种查询方式? 三种:hql、原生 SQL、条件查询 Criteria。 117.hibernate 实体类可以被定义为 final 吗? 实体类可以定义为 final 类,但这样的话就不能使用 hibernate 代理模式下的延迟关联提供性能了,所以不建议定义实体类为 final。 118.在 hibernate 中使用 Integer 和 int 做映射有什么区别? Integer 类型为对象,它的值允许为 null,而 int 属于基础数据类型,值不能为 null。 119.hibernate 是如何工作的? 读取并解析配置文件。 读取并解析映射文件,创建 SessionFactory。 打开 Session。 创建事务。 进行持久化操作。 提交事务。 关闭 Session。 关闭 SessionFactory。 120.get()和 load()的区别? 数据查询时,没有 OID 指定的对象,get() 返回 null;load() 返回一个代理对象。 load()支持延迟加载;get() 不支持延迟加载。

如何根据hibernate的实体类和实体类配置文件生成数据库的表

网络地址: 主题:如何根据hibernate的实体类和实体类配置文件生成数据库的表 内容部分 [c-sharp]view plaincopyprint? 1. 4. 5. 6. jdbc:mysql://12 7.0.0.1/lianxi 7. com.mysql.jdbc.Driver 8. root 9. root 10. org.hibernate.dialect.MySQLDialect 11. true 12. update 13. 14. 15. 16. 17. 18. 19.

Struts+Spring+Hibernate框架搭建

整合SSH框架 整合框架版本:hibernate-distribution-3.6.0.Final-dist + spring-framework-2.5.6.SEC01-with-dependencies + struts-2.1.8.1 一、搭建工具 Windows 、Tomcat 6.0+ 、MyEclipse、SQLServer2008 R2 、Google 二、创建工程 新建WEB项目工程(MyEclipse),包含web.xml配置文件。 三、添加框架环境Junit4 右击新建的项目,选择Build Path —> Add Library —> Junit —> 选择Junit4 —> 确定完成单元测试的添加。 四、添加框架环境Struts2 1.解压struts- 2.1.8.1 ,如下图所示: 可在apps文件里,随机选择一个.war文件解压,到WEB-INF→lib下的基础jar文件:

复制黏贴添加到项目工程的lib下。也可将lib下的全部jar(71个)都复制到项目中来,不过很多用不到。我们崇尚即用即加的原则…… 2. 配置struts.xml和web.xml文件,如下: web.xml: ItcastOA struts2 org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndE xecuteFilter struts2 /* index.html index.htm index.jsp default.html default.htm default.jsp struts.xml:

马士兵hibernate文档 (个人完善版)

3. hibernate.hbm2ddl.auto : 在SessionFactory 创建时,自动检查数据库结构,或者将数据库schema 的DDL 导出到数据库。使用create-drop 时,在显式关闭SessionFactory 时,将删除掉数据库schema。 例如:validate | update | create | create-drop create :如果没有表就创建 update :如果表结构更新,就更新 validate :每次插入表的时候看看表结构有没有更新。 理论上是先建类后建表:这个时候只要你的类建好了,可以跨数据库。 实际中先建表比先建类多,建好表以后要对数据库进行优化,比如建索引,建试图,各种各样的优化。 project\etc目录下面有很多示例性的文档,log4j的文档就在那个下面。 SessionFactory sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory(); SessionFactory的建立是很耗费时间的,应该像连接池一样,只建立一次,以后要用就直接从那用。 Hibernate文档建议我们自己写一个辅助类,用单例来做。 JUnit的一个bug: @BeforeClass public static void beforeClass() { sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory(); } 在这句话的时候 配置文件如果有的时候写错了,她悄悄把错误隐藏起来了。 解决的方法:可以对这句话加try catch块 8.表名和类名不一致的时候: @Entity @Table(name="_teacher")

Struts、Spring、Hibernate三大框架的原理和优点

Struts的原理和优点. Struts工作原理 MVC即Model-View-Controller的缩写,是一种常用的设计模式。MVC 减弱了业务逻辑接口和数据接口之间的耦合,以及让视图层更富于变化。MVC的工作原理,如下图1所示: Struts 是MVC的一种实现,它将Servlet和JSP 标记(属于J2EE 规范)用作实现的一部分。Struts继承了MVC的各项特性,并根据J2EE的特点,做了相应的变化与扩展。Struts的工作原理, 视图:主要由JSP生成页面完成视图,Struts提供丰富的JSP 标签库:Html,Bean,Logic,Template等,这有利于分开表现逻辑和程序逻辑。 控制:在Struts中,承担MVC中Controller角色的是一个Servlet,叫ActionServlet。ActionServlet是一个通用的控制组件。这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。它截取和分发这些请求到相应的动作类(这些动作类都是Action类的子类)。另外控制组件也负责用相应的请求参数填充Action From(通常称之为FromBean),并传给动作类(通常称之为ActionBean)。动作类实现核心商业逻辑,它可以访问java bean 或调用EJB。最后动作类把控制权传给后续的JSP 文件,后者生成视图。所有这些控制逻辑利用Struts-config.xml文件来配置。 模型:模型以一个或多个java bean的形式存在。这些bean分为三类:Action Form、Action、JavaBean or EJB。Action Form通常称之为FormBean,封装了来自于Client的用户请求信息,如表单信息。Action通常称之为ActionBean,获取从ActionSevlet传来的FormBean,取出FormBean中的相关信息,并做出相关的处理,一般是调用Java Bean或EJB等。 流程:在Struts中,用户的请求一般以*.do作为请求服务名,所有的*.do请求均被指向ActionSevlet,ActionSevlet根据Struts-config.xml中的配置信息,将用户请求封装成一个指定名称的FormBean,并将此FormBean传至指定名称的ActionBean,由ActionBean完成相应的业务操作,如文件操作,数据库操作等。每一个*.do均有对应的FormBean名称和ActionBean名称,这些在Struts-config.xml中配置。 核心:Struts的核心是ActionSevlet,ActionSevlet的核心是Struts-config.xml。 Struts优缺点 优点: 1.开源软件,能更深入的了解其内部实现机制。 2.Taglib标记库,灵活动用,能大大提高开发效率。 3.页面导航使系统的脉络更加清晰。通过一个配置文件,即可把握整个系统各部分之间的联系,这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时,这种优势体现得更加明显。

hibernate关系映射注解配置

1. Hibernate Annotation关系映射有下面几种类型: 1)一对一外键关联映射(单向) 2)一对一外键关联映射(双向) 3)一对一主键关联映射(不重要,有需要看下文档即可) 在实际中很少用,使用注解@PrimaryKeyJoinColumn 意思是说,我的主键去参考另外一张表中的主键,作为我的主键,但是在我测试使用 注解一对一主键关联映射,在生成表的时候,数据库中并没有生成关联,使用XML 映射可以生成。Annotation注解一对一主键关联映,有些bug。不过没空去研究它。 因为在实际开发中一对一很少用。在实际开发中我机会没有用过,主键关联就更少了 4)多对一关联映射(单向) 5)一对多关联映射(单向) 6)一对多关联映射(双向) 7)多对多关联映射(单向) 8)多对多关联映射(双向) 2.介绍各种映射用法 1)一对一外键关联映射(单向)Husband ---> Wife public class Husband{ private Wife wife; @OneToOne(cascade=CascadeType.ALL) @JoinColumn(name="wife_id",unique=true) public Wife getWife(){…} … } public class Wife{ } 一对一外键关联,使用@OneToOne,并设置了级联操作 @JoinColum设置了外键的名称为wife_id(数据库字段名),如果不设置,则默认为另一类的属性名+ _id 外键的值是唯一的(unique),不可重复,与另一类的主键一致 2)一对一外键关联映射(双向)Husband <---> Wife public class Husband{ private Wife wife; @OneToOne(cascade=CascadeType.ALL) @JoinColumn(name="wife_id",unique=true) public Wife getWife(){…} ... } public class Wife{ private Husband husband; @OneToOne(mappedBy="wife",cascade=CascadeType.ALL) public Husband getHusband(){…} ... } 一对一双向关联关系,使用@OneToOne 注意:需要加上mappedBy="wife",如果不加上的话,Wife也会生成一个外键(husband_id)。mappedby="wife"需要指向与他关联对象的一个属性(即Husband类里面的wife属性),这里的会在Husband表里面生成个外键wife_id字段,而Wife表里则不会生成。这里Husband作为维护端即主

Struts+Hibernate+Spring+三个框架简介

Struts 是一个为开发基于模型(Model)-视图(View)-控制器(Controller)(MVC)模式的应用架构的开源框架,是利用Java Servlet和JSP构建Web应用的一项非常有用的技术。由于Struts能充分满足应用开发的需求,简单易用,敏捷迅速,因而吸引了众多的开发人员的关注。 首先事件是指从客户端页面(浏览器)由用户操作触发的事件,Struts使用Action来接受浏览器表单提交的事件,这里使用了Command 模式,每个继承Action的子类都必须实现一个方法execute。 struts重要的表单对象ActionForm是一种对象,它代表了一种应用,这个对象中至少包含几个字段,这些字段是Jsp页面表单中的input字段,因为一个表单对应一个事件,所以,当我们需要将事件粒度细化到表单中这些字段时,也就是说,一个字段对应一个事件时,单纯使用Struts就不太可能,当然通过结合JavaScript也是可以转弯实现的。 Struts是一个基于Sun J2EE平台的MVC框架,主要是采用Servlet和JSP技术来实现的。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中,开发人员利用其进行开发时不用再自己编码实现全套MVC模式,极大的节省了时间,所以说Struts是一个非常不错的应用框架。 Struts框架可分为以下四个主要部分: 1、模型(Model),本质上来说在Struts中Model是一个Action类(这个会在后面详细讨论),开发者通过其实现商业逻辑,同时用户请求通过控制器(Controller)向Action的转发过程是基于由struts- config.xml文件描述的配置信息的。 2、视图(View),View是由与控制器Servlet配合工作的一整套JSP定制标签库构成,利用她们我们可以快速建立应用系统的界面。 3、控制器(Controller),本质上是一个Servlet,将客户端请求转发到相应的Action类。

相关主题