Hibernate配置文件的DTD

合集下载

hibernate.xml文件详解

hibernate.xml⽂件详解1 2 <?xml version='1.0' encoding='gb2312'?>3 <!--表明解析本XML⽂件的DTD⽂档位置，DTD是Document Type Definition 的缩写,即⽂档类型的定义,XML解析器使⽤DTD⽂档来检查XML⽂件的合法性。

/hibernate-configuration-3.0dtd可以在Hibernate3.14 <!DOCTYPE hibernate-configuration PUBLIC5"-//Hibernate/Hibernate Configuration DTD 3.0//EN"6"/hibernate-configuration-3.0.dtd">7 8 <hibernate-configuration>9 10 <session-factory>11 12 <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver </property>13 14 <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate </hibernate>15 16 <property name="ername">root </property>17 18 <property name="hibernate.connection.password">123456 </property>19 20 <property name="hibernate.connection.pool.size">20 </property>21 <!--是否在后台显⽰Hibernate⽤到的SQL语句，开发时设置为true，便于差错，程序运⾏时可以在Eclipse的控制台显⽰Hibernate的执⾏Sql语句。

Hibernate基本使用及配置

Hibernate基本使⽤及配置Hibernate基本使⽤及配置Hibernate是什么框架Hibernate是⼀个开放源代码的对象关系映射框架1.它对JDBC进⾏了⾮常轻量级的对象封装2.它将POJO与数据库表建⽴映射关系，是⼀个全⾃动的orm框架3.Hibernate可以⾃动⽣成SQL语句，⾃动执⾏，使得Java程序员可以随⼼所欲的使⽤对象编程思维来操纵数据库。

4.Hibernate可以应⽤在任何使⽤JDBC的场合，既可以在Java的客户端程序使⽤，也可以在Servlet/JSP的Web应⽤中使⽤5.它是持久层的ORM框架POJO是什么简单的Java对象，实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称EJB是什么是Sun的JavaEE服务器端组件模型，设计⽬标与核⼼应⽤是部署分布式应⽤程序。

简单来说就是把已经编写好的程序（即：类）打包放在服务器上执⾏。

ORM是什么Object Relational Mapping（对象关系映射），指的是将⼀个Java中的对象与关系型数据库中的表建⽴⼀种映射关系，从⽽操作对象就可以操作数据库中的表。

使⽤Hibernate有什么好处1.对JDBC访问数据库的代码进⾏了轻量级封装，简化了数据访问层繁琐重复性的代码，减少了内存消耗，加快了运⾏效率2.是⼀个基本JDBC的主流持久化框架，很⼤程度上简化了DAO层的编码⼯作3.性能⾮常好，映射灵活性⽐较好，⽀持多关系数据库，⼀对⼀，⼀对多，多对多的各种复杂关系4.可扩展性强，源代码及API开放，当本⾝功能不够⽤时，可以⾃⾏编码进⾏扩展框架下载地址/doc/81822fa9366baf1ffc4ffe4733687e21af45ffb1.html /orm/Hibernate⽬录解析documentation Hibernate开发的⽂档project Hibernate提供的参考项⽬lib Hibernate开发的⽂档required Hibernate开发的必须的依赖包optional Hibernate开发的可选的jar包Hibernate使⽤1.创建⼀个项⽬（普通Java项⽬、Web项⽬都可以）2.引⼊必须的jar包①数据库的驱动包②Hibernate开发必须的Jar包3.建表5.创建Hibernate的核⼼配置⽂件，通常都叫hibernate.cfg.xml①创建完毕后，也有⼀个约束要引⼊，在org.hibernate包当中可以找到对应的dtd configuration.dtd数据库相关配置（如果属性名记不住）：在⽬录提供的project当中有⼀个etc，在etc当中有⼀个hibernate.properties 的⽂件打开。

Hibernate配置文件详解

Hibernate配置文件详解hibernate的基本配置文件有两种：hibernate.cfg.xml和model.hbm.xml文件。

hibernate.cfg.xml包含了Hibernate与数据库的基本连接信息，在Hibernate工作的初始阶段，这些信息被先后加载到Configuration和SessionFactory实例；model.hbm.xml包含了Hibernate的基本映射信息，即系统中每一个类与其对应的数据库表之间的关联信息，在Hibernate工作的初始阶段，这些信息通过hibernate.cfg.xml的mapping 节点被加载到Configuration和SessionFactory实例。

这两种文件信息包含了Hibernate的所有运行期参数。

下面我们用详细的例子来说明这两种文件的基本结构和内容。

一、hibernate.cfg.xml文件：[html] view plain copy 在CODE上查看代码片派生到我的代码片 <?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><property name="ername">root</property><property name="connection.url">jdbc:mysql://localhost:3306/webases</property><property name="dialect">org.hibernate.dialect.MySQLDialect</property><property name="connection.password">274507</property><property name="connection.driver_class">com.mysql.jdbc.Driver</property><mapping resource="com/Hibernate/test_products.hbm.xml" /></session-factory></hibernate-configuration>二、.hbm.xml文件：由于Hibernate的关联关系包含了一对一、一对多、多对一和多对多等四种类型，因此，也就有分别与之对应的四种.hbm.xml文件。

Hibernate的使用概括

Hibernate学习笔记1．Hibernate的相关配置配置文件<?xml version='1.0' encoding='utf-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration -3.0.dtd"><hibernate-configuration><session-factory><propertyname="connection.driver_class">com.mysql.jdbc.Driver</pro perty><propertyname="connection.url">jdbc:mysql://localhost:3306/dipihn< /property><propertyname="ername">root</property><propertyname="connection.password">bipt123</property><property name="connection.pool_size">1</property><propertyname="dialect">org.hibernate.dialect.MySQLDialect</proper ty><propertyname="current_session_context_class">thread</property><propertyname="cache.provider_class">org.hibernate.cache.NoCachePr ovider</property><property name="show_sql">true</property><mappingresource="cn/net/persist/domain/User.hbm.xml"/></session-factory></hibernate-configuration>映射文件<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.d td"><hibernate-mapping><class name="er" table="User"> <id name="id" column="id"><generator class="native"/></id><property name="name" column="name"/><property name="age" column="age"/><property name="state" column="state"/></class>2．</hibernate-mapping>Hibernate common annotation实体类前加Entityid的注释@IdId自增长@GeneratedV alueId table生成策越相应配置改变<mapping class=".persist.domain.Teacher"/>3．Log4j注释加入log4j.jar slf4j.jar slf4j-log4j.jar加入log4j.properties4 定义组合主键将组件类注解为@Embeddable,并将组件的属性注解为@Id将组件的属性注解为@EmbeddedId将实体类注解为@IdClass,并将该实体中所有属于主键的属性都注解为@Id 5．hibernate inheritance父类前加@MappedSuperclass6. coreapisave() saveOrUpdate() update() delete()get() load()clear() flush() close()7. one2one@oneToOne@joinColumn(name=”WifeId”)one@one Bi @oneToOne(mappedBy=”wife”)8 components对应属性@Enbedded9 many to one@manyToOne(cascade=cascadeType.ALL)10．one to many@OneToMany(cascade=CascadeType.ALLs)@JoinColumn(name="groupId")Join table@OneToMany(cascade=CascadeType.ALL)@JoinTable(name="group_users",joinColumns = @JoinColumn(name="groupId"),inverseJoinColumns = @JoinColumn(name = "userId"))11. many to many@ManyToMany(cascade=(CascadeType.ALL)@JoinTable(name="teacher_students",joinColumns = @JoinColumn(name= "teacherId"),inverseJoinColumns = @JoinColumn(name = "studentId"))12.tree@ManyToOne(cascade=CascadeType.ALL)@JoinColumn(name="parentId")public Org getParent() {return parent;}public void setParent(Org parent) {this.parent = parent;}@OneToMany(cascade=CascadeType.ALL,mappedBy="parent",f etch=FetchType.EAGER)public Set<Org> getChildren() {return children;}public void setChildren(Set<Org> children) {this.children = children;}13 HQL语句的使用@Testpublic void testHQL_1(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "from Category";Query q = session.createQuery(hql);List<Category>categorys = (List<Category>)q.list();for(Category c:categorys){System.out.println(c.getId()+" - "+c.getName());}session.getTransaction().commit();}@Testpublic void testHQL_2(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "from Category c where >'c5'";Query q = session.createQuery(hql);List<Category>categorys = (List<Category>)q.list();for(Category c:categorys){System.out.println(c.getId()+" - "+c.getName());}session.getTransaction().commit();}@Testpublic void testHQL_3(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "from Category c order by DESC";Query q = session.createQuery(hql);List<Category>categorys = (List<Category>)q.list();for(Category c:categorys){System.out.println(c.getId()+" - "+c.getName());}session.getTransaction().commit();}@Testpublic void testHQL_4(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "select distinct c from Category c order by DESC";Query q = session.createQuery(hql);List<Category>categorys = (List<Category>)q.list();for(Category c:categorys){System.out.println(c.getId()+" - "+c.getName());}session.getTransaction().commit();}@Testpublic void testHQL_5(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "from Category c where c.id > :min and c.id < :max";Query q = session.createQuery(hql).setInteger("min", 2).setInteger("max", 8);List<Category>categorys = (List<Category>)q.list();for(Category c:categorys){System.out.println(c.getId()+" - "+c.getName());}session.getTransaction().commit();}@Testpublic void testHQL_6(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "from Category c where c.id>? and c.id<?";Query q = session.createQuery(hql).setParameter(0, 2).setParameter(1, 8);List<Category>categorys = (List<Category>)q.list();for(Category c:categorys){System.out.println(c.getId()+" - "+c.getName());}session.getTransaction().commit();}@Test//翻页查询public void testHQL_7(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "from Category c order by DESC";Query q =session.createQuery(hql).setMaxResults(4).setFirstResult( 2);List<Category>categorys = (List<Category>)q.list();for(Category c:categorys){}session.getTransaction().commit();}@Testpublic void testHQL_8(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "select c.id, from Category c order by DESC";Query q = session.createQuery(hql);//返回的集合中元素为Object数组List<Object[]>categorys = (List<Object[]>)q.list();for(Object[] c:categorys){System.out.println(c[0]+" - "+c[1]);}session.getTransaction().commit();}//设定fetch type 为lazy后将不会有第二条sql语句@Testpublic void testHQL_9(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "from Topic t where t.category.id = 1";Query q = session.createQuery(hql);List<Topic> topics = (List<Topic>)q.list();for(Topic t:topics){System.out.println(t.getId()+" - "+t.getTitle());}session.getTransaction().commit();}@Testpublic void testHQL_10(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "from Topic t where t.category.id = 1";Query q = session.createQuery(hql);List<Topic> topics = (List<Topic>)q.list();for(Topic t:topics){}session.getTransaction().commit();}@Testpublic void testHQL_11(){Session session =sessionFactory.getCurrentSession();session.beginTransaction();String hql = "from Message m where m.topic.category.id = 1";Query q = session.createQuery(hql);List<Message> msgs = (List<Message>)q.list();for(Message m:msgs){System.out.println(m.getId()+" -"+m.getContent());}session.getTransaction().commit();}@Testpublic void testHQL_12() {Session session =sessionFactory.getCurrentSession();session.beginTransaction();Query q = session.createQuery("select new.persist.domain.MsgInfo" +"(m.id, m.content, m.topic.title,) from Message m");for(Object o : q.list()) {MsgInfo m = (MsgInfo)o;System.out.println(m.getContent());}session.getTransaction().commit();}@Testpublic void testHQL_13() {String hql = "select t.title, from Topic t join t.category c";Session session =sessionFactory.getCurrentSession();session.beginTransaction();Query q = session.createQuery(hql);for(Object o : q.list()) {Object[] m = (Object[])o;System.out.println(m[0]+" - " + m[1]);}session.getTransaction().commit();}@Testpublic void testHQL_14() {String hql = "from Message m where m = :MsgSearch";Session session =sessionFactory.getCurrentSession();session.beginTransaction();Query q = session.createQuery(hql);Message m = new Message();m.setId(1);q.setParameter("MsgSearch", m);Message mResult = (Message)q.uniqueResult();System.out.println(mResult.getContent());session.getTransaction().commit();}@Testpublic void testHQL_15() {String hql = "select count(*)from Message m";Session session =sessionFactory.getCurrentSession();session.beginTransaction();Query q = session.createQuery(hql);long count = (Long)q.uniqueResult();System.out.println(count);session.getTransaction().commit();}@Testpublic void testHQL_16() {String hql = "select max(m.id)from Message m";Session session =sessionFactory.getCurrentSession();session.beginTransaction();Query q = session.createQuery(hql);Object o = q.uniqueResult();System.out.println(o.toString());session.getTransaction().commit();}@Testpublic void testHQL_17() {String hql = "from Message m where m.id between 3 and 5";Session session =sessionFactory.getCurrentSession();session.beginTransaction();Query q = session.createQuery(hql);for(Object o:q.list()){Message m = (Message)o;System.out.println(m.getId()+" -"+m.getContent());}session.getTransaction().commit();}@Testpublic void testHQL_18() {String hql = "from Message m where m.id in(3,4,5)";Session session =sessionFactory.getCurrentSession();session.beginTransaction();Query q = session.createQuery(hql);for(Object o:q.list()){Message m = (Message)o;System.out.println(m.getId()+" -"+m.getContent());}session.getTransaction().commit();}@Testpublic void testHQL_19() {String hql = "from Message m where m.content is not null";Session session =sessionFactory.getCurrentSession();session.beginTransaction();Query q = session.createQuery(hql);for(Object o:q.list()){Message m = (Message)o;System.out.println(m.getId()+" - "+m.getContent());}session.getTransaction().commit();}。

【Hibernate】Hibernate框架配置详解

【Hibernate】Hibernate框架配置详解通过Hibernate我们可以⽅便地操作数据库读取出来的信息，减少了繁琐的JDBC操作。

⼀般情况下，有两种⽅式可以进⾏Hibernate的配置，⼀种是通过配置⽂件进⾏配置，另⼀种是通过注解进⾏配置。

我将通过注解简单介绍Hibernate框架的配置。

Hibernate框架的配置⼀般可以分为以下⼏个步骤：1.添加基本的Hibernate Jar包2.添加注解的Jar包3.编写Hibernate.cfg.xml⽂件4.编写POJO⽂件，并编写注释5.编写测试⽂件，导出到数据库进⾏测试。

⼀、导⼊基本的Hibernate Jar包⼆、导⼊Hibernate Annotation 的Jar包三、编写Hibernate.cfg.xml⽂件1<?xml version='1.0' encoding='UTF-8'?>2<!DOCTYPE hibernate-configuration PUBLIC3 "-//Hibernate/Hibernate Configuration DTD 3.0//EN"4 "/hibernate-configuration-3.0.dtd">567<hibernate-configuration>89<session-factory>1011<property name="myeclipse.connection.profile">12 com.mysql.jdbc.Driver13</property>14<property name="connection.url">15 jdbc:mysql://localhost:3306/basehibernate16</property>17<property name="ername">root</property>18<property name="connection.password">sa</property>19<property name="connection.driver_class">20 com.mysql.jdbc.Driver21</property>22<property name="dialect">23 org.hibernate.dialect.MySQLDialect24</property>252627<property name="hbm2ddl.auto">auto</property>28<property name="connection.autocommit">true</property>29<mapping class="com.basehibernate.pojo.Department"/>30<mapping class="com.basehibernate.pojo.Employee"/>31<mapping class="com.basehibernate.pojo.Meal"/>32<mapping class="com.basehibernate.pojo.OrderMeal"/>33<mapping class="com.basehibernate.pojo.GradeMeal"/>34<mapping class="com.basehibernate.pojo.RewardMeal"/>3536</session-factory>3738</hibernate-configuration>不同数据库连接在Hibernate.cfg.xml中的配置不同，这⾥以MySQL为例。

Hibernate学习笔记

Hibernate项目的构建与配置1.在项目里倒入Hibernate所必须的Jar包(1)Hibernate框架可以使用在任何的Java项目里，并不一定是Web项目。

只需要在项目里倒入Hibernate所必须要使用的jar包就可以了。

(2)在Hibernate的官网下载hibernate-release-4.2.2.Final.zip解压，要使用Hibernate必须导入的jar包就在目录“hibernate-release-4.2.2.Final\lib\required”下。

倒入此路径下的所有jar包就可以了。

2.配置hibernate.cfg.xml文件(1)配置hibernate.cfg.xml文件可以参考“\project\etc”目录下的hibernate.cfg.xml文件与hibernate.properties文件。

(2)使用Hibernate连接MySQL的hibernate.cfg.xml配置文件如下：<!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory>（设置显示Hibernate产生的SQL语句）<property name="show_sql">true</property>（设置MySQL的SQL语法的方言）<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>（设置MySQL的驱动程序）<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>（设置MySQL的数据库路径、用户名、密码）<property name="hibernate.connection.url">jdbc:mysql:///java</property><property name="ername">root</property><property name="hibernate.connection.password">lizhiwei</property>（设置当数据库要保存的表不存在时，就新建表）<property name="hibernate.hbm2ddl.auto">update</property>（设置对象与数据库表的关系映射文件）<mapping resource="vo/User.hbm.xml"/></session-factory></hibernate-configuration>(3)此配置文件一般放在项目的src目录下。

Hibernate基础知识详解

Hibernate基础知识详解<hibernate-mapping><class name="*.*.*" table="t_customer" catalog="***"><id name="id" column="c_id"><generator class="identity"/></id><property name="name" column="c_name" length="20"/><set name="orders" inverse="false" cascade="save-update"><key column="c_customer_id"/></set></class></hibernate-mapping>(1)统⼀声明包名，这样在<class>中就不需要写类的全名。

(2)关于<class>标签配置name 属性:类的全名称table 表的名称,可以省略，这时表的名称就与类名⼀致catalog 属性:数据库名称可以省略.如果省略，参考核⼼配置⽂件中 url 路径中的库名称(3)关于<id>标签,<id>是⽤于建⽴类中的属性与表中的主键映射。

name 类中的属性名称column 表中的主键名称 column 它也可以省略，这时列名就与类中属性名称⼀致length 字段长度type 属性指定类型<generator>它主要是描述主键⽣成策略。

Hibernate配置文件中映射元素详解

Hibernate配置文件中映射元素详解添加时刻:2007-4-22本文中将讲述Hibernate的大体配置及配置文件的应用，这关于正确熟练利用Hibernate是相当关键的。

配置文件中映射元素详解对象关系的映射是用一个XML文档来讲明的。

映射文档能够利用工具来生成，如XDoclet，Middlegen 和AndroMDA等。

下面从一个映射的例子开始讲解映射元素，映射文件的代码如下。

＜?xml version="1.0"?＞＜!--所有的XML映射文件都需要定义如下所示的DOCTYPE。

Hibernate会先在它的类路径（classptah）中搜索DTD文件。

--＞＜!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http：///hibernate-mapping-3.0.dtd"＞＜!--hibernate-mapping有几个可选的属性：schema属性指明了这个映射的表所在的schema名称。

default-cascade属性指定了默认的级联风格可取值有none、save、update。

auto-import属性默认让我们在查询语言中可以使用非全限定名的类名可取值有true、false。

package属性指定一个包前缀。

--＞＜hibernate-mapping schema="schemaName" default-cascade="none"auto-import="true" package="test"＞＜!--用class元素来定义一个持久化类--＞＜class name="People" table="person"＞＜!-- id元素定义了属性到表主键字段的映射。

Hibernate连接池的三种配置方式

Hibernate 连接池的三种配置方式：dbcp , c3p0 , proxoolURL的多种指定方式连接池监控在hibernate3.0中，已经不再支持dbcp了，hibernate的作者在中，明确指出在实践中发现dbcp有BUG,在某些种情会产生很多空连接不能释放，所以抛弃了对dbcp的支持。

1 =================== C3P0 配置=============================Xml代码<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><property name="transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</property><property name="jdbc.batch_size">50</property><property name="e_second_level_cache">false</property><property name="current_session_context_class">thread</property><property name="show_sql">true</property><property name="format_sql">true</property><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property><property name="ername">0804</property><property name="connection.password">0804</property><property name="connection.url">jdbc:oracle:thin:@192.168.0.200:1521:orcl</property><property name="c3p0.max_size">2</property><property name="c3p0.min_size">2</property><property name="c3p0.timeout">5000</property><property name="c3p0.max_statements">100</property><property name="c3p0.idle_test_period">3000</property><property name="c3p0.acquire_increment">2</property><property name="c3p0.validate">false</property><mapping resource="com/ket/ruan/so/entity/User.hbm.xml"/><mapping resource="com/ket/ruan/so/entity/Product.hbm.xml"/>。

hibernate映射文件的配置

1. Doctype所有的XML映射都需要定义如上所示的doctype。

DTD可以从上述URL中获取，也可以从hibernate-x.x.x/src/net/sf/hibernate目录中、或hibernate.jar文件中找到。

Hibernate总是会首先在它的classptah中搜索DTD文件。

如果你发现它是通过连接Internet查找DTD 文件，就对照你的classpath目录检查XML文件里的DTD声明。

2. hibernate-mapping这个元素包括一些可选的属性。

schema和catalog属性，指明了这个映射所连接（refer）的表所在的schema和/或catalog名称。

假若指定了这个属性，表名会加上所指定的schema 和catalog的名字扩展为全限定名。

假若没有指定，表名就不会使用全限定名。

default-cascade指定了未明确注明cascade属性的Java属性和集合类Hibernate会采取什么样的默认级联风格。

auto-import属性默认让我们在查询语言中可以使用非全限定名的类名。

<hibernate-mappingschema="schemaName" (1)catalog="catalogName" (2)default-cascade="cascade_style" (3)default-access="field|property|ClassName" (4)default-lazy="true|false" (5)auto-import="true|false" (6)package="" (7)/>(1) schema (可选): 数据库schema的名称。

(2) catalog (可选): 数据库catalog的名称。

Hibernate教程

其实Hibernate本身是个独立的框架，它不需要任何web server或application server的支持。

然而，大多数的Hibernate入门介绍都加入了很多非Hibernate的东西，比如: Tomcat, Eclipse, Log4J,Struts, XDoclet, 甚至JBoss。

这容易让人产生Hibernate复杂难懂的误解，特别是打击了初学者的积极性。

在这篇文章将不涉及Eclipse, log4j, Struts, Tomcat, XDoclet，和JBoss。

本文的目的是演示一下Hibernate的安装过程以及最基本的功能，从而给初学者一个低得不能再低的入门门槛。

下载文件你需要Java SDK、Hibernate包、Ant包、和JDBC Driver。

1、Hibernate包下载地址:/hibernate/?sort_by=date&sort=desc2、Ant包下载地址:/ant/binaries/apache-ant-1.6.1-bin.zip3、JDBC Driver要根据你用的database来定，一般database官方网站上都会有。

Hibernate 支持常用的database，比如MySQL, Oracle, PostgreSQL, 和MS-SQL Server。

这些数据库都有JDBC Driver:Oracle JDBC Driver下载地址(下载前必须同意Oracle协议书)/software/htdocs/distlic.html?/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.h tmlMySQL JDBC Driver下载地址/downloads/connector/j/3.0.htmlPostgreSQL JDBC Driver下载地址/download.htmlMS-SQL Server JDBC Driver下载地址/downloads/details.aspx?FamilyID=9f1874b6-f8e1-4bd6-947c-0fc5bf05 bf71&displaylang=en4、将Hibernate包和Ant包分别解压至c:\dev\下(此目录不重要，你可以换其它任何目录)。

Hibernate配置文件

数据库自动生成
uuid(字符串类型) increment(整型数值类型) identity (整型数值类型) sequence (整型数值类型) native(整型数值类型)
assigned

assigned策略是由程序员手工控制输入数据模型 OID的一种id生成策略 assigned策略不限定数据库中id字段的类型 assigned策略无法保障id的不重复性 assigned策略通常配合外部自定义的id生成策略使用，否则将具有很大的风险性
基本数据有一个默认值的特点，特性在对象数据封装时存在着数据隐患，一旦基本数据类型取值为默认值，开发者将无法区分该值是用户输入数据还是未输入数据由系统默认给出封装类数据类型可以使用是否为null来判定该数据是来自于用户输入还是未输入
Hibernate配置文件分类

Hibernate配置文件分为两大类
数据库连接的配置可选配置资源注册二级缓存(后面详细讲解)
数据库连接配置

hibernate.connection.driver_class
JDBC驱动类类名
hibernate.connection.url
JDBC连接字符串
ername

代理主键：不具有业务含义
声明一个不具有任何业务含义的属性，仅用于区分对象，这种属性即便暴漏给最终用户查看，也不具有安全隐患

OID选择应尽量避免使用自然主键，改用代理主键
对象属性的类型选择

Java对象中的属性描述对象具有的状态，在对状态进行描述时，应避免使用基本数据类型，改用对应的封装类模型
property格式

属性与字段的映射要配置数据模型中声明的属性与字段之间的对应关系，共有以下三种格式格式一：格式二：格式三：

hibernate实现有两种配置,xml配置与注释配置

Hibernate实现有两种配置，xml配置与注释配置hibernate实现有两种配置，xml配置与注释配置。

（1）：xml配置：hibernate.cfg.xml （放到src目录下）和实体配置类:xxx.hbm.xml（与实体为同一目录中）<?xml version='1.0' encoding='utf-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><property name="connection.driver_class">com.mysql.jdbc.Driver</property><property name="connection.url">jdbc:mysql://localhost:3306/hxj</property><property name="ername">root</property> <property name="connection.password">root</property><property name="connection.pool_size">1</property><property name="dialect">org.hibernate.dialect.MySQLDialect</property> <property name="current_session_context_class">thread</property><property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property><property name="show_sql">true</property><!—update也可以用create/create-drop/update/validate代替, create 表示可以根据实体配置文件来自动生成表（只能生成表）.--><property name="hbm2ddl.auto">update</property>// 实体配置类<mapping resource="com/wsw/struts/model/Person.hbm.xml"/></session-factory></hibernate-configuration>(2): 实体配置类：xxx.hbm.xml<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package=”com.wsw.struts.model”><class name="Person" table="per"><id name="id" column="id"><generator class="native"/> //字段自增</id><property name="username" column="p_username"/><property name="age" column="p_age"/></class></hibernate-mapping>（3）：测试类（包括获取SessionFactory类和实体测试类）SessionFactory类：HibernateUtilpublic class HibernateUtil {private static final SessionFactory sessionFactory;static {try {// Create the SessionFactory from hibernate.cfg.xmlsessionFactory = new Configuration().configure().buildSessionFactory();} catch (Throwable ex) {// Make sure you log the exception, as it might be swallowedSystem.err.println("Initial SessionFactory creation failed." + ex);throw new ExceptionInInitializerError(ex);}}public static SessionFactory getSessionFactory() {return sessionFactory;}}实体测试类：PersonManager-----------------------------------------------------------------------------------public class PersonManager {public static void main(String[] args) {createAndStorePerson();HibernateUtil.getSessionFactory().close();}private static void createAndStorePerson() {Session session = // 通过Session工厂获取Session对象HibernateUtil.getSessionFactory().getCurrentSession();session.beginTransaction(); //开始事务Person person = new Person();person.setUsername("何小景");person.setAge(26);session.save(person);session.getTransaction().commit(); // 提交事务}}（4）：注解方式：注解的方式与xml很很多类似：首先是需要加入4个jar包：hibernate-commons-annotations.jar 、 hibernate-annotations.jar ejb3-persistence.jar 、 hibernate-jpa-2.0-api-1.0.1.Final.jar下面是不同的地方：（1）：hibernate.hbm.xml 文件中把引用：xxx.hbm.xml改为引用实体类：即把：<mapping resource="com/wsw/hibernate/model/Person.hbm.xml"/>改为：<mapping class="com.wsw.hibernate.model.Teacher" />（2）：获取SessionFactory方式发生了变化：即：由SessionFactory sf = new Configuration().configure().buildSessionFactory()改为：SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory() （3）：注解方式不需要在xxx.hbm.xml把实体类与表进行映射。

hibernate注解简介

在最近发布的几个Hibernate版本中，出现了一种基于 Java 5 注释的更为巧妙的新方法。借助新的 Hibernate Annotation 库，即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注释直接嵌入到您的 Java 类中，并提供一种强大及灵活的方法来声明持久性映射。籍由自动代码完成和语法突出显示功能，最近发布的Java IDE也为其提供了有力的支持。
@Entity
@Table(name="T_MODEL_PLANE")
public class ModelPlane {
private Long id;
private String name;
@Id
@Column(name="PLANE_ID")
传统上，Hibernate的配置依赖于外部 XML 文件：数据库映射被定义为一组 XML 映射文件，并且在启动时进行加载。创建这些映射有很多方法，可以从已有数据库模式或Java类模型中自动创建，也可以手工创建。无论如何，您最终将获得大量的 Hibernate 映射文件。此外，还可以使用工具，通过javadoc样式的注释生成映射文件，尽管这样会给您的构建过程增加一个步骤。
...
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate</artifactId>
<version>3.2.1.ga</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>

hibernate.hbm.xml配置详解

Hibernate中hbm.xml配置说明。

在Hibernate中，各表的映射文件….hbm.xml可以通过工具生成，例如在使用MyEclipse开发时，它提供了自动生成映射文件的工具。

配置文件的基本结构如下：Xml代码1<?xml version="1.0"encoding='UTF-8'?>23<!DOCTYPE hibernate-mapping PUBLIC4"-//Hibernate/Hibernate Mapping DTD 3.0//EN"5"/hibernate-mapping-3.0.dtd">6<hibernate-mapping package="包名">7<class name="类名"table="表名">8<id name="主键在java类中的字段名"column="对应表中字段"type="类型">9<generator class="主键生成策略"/>10</id>1112……13</class>14</hibernate-mapping>1. 主键（id）Hibernate的主键生成策略有如下几种：1) assigned主键由外部程序负责生成，在save() 之前指定。

2) hilo通过hi/lo 算法实现的主键生成机制，需要额外的数据库表或字段提供高位值来源。

3) seqhilo与hilo 类似，通过hi/lo 算法实现的主键生成机制，需要数据库中的Sequence，适用于支持Sequence 的数据库，如Oracle。

4) increment主键按数值顺序递增。

Hibernate配置(web开发)

Hibernate的映射文件Hibernate的映射文件映射文件也称映射文档,用于向Hibernate提供关于将对象持久化到关系数据库中的信息.持久化对象的映射概念可全数存储在同一个映射文件中,也可将每一个对象的映射概念存储在独立的文件中.后一种方式较好,因为将大量持久化类的映射概念存储在一个文件中比较麻烦,建议采纳每一个类一个文件的方式来组织映射文档.利用多个映射文件还有一个优势:若是将所有映射概念都存储到一个文件中,将难以调试和隔离特定类的映射概念错误.映射文件的命名规那么是,利用持久化类的类名,并利用扩展名.映射文件需要在中注册,最好与领域对象类放在同一目录中,如此修改起来很方便.领域对象和类public class User{个选项在第一次启动程序时放开,以后切记关闭 --><mapping resource="com/sitinspring/domain/" /><mapping resource="com/sitinspring/domain/" /><mapping resource="com/sitinspring/domain/" /><mapping resource="com/sitinspring/domain/" /></session-factory></hibernate-configuration>映射文件物理位置例如映射文件的大体结构映射概念以hibernate-mapping元素开始, package属性设置映射中非限定类名的默许包.设置那个属性后,关于映射文件中列出的其它持久化类,只需给出类名即可.要引用指定包外的持久化类,必需在映射文件中提供全限定类名.在hibernate-mapping标签以后是class标签.class标签开始指定持久化类的映射概念.table属性指定用于存储对象状态的关系表.class元素有很多属性,下面将逐个介绍.IDId元素描述了持久化类的主码和他们的值如何生成.每一个持久化类必需有一个ID元素,它声明了关系表的主码.如右:Name属性指定了持久化类顶用于保留主码值的属性,该元素说明,User类中有一个名为id的属性.若是主码字段与对象属性不同,那么能够利用column属性.<id name="id" column="ID" ><generator class=""/></id>生成器生成器创建持久化类的主码值.Hibernate提供了多个生成器实现,它们采纳了不同的方式来创建主码值.有的是自增加式的,有点创建十六进制字符串, 还能够让外界生成并指定对象ID,另外还有一种Select生成器你那个从数据库触发器trigger检索值来取得主码值.右边利用了用一个128-bit的UUID算法生成字符串类型的标识符，这在一个网络中是唯一的（利用了IP地址）。

详解hibernatemapping配置

详解hibernatemapping配置详解 hibernate mapping配置每个hibernate只会启动的时候引⼊⼀个⽂件，那就是：hibernate.cfg.xmlmapping需要我们在hibernate中引⼊，<mapping resource="com/hibernate/test/hibernate_IP.xml"/><mapping class="com.hibernate.test.Student"/>代码⽚段:<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.hibernate.test"><class name="IP_List" table="IP_LIST"><id name="ip" column="Ip"><generator class="native"></generator></id><property name="Status" column="Status"></property></class></hibernate-mapping>class标签对应的name为Java实体类 table为表名；id为主键主键⾃增策略：<generator class="native"></generator> native会根据不同数据库采取不同的⾃增策略<property>标签对应数据库中的字段 columnpackage com.hibernate.test;import javax.persistence.Entity;import javax.persistence.Id;import javax.persistence.Table;@Entity@Table(name="Student")public class Student {private int id;private String name;/*** id** @return the id* @since CodingExample Ver(编码范例查看) 1.0*/@Id@GeneratedValuepublic int getId() {return id;}/**** @param id* the id to set*/public void setId(int id) {this.id = id;}/*** name** @return the name* @since CodingExample Ver(编码范例查看) 1.0*/@Column(name="name")public String getName() {return name;}/**** @param name* the name to set*/public void setName(String name) { = name;}}实体类添加注解：@Entity 对应的表为@Table主键为@ID ⾃增策略配置：@GeneratedValue@Column 注解对应为数据库中的字段感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。

改进版的hibernate泛型dao

改进版的hibernate泛型dao(依赖spring) 收藏结构看图：HinernateEntityDao和HibernateGenericDao都继承在spring的HibernateDaoSupport一个提供和实体相关的操作,一个提供和实体类无关的操作。

然后以组合的方式在BaseDao中使用,这样程序中全部使用IBaseDao接口来操作数据,便于修改和维护.xml配置实用如下:1.<?xml version="1.0" encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3. xmlns:xsi="/2001/XMLSchema-instance"4. xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd">5.6. <!-这个是和实体相关的dao,所以scope是prototype的每个实体对应一个对象->7. <bean id="hedao"8. class="com.hibernate.dao.extend.HibernateEntityDao" scope="prototype" lazy-init="true">9. <property name="sessionFactory">10. <ref bean="sessionFactory" />11. </property>12. </bean>13.14. <!-这个和具体实体无关,所有dao共享->15. <bean id="hgdao"16. class="com.hibernate.dao.generic.HibernateGenericDao">17. <property name="sessionFactory">18. <ref bean="sessionFactory" />19. </property>20. </bean>21.22.23. 24. <bean id="baseDao" class="com.hibernate.dao.base.BaseDao"25. abstract="true" depends-on="hedao,hgdao">26. <property name="hedao">27. <ref bean="hedao" />28. </property>29. <property name="hgdao">30. <ref bean="hgdao" />31. </property>32. </bean>33.34. 35. <bean id="demoDao" parent="baseDao">36. <constructor-arg>37. <value>com.hibernate.entityclass.Demodata</value>38. </constructor-arg>39. </bean>40.41.</beans>42.43.代码：BaseDao.java1.package com.hibernate.dao.base;2.3.import java.io.Serializable;4.import java.util.List;5.6.import org.hibernate.Criteria;7.import org.hibernate.Query;8.import org.hibernate.criterion.Criterion;9.import org.springframework.orm.hibernate3.HibernateTemplate;10.11.import com.hibernate.dao.extend.HibernateEntityDao;12.import com.hibernate.dao.generic.HibernateGenericDao;13.import com.hibernate.dao.support.Page;14.15./**16. * 提供hibernate dao的所有操作,<br>17. * 实现类由spring注入HibernateEntityDao和HibernateGenericDao来实现18. *19. */20.public class BaseDao<T,PK extends Serializable> implements IBaseDao<T,PK> {21.22. protected Class<T> entityClass;// DAO所管理的Entity类型.23. private HibernateEntityDao<T,PK> hedao;24. private HibernateGenericDao hgdao;25.26. public void setHedao(HibernateEntityDao<T, PK> hedao) {27. hedao.setEntityClass(entityClass);28. this.hedao = hedao;29. }30.31. public void setHgdao(HibernateGenericDao hgdao) {32. this.hgdao = hgdao;33. }34.35. /**36. *让spring提供构造函数注入37. */38. public BaseDao(Class<T> type) {39. this.entityClass = type;40. }41.42. public BaseDao(){}43.44. /**45. * 清除所有对象缓存46. */47. public void clear() {48.49. hgdao.clear();50. }51.52. /**53. * 创建Criteria对象.54. * @param criterions 可变的Restrictions条件列表55. */56. public Criteria createCriteria(Criterion... criterions) {57.58. return hedao.createCriteria(criterions);59. }60.61. /**62. * 创建Criteria对象，带排序字段与升降序字段.63. */64. public Criteria createCriteria(String orderBy, boolean isAsc,65. Criterion... criterions) {66.67. return hedao.createCriteria(orderBy, isAsc, criterions);68. }69.70. /**71. * 创建Query对象. 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.72. * 留意可以连续设置,如下：73. * <pre>74. * dao.getQuery(hql).setMaxResult(100).setCacheable(true).list();75. * </pre>76. * 调用方式如下：77. * <pre>78. * dao.createQuery(hql)79. * dao.createQuery(hql,arg0);80. * dao.createQuery(hql,arg0,arg1);81. * dao.createQuery(hql,new Object[arg0,arg1,arg2])82. * </pre>83. *84. * @param values 可变参数.85. */86. public Query createQuery(String hql, Object... values) {87.88. return hgdao.createQuery(hql, values);89. }90.91. /**92. * @param hql 查询sql93. * @param start 分页从哪一条数据开始94. * @param pageSize 每一个页面的大小95. * @param values 查询条件96. * @return page对象97. */98. public Page dataQuery(String hql, int start, int pageSize, Object... values) {99.100. return hgdao.dataQuery(hql, start, pageSize, values);101. }102.103. /**104. * 消除与Hibernate Session 的关联105. * @param entity106. */107. public void evit(T entity) {108.109. hedao.evict(entity);110. }111.112. /**113. * 执行本地sql语句获得标量数值列表114. */115. @SuppressWarnings("unchecked")116. public List executeNativeSql(String sql) {117.118. return hgdao.executeNativeSql(sql);119. }120.121. /**122. * 根据hql查询,直接使用HibernateTemplate的find函数.123. * @param values 可变参数124. */125. @SuppressWarnings("unchecked")126. public List find(String hql, Object... values) {127.128. return hgdao.find(hql, values);129. }130.131. /**132. * 根据属性名和属性值查询对象.133. * @return 符合条件的对象列表134. */135. public List<T> findBy(String propertyName, Object value) {136.137. return hedao.findBy(propertyName, value);138. }139.140. /**141. * 根据属性名和属性值查询对象,带排序参数.142. */143. public List<T> findBy(String propertyName, Object value, String orderBy, 144. boolean isAsc) {145.146. return hedao.findBy(propertyName, value, orderBy, isAsc);147. }148.149. /**150. * 根据属性名和属性值查询唯一对象.151. * @return 符合条件的唯一对象or null if not found.152. */153. public T findUniqueBy(String propertyName, Object value) {154.155. return hedao.findUniqueBy(propertyName, value);156. }157.158. /**159. * 执行一些必须的sql语句把内存中的对象同步到jdbc的链接中160. */161. public void flush() {162.163. hgdao.flush();164. }165.166.167. /**168. * 根据Serializable类型的id获取实体对象<p/>169. * 实际调用Hibernate的session.load()方法返回实体或其proxy对象. 如果对象不存在，抛出异常.170. * @param id171. */172. public T get(PK id) {173.174. return hedao.get(id);175. }176.177. /**178. * 获取实体类型的全部对象179. */180. public List<T> getAll() {181.182. return hedao.getAll();183. }184.185. /**186. * 获取全部对象,带排序字段与升降序参数.187. */188. public List<T> getAll(String orderBy, boolean isAsc) {189.190. return hedao.getAll(orderBy, isAsc);191. }192.193. /**194. * 直接使用spring提供的HibernateTemplate195. */196. public HibernateTemplate getHibernateTemplate() {197.198. return hgdao.getHibernateTemplate();199. }200.201. /**202. * 判断对象某些属性的值在数据库中是否唯一.203. *204. * @param uniquePropertyNames 在POJO里不能重复的属性列表,以逗号分割如"name,loginid,password"205. */206. public boolean isUnique(T entity, String uniquePropertyNames) {207.208. return hedao.isUnique(entity, uniquePropertyNames);209. }210.211. /**212. * 分页查询函数，使用hql.213. *214. * @param pageNo 页号,从1开始.215. */216. public Page pagedQuery(String hql, int pageNo, int pageSize,217. Object... values) {218.219. return hgdao.pagedQuery(hql, pageNo, pageSize, values);220. }221.222. /**223. * 分页查询函数，使用已设好查询条件与排序的<code>Criteria</code>.224. *225. * @param pageNo 页号,从1开始.226. * @return 含总记录数和当前页数据的Page对象.227. */228. public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) {229.230. return hedao.pagedQuery(criteria, pageNo, pageSize);231. }232.233. /**234. * 分页查询函数，根据entityClass和查询条件参数创建默认的<code>Criteria</code>.235. *236. * @param pageNo 页号,从1开始.237. * @return 含总记录数和当前页数据的Page对象.238. */239. public Page pagedQuery(int pageNo, int pageSize, Criterion... criterions) {240.241. return hedao.pagedQuery(pageNo, pageSize, criterions);242. }243.244. /**245. * 分页查询函数，根据entityClass和查询条件参数,排序参数创建默认的<code>Criteria</code>.246. *247. * @param pageNo 页号,从1开始.248. * @return 含总记录数和当前页数据的Page对象.249. */250. public Page pagedQuery(int pageNo, int pageSize, String orderBy,251. boolean isAsc, Criterion... criterions) {252.253. return hedao.pagedQuery(pageNo, pageSize, orderBy, isAsc, criterions);254. }255.256. /**257. * 删除对象.258. */259. public void remove(T entity) {260.261. hedao.remove(entity);262. }263.264. /**265. * 根据ID删除对象.266. */267. public void removeById(PK id) {268.269. hedao.removeById(id);270. }271.272. /**273. * 保存对象.<br>274. * 如果对象已在本session中持久化了,不做任何事。

Hibernate配置文件

Hibernate配置⽂件⼀、概述：1、Hibernate配置⽂件主要⽤于配置数据库连接和Hibernate运⾏时所需的各种属性2、每个Hibernate配置⽂件对应⼀个Cconfiguration对象3、Hibernate配置⽂件可以有两种格式：1）hibernate.properties2）hibernate.cfg.xml⼆、hibernate.cfg.xml的常⽤属性：1、JDBC连接属性：1）hibernate.connection.driver_class：数据库驱动2）hibernate.connection.url：数据库的url3）ername：数据库⽤户名4）hibernate.connection.password：数据库密码5）dialect：配置数据库的⽅⾔，根据底层的数据库不同产⽣不同的sql语句，Hibernate会针对数据库的特性在访问时进⾏优化2、C3P0数据库连接池属性：1）hibernate.c3p0.max_size：最⼤连接数2）hibernate.c3p0.min_size：最⼩连接数3）hibernate.c3p0.acquire_increment：当数据库连接池中的连接耗尽时，同⼀时刻获取多少个数据库连接4）hibernate.c3p0.timeout：连接池中连接对象在多长时间没有使⽤过后，就应该被销毁5）hibernate.c3p0.idle_test_period：表⽰连接池检测线程多长时间检测⼀次池内的所有连接对象是否超时，连接池本⾝不会把⾃⼰从连接池中移除⽽是专门有⼀个线程按照⼀定的时间间隔来做这件事，这个线程通过⽐较连接对象最后⼀次呗使⽤和当前时间的时间差来和timout做对⽐，进⽽决定是否销毁这个连接对象。

6）hibernate.c3p0.max_statements：缓存Statement对象的数量三、在hibernate.cfg.xml中配置C3P0：<property name="hibernate.c3p0.max_size">10</property><property name="hibernate.c3p0.min_size">5</property><property name="hibernate.c3p0.acquire_increment">2</property><property name="hibernate.c3p0.timeout">2000</property><property name="hibernate.c3p0.idle_test_period">2000</property><property name="hibernate.c3p0.max_statements">10</property>四、hibernate.cfg.xml的其他属性：1、show_sql：是否将运⾏时⽣成的sql语句输出到⽇志以供调试。