当前位置：首页 > 实用文档 > 其他范文> hibernate配置文件映射文件

hibernate配置文件映射文件

时间：2023-08-01 07:39:54 其他范文收藏本文下载本文

hibernate配置文件映射文件（共6篇）由网友“喜剧之王”投稿提供，这次小编给大家整理过的hibernate配置文件映射文件，供大家阅读参考。

hibernate配置文件映射文件

篇1：hibernate配置文件映射文件

hibernate:

优点和缺点

优点：

* 数据缓存

* 面向对象编程

* 代码操作比较简单

缺点：

* 大量的数据条件下不适合用hibernate

* 程序员对于hibernate生成的sql语句不可控

程序员不能干预hibernate生成sql语句，

所以在sql语句优化比较高的项目中，

hibernate也是不适合的

jdbc的优点和缺点：

* jdbc的优点

* 效率要高

* Connection pool

* 缺点

* 代码比较繁琐

try{

}catch{

}

finally{

//做各种关闭操作

}

* data pool

hibernate主配置文件

“-//Hibernate/Hibernate Configuration DTD 3.0//EN”

hibernate.sourceforge.net/hibernate-configuration-3.0.dtd“>

com.mysql.jdbc.Driver

jdbc:mysql://localhost:3306/数据库名

root

update

true

resource=”cn/domain/Person.hbm.xml“ />

持久化类的映射文件

”hibernate.sourceforge.net/hibernate-mapping-3.0.dtd“>

在映射文件中的主键产生器的类型

主键的生成机制

* * increment

* 效率是比较低的，但是主键的值是连续的，hibernate内部会去查询该表中的主键的最大值，然后把最大值加1 *

* identity

* 根据底层的数据库的自增生成，效率比较高，但是主键的值不连续，注意，当采用这种机制时，数据库中主键要选择自增类型，

hibernate配置文件映射文件

，

* * assigned

* 手动赋值

* * uuid

* * sequence

java对应的持久化类该持久化类中一定要保证有一个不带参数的构造方法，原因是当通过hibernate框架反射出持久化类对象时，会调用到不带参数的构造方法。

篇2：Hibernate关系映射

六、继承映射

Single_Table

1、当多个类存在继承关系的时候，这时候建表的方案有3种，

2、第一种是父类中包含全部的属性，任何子类的信息都由父类对应的数据表来存储。在该表中，增加一个用于表示不同的子类及父类的字段，这样就可以对父类和子类数据进行区分。这种设计成为Single_Table。如下实验：

（1）设计一个父类Person.java。其中定义共有的属性id,name

package com.zgy.hibernate.model;

import javax.persistence.DiscriminatorColumn;

import javax.persistence.DiscriminatorType;

import javax.persistence.DiscriminatorValue;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Inheritance;

import javax.persistence.InheritanceType;

@Entity

@Inheritance(strategy=InheritanceType.SINGLE_TABLE)

@DiscriminatorColumn(name=”discriminator“,discriminatorType=DiscriminatorType.STRING)

@DiscriminatorValue(”person“)

public class Person {

private int id;

private String name;

@Id

@GeneratedValue

public int getId {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

（2）定义Student.java，定义自己的私有属性score

package com.zgy.hibernate.model;

import javax.persistence.DiscriminatorValue;

import javax.persistence.Entity;

@Entity

@DiscriminatorValue(”student“)

public class Student extends Person{

private int score;

public int getScore() {

return score;

}

public void setScore(int score) {

this.score = score;

}

（3）定义Teacher.java，定义自己的私有属性title

package com.zgy.hibernate.model;

import javax.persistence.DiscriminatorValue;

import javax.persistence.Entity;

@Entity

@DiscriminatorValue(”teacher“)

public class Teacher extends Person{

private String title;

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

（4）测试save()方法

package com.zgy.hibernate.model;

import java.util.Map;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

import org.hibernate.cfg.Configuration;

import org.hibernate.service.ServiceRegistry;

import org.hibernate.tool.hbm2ddl.SchemaExport;

import org.junit.AfterClass;

import org.junit.BeforeClass;

import org.junit.Test;

public class ORMapppingTest {

public static SessionFactory sf = null;

@BeforeClass

public static void beforeClass(){

Configuration configure =new Configuration().configure();

new SchemaExport(configure).create(true, true);

sf = configure.buildSessionFactory();

}

@Test

public void testSave() {

Student s = new Student();

s.setName(”s1“);

s.setScore(80);

Teacher t = new Teacher();

t.setName(”t1“);

t.setTitle(”中级“);

Session session = sf.openSession();

session.beginTransaction();

session.save(s);

session.save(t);

session.getTransaction().commit();

session.close();

}

@AfterClass

public static void afterClass(){

sf.close();

}

（5）查看SQL语句：

create table Person (

discriminator varchar(31) not null,

id integer not null auto_increment,

name varchar(255),

score integer,

title varchar(255),

primary key (id)

)

Hibernate: insert into Person (name, score, discriminator) values (?, ?, ‘student‘)

Hibernate: insert into Person (name, title, discriminator) values (?, ?, ‘teacher‘)

可以看出，在Person表中，产生了所有子类的字段，并且在保存数据的时候，每条数据都加入了对应的标识。

@Inheritance(strategy=InheritanceType.SINGLE_TABLE)用于定义存储的策略使用的是单表存储

@DiscriminatorColumn(name=”discriminator“,discriminatorType=DiscriminatorType.STRING)定义标识列，该列的类型是String类型

@DiscriminatorValue(”person“)定义Person类的数据在标识列discriminator中的取值是“person”

@DiscriminatorValue(”student“)定义Student类的数据对应的表示是“student”

@DiscriminatorValue(”teacher“)定义Teacher类的数据对应的表示是“teacher”

测试读取数据：

@Test

public void testLoad() {

testSave();

Session session = sf.openSession();

session.beginTransaction();

Student s = (Student)session.load(Student.class, 1);

Person t = (Person)session.load(Person.class, 2);

System.out.println(s.getScore());

System.out.println(t.getName());

session.getTransaction().commit();

session.close();

}

查看SQL语句：

Hibernate: select student0_.id as id2_0_0_, student0_.name as name3_0_0_, student0_.score as score4_0_0_ from Person student0_ where student0_.id=? and student0_.discriminator=‘student‘

Hibernate: select person0_.id as id2_0_0_, person0_.name as name3_0_0_, person0_.score as score4_0_0_, person0_.title as title5_0_0_, person0_.discriminator as discrimi1_0_0_ from Person person0_ where person0_.id=?

Table_Per_Class

(1)修改Person.java中的ID生成策略，使用Table生成主键

package com.zgy.hibernate.model;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.Inheritance;

import javax.persistence.InheritanceType;

import javax.persistence.TableGenerator;

@Entity

@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)

@TableGenerator(

name=”t_gen“,

table=”t_gen_table“,

pkColumnName=”t_pk“,

valueColumnName=”t_value“,

pkColumnValue=”person_pk“,

initialValue=1,

allocationSize=1

)

public class Person {

private int id;

private String name;

@Id

@GeneratedValue(generator=”t_gen“,strategy=GenerationType.TABLE)

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

(2)修改Student.java

package com.zgy.hibernate.model;

import javax.persistence.Entity;

@Entity

public class Student extends Person{

private int score;

public int getScore() {

return score;

}

public void setScore(int score) {

this.score = score;

}

(3)修改Teacher.java

package com.zgy.hibernate.model;

import javax.persistence.Entity;

@Entity

public class Teacher extends Person{

private String title;

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

(4)测试save()方法

@Test

public void testSave() {

Student s = new Student();

s.setName(”s1“);

s.setScore(80);

Teacher t = new Teacher();

t.setName(”t1“);

t.setTitle(”中级“);

Session session = sf.openSession();

session.beginTransaction();

session.save(s);

session.save(t);

session.getTransaction().commit();

session.close();

}

(5)观察生成的SQL语句

create table Person (

id integer not null,

name varchar(255),

primary key (id)

)

create table Student (

id integer not null,

name varchar(255),

score integer not null,

primary key (id)

)

create table Teacher (

id integer not null,

name varchar(255),

title varchar(255),

primary key (id)

)

create table t_gen_table (

t_pk varchar(255),

t_value integer

)

Hibernate: insert into Student (name, score, id) values (?, ?, ?)

Hibernate: insert into Teacher (name, title, id) values (?, ?, ?)

（6）测试load()方法

@Test

public void testLoad() {

testSave();

Session session = sf.openSession();

session.beginTransaction();

Student s = (Student)session.load(Student.class, 1);

Teacher t = (Teacher)session.load(Teacher.class, 2);

System.out.println(s.getScore());

System.out.println(t.getName());

session.getTransaction().commit();

session.close();

}

（7）观察SQL语句

Hibernate: select student0_.id as id1_0_0_, student0_.name as name2_0_0_, student0_.score as score1_1_0_ from Student student0_ where student0_.id=?

Hibernate: select teacher0_.id as id1_0_0_, teacher0_.name as name2_0_0_, teacher0_.title as title1_2_0_ from Teacher teacher0_ where teacher0_.id=?

Joined

（1）修改Person.java

package com.zgy.hibernate.model;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Inheritance;

import javax.persistence.InheritanceType;

@Entity

@Inheritance(strategy=InheritanceType.JOINED)

public class Person {

private int id;

private String name;

@Id

@GeneratedValue

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

（2）Student.java和Teacher只保留@Entity

（3）测试save()方法

@Test

public void testSave() {

Student s = new Student();

s.setName(”s1“);

s.setScore(80);

Teacher t = new Teacher();

t.setName(”t1“);

t.setTitle(”中级“);

Session session = sf.openSession();

session.beginTransaction();

session.save(s);

session.save(t);

session.getTransaction().commit();

session.close();

}

（4）查看SQL语句

create table Person (

id integer not null auto_increment,

name varchar(255),

primary key (id)

)

create table Student (

score integer not null,

id integer not null,

primary key (id)

)

create table Teacher (

title varchar(255),

id integer not null,

primary key (id)

)

alter table Student

add constraint FK_ohs43dct8k52ch2exlmf4bs3l

foreign key (id)

references Person (id)

alter table Teacher

add constraint FK_g6jmt7fcm6gfd0jvhimb9xy84

foreign key (id)

references Person (id)

Hibernate: insert into Person (name) values (?)

Hibernate: insert into Student (score, id) values (?, ?)

Hibernate: insert into Person (name) values (?)

Hibernate: insert into Teacher (title, id) values (?, ?)

（5）测试load()方法

@Test

public void testLoad() {

testSave();

Session session = sf.openSession();

session.beginTransaction();

Student s = (Student)session.load(Student.class, 1);

Teacher t = (Teacher)session.load(Teacher.class, 2);

System.out.println(s.getScore());

System.out.println(t.getName());

session.getTransaction().commit();

session.close();

}

（6）观察SQL语句

Hibernate: select student0_.id as id1_0_0_, student0_1_.name as name2_0_0_, student0_.score as score1_1_0_ from Student student0_ inner join Person student0_1_ on student0_.id=student0_1_.id where student0_.id=?

Hibernate: select teacher0_.id as id1_0_0_, teacher0_1_.name as name2_0_0_, teacher0_.title as title1_2_0_ from Teacher teacher0_ inner join Person teacher0_1_ on teacher0_.id=teacher0_1_.id where teacher0_.id=?

篇3：Hibernate关系映射之关联映射

Hibernate关系映射

1.关联映射

概念：关联映射，就是将关联关系映射到数据库中，所谓的关联关系，在对象模型中，就是一个或多个引用

分类：

（1）多对一关联映射

many-to-one

多对一关联映射原理：在多的一端加入一个外键，指向一的一端

在多的一端采用如下标签映射：

（2）一对一关联映射

one-to-one

A主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联

示例1:

hibernate一对一主键关联映射（单向关联Person--->IdCard）

一对一关联映射原理：让两个实体的主键一样，这样就不需要加入多余的字段了（扩展性不好）

示例2:

hibernate一对一主键关联映射（双向关联Person<--->IdCard）

需要在IdCard加入标签，

指示hibernate将关联对象Person根据主键加载上来

不影响存储，只影响加载

标签fetch属性默认为”join“.

B唯一外键关联：外键关联，本来是用于多对一的配置，但是如果加上唯一的限制之后，也可以用来表示一对一关联关系

示例1:

hibernate一对一唯一外键关联映射（单向关联Person--->IdCard）

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

采用标签来映射，指定多的一端unique为true,

这样就限制了多的一端的多重性为一，就是这样来映射的，

示例2:

hibernate一对一唯一外键关联映射（双向关联Person<--->IdCard）

一对一唯一外键关联双向，采用标签映射，

必须指定标签中的property-ref属性为关系字段的名称

（3）一对多关联映射

one-to-many

示例1:

hibernate一对多关联映射（单向Classes--->Student）

一对多和多对一的映射原理是一样的，都是在多的一端加入一个外键指向一的一端

它们的区别在于维护的关系不同：

*多对一维护的关系：多指向一的关系，如果维护了多指向一的关系，那么加载多的时候会把一加载上来

*一对多维护的关系：一指向多的关系，如果维护了一指向多的关系，那么加载一的时候会把多加载上来

在一的一端维护关系存在缺陷：

*因为多的一端Student不知道Classes的存在（也就是Student没有维护与Classes的关系）

所以在保存Student的时候关系字段classesId是为null的，如果将该字段设置为非空，则将无法保存数据

*另外因为Student不维护关系，而Classes维护关系，Classes就会发出多余的update语句，保证Classes和Student有关系，这样加载Classes的时候才能把该Classes对应的学生集合加载上

--会发出多余的update语句来维持关系

示例2:

hibernate一对多关联映射（双向Classes<--->Student）

采用一对多双向关联映射的目的主要是为了解决一对多单向关联的缺陷

而不是需求驱动的

一对多双向关联的映射方式：

*在一的一端的集合上采用标签，在多的一端加入一个外键

*在多的一端采用标签

!!!注意：

标签和标签加入的字段保持一致，否则会产生数据混乱

（4）多对多关联映射

many-to-many

示例1:

hibernate多对多关联映射（单向User--->Role）

具体映射：

把第三张表也抽取出一个类出来，使用两个many-to-one来完成

示例2:

hibernate多对多关联映射（双向User<--->Role）

具体映射：

需要注意：

*生成的中间表名称必须一样

*生成的中间表中的字段必须一样

篇4：映射 Git 资料库到文件：gitannex

git-annex 允许映射 Git 资料库到文件，主要为 Git 用户设计，用于管理 git 的文件，

项目主页：www.open-open.com/lib/view/home/1396341793809

篇5：用HOSTS文件屏蔽网站建立网站映射的方法

最初想到利用Hosts文件是基于学校跨网段访问网页时用IP地址访问带来的不便：学校教学网系统分成四个网段，包括三个学生机房网段和一个办公室教师用机网段，服务器没有使用D，办公室教师机有的开了PWS(个人Web服务器)，教师在同一网段中输入HostName(主机名)即可顺利访问网页，但在学生机房要访问教师Web页，必须使用IP地址。

Hosts是Windows早期用来建立IP地址和Hostname(主机名)映射关系的文件。这样在客户机上访问主机时，只要输入主机名即可。随着后来D概念的引入，Internet网上D服务器的建立，这个文件已经逐渐被人们谈忘。由于Hosts文件的执行优先级高于D域名解析，为了防止出现Hosts和D域名访问的混乱，在Windows98中把Hosts改成了Hosts.sam，就是要取消该文件的域名解析功能。而本文所述恰恰是利用了Hosts文件的这一功能。

Hosts.sam文件位于C:\Windows文件夹中，要使用它的功能，首先要改成Hosts文件，即把扩展名去掉。用记事本打开Hosts文件，首先看见的是微软对这个文件的说明。这个文件是根据TCP/IPforWindows的标准来工作的，规定要求每段只能包括一个映射关系，IP地址要放在每段的最前面，空格后再写上映射的Hostname(主机名)，如：

7.0.0.www.sina.com.cn

#屏蔽新浪网站

9.68.0.50www.stw.net

#学校内部Web服务器主机名映射

按照上面的方法输入后，打开浏览器输入上述两个域名，却出现了问题：新浪网仍能正常访问，不过网页打开的速度变慢(没有被屏蔽)，而学校内部网站却仍然不能正确访问，

偶然在MS-DOS下Ping了一下这两个域名，却发现映射已经成立。奇怪，为什么在DOS命令行下能Ping通，在浏览器中却不能正确映射？

解释只有一个：就是Hosts设置是有效的，是IE浏览器让Hosts设置无效的。

打开浏览器后，笔者对IE的“Internet选项”设置进行了研究，终于发现了问题的症结所在，并且找到了解决的方法。

我校客户机通过HTTP代理进行上网，因此在浏览器里如图所示的设置。去掉“为LAN使用代理服务器”前面的“√”后，上面的映射在IE中就全部生效了，并且校园网跨网段的网页可以通过Http://www.stw.net

上述问题对于通过单机联入公网的用户来说是碰不到的，因为它不需要设置代理服务器；对于要求用代理连接公网又想屏蔽不健康网页的局域网用户来说，就需要这样做了。