Hibernate学习入门教程
Hibernate学习入门教程
开发环境搭建
[日期：2015-08-11] 来源：Linux社区作者：doctorJoe [字体：大中小]
其实一两个月前就在了解Hibernate方面的知识了，但一直以来，都没有好好的总结，而且一直使用的是myeclipse，感觉有些傻瓜式的操作就可以搭建起Hibernate的开发环境，但这样一点都不好，没有理解到Hibernate到底是怎么配置的，所以你今天特使用Eclipse来一步一步搭建Hibernate的开发环境，下面，正式进入正题。
在Hibernate中开启日志https://www.wendangku.net/doc/0712031757.html,/Linux/2015-07/120499.htm
Hibernate+JUnit测试实体类生成数据库表https://www.wendangku.net/doc/0712031757.html,/Linux/2015-07/120161. htm
Hibernate整体理解https://www.wendangku.net/doc/0712031757.html,/Linux/2014-07/104405.htm
Hibernate的映射机制https://www.wendangku.net/doc/0712031757.html,/Linux/2014-12/110265.htm 新建一个web项目，名字就随便吧，你喜欢什么名字就什么吧，这是我的截图。
引入hibernate的依赖jar包，我使用的是hibernate-release-4.3.10.Final，下载好后解压，打开压缩包下的lib目录下的require文件夹，这是hibernate的所以来的必须的jar包，接下来，在刚才新建的项目里新建一个libs文件夹，将刚才的所说的jar包copy进去，另外，由于我们需要连接MySQL数据库以及使用JUnit测试，将所需的mysql-connector-java-5.0.8-bin.jar和junit-4.5.jar两个jar包引用进去，关于这些jar包，可以在网上搜索。接下来，就是把这些jar 包添加到编译环境中去，选中libs下的jar包，右击选择Build Path –>Add to Build Path,这样就把依赖jar包成功添加进去了。
继续往下，我们需要配置最重要的hibernate配置文件hibernate.cfg.xml以及进行日志处理的log4j.properties属性文件：打开上一步解压后的hibernate文件夹，打开project—>etc文件夹，将该文件夹下的hibernate.cfg.xml和log4j.properties文件拷贝到项目的src文件夹下，打开hibernate.cfg.xml文件，将session-factory标签中的内容替换成如下的内容：
这样就配置好了。
接下来，要做的就是做开发测试了：在项目的src目录下新建一个实体类包com.joe.entity,在该包下新建一个实体类Student，代码如下：
package com.joe.entity;
import java.io.Serializable;
p u b l i c c l a s s S t u d e n t i m p l e m e n t s S e r i a l i z a b l e{
/**
*
*/ pr i va t e s ta ti c f ina l l o ng s er i a lV e r s ion U ID=5548279324472937805L;
p r i v a t e i n t i d;
p r i v a t e S t r i n g n a m e;
p r i v a t e i n t a g e;
/**
*申明无参构造函数
*/ p u b l i c S t u d e n t(){
} p u b l i c i n t g e t I d(){
r e t u r n i d;
} p u b l i c v o i d s e t I d(i n t i d){
t h i s.i d=i d;
} p u b l i c S t r i n g g e t N a m e(){
r e t u r n n a m e;
} p u b l i c v o i d s e t N a m e(S t r i n g n a m e){
t h i s.n a m e=n a m e;
} p u b l i c i n t g e t A g e(){
r e t u r n a g e;
} p u b l i c v o i d s e t A g e(i n t a g e){
t h i s.a g e=a g e; }
}
对了，说明下，必须申明一个无参的构造函数，这是必须的哦！
关键问题来了，我们不是说hibernate是做数据持久化的吗？那说百了就是要和数据库打交道呗，对于Student类，怎么和数据库关联呢，那我们就要说说这对象关系映射文件了Xxx.hbm. xml文件了，其中的Xxx是实体类的名称，那我们的Student.hbm.xml文件的内容就是：
3.0.d t d">
将该文件同样添加到com.joe.entity包下，这样就行了吗？答案当然是否定的，我们还要将这个实体类注册到hibernate.cfg.xml文件中，在session-factory标签下面最后一个property标签后添加：
再往下走，我们来测试一下，在项目下新建一个资源文件夹test，再在test文件下新建测试包com.joe.test,在该包下新建一个StudentTest.java类，并书写如下代码：
package com.joe.test;
i m p o r t o r g.h i b e r n a t e.S e s s i o n;
i m p o r t o r g.h i b e r n a t e.S e s s i o n F a c t o r y;
i m p o r t o r g.h i b e r n a t e.T r a n s a c t i o n;
i m p o r t o r g.h i b e r n a t e.b o o t.r e g i s t r y.S t a n d a r d S e r v i c e R e g i s t r y B u i l d e r;
i m p o r t o r g.h i b e r n a t e.c f g.C o n f i g u r a t i o n;
i m p o r t o r g.h i b e r n a t e.s e r v i c e.S e r v i c e R e g i s t r y;
i m p o r t o r g.h i b e r n a t e.t o o l.h b m2d d l.S c h e m a E x p o r t; import org.junit.Test;
import com.joe.entity.Student;
p u b l i c c l a s s S t u d e n t T e s t{
/** *@T e s t是j u n i t4测试的注解方式申明
*根据对象关系映射文件生成D D L
*/
@T e s t p u b l i c v o i d c r e a t e T a b l e(){
C o n f i g u r a t i o n c f g=n e w C o n f i g u r a t i o n().c o n f i g u r e();
S c h e m a E x p o r t s e=n e w S c h e m a E x p o r t(c f g);
s e.c r e a t e(t r u e,t r u e);
} }
当然，也可以使用如下的方式生成DDL，在hibernate.cfg.xml问价中新增：
最后，执行StudentTest.java类，选择Run As—>JUnit Test，在控制台可以看到如下的信息，那就证明成功了：
当然，也可以打开MySQL ，进一步验证。
好了，hibernate的开发环境就算正式搭建完成。
更多详情见请继续阅读下一页的精彩内容：https://www.wendangku.net/doc/0712031757.html,/Linux/2015-08/121498 p2.htm
在上一篇文章hibernate学习系列-----（1）开发环境搭建中，大致总结了hibernate的开发环境的搭建步骤，今天，我们继续了解有关hibernate的知识，先说说这篇文章的主要内容吧：
1.Configuration类
2.SessionFactory接口
3.Session接口
4.Transaction接口
5.Query和Criteria接口
下面就进行分类别地详细说明：
Configuration类
1.功能描述：Configuration类负责管理Hibernate的配置信息作并根据配置信息启动
Hibernate。
2.详细说明：提供数据库的链接参数；数据库连接池以及对象关系文件的配置，通过
Configuration类来加载配置信息并且启动hibernate的应用程序
3.hibernate的配置方法：（1）：使用hibernate.properties文件进行配置；（2）使用
xml文件进行配置，也就是―hibernate.cfg.xml‖文件，推荐使用后者SessionFactory接口
?SessionFactory实例对应一个数据存储源，我们的应用程序就是通过SessionFactory 实例来获取我们的Session对象，SessionFactory的特点有：
o（1）线程安全，一个SessionFactory实例可以被应用的多个线程共享
o（2）重量级：需要很大的缓存来存储预定义的SQL语句以及映射数据，so，如果我们的应用程序只使用一个数据库，则只需建立一个SessionFactory对象
即可
Session接口
?Session又被称之为持久化管理器，它提供了和持久化相关的CRUD操作，在hibernate中应用最为广泛。Session接口有哪些特点呢？
o（1）线程不安全：它代表了我们对数据库的一次操作，因此在开发中应尽量避免多个线程共享同一个Session实例；
o（2）轻量级：它的销毁和创建不需要消耗太多资源；
o（3）hibernate的一级缓存:存放了当前工作单元加载的一些对象，每一个Session都有自己的缓存，缓存中的对象只能被当前的工作单元所使用；
o（4）SessionFactory对象打开：使用完毕后要及时关闭。
Transaction接口
?Transaction接口是hibernate中的事务接口，它包括：JDBC API、JTA，hibernate在进行持久化操作时（CRUD）,必须在事务中加以控制。
?
Query和Criteria接口
?Query和Criteria接口是hibernate中的查询接口：
o（1）Query接口包装了一个HQL(Hibernate Query Language)查询语句。
o（2）Criteria接口比较面向对象，擅长执行动态查询。
hibernate的核心接口就大致说到这儿了，下面说一下hibernate的工作机制，先上图：
这张图还是比较好理解的，我就不再说明。
Session缓存原理
为了能够在控制台更好的看到我们的hibernate干了些什么，可以在hibernate.cfg.xml文件中写入如下配置：
在上一篇中，我们就曾说：Session在hibernate中被称为一级缓存，Session接口的原理：
1.当应用程序调用Session的CRUD方法、以及调用查询接口的list()、iterate()或filter()
方法时，如果在Session缓存中还不存在相应的对象，Hibernate就会把该对象加入到第一级缓存中
2.当清理缓存时，Hibernate会根据缓存中对象的状态变化来同步更新数据库。Session缓存的作用：
1.减少访问数据库的频率
2.保证缓存中的对象与数据库中的对象同步
3.当缓存中的持久化对象之间存在循环关联关系时，Session会保证不出现访问对象图的
死循环，以及由死循环引起的JVM堆栈溢出异常
Session缓存的应用：
1.当应用程序调用Transaction的commit方法时，commit方法会清理缓存，然后再向
数据库提交事务，这里使用一个例子来简单说明一下
目前数据库表中数据有：
使用JUnit测试下面的这个方法：
@Test
publicvoid get(){
Configuration cfg=new Configuration().configure();
StandardServiceRegistryBuilder
ssrb=new StandardServiceRegistryBuilder().applySettings(cfg.getPropertie s());
ServiceRegistry service=ssrb.build();
SessionFactory factory=cfg.buildSessionFactory(service);
Session session=factory.openSession();
Transaction tx=session.beginTransaction();
try {
Student stu=(Student)session.get(Student.class, 1);
stu.setName("lisi");
https://www.wendangku.net/doc/0712031757.html,mit();
} catch (Exception e) {
// TODO: handle exception
tx.rollback();
}finally {
session.close();
}
}
运行时，我们可以在控制台看到：
再次看看数据库表中的数据：
透过这个案例，我们可以看到调用commit()方法时，hibernate进行了事务提交并把数据永久地保存到了数据库中，变为持久态。
1.当应用程序中显示调用session的flush方法时，通过session的
setFlushMode(FlushMode fm)方法来设定清理缓存的时间点。
（1）FlushMode.ALWAYS：在session执行查询、commit方法以及flush方法时都会清理缓存；
（2）FlushMode.AUTO：在session执行查询、commit方法以及flush方法时都会清理缓存，这与第一种在本质上没有区别；
（3）https://www.wendangku.net/doc/0712031757.html,MIT：在session执行commit方法以及flush方法时都会清理缓存；
（4）FlushMode.MANUAL：只有显示地调用flush方法时才会清理缓存，其他情况都不会清理缓存；
session缓存对象的生命周期：
首先来说一说session缓存对象都有哪些状态吧：
1.瞬时（Transient）状态
2.持久化（Persistent）状态
3.脱管（detached）状态
4.移除（removed）状态
这里我们用一个图来说明：
Session的基本操作
在项目的测试包中，新建一个StudentTest2.java文件。
Session接口:
Session接口是Hibernate向应用程序提供的操作数据库的最主要的接口，它提供了基本的保存、查询、更新和删除等方法。
save()方法：
使一个瞬时状态的对象转变为持久化状态的对象。
使用JUnit测试下面的方法：
@Test
publicvoid add() {
Configuration cfg = new Configuration().configure();
// 如果是hibernate4.0以前的版本，使用如下的方式创建SessionFactory对象
// SessionFactory factory=cfg.buildSessionFactory();
StandardServiceRegistryBuilder ssrb = new StandardServiceRegistryBuilder().applySettings(cfg.getProperties()); ServiceRegistry service =ssrb.build();
SessionFactory factory =cfg.buildSessionFactory(service);
Session session =factory.openSession();
Transaction tx =session.beginTransaction();
try {
//new 一个Student类的对象，在未执行session.save(stu1)方法时，它是瞬时对象
Student stu1 = new Student();
stu1.setName("yu zhiping");
stu1.setAge(22);
session.save(stu1);
https://www.wendangku.net/doc/0712031757.html,mit();
} catch (Exception e) {
// TODO: handle exception
tx.rollback();
} finally {
session.close();
}
}
运行，查看控制台的输出信息：
此时，stu1就由一个瞬时状态对象变为了一个持久化状态的对象，并由session来管理，位于session的缓存中。如果在save()方法后再对stu1进行操作，就是对缓存???的数据进行操作，那当我们再次提交事务的时候会清理缓存，session会把缓存中的数据与数据库中的数据进行同步的更新，我们在上面的代码中，位于session.save(stu1);后添加：
stu1.setAge(22);
再次运行该方法，控制台的输出信息是：
执行了两条SQL语句，这说明在调用save()方法后，stu1的确由瞬时态变为了持久态。
get()和load()方法：
都是根据给定的OID，加载一个持久化对象。
get()方法和load()方法的异同点：
1.都是先根据OID从缓存中获取，存在就直接返回
2.get()方法：执行SQL从数据库获取
3.load()方法：返回一个代理对象（延迟加载、懒加载）
4.如果数据库中不存在给定OID对应的记录：get()方法返回null；load()方法跑出
ObjectNotFoundException异常
get()方法：
@Test
publicvoid get(){
Configuration cfg=new Configuration().configure();
StandardServiceRegistryBuilder
ssrb=new StandardServiceRegistryBuilder().applySettings(cfg.getPropertie s());
ServiceRegistry service=ssrb.build();
SessionFactory factory=cfg.buildSessionFactory(service);
Session session=factory.openSession();
Transaction tx=session.beginTransaction();
try {
Student stu=(Student)session.get(Student.class, 1); System.out.println(stu.getId());
https://www.wendangku.net/doc/0712031757.html,mit();
} catch (Exception e) {
// TODO: handle exception
tx.rollback();
}finally {
session.close();
}
}
执行的结果是:
查询了数据库表，再看看load()方法：
@Test
publicvoid load(){
Configuration cfg=new Configuration().configure();
StandardServiceRegistryBuilder
ssrb=new StandardServiceRegistryBuilder().applySettings(cfg.getPropertie s());
ServiceRegistry service=ssrb.build();
SessionFactory factory=cfg.buildSessionFactory(service);
Session session=factory.openSession();
Transaction tx=session.beginTransaction();
try {
Student stu=(Student)session.load(Student.class, 1); System.out.println(stu.getId());
https://www.wendangku.net/doc/0712031757.html,mit();
} catch (Exception e) {
// TODO: handle exception
tx.rollback();
}finally {
session.close();
}
}
执行的结果：
为什么没有在数据库中查询呢？这就是load()方法的特点：懒加载、延迟加载，只有访问非对象关系表示符OID属性以外的其他属性时load()方法才会发起select语句，我们把上面的方法稍微修改一下：
Student stu=(Student)session.load(Student.class, 1);
System.out.println(stu.getName());//获取name属性
https://www.wendangku.net/doc/0712031757.html,mit();
在次执行，看看控制台的信息：
特别注意，在使用load()方法时，千万不要在session关闭后对非对象关系表示符属性以外的其他属性的访问，否则会跑出异常。
delete()方法
使一个持久化对象变成移除状态，从数据库中移除它的持久化状态。
看看delete()方法的定义：
@Test
publicvoid delete(){
Configuration cfg=new Configuration().configure();
StandardServiceRegistryBuilder
ssrb=new StandardServiceRegistryBuilder().applySettings(cfg.getPropertie s());
ServiceRegistry service=ssrb.build();
SessionFactory factory=cfg.buildSessionFactory(service);
Session session=factory.openSession();
Transaction tx=session.beginTransaction();
try {
Student stu=(Student)session.load(Student.class, 1); session.delete(stu);
https://www.wendangku.net/doc/0712031757.html,mit();
} catch (Exception e) {
// TODO: handle exception
tx.rollback();
}finally {
session.close();
}
}
测试该方法，看看控制台的输出信息：
可以看到，有两条sql语句，第一条就是get()方法的select语句，第二条就是delete()的删除语句。
update()方法
使一个脱管对象重附到新的session中，成为持久化对象。
看看update(）方法的代码：
@Test
publicvoid update(){
Configuration cfg=new Configuration().configure();
StandardServiceRegistryBuilder
ssrb=new StandardServiceRegistryBuilder().applySettings(cfg.getPropertie s());
ServiceRegistry service=ssrb.build();
SessionFactory factory=cfg.buildSessionFactory(service);
Session session=factory.openSession();
Transaction tx=session.beginTransaction();
try {
Student stu=(Student)session.load(Student.class, 2);
stu.setAge(50);
session.update(stu);
https://www.wendangku.net/doc/0712031757.html,mit();
} catch (Exception e) {
// TODO: handle exception
tx.rollback();
}finally {
session.close();
}
}
执行本方法，可以看到如下结果：
在使用update()方法时，如果操作的是托管对象，它也依然会把托管对象变为持久化对象，然后再执行update语句，当清理缓存的时候，再把缓存中的数据同步更新到数据库。
merge()方法
将给定实例的状态复制到具有相同标识符的持久化实例上，并返回这个持久化实例；
常用来代替update()方法、saveOrUpdate()方法。
先看看使用merge()方法操作瞬时态对象：
@Test
publicvoid merge(){
Hibernate3.6(开发必看)
1.Java对象持久化概述 1.1.应用程序的分层体系结构 1.1.1.基于B/S的典型三层架构 说明： 1，展现层：提供与用户交互的界面。 2，业务逻辑层：实现各种业务逻辑。 3，数据访问层：负责存放和管理应用程序的持久化业务数据。 1.1. 2.数据访问层与Hibernate在Java应用程序中的 角色 数据访问层（持久化层）封装了数据访问的细节，为业务逻辑层提供了面向对象的API。完善的持久化层应该达到的目标： 1，代码重用性高，可完成所有的数据访问操作。 2，如果需要的话，能够支持多种数据库平台。 3，具有相对独立性，当持久化层变化时，不会影响上层实现。 在数据访问层（持久化层）中可以使用Hibernate框架以实现要求，如下图所示：
1.2.软件模型 1.2.1.各种模型的说明 概念模型： 模拟问题域中的真实实体。描述每个实体的概念和属性及实体间关系。不描述实体行为。实体间的关系有一对一、一对多和多对多。。 关系数据模型： 在概念模型的基础上建立起来的，用于描述这些关系数据的静态结构。有以下内容组成：1，若干表 2，表的所有索引 3，视图 4，触发器 5，表与表之间的参照完整性
域模型： 在软件的分析阶段创建概念模型，在软件设计阶段创建域模型。 组成部分： 1，具有状态和行为的域对象。 2，域对象之间的关联。 域对象(domain object)： 构成域模型的基本元素就是域对象。对真实世界的实体的软件抽象，也叫做业务对象（Business Object，BO）。域对象可代表业务领域中的人、地点、事物或概念。 域对象分为以下几种: 1，实体域对象：通常是指业务领域中的名词。（plain old java object，简单Java 对象）。 2，过程域对象：应用中的业务逻辑或流程。依赖于实体域对象，业务领域中的动词。如发出订单、登陆等。 3，事件域对象：应用中的一些事件（警告、异常）。 1.2.2.域对象间的关系 关联： 类间的引用关系。以属性定义的方式表现。
Hibernate学习入门教程
Hibernate学习入门教程 开发环境搭建 [日期：2015-08-11] 来源：Linux社区作者：doctorJoe [字体：大中小] 其实一两个月前就在了解Hibernate方面的知识了，但一直以来，都没有好好的总结，而且一直使用的是myeclipse，感觉有些傻瓜式的操作就可以搭建起Hibernate的开发环境，但这样一点都不好，没有理解到Hibernate到底是怎么配置的，所以你今天特使用Eclipse来一步一步搭建Hibernate的开发环境，下面，正式进入正题。 在Hibernate中开启日志https://www.wendangku.net/doc/0712031757.html,/Linux/2015-07/120499.htm Hibernate+JUnit测试实体类生成数据库表https://www.wendangku.net/doc/0712031757.html,/Linux/2015-07/120161. htm Hibernate整体理解https://www.wendangku.net/doc/0712031757.html,/Linux/2014-07/104405.htm Hibernate的映射机制https://www.wendangku.net/doc/0712031757.html,/Linux/2014-12/110265.htm 新建一个web项目，名字就随便吧，你喜欢什么名字就什么吧，这是我的截图。
引入hibernate的依赖jar包，我使用的是hibernate-release-4.3.10.Final，下载好后解压，打开压缩包下的lib目录下的require文件夹，这是hibernate的所以来的必须的jar包，接下来，在刚才新建的项目里新建一个libs文件夹，将刚才的所说的jar包copy进去，另外，由于我们需要连接MySQL数据库以及使用JUnit测试，将所需的mysql-connector-java-5.0.8-bin.jar和junit-4.5.jar两个jar包引用进去，关于这些jar包，可以在网上搜索。接下来，就是把这些jar 包添加到编译环境中去，选中libs下的jar包，右击选择Build Path –>Add to Build Path,这样就把依赖jar包成功添加进去了。 继续往下，我们需要配置最重要的hibernate配置文件hibernate.cfg.xml以及进行日志处理的log4j.properties属性文件：打开上一步解压后的hibernate文件夹，打开project—>etc文件夹，将该文件夹下的hibernate.cfg.xml和log4j.properties文件拷贝到项目的src文件夹下，打开hibernate.cfg.xml文件，将session-factory标签中的内容替换成如下的内容：
MyEclipse+Hibernate+快速入门+中文版
提纲 1前言2准备工作3介绍4Hibernate 一览5创建HibernateDemo 项目 5创建HibernateDemo Java Project 5555使用模版调整生成更好的代码55编辑映射文件 6使用HQL 编辑器 7测试HibernateDemo 应用 8使用示例HibernateDemo 项目 9 总结1.前言 本文档基于以下环境编写:Sun JDK 1.5,Eclipse 3.2和MyEclipse 5.0.所有的截屏基于Eclipse,MyEclipse Enterprise Workbench,和Windows XP 的默认用户界面设置.如果你对本文档的介绍有阅读上的困难,请阅读用户反馈部分来了解如何向MyEclipse 文档团队提交反馈. 2.准备工作 下面是这个快速入门的准备工作列表: Java 2SDK,Standard Edition 1.4或者更高版本(参考来了解下载地址) Eclipse 3.2SDK (参考资源来了解下载地址) MyEclipse 5.0(参考资源来了解下载地址) 选择以下可以被Hibernate 和MyEclipse Database Explorer 所支持的数据库服务器列表中的一个 : MyEclipse Hibernate 快速入门中 文版
3.介绍 这个快速入门展示了使用MyEclipse Enterprise Workbench 开发Hibernate 的基本功能,概念和技术.我们将全程带领你来开发一个非常简单的Java Hibernate 应用.对于这个教程没有包含到的问题和概念,我们推荐你去参考资源部分列出的Hibernate 资源. 这个文档展示了如何进行下列工作: 为Java 项目添加MyEclipse Hibernate 支持 在项目中创建Hibernate 配置文件 如何使用自定义的Session Factory 从Database Explorer 的表定义中生成Java 类和Hibernate 数据库映射文件(.hbm ) ?使用HQL 编辑器 创建使用Hibernate 的小测试应用注意:在使用本教程时建议您事先阅读了Database Explorer 快速入门这个教程来了解如何创建连接和元数据功能. 4.Hibernate 一览 Hibernate 是一个非常流行的开源的易于配置和运行的基于Java 的对象-关系映射(JORM)引擎.它提供了很丰富的功能包括: 多种映射策略 可迁移的持久化 单个对象映射到多个表 支持集合 多态关联可自定义的SQL 查询 Axion Hypersonic DB InstantDB Interclient Firebird ODBC Bridge jTDS Mckoi Microsoft SQL Server Mimer SQL MySQL Oracle Pointbase PostgresQL SAPDB Sunopsis XML Sybase ThinkSQL
Hibernate知识的学习
Hibernate知识的学习 --------------------------------------------------第一章------------------------------------------------ 1、为什么用Hibernate呢？ 他属于ORM中的一种；用来解决对象与关系模型不匹配的； ===用来解决对象与关系模型不匹配的{方法有两种：使用JDBC手工来操作；还有就是使用ORM来解决}； 学习Hibernate都要到那些包； Hibernate自动创建表； Hibernate测试类中应该怎样启动hibernate调用（主要是构造一个sessionFactory工厂，通过工厂来产生一个session对象，在通过session对象来对Hibernate操作数据库）； --------------------------------------------------第二章------------------------------------------------ Hibernate的开发流程；(三点) Hibernate控制一个JavaBean时，应注意的JavaBean应该满足哪三点? --------------------------------------------------第三章------------------------------------------------ 做了一个简单的Hibernate的实例：其中编写了一个HibernateUtil.java文件来专门创建Session 对象的一个公共组件!Hibernate02实例中 --------------------------------------------------第四章------------------------------------------------ Hibernate中Session是最核心的接口，现在我们来学习一下： 通过session对象来完成增、删、改、查、的主要操作！ 1.session对象的常用方法： save():添加一个对象，对应到表也就是添加一个信息; delete():删除一个对象，对应到表也就是删除一条信息； update():修改数据库信息，注意一点，当数据库没有信息时，会报出异常； get():根据id查询信息，会立刻访问数据库；【查询数据库时可以不打开事务操作】； Load():根据id查询信息，(返回的是代理，不会立即访问数据库【所以先不产生sql语句，而是当你真正的使用通过Load方法从数据库中去到的记录对象时才输出sql语句】也就是使用了懒加载机制 .如果在使用了Load方法了后，千万不要试图判断去到的对象是否为空值，因为load在这里将会产生出一个对应表JavaBean实体类的子类来处理的，相当于一个代理类的意味;通过user.getClass().getName()来获取这个代理类名称)； saveOrUpdate()和merge方法:根据id和version的值来确定是save或update)，【调用merge你的对象还是托管的】。【托管中用到了】 refresh():将数据重新读取一次! Lock()方法：查出一条数据，再给数据加一道锁【即为：把对象变成持久对象，但不会同步对象状态】 ------------------------------------------------------------------------------------------- 注意： 1、get和load方法获取数据库表中记录的区别； get():根据id查询信息，会立刻访问数据库；【查询数据库时可以不打开事务操作】； Load():根据id查询信息，(返回的是代理，不会立即访问数据库【所以先不产生sql语句，而是当你真正的使用通过Load方法从数据库中去到的记录对象时才输出sql语句】也就是使用了懒加载机制 .如果在使用了Load方法了后，千万不要试图判断去到的对象是否为空值，因为load在这里将会产生出一个对应表JavaBean实体类的子类来处理的，相当于一个代理类的意味;通过user.getClass().getName()来获取这个代理类名称)；
Eclipse从入门到精通(第二版)_ch37
第37章 在Eclipse中使用Hibernate 本章将把Hibernate应用到myweb项目中，对数据库层的代码进行改造，同时还会介绍一些Hibernate工具的使用。 37.1 概述 37.1.1 持久化框架产生的背景和现状 什么叫持久化？数据在内存中，关机后就会丢失。而如果把数据保存到后台的数据库中，就能达到“持久”保存数据的目的。而持久化框架的目的就是为了帮助用户更好地使用数据库。 在Java数据库项目中，由于数据库是关系型而非面向对象的。很多时候，用面向对象方法完成了前期的设计和分析，到了数据库层编程时就会变得很别扭，其中最痛苦的就是写面向过程的SQL语句。 J2EE开发主要由JSP、Servlet、JavaBean和EJB 4部分组成。其中EJB是J2EE中一个比较重要的部分，它提供了企业级开发所需的分布式支持。但现实中的大部分项目都是单服务器的轻量级项目，一般都不会涉及分布式的开发环境，这时用EJB就像大炮打蚊子，蚊子没打到，房子却被打破个洞。EJB的笨重和复杂一直让开发者很不满，其中EJB中Entity Bean受到的批评最多，现实项目中鲜有使用Entity Bean的成功范例。 开发者急切地需要一种符合Java编程习惯的、适合轻量级开发的、易于使用的数据库持久化解决方案。在这个背景下就产生了轻量级的数据库持久化技术，其中最主要的就是Hibernate、JDO。 Hibernate是一个民间开源项目，有点像一个草莽英雄，但Hibernate从实用出发的设计思路，使得它脱颖而出成为最流行的持久化技术。Hibernate的作者Gavin King也一举成名，现已成为EJB 3.0专家组的成员，并且在EJB 3.0的Entity Bean部分，将采用和Hibernate 类似的设计方案。因此，Hibernate是开发者学习和使用持久化技术的一个比较好的选择，即使以后EJB 3.0一统天下，所学的Hibernate知识也不会浪费。 JDO 2.0是经JCP（Java规范管理委员会，由SUN、IBM、Oracle等共同参与）承认的一个正式规范，所以也受到了开发者很大的关注。估计未来3年内，持久化技术将以EJB 3.0、Hibernate和JDO 2.0为主，成三足鼎立之势。
实验 五 Hibernate基础实验
实验五Hibernate基础实验 Part one Hibernate对表的添加 实验目的：掌握Hibernate的基本功能和基本用法 实验要求：通过Hibernate将一个Java对象插入到数据库表中 实验原理： （1）Hibernate是一个面向Java环境的对象/关系数据库映射工具，Hibernate不仅管理Java类型到数据库表的映射，还提供查询数据 和操作数据的OO方法。 （2）Hibernate对JDBC进行了轻量级的对象封装，使Java程序员可以随心所欲地使用OO编程思想来处理数据库。 （3）Hibernate采用映射元数据来描述对象-关系的映射细节，元数据通常采用XML。 （4）关系数据库中的元组通过ORM转换成应用程序中的对象；反之，应用程序中的对象通过ORM持久化成关系数据库中的元组。 （5）可以利用Hibernate框架根据配置和类及映射文件生成数据库表结构，反过来，也可以根据数据库表结构生成持久化类和映射文 件。 实验准备： 安装SQL Server20XY（如果是Windows XP上的SQL Server2000版，需要加补丁程序SP3）。 实验步骤： 一．创建Java Project TestH3_2 二．创建数据库及数据源 1.在test数据库中创建表News Use test CREATE TABLE news ( id int IDENTITY (1, 1) primary key ,
title varchar (20) NOT NULL , content text ) Go context的长度在Hibernate中可能闲长，不能插入，需改成较短的类型！设计表结构的图形界面如图5-1所示。 图5-1 设计News表结构的图形化界面 2.打开MyEclipse的Database Explore透视图，如图5-2所示。 图5-2 打开Database Explore透视图 3.创建数据库连接驱动，如图5-3所示。找到jtds-1.2.jar包所在位置。点击Add JARS，把该包包含进去即可。注意：SQL Server的Driver template 选Microsoft SQL Server(jTDS Driver)。
(最新)JSF+Spring+Hibernate的实例讲解
JSF+Spring+Hibernate的实例讲解 使用JSF建立一个真实的Web应用程序不是没有意义的任务，这篇文章介绍了如何将JSF与Sping Framework和Hibernate集成,并且给出了使用这些技术建立这个真实的Web应用程序的最佳实践和设计指导 JavaServer Faces(JSF)技术是J2EE应用程序的一个新的用户接口框架,它非常适合基于 MVC(Model-View-Controller)体系结构的应用程序。已经有大量的文章介绍JSF。然而，很多文章都是站在理论研究的层面上，没有挑战一个真实的企业开发。很多问题没有解决，例如，JSF怎样全面适合MVC体系结构？JSF如何与其他JAVA框架集成？业务逻辑应该放在JSF的backing beans里面吗？怎样处理JSF里面的安全问题？最重要的是你怎样使用JSF建立一个真实的Web应用程序？ 这篇文章涉及所有这些问题。它向你展示如何集成其他特定的Java框架，Spring Framework和Hibernate,它示范怎样去创建一个叫JCatalog的Web应用程序，一个在线的产品目录系统。这篇文章使用JCatalog例子，介绍了Web应用程序设计的每一个阶段，包括业务需求收集，分析，技术选择，高层体系结构和详细设计。这篇文章论述了JCatalog里面好的和不好的技术，示范了应用程序设计中一些关键方面的方法和步骤。 这篇文章是写给正在从事基于J2EE Web应用程序的Java架构师，开发者，它不是对JSF、Spring Framework和Hibernate的入门教程。如果您对这些领域不熟悉，请参考文章最后的资源链接。 例子应用程序的功能需求 这篇文章的例子应用程序JCatalog是一个真实的Web应用程序，例子足够现实是为了决定应用程序架构而进行意味深长的讨论的基础。我通过介绍JCatalog项目的需求开始。我在这里谈到后面贯穿于整个文章的内容是为了演示技术选择和体系结构设计。 设计Web应用程序的第一步是收集系统的功能需求，这个例子应用程序是一个典型的电子商务应用系统。用户能浏览产品目录和查看产品细节，管理员能管理产品目录。功能还可以增加，举例来说，为了开发一个成熟的电子商务系统，可以添加库存管理和订单处理的功能。 用例 用例分析被用于去访问例子应用程序的功能需求，图1是应用程序的用例图。
struts2+spring3+hibernate整合教程
Struts2+Spring3+hibernate3整合 （2011年7月末，最新） 上次下载了一个教程，上面写着：“献给我亲爱的老婆！”（羡慕不已）。想了想，我没老婆，难道没什么好写了！不难… 献给我暗恋过的每一个女人!（嘿嘿…） 如果在你遇到的女生中有一个幽默豁达的女生，不要犹豫，追上去，就娶她了！
一，需要的框架包 二，建立project，添加相应的.jar文件（重点） 1，eclipse中建立dynamic web project，这里是ssh_integrate_0100。 2，src中创建需要的类，这里以一个域模型为user的例子说明。(现在建立这些类，可以方便我们在搭建时候随时测试!) User.java IUserDao.java
UserDaoImpl.java IUserService.java UserServiceImpl.java
3，拷贝spring-framework-3.1.0\dist目录下的所有jar包，注意有一个不是jar的文件，当然拷过去也没事。 4，拷贝spring运行中需要的其他jar文件，主要是 https://www.wendangku.net/doc/0712031757.html,mons-logging，可以从spring-framework-3.0.2.RELEASE-dependencies 中找到。 ii.Aspectjrt.jar和aspect-waver.jar，可以从spring-framework-2.5.6-with-dependencies/lib/aspectj下面找到（不知道为什 么，spring-framework-3.0.2.RELEASE-dependencies中没有aspectjrt的jar 包） iii.aopalliance.Jar，apache-dbcp.jar，apache-pool.jar，可以从spring-framework-3.0.2.RELEASE-dependencies中找到。 5，建立beans.xml，这里使用的是annotation和component-scan，这样配置可以大大简化配置，所以是best-practice，其他配置请参考spring文档。
NHibernate初学实例
NHibernate相信大家都已非常熟悉，园子里有很多高手写了相关的系列文章，不过我还是NHibernate的一名初学者，在此将一个晚上学习成果分享一下，一个很简单的利用NHibernate实现增删改的例子。 本例中使用的NHibernate版本为版本为官方2008年9月29日最新发布的NHibernate-2.0.1.GA 版本，点击下载 1 首先创建一个数据库NHibernateSample，使用的数据库版本为sqlserver2005。在该数据库中创建表UserInfo。 CREATE TABLE[dbo].[UserInfo] ( [UserInfoID][int]IDENTITY(1,1) NOT NULL, [UserName][varchar](20) COLLATE Chinese_PRC_CI_AS NULL, [Email][varchar](100) COLLATE Chinese_PRC_CI_AS NULL ） 2 打开vs2008，创建web application 命名为Web，解决方案的名称设为NHibernateDemo，然后在此解决方案下添加两个类库项目BLL和Model。
3 解压下载的NHibernate包，将NHibernate-2.0.1.GA-bin\bin\net-2.0目录下的dll文件复制到web项目中的DLL文件夹中。DLL文件夹用来存放一些公用的dll文件。 4 在Model项目中创建两个目录:Entities和Mappings。分别存放实体类和映射文件。 在Entities目录下创建类UserInfo.cs public class UserInfo { public virtual int UserInfoID { get; set; } public virtual string UserName { get; set; } public virtual string Email { get; set; } } 需要注意到是实体类中的属性必须加virtual修饰符。 在Mappings目录下创建映射文件UserInfo.hbm.xml
(完整版)SSH框架搭建实例教程,毕业课程设计
. SSH的理解及其应用实践
1.SSH是什么 (3) 2 Spring 介绍理解： (3) 2.1简单介绍 (3) 2．2各种特性 (3) 2.2.1轻量 (3) 2.2.2控制反转 (3) 2.2.3面向切面 (4) 2 .2.4容器 (4) 2.2.5框架 (4) 2.3总结 (4) 3.Hibernate介绍理解： (4) 3.1简单介绍 (4) 3.2核心接口 (5) .3.2.1 Session接口 (5) 3.2.2 .SessionFactory接口 (5) 3.2.3.Configuration接口 (5) 3.2.4.Transaction接口 (5) 3.2.5 Query和Criteria接口 (5)
4. Struts (6) 4.1什么是Struts框架 (6) 4.2 Struts 概览 (6) 4.2.1Client browser（客户浏览器） (6) 4.4 Struts中的Controller（控制器）命令设计模式的实现 (7) 4.5 在Struts框架中控制器组件的三个构成部分 (7) 4.7 Struts中的Model（模型） (8) 5.SSH整合步骤 (8) 5.1安装所需软件环境： (8) 5.1.1、首先安装JDK，配置Java环境变量 (8) 5.1.2安装MyEelipse (8) 5.1.3 数据库 (9) 5.1.4、 (9) 5.2环境配置好了就可以做SSH整合的项目 (9) 6.搭建框架并简单应用 (11) 6.1准备工作 (11) 6.2(建立项目，包结构，导入所需jar文件) (12) 6.3撰写资源文件 (15) 6.4在com.ssh.utilm 包下添加下列文件 (19) 6.5添加hibernate DAO 模板 (20) 6.6以上的工作还不够，我们还需要进行WEB方面的配置 (20) 7.测试： (23) 7.1.ssh.model 包下建立User.java (23) 7.2 com.ssh.service 包下建立UserService.java (24) 7.3com.ssh.test 下建立Test.java (25)
3 MyEclipse Hibernate 快速入门开发
MyEclipse 6 实战开发讲解视频入门3 MyEclipse Hibernate 快速入门开发 2007-9-27 观看本视频时建议您阅读配套的教材, 由本人翻译的MyEclipse 帮助文档: MyEclipse Hibernate 快速入门中文版摘要: 是位于帮助文件中的MyEclipse Hibernate Quickstart 的中文翻译, 历时3天完成, 排版太困难了, 因此就没发完整的HTML 版本了, HTML完整版本下载地址: https://www.wendangku.net/doc/0712031757.html,/download/MyEclipse_Hibernate_Quickstart_zh_CN.zip 719KB 阅读全文 视频的内容主要按照这个教材的内容进行, 个别地方略有删减. 下一次将讲解JPA 开发. 观看本视频前您必须首先观看过视频: MyEclipse 6 实战开发讲解视频入门 2 用MyEclipse Database Explorer 管理MySQL 数据库否则本文内容将无法进行. 下载视频中提到的稳定版的Mysql JDBC 驱动: mysql-connector-java-3.1.11-bin.jar430KB 下载视频: 第一部分 MyEclipse6_3.exe 4.90 MB 15分56秒 第二部分 MyEclipse6_4.exe 4.21 MB 14分47秒 建表SQL: echo_message DDL CREATE TABLE echo_message ( id integer PRIMARY KEY not null, msg VARCHAR(255) ); insert into echo_message values(1, 'hello world'); insert into echo_message values(2, 'goodbye world'); Java 测试类代码: import org.hibernate.Transaction;
Struts+Spring+Hibernate真正入门级实例
Struts+Spring+Hibernate真正入门级实例 网上有很多关于SSH架构的实例文章，但都显得复杂，我想，入门的朋友，还是希望从最简单的CRUD操作开始，一些复杂的数据库关系，逻辑关系，以后在项目中就能碰到，所以，本文定位于从零开始的一个SSH架构的例子，功能很简单，就是完成一个人员的CRUD操作，麻雀虽小，五脏俱全，希望能对从来没有接触过三者结合开发的朋友带来一点点帮助，这个例子，也算是我的入门实例，从此，开始Struts+Spring+Hibernate之旅 开发工具：MyEclipse5.1+Tomcat+Mysql 开发前准备：数据库安装，tomcat安装，下载jar包这些就不费口水了，直接切入正题吧 CREATE TABLE `people` ( `id` int(11) NOT NULL auto_increment, `name` varchar(100) default NULL, `location` varchar(100) default NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=gb2312 ROW_FORMAT=COMPRESSED; 首先，建立工程和package,以下是我的工程目录 action DeletePeopleAction.java //删除人员action EditPeopleAction.java //编辑人员action第一步，读取需要修改的人员资料 EditPeopleActionDo.java //修改人员action ListPeopleAction.javaSave //显示人员列表action SavePeopleAction.java //新增人员action SearchPeopleAction.java //查找人员action dao IDAO.java //数据库操作接口 StudentDAOImpl.java //数据库操作实现 domain AbstractPeople.java //实体抽象类 People.hbm.xml //数据库映射 People.java //实体类 service IService.java //服务层接口 StudentManagerImpl.java //服务层实现 util Character.java //字符编码过滤器 PageSupport.java //分页 applicationContext_hibernate.xml //Spring配置文件（hibernate部分）applicationContext_service.xml //Spring配置文件(Service部分)
hibernate教程
一、使用Hibernate的3个准备和7个步骤 准备1：导入Hibernate库（jar包）； 准备2：添加配置文件-Hibernate.cfg.xml
Struts2+Hibernate架构教程课后参考答案
第1章 Struts2框架技术入门 1.5 习题 1.5.1 选择题 1.D 2.A 3.C 4.B 5.B 1.5.2 填空题 1.MVC 2.Struts1和WebWork 3.IBM 4.FilterDispatcher 5.JSP、Struts2标签 1.5.3 简答题 1.简述MVC设计模式的工作流程。 答：MVC设计模式工作流程是： （1）用户的请求 Hibernate 安装与入门示例 目录 1.Hibernate安装 (1) 2.Hibernate入门示例 (2) 2.1.创建USERS表 (2) 2.2.定义USERS表对应的Model类 (3) 2.3.定义User Model类与USERS表的ORM映射 (4) 2.4.把ORM映射文件注册到“hibernate.cfg.xml”文件中 (5) 2.5.用户数据添加测试程序 (5) 2.6.用户数据修改测试程序 (6) 1.Hibernate安装 (1)拷贝Hibernate的jar包到/WEB-INF/lib/目录下。 ●/hibernate3.jar ●/lib/required/目录下的所有jar包 ●连接池组件包，Hibernate包中自带有c3p0组件包： /lib/optional/c3p0/c3p0-0.9.1.jar。如果不想用此连接池组件，也可以用其它的连 接池组件。本示例使用C3P0连接池组件。 ●ejb3-persistence.jar。此包不在Hibernate的下载包中，需另外下载。 (2)在项目的/src/目录下创建“hibernate.cfg.xml”配置文件。 配置参考如下： 2.Hibernate入门示例实现对USERS表的添加和修改功能。 2.1.创建USERS表 2.2.定义USERS表对应的Model类 2.3.定义User Model类与USERS表的ORM映射 创建User.hbm.xml映射文件，每个表都需要定义一个ORM映射文件，文件名自定义，文件放到/src/hbm/目录下（也可放到其它目录下）。 java平台 1、J2SE java开发平台标准版 2、J2EE java开发平台企业版 java程序需要在虚拟机上才可以运行，换言之只要有虚拟机的系统都可以运行java程序。不同系统上要安装对应的虚拟机才可以运行java程序 开发步骤 1、编写源文件 (.java) 2、编译源文件为类文件(.class)可用J2SE或J2EE编译 3、在虚拟机上运行 注释 //单行注释 /* */多行注释 java内容介绍 java编程可以分成三个方向： 1、java se (j2se)桌面开发 java中的基础中的基础 2、java ee (j2ee)web开发 3、java me (j2me)手机开发 java se课程介绍 java面向对象编程(基础) java图开界面开发 java数据库编程 java文件io流编程 java网络编程 java多线程编程 java ee基础1 java面向对象编程--数据库编程-->java se java 基础2 html--css--javascript-->div+css java ee中级部分 Servlet--Jsp-->mvc模式 java ee高级部分 Struts--Ejb--Hibernate--Spring--Ajax(ext,dw2)-->ssh框架 java之父gosling 1990 sun启动绿色计划 1 | 445 1992 创建oak语言-->java 1994 gosling参加硅谷大会演示java功能，震惊世界 1995 sun正式发布java第一个版本，目前最新是jdk7.0 java开发工具 记事本、(jcreator、jbuilder退出舞台了)、netbean、eclipse 如何选择开发工具 先选择记事本，对java有一定了解后再使用eclipse高级开发工具 为什么呢？ 1、更深刻的理解java技术，培养代码感 2、有利于公司面试 java语言的特点 1、java语言是简单的 2、java语言是面向对象的 3、java语言是跨平台(操作系统)的[即一次编译，到处运行] 4、java是高性能的 java第一个程序hello.java 运行java程序要安装和配置jdk jdk是什么？ 1、jdk全称java dvevlopment kit中文java开发工具包 2、jdk是sun公司开发的 3、jdk包括jre(java runtime envirnment)java运行环境、一堆java工具和java基础的类库(类共3600左右，常用类在150个左右) 4、可以在https://www.wendangku.net/doc/0712031757.html,下载 **开发安装jdk,用户执行需要安装jre 配置JDK 添加环境变量即可 windows下配置jdk 在计算机属性--高级设置--环境变量--添加PATH将JDK所在路径指定即可。多个环境变量设置时需要用;号进行隔开 1、编写第一个hello.java //注释 (解释) 作者： //功能：在控制台显示"hello" //日期：2013.11.28 //public：表示这个类是公共的，一个java文件中只能有一个public类 //class：表示这是一个类 //hello：类名(公共类的类名必须和文件名一致) public class hello{ 2 | 445Hibernate 安装与入门示例
韩顺平java从入门到精通视频教程(全94讲)学习笔记整理(齐全)
- 经典heibernate教程,从入门到精通
- 最经典的hibernate教程 从入门到精通 第一篇(共四篇)
- Hibernate教程(非常详细)
- Struts+Spring+Hibernate框架实用教程(SSH框架)
- Hibernate学习入门教程
- 传智播客hibernate教程
- Struts2+Hibernate架构技术教程课后参考答案
- Struts+Spring+Hibernate整合教程
- myeclipse hibernate反向工程图文教程
- hibernate教程
- Struts2.5+Hibernate3.1+Spring应用开发实例(图)
- Spring教程(完整版)
- struts2+spring3+hibernate整合教程
- 韩顺平java从入门到精通视频教程(全94讲)学习笔记整理(齐全)
- 最经典的hibernate教程_从入门到精通_第三篇(共四篇)
- Hibernate知识的学习
- 最经典的hibernate教程_从入门到精通_第二篇(共四篇)
- JAVA.Extjs.Hibernate.Web开发应用免费教程集锦
- Hibernate_Annotation中文教程
- (最新)JSF+Spring+Hibernate的实例讲解