14 Hibernate高级编程

Hibernate笔记

Main.java
package com.it315.main; import java.util.Date; import org.hibernate.Session; import org.hibernate.Transaction; import er; import ls;
批注 [z3]: 连接数据库的 URL 地址。批注 [z4]: 用户名。批注 [z5]: 密码。批注 [z6]: 每次加载 hibernate，重新创建数据库表结构，这就是导致数据库表数据丢失的原因。批注 [z7]: 显示生成的 SQL 语句。批注 [z8]: 指定映射文件的路径。批注 [z2]: 数据库驱动的名称。批注 [z1]: 数据库的方言。
注意：初始化的代码是很耗资源的，所以将上面代码修改为：
HibernateUtils.java package com.it315.util; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public final class HibernateUtils { private static SessionFactory sessionFactory; static { Configuration cfg = new Configuration(); sessionFactory = cfg.configure().buildSessionFactory(); } public static Session getSession(){ return sessionFactory.openSession(); } }

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项目的构建与配置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框架环境任何一项新技术的出现都有它的必然性，Hibernate也不例外，所以在掌握Hibernate的具体应用之前我们一定先要了解Hibernate是什么？使用Hibernate会给我们的程序开发带来哪些好处？使用Hibernate的好处简单来讲体现在以下几个方面：1. Hibernate说白了就是对持久层进行的封装，它简化了对数据库的操作，使得我们可以以对象方式直接访问数据库中的数据。

实现了完全的OO思想。

2. 另外由于Hibernate对JDBC的彻底封装，使得我们可以不用在程序中写传统的sql语句便能实现对数据库的各种操作，极大的提高了生产力。

3. Hibernate支持MySQL，SQL Server等多种数据库。

Hibernate提供了多种数据库的接口，只要更改配置信息可以实现对不同数据库的操作，换句话说也就是你可以轻视的实现数据库更换。

说了这么多Hibernate的好处，那Hibernate到底该怎样用呢？别急下面我们就来看看Hibernate环境是如何搭建起来的。

1. 建立Java项目（也可以是java web项目）。

2. 导入相关jar包。

导入jar包的方式可以有两种。

第一种是直接添加外部jar包，也就是我们的“Add External JARs”。

另外一种是先建立自己的jar包库，然后向新建的库中加入jar包，如果使用这种方式最后一定不要忘记将建好的库引入到项目中。

两种方式均可，但一般更推荐第二种方式。

加入的jar包主要有以下这些：2.1在Hibernate_Home/lib/路径下的所有jar包。

2.2加入Hibernate核心jar包：hibernate3.jar。

2.3加入所使用的数据库的JDBC驱动包。

使用MySQL数据库则加入MySQL数据库驱动mysql-connector-java-3.1.13-bin.jar。

hibernatehql语句详解

hibernatehql语句详解Hibernate HQL语句详解1. 什么是Hibernate HQL语句？Hibernate HQL（Hibernate Query Language）是Hibernate框架提供的一种面向对象的查询语言。

它类似于SQL，但是更注重于面向对象的概念和操作。

2. HQL语句的基本语法•HQL语句以FROM关键字开始，后面跟着要查询的实体类名。

•可以使用SELECT关键字来选择要查询的属性。

•可以使用WHERE关键字来添加查询条件。

•可以使用JOIN关键字来进行表连接查询。

•可以使用ORDER BY关键字来排序查询结果。

•可以使用GROUP BY关键字来进行分组查询。

3. HQL中的参数绑定•HQL语句中可以使用占位符（?）来表示参数，然后使用setXxx 方法来为占位符绑定实际的值。

•也可以使用命名参数（:name）来表示参数，然后使用setParameter方法来为参数绑定实际的值。

4. HQL中的函数HQL支持多种函数，常用的函数有：•数字函数：abs、sqrt、mod等。

•字符串函数：length、concat、substring等。

•日期函数：year、month、day等。

5. HQL中的聚合函数HQL中支持多种聚合函数，常用的聚合函数有：•avg：计算平均值。

•sum：计算总和。

•max：获取最大值。

•min：获取最小值。

•count：计算记录数。

6. HQL中的子查询•子查询是指一个查询语句内包含另一个查询语句。

•子查询可以用在WHERE子句中的条件表达式中。

•HQL支持分页查询，可以使用setFirstResult和setMaxResults方法来实现分页。

•setFirstResult用于设置查询结果的起始位置。

•setMaxResults用于设置查询结果的最大数量。

8. HQL中的更新和删除操作•HQL不仅可以用于查询，还可以用于更新和删除操作。

用Hibernate实现Java对象持久化

实现这种对象-关系转换的核心的问题是对象持久化,即把对象由内存中的瞬态对象变成数据库中的持久对象。目前通过直接内嵌SQL或者数据访问类的方法可以解决两种模型不匹配的问题,但却使得应用的可维护性降低,数据库发生变动就涉及到大量修改应用中的数据访问代码。一个更好的解决方案是构建一个数据访问层,用户接口、业务逻辑和数据库访问各为一层,各层通过接口与相邻层通信,每个层中的代码改变不会对其他层造成太大的影响。
包含5个Action文件用来响应业务订单的生成,工作在控制层:security包含3个Action文件用来响应会员登入、退出事件,工作在控制层;service在上面章节介绍过用来实现业务代理模式,工作在模型层。
netstore最主要的业务逻辑就是在用户选定商品后生成订单。当用户在网站上选购了商品,购物信息先保存在ShoppingCart对象中;当用户发出生成订单的请求,在控制层,ProcessCheckoutAction负责处理这一请求,在PmcessCheckoutAction 的saveOrder0方法中,先从HttpSession范围内取得当前的Customer游离对象与ShoppingCart对象,接着创建了一个Order临时对象,把它与Customer对象关联,然后根据ShoppingCart对象的items集合中的ShoppingCart对象生成Lineltem对象,再把这些LineRem对象都加入到Order对象的lineItems集合中,最后调用NetstomServiceImpl业务代理类的saveOrder0方法保存这个Order对象。
本文分析了对象模型与关系模型的各自特点以及对象-关系映射理论,详细描述了不同映射策略的适用性并进行了比较。探讨了基于关系数据库的对象持久化方法,分析了数据访问层的数据访问模式、事务模式和Cache模式的特征以及各种模式的适用点,结合这些设计模式提出了具有性能优化策略的轻量级的对象持久层框架,并对框架的设计细节进行了描述和说明。

实验3 Hibernate使用基础

实验3Hibernate使用基础一、实验目的1.理解Hibernate的基本概念与作用2.掌握Hibernate体系结构、核心接口及其对象状态和对象特征3.熟悉利用MyEclipse2014进行Hibernate应用开发的基本步骤；4.了解Hibernate对象关系映射5.掌握事务管理的基本方法。

二、实验步骤1.建立数据库及表利用MySQLInstance建立MySQL数据库，数据库名为：hibernatedb，并在其中建立表，表名为：students。

SQL命令如下：CREATE DATABASE `hibernated ;CREATE TABLE `students` (`sid` int(11) NOT NULL,`sname` varchar(45) DEFAULT NULL,PRIMARY KEY (`sid`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;2.在MyEclipse 2014中建立MySQL数据库连接驱动Hibernate2（1）启动MyEclipse 2014，选择Windows→OpenPerspective→MyEclipse DatabaseExplorer（2）在MyEclipse Database Explorer中，在左侧窗格中右击鼠标，在快捷菜单中选择New命令，如图6.10所示。

（3）在弹出编辑数据库连接驱动对话框中，编辑如下内容：DriveName：Hibernate2ConnectionURL：jdbc:mysql://localhost:3306/hibernatedbUser Name: rootPassword: 123456单击Add JARs添加Drive JARs:mysql-connector-java-5.1.13-bin（4）勾选SavePassword，单击TestDriver，测试成功后单击Finish。

新手上路之java Hibernate：第一个Hibernate例子

新手上路之java Hibernate：第一个Hibernate例子一、Hibernate概述（一）什么是Hibernate？hibernate核心内容是ORM（关系对象模型）。

可以将对象自动的生成数据库中的信息，使得开发更加的面向对象。

这样作为程序员就可以使用面向对象的思想来操作数据库，而不用关心繁琐的JDBC。

所以，Hibernate处于三层架构中的D层（持久层）。

（二）使用Hibernate的优点1、Hibernate可以使用在Java的任何项目中，不一定非要使用在Java web项目中。

因为Hibernate不需要类似于tomact这些容器的支持，可以直接通过一个main方法进行测试。

2、通过下面的实例，可以发现使用Hibernate可以大大减少代码量。

3、由于使用了Hibernate，代码中不涉及具体的JDBC语句，所以就方便了代码的可移植性。

二、Hibernate开发的环境搭建（一）Hibernate的环境搭建非常简单，只需要引入Hibernate核心包（单击下载）以及Hibernate依赖包（单击下载）即可。

（二）加入数据库驱动。

下面的例子中主要是采用Mysql数据库来演示的，所以在这里引入MysqL的JDBC驱动（点击下载）。

（三）提供核心配置文件hibernate.cfg.xml文件（在src文件夹下即可）。

其中的配置如下（针对mysql）[html]view plain copy1.<!DOCTYPE hibernate-configuration PUBLIC2. "-//Hibernate/Hibernate Configuration DTD3.0//EN"3. "/hibernate-configuration-3.0.dtd">4.5.<hibernate-configuration>6.<session-factory>7.8.<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>9.10.<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>11.12.<property name="ername">root</property>13.14.<property name="hibernate.connection.password">root</property>15.16.<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>17.18.</session-factory>19.</hibernate-configuration>三、HIbernate第一个实例该实例的目录结构如下说明：最后一个HIBERNATE3里面包含了所有的需要引用的jar包1、新建一个普通的java项目，按照上面的步骤引入相关的jar包和配置文件2、建立User实体类[java]view plain copy1.import java.util.Date;2.3.public class User {4.private String id;5.private String username;6.private String password;7.private Date createTime;8.private Date expireTime;9.10.public String getId() {11.return id;12. }13.public void setId(String id) {14.this.id = id;15. }16.public String getUsername() {17.return username;18. }19.public void setUsername(String userName) {ername = userName;21. }22.public String getPassword() {23.return password;24. }25.public void setPassword(String password) {26.this.password = password;27. }28.public Date getCreateTime() {29.return createTime;30. }31.public void setCreateTime(Date createTime) {32.this.createTime = createTime;33. }34.public Date getExpireTime() {35.return expireTime;36. }37.public void setExpireTime(Date expireTime) {38.this.expireTime = expireTime;39. }40.}2、提供User.hbm.xml文件，完成实体类的映射[html]view plain copy1.<?xml version="1.0"?>2.<!DOCTYPE hibernate-mapping PUBLIC3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"4. "/hibernate-mapping-3.0.dtd">5.6.<hibernate-mapping>7.<class name="er">8.<id name="id">9.<generator class="uuid"/>10.</id>11.<property name="username"/>12.<property name="password"/>13.<property name="createTime"/>14.<property name="expireTime"/>15.</class>16.</hibernate-mapping>其中的property标签是将要生成是数据库表中的字段，在这里不用关心各个字段是什么类型的。

Hibernate 入门

TransactionnewTransaction=newSession.beginTransactission.find("from Message as m order bym.textasc");
System.out.println(messages.size() + " message(s) found:" );
我们这个简单示例程序的目的是将一些持久类存储在数据库中，然后从数据库取出来，并将其信息正文显示给用户。其中Message正是一个简单的持久类：，它包含我们要显示的信息，其源代码如下：
列表1Message.Java一个简单的持久类
package hello;
public class Message {
Type是Hibernate发明者发明的一个术语，它在整个构架中是一个非常基础、有着强大功能的元素，一个Type对象能将一个Java类型映射到数据库中一个表的字段中去。
策略接口
Hibernate与某些其它开源软件不同的还有一点――高度的可扩展性，这通过它的内置策略机制来实现。
基础配置
Hibernate可以配置成可在任何Java环境中运行，一般说来，它通常被用在2－3层的C/S模式的项目中，并被部署在服务端。
message.setText("Greetings Earthling");
＜many-to-one name="nextMessage" cascade="all" column="NEXT_MESSAGE_ID"/＞
＜/class＞
＜/hibernate-mapping＞
以上这个文档告诉Hibernate怎样将Message类映射到MESSAGES表中，其中Message类的id属性与表的MESSAGE_ID字段对应，text属性与表的MESSAGE_TEXT字段对应，nextMessage属性是一个多对一的关系，它与表中的NEXT_MESSAGE_ID相对应。

Hibernate入门_1

类的映射文件第二种格式
<hibernate-mapping> <class name=" com.pojo.Emp " table="emp"> <id name="id" type="ng.Integer" column="id"> <generator class="increment"/> </id> <property name="empname" type="ng.String" column="empname"/> <property name="salary" type="ng.Double" column="salary"/> <property name="hiredate" type="java.util.Date" column="hiredate"/> </class> </hibernate-mapping>
创建实体类Emp.java
package com.pojo; import java.util.Date; public class Emp implements java.io.Serializable { private Integer id; private String empname; private Double salary; private Date hiredate; public Emp() { } public Emp(Integer id) { this.id = id; } public Emp(Integer id, String empname, Double salary, Date hiredate) { this.id = id; this.empname = empname; this.salary = salary; this.hiredate = hiredate; } get和set方法略 }

【Java SSH进阶之路】Hibernate基本映射(三)

【Java SSH进阶之路】Hibernate基本映射（三）本文介绍Hibernate的经典内容：对象关系映射。

主要介绍映射的基本概念，映射的分类，映射文件。

概念ORM（Object Relational Mapping），即对象关系映射。

它的作用就是在关系型数据库和对象之间做了一个映射。

从对象（Object）映射到关系（Relation），再从关系映射到对象。

相信很多人跟小编一个毛病，看到概念就头疼，下面小编画了一张图加深理解。

这张图特别简单：原来，没有Hibernate时，我们需要通过JDBC+手动写SQL 语句来操作数据库，现在，有了Hibernate，它将JDBC+SQL进行了高度封装，我们不需要再去和复杂SQL打交道，只要像操作对象一样操作数据库就可以了。

ORM的实现思想就是将数据库中表的数据映射成对象，Hibernate可以使我们采用对象化的思维操作关系型数据库。

映射文件Hibernate在实现ORM功能的时候主要用到的文件有：1、映射类（*.Java）：它是描述数据库表的结构，表中的字段在类中被描述成属性，将来就可以实现把表中的记录映射成为该类的对象了。

2、映射文件（*.hbm.xml）：它是指定数据库表和映射类之间的关系，包括映射类和数据库表的对应关系、表字段和类属性类型的对应关系以及表字段和类属性名称的对应关系等。

3、 hibernate核心配置文件（*.properties/*.cfg.xml）：它指定hibernate 的一些核心配置，包含与数据库连接时需要的连接信息，比如连接哪种数据库、登录数据库的用户名、登录密码以及连接字符串等。

映射文件的地址信息也放在这里。

分类上面的内容看上去挺多，其实特别少，基本映射很简单，我们主要学习关联关系映射，其他几种映射一般不会用，只需要了解即可，用的时候看一下相关资料会做就好。

基本映射基本映射，是使用XML方式配置映射，如下所示：1.<span style="font-size:12px;"><?xml version="1.0"?>2.<!DOCTYPE hibernate-mapping PUBLIC3."-//Hibernate/Hibernate Mapping DTD 3.0//EN"4."/hibernate-mapping-3.0.dtd">5.<hibernate-mapping>6.<class name="er" >7.<id name="id">8.9.<generator class="uuid"></generator>10. </id>11. <property name="name"></property>12. <property name="password"></property>13. <property name="createTime" type="date"></property>14. <property name="expireTime" type="date"></property>15. </class>16.</hibernate-mapping></span>除了XML方式配置映射外，还可以通过给类文件添加注解的方式配置映射，在上篇博文的基础之上，我们稍加修改。

跟我学Hibernate框架技术——在容器外实现多对一的实体映射技术

杨教授工作室，版权所有，盗版必究， 1/33 页 1
杨教授工作室精心创作的优秀程序员职业提升必读系列资料
1.1
在容器外实现 Hibernate 框架的多对一映射
1.1.1 设计本示例相关的数据库表 1、设计本示例中所需要的数据库在本例中采用 MySql 数据库中的某个 CARD 表看起来是这样的字段名称 card_id cardName cardType cardMoney 数据类型 character(32) character varying(16) character(2) Float 要求 not null 并且为 PRIMARY KEY not null not null not null not null
com.px1987.sshwebcrm.dao.pobject
private String card_id; private String cardName; private char cardType; private float cardMoney;
杨教授工作室，版权所有，盗版必究， 3/33 页 3
PERSON_ID smallint
CREATE DATABASE DataBase; USE DataBase; Drop table CAT; CREATE TABLE CARD ( card_id nvarchar(32) NOT NULL, nvarchar(16) NOT NULL,
杨教授工作室，版权所有，盗版必究， 2/33 页 2
cardName
杨教授工作室精心创作的优秀程序员职业提升必读系列资料
cardType cardMoney
char(2)
NOT NULL,
float NOT NULL,

跟我学Hibernate框架技术——Hibernate中的事务管理及实现实例(第2部分)

1.1.2 基于 JDBC 的事务管理的编程实现
1、JDBC 的事务管理的回顾---JDBC 中的事务特点（1）在 JDBC 中，打开一个连接对象 Connection 时，缺省是 auto-commit 模式，也就是说，
杨教授工作室，版权所有3 ，盗版必究， 3/14 页
杨教授工作室精心创作的优秀程序员职业提升必读系列资料
一条对数据库的更新表达式代表一项事务操作，操作成功后，系统将自动调用 commit()来提交，否则将调用 rollback()来回滚。
杨教授工作室，版权所有1 ，盗版必究， 1/14 页
杨教授工作室精心创作的优秀程序员职业提升必读系列资料
1.1 Hibernate 中的事务管理及实现实例（第 2 部分）
1.1.1 Hibernate 中的事务管理及实现技术
1、Hibernate 中的事务管理的具体实现---- Hibernate 的事务管理，一般是编程性的 Hibernate 的事务管理方式仅仅就是托管给 JDBC 或者 JTA---- Hibernate 的事务管理可
杨教授工作室精心创作的优秀程序员职业提பைடு நூலகம்必读系列资料
目录
1.1 Hibernate 中的事务管理及实现实例（第 2 部分） ....................................................2 1.1.1 Hibernate 中的事务管理及实现技术 .....................................................................2 1.1.2 基于 JDBC 的事务管理的编程实现 ......................................................................3 1.1.3 J2EE 规范中基于 JTA 的事务管理的编程实现技术 ............................................7 1.1.4 在 Hibernate 中实现基于 JTA 的事务管理............................................................9 1.1.5 编程实现 Hibernate 中基于 JTA 的事务管理......................................................10

hibernate学习笔记

18.无论是update还是get,都会首先查找缓存(一级缓存),如果没有,才会去数据库里查找,调用clear()方法可以清除session缓存
19.flush():强制缓存与数据库同步
20.merge:合并 inverse:反转(true) cascade:级联(all)
21.关系映射:
2)不存在对应记录时表现不一样,get会返回null,load会抛出异常
16.merge:合并
17.update的用法:
1)用来更新detached对象,更新完状态转为persistent
2)更新transient对象会报错,除非自己设定id
3)persistent状态的对象只要设定不同字段就会发生更新(不用调update ()方法)
hibernate学习笔记
1.persist-->持久
PO-->Persistent Object:持久化对象
2.dialect:方言
3.factory:工厂
4.annotation:注释
5.assist-->辅助，帮助
Content assist--myeclipse不给提示
vii)一对多双向:两个PO都加对方对象引用
22.cascade:all/persist(存储)/remove(删除) 级联操作
写在保存的一方,例如要保存A的同时，把B也存进去，则在A的PO类里加上@ManyToOne(cascade={CascadeType.ALL})，即在getB的属性上加cascade
6.schema-->模式
7.@Transient--->短暂的，瞬变的,透明的
@Basic--->默认加上去的

hibernate注解（自动建表如何有表DDL注释）--Comment用法

hibernate注解（⾃动建表如何有表DDL注释）--Comment⽤法import java.io.Serializable;import java.sql.Date;import java.sql.Timestamp;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.Table;@Entity@Table(name="vmtracka")public class Vmtracka implements Serializable{@Id@GeneratedValue(strategy=GenerationType.IDENTITY)private Long id;private Date gmt_create;private Timestamp gmt_update;//@Id@Column(nullable=false,length=20)private String device_id;@Column(columnDefinition="int(11) unsigned zerofill DEFAULT NULL Comment '层数'")private Integer vm_layer;//层数@Column(columnDefinition="int(11) DEFAULT NULL COMMENT '最⼤可放商品数'")private Integer vm_max_store;//最⼤可放商品数@Column(columnDefinition="int(11) unsigned zerofill DEFAULT NULL COMMENT '当前的库存数'")private Integer vm_now_store;//当前的库存数@Column(columnDefinition="varchar(100) DEFAULT '0' COMMENT '货号01'")private String goods_no_01;//货号01@Column(columnDefinition="varchar(100) DEFAULT '0' COMMENT '货号02'")private String goods_no_02;//货号02@Column(length=100)private String goods_no_03;@Column(length=100)private String goods_no_04;@Column(length=100)private String goods_no_05;@Column(length=100)private String goods_no_06;@Column(length=100)private String goods_no_07;Hibernate注解1。

批量查询方法
批量查询方法一共有 3 种：
HQL 查询法 Criteria 准则查询法
SQL 查询
HQL
步骤如下：
Session 中提供了一个方法，名为"Query Session.createQuery(String queryString)"，该方法为 HQL 查询语句生成一个 Query 类的对象，进行返回
HQL
步骤如下：
返回的 Query 中，有 list()方法，返回一个 List 对象，通过遍历这个 List 对象得到查询的内容
HQL
HQL 语句看起来虽然和 SQL 语句很像，但由于数据库迁移的可能性，避免了程序员需要对数据库结构的了解
HQL
HQL 查询语句里也能够传递参数，比如，如果性别是由变量传入的情况下，就可以在HQL 中设置参数：
Configuration
Configuration 类常见的方法有：
configure()方法，默认读取hibernate.cfg.xml configure(File configFile)方法，可以指定参数，使之能够使用其它配置文件
Configuration
Configuration 类常见的方法有：
Hibernate 主键
主键生成策略
uuid.hex 策略，hibernate 利用 uuid 算法生成主键。如果将映射文件中的主键生成策略改为 "uuid.hex"，必须保证该列是字符串类型。添加记录时，也不需要为主键赋值，系统会自动给定一个随机、唯一的字符串
Hibernate 主键
SessionFactory
SessionFactory 非常消耗内存，它缓存了生成的 SQL 语句和 Hibernate 在运行时使用的映射元数据。也就是说，中间数据全部使用 SessionFactory 管理。因此，该对象的使用，有时关系到系统的性能

Hibernate问题集锦：概述

Hibernate问题集锦：概述Hibernate问题集锦: 概述ImportNew注：本⽂是ImportNew编译整理的⾯试题系列⽂章之⼀。

你可以从这⾥查看全部的系列。

Q．怎么配置？A．Configuration类使⽤配置hibernate.cfg.xml（或者hibernate.properties）以及映射⽂件*.hbm.xml来创建（例如，配置和引导hibernate）SessionFactory，然后SessionFactory创建Session的实例。

Session的实例是持久层服务对外提供的主要接⼝。

hibernate.cfg.xml（或者你也可以使⽤hibernate.properties）：这两个⽂件都是⽤来配置hibernate服务（连接的驱动类，连接URL，⽤户名，密码，⽅⾔等）。

如果这两个⽂件同时存在于classpath⾥的话，那么hibernate.cfg.xml会覆盖hibernate.properties⽂件⾥的配置。

映射⽂件（*.hbm.xml）:这些⽂件都是⽤来对持久层对象和关系数据库进⾏映射的。

最好的⽅式是对每个对象都使⽤单独的映射⽂件（例如⼀个类⼀个⽂件），因为如果在⼀个⽂件⾥存放⼤量的持久层对象，那么这个⽂件就变得⾮常难管理和维护。

约定的命名⽅式是映射⽂件名和持久层类名（POJO）保持⼀致。

例如，Account.class的映射⽂件名为Account.hbm.xml。

或者，你也可以在类⽂件的代码⾥加上hibernate的注解，从⽽不需要使⽤配置⽂件。

Q．什么是SessionFactory？它是线程安全的吗？A．SessionFactory对应Hibernate的⼀个数据存储的概念，并且它是线程安全的，可以被多个线程并发访问，也可以请求session和单个数据库的不可变编译过的映射的缓存。

SessionFactory⼀般只会在启动的时候构建。

对于应⽤代码，最好对SessionFactory通过单例的模式进⾏封装以便于访问。

Hibernate自定义类型

Hibernate自定义类型集合--->字符串
存储
场景：
角色[1]-----[*](资源[1]---[*]权限)
某个角色具有某个资源的某些权限，当然此处都是多对多为了好理解暂时1---*。

这里是资源-对应-多个权限，但是权限一般不会很多，而且我们一般也不会根据权限去查找，因此没必要做个关联表，此处我们可以使用字符串如1,2,3,4来存储其id，这样可以有效减少中间表数量提高效率。

方案：
如果不想在程序中拼接这种字符串我们可以考虑使用Hibernate自定义数据类型；即把集合类型--->某个分隔符连接的字符串
Java代码
1、setParameterValues 作用是参数化集合类型和分隔符不写死了
2、deepCopy必须复制一份否则即使我们改了session也检测不到脏数据使用：
Java代码
TypeDef(
name = "SetToStringUserType",
typeClass = CollectionToStringUserType.class,
parameters = {
Parameter(name = "separator", value = ","),
Parameter(name = "collectionType", value = "java.util.HashSet"),
Parameter(name = "elementType", value = "ng.Long") }
)
定义类型并指定参数化的集合类型、元素类型和分隔符。

hibernate框架总结

hibernate框架总结实体类编写规则1 实体类⾥⾯属性私有的2 私有属性使⽤公开的set和get⽅法操作3 要求实体类有属性作为唯⼀值（⼀般使⽤id值）4 实体类属性建议不使⽤基本数据类型，使⽤基本数据类型对应的包装类（1）⼋个基本数据类型对应的包装类- int – Integer- char—Character、- 其他的都是⾸字母⼤写⽐如 double – Double（2）⽐如表⽰学⽣的分数，假如 int score;- ⽐如学⽣得了0分，int score = 0;- 如果表⽰学⽣没有参加考试，int score = 0;不能准确表⽰学⽣是否参加考试解决：使⽤包装类可以了， Integer score = 0，表⽰学⽣得了0分，表⽰学⽣没有参加考试，Integer score = null;对实体类crud操作添加操作1 调⽤session⾥⾯的save⽅法实现根据id查询1 调⽤session⾥⾯的get⽅法实现修改操作1 ⾸先查询，然后修改值（1）根据id查询，返回对象删除操作1 调⽤session⾥⾯delete⽅法实现实体类对象状态（概念）1 实体类状态有三种（1）瞬时态：对象⾥⾯没有id值，对象与session没有关联（2）持久态：对象⾥⾯有id值，对象与session关联（3）托管态：对象有id值，对象与session没有关联2 演⽰操作实体类对象的⽅法（1）saveOrUpdate⽅法：实现添加、实现修改测试代码：⼀.创建瞬时态对象[没有id，与session没有关联]，使⽤saveOrupdate保存，做插⼊操作 Customer c=new Customer();c.setCname("传智");session.saveOrUpdate(c); 底层sql语句Hibernate:insertintot_customer(cname, tel)values(?, ?) 数据库插⼊了⼀条数据(使⽤的是主键⾃动增长策略)：⼆.创建托管态对象[有id，与session没有关联]，使⽤saveOrupdate保存，做更新操作⾸先需要明⽩它做的是更新的操作，那么问题就产⽣了，如果数据库中存在这个id值，那么会更新，如果设置的id值，数据库中没有呢？那么就⽆法完成更细，会报错（1）数据库中没有该id值(数据库中没有id为9的记录，那么进⾏更新的时候肯定会报错)Customer c=new Customer();c.setCid(9);c.setCname("传智9");session.saveOrUpdate(c);（2）数据库中有该id值(把id为1的记录的cname字段由“传智播客1”改为“百度”)Customer c=new Customer();c.setCid(1);c.setCname("百度");session.saveOrUpdate(c);　底层sqlHibernate:updatet_customersetcname=?,tel=?wherecid=?Hibernate:updatet_linkmansetclid=nullwhereclid=?　数据库是更新了没错但是它⼜多了⼀条更新语句，就是把关联表中的外键字段置为null,⾸先这⾥只需要明⽩产⽣的原因是hibernate双向维护机制，解决办法就是在customer配置⽂件的set标签中使⽤inverse="true" 表⽰让它放弃外键的维护能⼒，这样就不会出现下⾯的更新语句了，详解请参考框架截图总结（⼀）当然上⾯演⽰的情况因为在关联表中本来就没有记录，所以没有影响，但是如果是存在记录，那么根据打印的sql语句就能知道⼀定会出现下⾯的情况修改之前数据库中的记录(存在外键的约束，即百度这个客户它对应的联系⼈是李彦宏)：现在把百度的名称，改变为百度1Customer c=new Customer();c.setCid(1);c.setCname("百度1");session.saveOrUpdate(c); sql语句：Hibernate:updatet_customersetcname=?,tel=?wherecid=?Hibernate:updatet_linkmansetclid=nullwhereclid=? 所以看表中的变化更新没有问题，但是联系⼈表中的外键字段是null三.创建持久态对象[有id，与session有关联]，使⽤saveOrupdate保存，做更新操作修改之前现在把百度1改回百度Customer c=session.get(Customer.class,1);//持久态对象c.setCid(1);//这条语句写不写对结果没有任何的影响，因为id的值没有变化，但是如果把id值改变就会保错c.setCname("百度");session.saveOrUpdate(c); sql语句：Hibernate:selectcustomer0_.cid as cid1_0_0_,customer0_.cname as cname2_0_0_,customer0_.tel as tel3_0_0_fromt_customer customer0_wherecustomer0_.cid=?Hibernate:updatet_customersetcname=?,tel=?wherecid=? 只做⼀次更新，观察数据库中的变化可以发现在修改持久态对象的时候，并没有把关联表的外键字段置为null的语句打印，说明托管态和持久态之间使⽤saveOrupdate是有区别的虽然同样是更新操作，托管态在更新数据之后会把关联表的外键字段再做⼀次更新（做了2次更新），置为null，⽽持久态的对象在更新之后只是更新了⾃⼰表的数据(1次更新)全部测试代码：1package org.testdemo;23import org.hibernate.Session;4import org.hibernate.SessionFactory;5import org.hibernate.Transaction;6import org.hibernate.cfg.Configuration;7import org.junit.Test;8import er;9import org.util.SessionFactoryUtil;1011public class TestDemo {12// 1通过⼯具类得到sessionfactory 对象13// SessionFactory sessionfactory = SessionFactoryUtil.getSessionFactory();14// 2通过sessionfactory得到session对象15// Session session = sessionfactory.openSession();16// 3通过session创建事务17// Transaction tran = session.beginTransaction();1819// 4进⾏数据库的操作2021// 5提交事务22// mit();23// 6关闭链接24// session.close();25// sessionfactory.close();2627 @Test28public void add() {29//insert into t_user(name,password) values(?,?)30 SessionFactory sessionfactory = SessionFactoryUtil.getSessionFactory();31 Session session = sessionfactory.openSession();32 Transaction tran = session.beginTransaction();33//添加⼀条数据34 User user = new User();35 user.setName("jay");36 user.setPassword("root");37 session.save(user);38 mit();39 session.close();40 sessionfactory.close();4142 }4344 @Test45public void select() {46//select * from t_user where id=?47 SessionFactory sessionfactory = SessionFactoryUtil.getSessionFactory();48 Session session = sessionfactory.openSession();49 Transaction tran = session.beginTransaction();50//查询⼀条记录根据id值51 User user = session.get(User.class, 1);52 System.out.println(user);53 mit();54 session.close();55 sessionfactory.close();56 }5758 @Test59public void update() {60//update t_user set name=?,password=? where id=?61 SessionFactory sessionfactory = SessionFactoryUtil.getSessionFactory();62 Session session = sessionfactory.openSession();63 Transaction tran = session.beginTransaction();64//执⾏修改操作先找到对象在进⾏修改最后使⽤update⽅法执⾏最后的变更65 User user=session.get(User.class,1);66 user.setName("Joke");67 session.update(user);6869 mit();70 session.close();71 sessionfactory.close();72 }7374 @Test75public void delete() {76//delete from t_user where id=?77 SessionFactory sessionfactory = SessionFactoryUtil.getSessionFactory();78 Session session = sessionfactory.openSession();79 Transaction tran = session.beginTransaction();80//执⾏删除操作先找到对象在进⾏删除81 User user=session.get(User.class,1);82 session.delete(user);83// User user=new User();84// user.setUid(2);85// session.delete(user);8687 mit();88 session.close();89 sessionfactory.close();90 }9192 @Test93public void saveorupdate() {94//delete from t_user where id=?95 SessionFactory sessionfactory = SessionFactoryUtil.getSessionFactory();96 Session session = sessionfactory.openSession();97 Transaction tran = session.beginTransaction();9899//创建游离态100// User user=new User();101// user.setName("aa");102// user.setPassword("bb");103// session.saveOrUpdate(user);//执⾏插⼊操作104105//创建托管态106// User user=new User();107// user.setUid(3);108// user.setName("cc2");109// user.setPassword("dd3");110// session.saveOrUpdate(user);//执⾏更新操作111112//创建持久态113 User user=session.get(User.class,3);114 user.setName("feafw");115 session.saveOrUpdate(user);//执⾏更新操作116117118 mit();119 session.close();120 sessionfactory.close();121 }122123124 }Hibernate的⼀级缓存什么是缓存1 数据存到数据库⾥⾯，数据库本⾝是⽂件系统，使⽤流⽅式操作⽂件效率不是很⾼。