博客分类：
&&&&& 学过hibernate的都知道hibernate支持n种主键生成策略。但有一种比较诡异，就是sequence。众所周知，oracle 表的主键生成策略是没有自增(identity或者autoIncrement)的，他是通过 sequence 来实现的。而mysql正好与oracle相反，mysql支持自增，恰好不支持 sequence。如果想要在mysql上应用sequence主键生成策略那就悲剧了。
&&&&& 但是天无绝人之路，问题总是有办法解决的。hibernate为我们提供了其他的解决办法。像一般，我们配置sequence的主键生成策略是这样的：
&?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="com.example.entity"&
&class name="Foo"&
&id name="id"&
&generator class="sequence"&&/generator&
&/hibernate-mapping&
但上面的配置在mysql下是行不通的，如果要适应mysql，需要做将配置改为：
&?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="com.example.entity"&
&class name="Foo"&
&id name="id"&
&generator class="org.hibernate.id.enhanced.SequenceStyleGenerator"&
&!--初始值，默认是1--&
&param name="initial_value"&1000&/param&
&!--自增大小，默认是1--&
&param name="increment_siz"&1&/param&
&!--sequence的名字，默认是"hibernate_sequence"--&
&param name="sequence_name"&hibernate_sequence&/param&
&/generator&
&/hibernate-mapping&
(以上配置是我在hibernate 3.6.1 上完成的)
你这样写,MYSQL是怎么实现的?hibernate会在MYSQL中做什么操作,新增一个表在管理吗?这个时间久远了已经忘记了，貌似没有新增表。
浏览: 115220 次
来自: 西安
可以用~！！
嗯分析的不错。我们也是采用类似LengthFieldBased ...
成功集成了guice容器，多谢！
&div class=&quote_title ...
你这样写,MYSQL是怎么实现的?hibernate会在MYS ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'structs+hibernate+mysql开发中，添加数据后不能立马显示_百度知道
structs+hibernate+mysql开发中，添加数据后不能立马显示
structs+hibernate+mysql+tomcate 开发，现在DispatchAction处理 新闻查询（newslist）和新闻添加(newsadd)的操作。 现在通过jsp页面请求数据经过newsadd处理后添加到mysql 数据后，添加任务完成后，通过转发至查询action（ return newslist ），然后再看查询...
我有更好的答案
这个就是hibernate的的缓存的问题，就是hibernate中的数据没有和数据库中的数据一致。 以前我们遇到过，你可以在连接hibernate中哪个连接后面加点点东西，你上网可以查的到的。
我是重新查询数据库.相当于,然后返回给结果页面我也遇到过同样的问题不知道为什么
朋友，您这个问题解决了吗？我也同样遇到这个问题。
为您推荐：
其他类似问题
structs的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。博客分类：
Hibernate对象关系映射：
在我们了解hibernate对象关系映射之前，我们还应该了解什么是hibernnate
Hibernate是一个开源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装。以对象编程思维来操作数据库。Hibernate核心接口一共有五个：session、sessionfactory、transaction、query和configuration。
下面将讲解如何实现集合关系的映射、继承关系的映射和关联关系的映射。
关联映射的本质：
是将关联关系映射到数据库中，关联关系在对象模型中体现为内存中的一个或多个引用
第一|：集合关系映射：
Set映射实例：
Javabean&&& User类
package com.lovo.
import java.util.HashS
import java.util.S
public class User {
private Set pet = new HashSet();
public void addPet(Pet pet){
this.pet.add(pet);
public Integer getId() {
public void setId(Integer id) {
public String getName() {
public void setName(String name) {
this.name =
public String getPassword() {
public void setPassword(String password) {
this.password =
public Set getPet() {
public void setPet(Set pet) {
this.pet =
Hiberbate映射文件：
Set集合映射：用于不重复的记录，可以理解为一个用户有多个宠物，而宠物我们用一个对象来装载，因此javabean中我们使用set范型。
解析一下映射文件：
就是实体bean,一个实体bean只有一个class,对应参数
Name:指定实体bean中的路径
Table:指定实体bean在数据库中的表名
设置表的主键，里面参数有
Name：实体bean对象的属性，一定要一致对应。
Type: 属性的类型，这里有可以用两种方式，一个是hibernate类型对应string…….记住一定是小写。第二种就是java类型java.lang.String….
Column: 对应数据库表中的例名
Length: 设置例名的长度
用来指定对象标识符生成器为持久化类的实例
生成唯一的主键值，里面参数
Class生成主键方式，有九种方式，下面逐一介绍：
　　Assigned方式由程序生成主键值，并且要在save()之前指定否则会抛出异常
　　特点：主键的生成值完全由用户决定，与底层数据库无关。用户需要维护主键值，在调用session.save()之前要指定主键值。
　　Hilo使用高低位算法生成主键，高低位算法使用一个高位值和一个低位值，然后把算法得到的两个值拼接起来作为数据库中的唯一主键。Hilo方式需要额外的数据库表和字段提供高位值来源。默认请况下使用的表是
　　hibernate_unique_key，默认字段叫作next_hi。next_hi必须有一条记录否则会出现错误。
　　特点：需要额外的数据库表的支持，能保证同一个数据库中主键的唯一性，但不能保证多个数据库之间主键的唯一性。Hilo主键生成方式由 Hibernate 维护，所以Hilo方式与底层数据库无关，但不应该手动修改hi/lo算法使用的表的值，否则会引起主键重复的异常。
　　Increment
　　Increment方式对主键值采取自动增长的方式生成新的主键值，但要求底层数据库的支持Sequence。如Oracle，DB2等。需要在映射文件xxx.hbm.xml中加入Increment标志符的设置。其中实现是 取数据库中的最大值加1
　　特点：由Hibernate本身维护，适用于所有的数据库，不适合多进程并发更新数据库，适合单一进程访问数据库。不能用于群集环境。
　　Identity
　　Identity当时根据底层数据库，来支持自动增长，不同的数据库用不同的主键增长方式。
　　特点：与底层数据库有关，要求数据库支持Identity，如MySQl中是auto_increment, SQL Server 中是Identity，支持的数据库有MySql、SQL Server、DB2、Sybase和HypersonicSQL。 Identity无需Hibernate和用户的干涉，使用较为方便，但不便于在不同的数据库之间移植程序。
　　Sequence
　　Sequence需要底层数据库支持Sequence方式，例如Oracle数据库等
　　特点：需要底层数据库的支持序列，支持序列的数据库有DB2、PostgreSql、Qracle、SAPDb等在不同数据库之间移植程序，特别从支持序列的数据库移植到不支持序列的数据库需要修改配置文件
　　Native
　　Native主键生成方式会根据不同的底层数据库自动选择Identity、Sequence、Hilo主键生成方式。注意oracle多表中对应一个序列，一次我们可以使用increment
　　特点：根据不同的底层数据库采用不同的主键生成方式。由于Hibernate会根据底层数据库采用不同的映射方式，因此便于程序移植，项目中如果用到多个数据库时，可以使用这种方式。
　　UUID使用128位UUID算法生成主键，能够保证网络环境下的主键唯一性，也就能够保证在不同数据库及不同服务器下主键的唯一性。
　　特点;能够保证数据库中的主键唯一性，生成的主键占用比较多的存贮空间
　　Foreign GUID
　　Foreign用于一对一关系中。GUID主键生成方式使用了一种特殊算法，保证生成主键的唯一性，支持SQL Server和MySQL
用于设定持久化类与表字段的映射关系。主要包括name、type、column、not-null等属性。
Name:实体bean的属性名。
Column：数据库表的字段名。
Type:hibernate映射数据类型。
Not-null:属性值不能为null。
创建hibernate配置文件
net.sourceforge.jtds.jdbc.Driverjdbc:jtds:sqlserver://127.0.0.1:1433/mastersasaorg.hibernate.dialect.SQLServerDialecttruetruetrue
Hibernate核心配置文件& 配置数据库连接信息hibernate.cfg.xml其中文件名可以修改，当时修改后在Configuration cfg = new Configuration().configure(文件名);hibernate默认为hibernate.cfg.xml
子元素用来配置数据库的url、user、password…………等等信息。下面详细讲解下：
Name=”Connection.?”设置需要的连接数据库的参数。
其中最重要的name=”dialect”指定数据库方言从而让hibernate对sql做一些优化处理等操作。
在控制台打印sql信息
Hibernate的三种状态：瞬时状态、持久状态、游离状态
第二：关联关系映射：
一对一（主键关联）：主键关联就是让两个对象具有相同的主键值，以表名他们之间的一对一关系。
在配置文件中只需要写one-to-one。。
Cascade 属性指定级联操作类型，取值可以：all、delete、save-update、none. 说白了就表连接的限制
Pet在主键生成器中使用的是foreign，其中param标签指定实体类（Pet）中所引用的属性
Constrainted：属性指定约束
一对一（唯一外键约束关联）：
把一个表的多条记录和另一个表的某条记录关联起来，而且的关系维护总是从多方参照一方，这样可以减少数据的冗余。因此，外键关联也大多用于多对以的配置。如果加上唯一限制后，外键关联也可以用于一对一的关联关系。
在User中使用其中column属性指定了User表中的外键字段。
在Pet中使用元素来指示hibernate如何加载起关联对象，其中property-ref属性指定User类中的pet属性，表名需要通过外键加载。
多对一关联：
多对一关联关系可以说是最常见的实体关系
Pet类中元素的column属性指定pet表中的外键字段t_user_id。需要注意的是由于在多对一的关系中，多方可能会有多条记录对应一方的一条记录，所以在插入、更新、删除多方操作是，可以不需要级联操作。
一对多映射：
理解： 如果从pet到user则是一对多的关系，但是关联是有方向的，如果从user到pet则是一对多的关联关系，一个客户可以有多个宠物。就是一个user对象可以有多个pet对象。
元素的name属性指定user实体类的集合属性，table属性指定集合所对应的表，元素指定表中的外键字段，元素指定集合元素所对应的类。
为了避免一端的更新操作造成数据库同步更新多段，在一对多的关联情况下一端的inverse=”true”
多对多关联：
由于多对多需要中间表，效率相对低下，所以应当尽量在自己的项目中少用多对多关 联。在多对多关联中，cascade 一般设为&save-update&因为在多对多中很少出现删除一方一后另一方也删除，比如下面的例子，一个老师调走了，学生是不会跟着老师走的。同样一 个学生转学了，老师也还是在自己的工作岗位上。下边是我个人做的一个小例子源码，要是能上传附件就好了。
package com.
import java.util.HashS
import java.util.S
* S generated by MyEclipse Persistence Tools
public class S implements java.io.Serializable {
private Set t=new HashSet();
// Constructors
/** default constructor */
public S() {
/** full constructor */
public S(String sname) {
&& this.sname =
// Property accessors
public Integer getSid() {
&& return this.
public void setSid(Integer sid) {
&& this.sid =
public String getSname() {
&& return this.
public void setSname(String sname) {
&& this.sname =
public Set getT() {
public void setT(Set t) {
&& this.t =
package com.
import java.util.HashS
import java.util.S
* T generated by MyEclipse Persistence Tools
public class T implements java.io.Serializable {
private Set s=new HashSet();
// Constructors
public Set getS() {
public void setS(Set s) {
&& this.s =
/** default constructor */
public T() {
/** full constructor */
public T(String tname) {
&& this.tname =
// Property accessors
public Integer getTid() {
&& return this.
public void setTid(Integer tid) {
&& this.tid =
public String getTname() {
&& return this.
public void setTname(String tname) {
&& this.tname =
继承关系的映射：
Hibernate中的继承映射
Hibernate的继承映射包含了三种不同的策略：
1. 每簇类使用一个表；
2. 每个子类一个表；
3. 每个具体内一个表（有限制）。
假设我们有四个类Animal，Dog，Cat，其代码如下：
文件名：Animal.java
& class Animal {
&&&& private S
&&&& private S
&&&& private S
&&&& // setter and getter
文件名：Dog.java
& class Dog extends Animal {
&&&& private String&
&&&& // setter and getter
文件名：Cat.java
& class Cat extends Animal {
&&&& private String&
&&&& // setter and getter
o 每簇类使用一个表
&&&&&& 使用每簇类使用一个表的策略时，有一个限制就时子类不能有NOT NULL，映射文件为：
&&&&&& 文件名：Animal.hbm.xml
o 每个子类一个表
&&&&&& 使用每个子类一个表的策略时，可以使用一个映射文件实现，也可以分成多个映射文件来实现。每个子类一个映射文件的情况：
&&&&&& 文件名：Animal.hbm.xml
&&&&&&& 文件名：Dog.hbm.xml
&&&&&&& 文件名：Cat.hbm.xml
&&&&&& 每个子类一个表的策略实际上一种one-to-one的映射。
o 每个具体内一个表（有限制）
&&&&&& 使用每个具体内一个表（有限制）策略时，每一个子类的映射文件将要包含所有父类中的属性，映射文件：
&&&&&& 文件名：Dog.hbm.xml
&&&&&&& 文件名：Cat.hbm.xml
关于配置文件中遗漏的知识点补充：
配置文件中的属性：
Access：里面有三种：field，loop，property。属性是否可以访问，说明白点，就是在实体类中是否有get/set方法，它默认是调用get/set方法（property）。如果没有get/set方法我们可以调用，其中的field反射方式通过setaccess设置属性。
Ubsaved-value：默认为null，表示的状态信息。
Lazy: 延迟加载，在配置property中使用时，不会加载此例，需要我们导入一个cglib开源包。
Hibernate面向对象的查询语句 中的
Get : 没有数据返回null，无论如何都要返回数据
Load: 没有数据会抛出异常，查询具体语句返回，延迟加载
Assertequals断言
网上拷贝的一个简单的hibernate实例：
一个简单的hibernate实例（之一）
关键字: hibernate
一、下载hibernate-3.2 core版本，解压。
二、打开eclipse，建立一个用户库，命名为:hibernate3.2，导入刚解压的hibernate目录下的hibernate3.jar
并\lib目录下的所有jar文件。在Builder path的source and output fold中选择Folder,并默认给出的文件夹名。
在as JRE library use中选择JRE_LIB variable。
三、新建一个java工程。在其属性的Java Build Path中引入刚建立的hibernate3.2用户库并mysql的java驱动（
视你所用的数据库而定，在这我用的是mysql数据库）。
四、在src中建立一个包，设为px.malijun,并在其中建立以下几个Java Class:
1. package px.&
3. public class User {&
5. &&& private S&
6. &&& private S&
7. &&& private S&
8. &&& public String getEmail() {&
9. &&&&&&&&
10. &&& }&
11. &&& public void setEmail(String email) {&
12. &&&&&&& this.email =&
13. &&& }&
14. &&& public String getName() {&
15. &&&&&&&&
16. &&& }&
17. &&& public void setName(String name) {&
18. &&&&&&& this.name =&
19. &&& }&
20. &&& public String getPassword() {&
21. &&&&&&&&
22. &&& }&
23. &&& public void setPassword(String password) {&
24. &&&&&&& this.password =&
25. &&& }&
26. &&& public int getId() {&
27. &&&&&&&&
28. &&& }&
29. &&& public void setId(int id) {&
30. &&&&&&& this.id =&
31. &&& }&
建立相应的xml映射文件：
User.hbm.xml
2. . &&&&&&& &-//Hibernate/Hibernate Mapping DTD 3.0//EN&&
4. &&&&&&& &http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd&&&
10. &&&&&&
11. &&&&&&&&&
12. &&&&&&&&&
13. &&&&&&&&&
在数据库中建立一个myproject(按你的意思定名)数据库，在其中建立一个users表（向RoR学习）：
1. CREATE TABLE `users` (&
2. & `id` int(11) NOT NULL auto_increment,&
3. & `name` varchar(255) default NULL,&
4. & `password` varchar(255) default NULL,&
5. & `email` varchar(255) default NULL,&
6. & PRIMARY KEY& (`id`)&
注：我是用phpmyadmin对mysql数据库进行管理的，在建立的时候我特意为其选择了utf-8编码。
在src的根目录下（以上的user.hbm.xml映射文件与User.java在同一目录下）建立hibernate的配置文件：
hibernate.cfg.xml
5. &-//Hibernate/Hibernate Configuration DTD 3.0//EN&&
7. &http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd&&&
13. &&&&&&&&&
14. &&&&&&&&&
15. &&&&&&& true&
16. &&&&&&&&&
17. &&&&&&&&&
18. &&&&&&&&&
19. &&&&&&& org.hibernate.dialect.MySQLDialect&
20. &&&&&&&&&
21. &&&&&&&&&
22. &&&&&&&&&
23. &&&&&&& com.mysql.jdbc.Driver&
24. &&&&&&&&&
25. &&&&&&&&&
26. &&&&&&&&&
27. &&&&&&& jdbc:mysql://localhost:3306/myproject?useUnicode=true&characterEncoding=utf8&
28. &&&&&&&&&
29. &&&&&&&&&
30. &&&&&&&&&
31. &&&&&&& root&
32. &&&&&&&&&
33. &&&&&&&&&
34. &&&&&&&&&
35. &&&&&&&&&
36. &&&&&&&&&
37. &&&&&&&&&
38. &&&&&&&&&
ok 了，下面我们就进入我们的实际使用阶段了：
由于常规操作都类似，我们建立了一个抽象类：
HibernateBase.java
1. package px.&
3. import org.hibernate.*;&
4. import org.hibernate.cfg.*;&
5. import java.util.*;&
6. import java.io.IOE&
7. import java.io.PrintW&
9. &&&& public abstract class HibernateBase&&
10. &&&& {&
11. &&&& protected SessionFactory sessionF//会话工厂，用于创建会话&
12. &&&& protected S//hibernate会话&
13. &&&& protected Tra //hiberante事务&
14. &&&&&&
15. &&&& public HibernateBase()throws HibernateException&
16. &&&& {&
17. &&&& this.initHibernate();&
18. &&&& }&
19. &&&& // 帮助方法&
20. &&&& protected void initHibernate()&
21. &&&& throws HibernateException {&
22. &&&&&&
23. &&&& // 装载配置，构造SessionFactory对象&
24. &&&& sessionFactory = new Configuration().configure().buildSessionFactory();&
25. &&&& }&
26. &&&&&&
27. &&&& /**
28. &&&& *开始一个hibernate事务
29. &&&& */&
30. &&&& protected void beginTransaction()&
31. &&&& throws HibernateException {&
32. &&&&&&
33. &&&& session = sessionFactory.openSession();&
34. &&&& transaction = session.beginTransaction();&
35. &&&& }&
36. &&&&&&
37. &&&& /**
38. &&&& *结束一个hibernate事务。
39. &&&& */&
40. &&&& protected void endTransaction(boolean commit)&
41. &&&& throws HibernateException {&
42. &&&&&&
43. &&&& if (commit) {&
44. &&&& transaction.commit();&
45. &&&& } else {&
46. &&&& //如果是只读的操作，不需要commit这个事务。&
47. &&&& transaction.rollback();&
48. &&&& }&
49. &&&& session.close();&
50. &&&& }&
然后建立一个具体针对User操作的一个类：
UserBean.java
1. package px.&
3. import org.hibernate.*;&
4. import org.hibernate.cfg.*;&
5. import java.util.*;&
* 和course相关的业务逻辑
10. public class UserBean extends HibernateBase {&
11. &&& public UserBean() throws HibernateException {&
12. &&&&&&& super();&
13. &&& }&
15. &&& /**
16. &&&& * 增加一个Course
17. &&&& */&
18. &&& public void addUser(User user) throws HibernateException {&
19. &&&&&&& beginTransaction();&
20. &&&&&&& session.save(user);&
21. &&&&&&& endTransaction(true);&
22. &&& }&
24. &&& /**
25. &&&& * 查询系统中所有的Course，返回的是包含有Course持久对象的Iterator。
26. &&&& */&
27. &&& public Iterator getAllUsers() throws HibernateException {&
28. &&&&&&& String queryString = &select users from User as user&;&
29. &&&&&&& beginTransaction();&
30. &&&&&&& Query query = session.createQuery(queryString);&
31. &&&&&&& Iterator it = query.iterate();&
32. &&&&&&&&
33. &&& }&
35. &&& /**
36. &&&& * 删除给定ID的course
37. &&&& */&
38. &&& public void deleteUser(String id) throws HibernateException {&
39. &&&&&&& beginTransaction();&
40. &&&&&&& User user = (User) session.load(User.class, id);&
41. &&&&&&& session.delete(user);&
42. &&&&&&& endTransaction(true);&
43. &&& }&
45. &&& /**
46. &&&& * 按course的名字进行模糊查找，返回的是包含有Course持久对象的Iterator。
47. &&&& */&
48. &&& public Iterator getSomeUser(String name) throws HibernateException {&
49. &&&&&&& String queryString = &select u from User as u where u.name like :name&;&
50. &&&&&&& beginTransaction();&
51. &&&&&&& Query query = session.createQuery(queryString);&
52. &&&&&&& query.setString(&name&, &%& + name + &%&);&
53. &&&&&&& Iterator it = query.iterate();&
54. &&&&&&&&
55. &&& }&
万事大吉，所欠的事情就是调用UerBean中定义的操作进行我们实际所要针对User所做的事情了。我们写一个简单的
1. package px.&
3. public class Test {&
5. &&& /**
6. &&&& * @param args
7. &&&& */&
8. &&& public static void main(String[] args) {&
9. &&&&&&& // TODO Auto-generated method stub&
10. &&&&&&& UserBean ub=new UserBean();&
11. &&&&&&& User user = new User();&
12. &&&&&&& user.setName(&你好，世界！&);&
13. &&&&&&& user.setPassword(&123456&);&
14. &&&&&&& user.setEmail(&ok@ujs.edu.cn&);&
15. &&&&&&& ub.addUser(user);&
17. &&& }&
浏览: 7264 次
来自: 成都
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Access denied | www.supmen.com used Cloudflare to restrict access
Please enable cookies.
What happened?
The owner of this website (www.supmen.com) has banned your access based on your browser's signature (3e87cb55a2a26e0e-ua98).博客访问： 344198
博文数量： 117
博客积分： 4000
博客等级： 上校
技术积分： 925
注册时间：
IT168企业级官微
微信号：IT168qiye
系统架构师大会
微信号：SACC2013
分类： Java
找这个东西很久了，结果就在我们的电脑上面，呵呵！还没看完的，先搬出来在说，等用的时候在仔细的看吧！& 映射定义（Mapping declaration）&& 对象和关系数据库之间的映射通常是用一个XML文档(XML document)来定义的。这个映射文档被设计为易读的，
并且可以手工修改。映射语言是以Java为中心，这意味着映射文档是按照持久化类的定义来创建的， 而非表的定义。
请注意，虽然很多Hibernate用户选择手写XML映射文档，但也有一些工具可以用来生成映射文档，
包括XDoclet,Middlegen和AndroMDA。
让我们从一个映射的例子开始：
我们现在开始讨论映射文档的内容。我们只描述Hibernate在运行时用到的文档元素和属性。
映射文档还包括一些额外的可选属性和元素，它们在使用schema导出工具的时候会影响导出的数据库schema结果。 （比如， not-null 属性。）
5.1.1.&Doctype
所有的XML映射都需要定义如上所示的doctype。DTD可以从上述URL中获取， 也可以从hibernate-x.x.x/src/net/sf/hibernate目录中、 或hibernate.jar文件中找到。Hibernate总是会首先在它的classptah中搜索DTD文件。
如果你发现它是通过连接Internet查找DTD文件，就对照你的classpath目录检查XML文件里的DTD声明。
5.1.1.1.&EntityResolver
As mentioned previously, Hibernate will first attempt to resolve DTDs in its
classpath. The manner in which it does this is by registering a custom org.xml.sax.EntityResolver implementation with the
SAXReader it uses to read in the xml files. This custom EntityResolver recognizes two different systemId
namespaces. 如前所述,Hibernate首先在其classpath中查找DTD。其行为是依靠在系统中注册的org.xml.sax.EntityResolver的一个具体实现，SAXReader依靠它来读取xml文件。这一
EntityResolver 实现能辨认两种不同的 systenId命名空间。
若resolver遇到了一个以http://hibernate.sourceforge.net/为开头的systemId，它会辨认出是hibernate
namespace，resolver就试图通过加载Hibernate类的classloader来查找这些实体。
若resolver遇到了一个使用classpath://URL协议的systemId，它会辨认出这是user
namespace,resolver试图通过(1)当前线程上下文的classloader和(2)加载Hibernate
class的classloader来查找这些实体。
使用user namespace(用户命名空间)的例子：
更多关于继承映射的信息，参考。
5.1.17.&联合子类(union-subclass)
第三种选择是仅仅映射类继承树中具体类部分到表中(每个具体类一张表的策略)。其中，每张表定义了类的所有持久化状态，包括继承的状态。在 Hibernate
中，并不需要完全显式地映射这样的继承树。你可以简单地使用单独的定义映射每个类。然而，如果你想使用多态关联(例如，一个对类继承树中超类的关联)，你需要使用映射。
<union-subclass
name="ClassName"
table="tablename"
proxy="ProxyInterface"
lazy="true|false"
dynamic-update="true|false"
dynamic-insert="true|false"
schema="schema"
catalog="catalog"
extends="SuperclassName"
abstract="true|false"
persister="ClassName"
subselect="SQL expression"
entity-name="EntityName"
node="element-name">
name: 子类的全限定名。
table: 子类的表名
proxy (可选): 指定一个类或者接口，在延迟装载时作为代理使用。
lazy (可选, 默认是 true):
设置为 lazy="false" 禁止使用延迟装载。
这种映射策略不需要指定辨别标志(discriminator)字段。
更多关于继承映射的信息，参考。
5.1.18.&连接(join)
元素，假若在表之间存在一对一关联,可以将一个类的属性映射到多张表中。
table="tablename"
schema="owner"
catalog="catalog"
fetch="join|select"
inverse="true|false"
optional="true|false">
table: 被连接表的名称。
schema (可选):覆盖由根元素指定的模式名称。
catalog (可选): 覆盖由根 元素指定的目录名称。
fetch (可选 - 默认是 join):
如果设置为默认值join， Hibernate 将使用一个内连接来得到这个类或其超类定义的，而使用一个外连接来得到其子类定义的。如果设置为select，则
Hibernate 将为子类定义的 使用顺序选择。这仅在一行数据表示一个子类的对象的时候才会发生。对这个类和其超类定义的，依然会使用内连接得到。
inverse (可选 - 默认是 false): 如果打开，Hibernate 不会插入或者更新此连接定义的属性。
optional (可选 - 默认是 false): 如果打开，Hibernate
只会在此连接定义的属性非空时插入一行数据，并且总是使用一个外连接来得到这些属性。
例如，一个人(person)的地址(address)信息可以被映射到单独的表中(并保留所有属性的值类型语义)： <class name="Person"
table="PERSON">
此特性常常对遗留数据模型有用，我们推荐表个数比类个数少，以及细粒度的领域模型。然而，在单独的继承树上切换继承映射策略是有用的，后面会解释这点。
5.1.19.&键(key)
我们目前已经见到过元素多次了。
这个元素在父映射元素定义了对新表的连接，并且在被连接表中定义了一个外键引用原表的主键的情况下经常使用。
column="columnname"
on-delete="noaction|cascade"
property-ref="propertyName"
not-null="true|false"
update="true|false"
unique="true|false"/>
column (可选): 外键字段的名称。也可以通过嵌套的 指定。
on-delete (可选, 默认是 noaction): 表明外键关联是否打开数据库级别的级联删除。
property-ref (可选): 表明外键引用的字段不是原表的主键(提供给遗留数据)。
not-null (可选): 表明外键的字段不可为空(这意味着无论何时外键都是主键的一部分)。
update (可选): 表明外键决不应该被更新(这意味着无论何时外键都是主键的一部分)。
unique (可选): 表明外键应有唯一性约束 (这意味着无论何时外键都是主键的一部分)。
对那些看重删除性能的系统，我们推荐所有的键都应该定义为on-delete="cascade"，这样
Hibernate 将使用数据库级的ON CASCADE DELETE约束，而不是多个DELETE语句。 注意，这个特性会绕过 Hibernate 通常对版本数据(versioned
data)采用的乐观锁策略。
not-null 和 update
属性在映射单向一对多关联的时候有用。如果你映射一个单向一对多关联到非空的(non-nullable)外键，你必须 用定义此键字段。
5.1.20.&字段和规则元素（column and formula
elements）
任何接受column属性的映射元素都可以选择接受 子元素。同样的，formula子元素也可以替换属性。 <column
name="column_name"
length="N"
precision="N"
not-null="true|false"
unique="true|false"
unique-key="multicolumn_unique_key_name"
index="index_name"
sql-type="sql_type_name"
check="SQL expression"
default="SQL expression"/>SQL expression
column 和 formula
属性甚至可以在同一个属性或关联映射中被合并来表达，例如，一些奇异的连接条件。 <many-to-one name="homeAddress" class="Address"
insert="false" update="false">
5.1.21.&引用(import)
假设你的应用程序有两个同样名字的持久化类，但是你不想在Hibernate查询中使用他们的全限定名。除了依赖auto-import="true"以外，类也可以被显式地“import(引用)”。你甚至可以引用没有被明确映射的类和接口。
class="ClassName"
rename="ShortName"/>
class: 任何Java类的全限定名。
rename (可选 - 默认为类的全限定名): 在查询语句中可以使用的名字。
5.1.22.&any
这是属性映射的又一种类型。
映射元素定义了一种从多个表到类的多态关联。这种类型的映射常常需要多于一个字段。第一个字段持有被关联实体的类型，其他的字段持有标识符。对这种类型的关联来说，不可能指定一个外键约束，所以这当然不是映射(多态)关联的通常的方式。你只应该在非常特殊的情况下使用它(比如，审计log，用户会话数据等等)。
属性使得应用程序能指定一个将数据库字段的值映射到持久化类的自定义类型。这个持久化类包含有用id-type指定的标识符属性。 你必须指定从meta-type的值到类名的映射。
name="propertyName"
id-type="idtypename"
meta-type="metatypename"
cascade="cascade_style"
access="field|property|ClassName"
optimistic-lock="true|false">
name: 属性名
id-type: 标识符类型
meta-type (可选 -默认是 string): 允许辨别标志(discriminator)映射的任何类型
cascade (可选 -默认是none):
级联的类型
access (可选 -默认是 property): Hibernate 用来访问属性值的策略。
optimistic-lock (可选 -默认是 true): 表明更新此组件是否需要获取乐观锁。换句话说，当这个属性变脏时，是否增加版本号(Version)
阅读(8252) | 评论(0) | 转发(0) |
相关热门文章
给主人留下些什么吧！~~
请登录后评论。}