hibernate是什么？
在实际的java开发过程中，我们要建立数据和维护数据以及进行数据处理，比如删除某条数据，先是取得数据库连接，执行sql语句达到数据操作逻辑需要（如删除等于某ID的记录），释放连接等等，我们在这个过程中需要编写大量重复性且繁琐的代码。
为解决这个问题，hibernate应势而生，hibernate其实就是一个开发框架，它是一个开源的轻量级的O/R Mapping框架，O/R Mapping的意思大概就是对象（说的是数据吧）/关系 映射。这个在后面的例子中就会有体悟。其目标就是要把程序员从95%的常用数据持久化编码中解放出来，从而能够更多地关注于业务逻辑及其实现。Hibernate支持常用的多种数据库，只要简单配置就可以了。
Hibernate版本介绍
Hibernate较新的是3系列，它相对于2系统
更容易与持久化对象交互
提供强大的对象关系查询
完全事件驱动，支持java5，对游标和自定义类型支持
更高效的级联删除和支持列级延迟加载
Hibernate的应用方案
Hibernate可以看作是位于应用程序和数据库间的一个中间层，通过配置和映射信息为应用程序提供持久化对象及相关服务，有多种应用方案：
。应用层完全不关心 数据库连接、事务等令人烦恼的东西，完全交由Hibernate负责，通过Session获取持久化对象
。较轻的体系，忽略某些部分，直接操作JDBC、JTA，这都取决于应用的需要
1、准备工作
到www.hibernate.org 上去下载Hibernate发布包，将他们放到ClassPath路径里面，把这些jar包作为外部包添加到Build Path，右击工程名-->Build Path-->add External archives，选择hibernate包就可以了用myeclipse加环境更简便。另外，安装好mysql数据库。
2、持久化类及其映射文件
文章类 Article.java
package beans;
import java.util.HashSet;
import java.util.Set;
public class Article {
private Long id;
private Column refColumn;
private String name;
private Set<Author> authors;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Column getRefColumn() {
return refColumn;
}
public void setRefColumn(Column refColumn) {
this.refColumn = refColumn;
}
// one article may be wirtten by a few persons
public Set<Author> getAuthors() {
if (authors == null)
authors = new HashSet<Author>();
return this.authors;
}
public void setAuthors(Set<Author> authors) {
this.authors = authors;
}
}
文章类映射文件 Article.hbm.xml：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="beans.Article" table="tb_articles">
<id name="id" column="article_id" type="java.lang.Long">
<generator class="native" />
</id>
<property name="name" type="string">
<column name="article_name" length="100" not-null="true" />
</property>
<!--'ref' is the field name in tb_articles, which refer to column_id of tb_columns -->
<many-to-one name="refColumn" column="ref" not-null="true" />
<!-- inverse="true" mean a author refers to many artilces -->
<set name="authors" table="tb_articles_author" inverse="true"
order-by="author_id">
<!-- means an article could be refered to more than one author values -->
<key column="article_id" not-null="true" />
<many-to-many column="author_id" class="beans.Author" />
</set>
</class>
</hibernate-mapping>
作者类 Author.java
package beans;
import java.util.HashSet;
import java.util.Set;
public class Author {
private Long id;
private String name;
private Set<Article> articles;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Article> getArticles() {
if (articles == null)
articles = new HashSet<Article>();
return this.articles;
}
public void setArticles(Set<Article> articles) {
this.articles = articles;
}
}
作者类的映射文件 Author.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="beans.Author" table="tb_authors">
<id name="id" column="id" type="java.lang.Long">
<generator class="native" />
</id>
<property name="name" type="string">
<column name="name" length="100" not-null="true" />
</property>
<!--
- 'inverse' value must be match value of Article.hbm.xml, means can not set as 'true' meanwhile.
(of course you can only set it in one file. )
- The side set as 'true'(at least a side must be 'true'), whose object could invoke setXXX(? extends Set),
the oppsite side will not impact even it invokes the method.
Here 'false' means a author is corresponds to many articles.
(fileds of tb_articles_author are combined keys)
-->
<set name="articles" table="tb_articles_author" inverse="false"
order-by="article_id">
<!-- means a author id could be refered to more than one article values -->
<key column="author_id" not-null="true" />
<many-to-many column="article_id" class="beans.Article" />
</set>
</class>
</hibernate-mapping>
目录类 Column.java
package beans;
import java.util.HashSet;
import java.util.Set;
public class Column {
private Long id;
private String name;
private Set<Article> articles;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Article> getArticles() {
if (articles == null)
articles = new HashSet<Article>();
return this.articles;
}
public void setArticles(Set<Article> articles) {
this.articles = articles;
}
}
目录类的映射文件 Column.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="beans.Column" table="tb_columns">
<id name="id" column="column_id" type="java.lang.Long">
<generator class="native" />
</id>
<property name="name" type="string">
<column name="column_name" length="100" not-null="true" />
</property>
<!--
please note that 'inverse' value in many-to-many element of Article.hbm.xml, which can be set 'false'.
-->
<set name="articles" table="tb_articles" inverse="true"
order-by="article_id asc">
<!--
'ref' is corresponding to the field of tb_aritcles,
even it could be defined other name that different from the one defined in Article.hbm.xml,
then one more field will be created
-->
<key column="ref" not-null="true" />
<one-to-many class="beans.Article" />
</set>
</class>
</hibernate-mapping>
3、辅助类
它的作用就是让Hibernate真正工作起来，并且封闭一下最基本的CRUD操作，就是删，增，修改等操作。
package util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
private static SessionFactory sessionFactory;
static {
try {
sessionFactory = new Configuration().configure()
.buildSessionFactory();
} catch (Exception e) {
System.err.println("Error creating SessionFactory");
e.printStackTrace();
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
public static Session getCurrentSession() {
return sessionFactory.getCurrentSession();
}
}
当然，为了简单地去进行对象操作，还写个DAO（Data Access Object），可以将CRUD方法写在里面，当然这些方法体也可以不封装。
package dao;
import org.hibernate.Session;
import util.HibernateUtil;
import beans.Article;
public class ArticleDao {
public Article find(Long id) {
Session session = HibernateUtil.getCurrentSession();
Article article = (Article) session.load(Article.class, id);
return article;
}
public void save(Article article) {
Session session = HibernateUtil.getCurrentSession();
session.saveOrUpdate(article);
}
public void delete(Article article) {
Session session = HibernateUtil.getCurrentSession();
session.delete(article);
}
}
package dao;
import org.hibernate.Session;
import util.HibernateUtil;
import beans.Author;
public class AuthorDao {
public Author find(Long id) {
Session session = HibernateUtil.getCurrentSession();
Author author = (Author) session.load(Author.class, id);
return author;
}
public void save(Author author) {
Session session = HibernateUtil.getCurrentSession();
session.saveOrUpdate(author);
}
public void delete(Author author) {
Session session = HibernateUtil.getCurrentSession();
session.delete(author);
}
}
package dao;
import org.hibernate.Session;
import util.HibernateUtil;
import beans.Column;
public class ColumnDao {
public Column find(Long id) {
Session session = HibernateUtil.getCurrentSession();
Column column = (Column) session.load(Column.class, id);
return column;
}
public void save(Column column) {
Session session = HibernateUtil.getCurrentSession();
session.saveOrUpdate(column);
}
public void delete(Column column) {
Session session = HibernateUtil.getCurrentSession();
session.delete(column);
}
}
4、配置Hibernate
它就是指定数据源等信息，文件名为hibernate.cfg.xml，放到classpath的根目录下。（其实还有另种方法），下面是针对Mysql数据库的配置，数据库的配置在Hibernate包里有说明：
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<!-- Generated by MyEclipse Hibernate Tools. -->
<hibernate-configuration>
<session-factory>
<property name="connection.username">root</property>
<property name="connection.url">
jdbc:mysql://localhost:3306/test
</property>
<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name="connection.password">root</property>
<property name="current_session_context_class">thread</property>
<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="hbm2ddl.auto">create</property>
<mapping resource="beans/Author.hbm.xml" />
<mapping resource="beans/Column.hbm.xml" />
<mapping resource="beans/Article.hbm.xml" />
</session-factory>
</hibernate-configuration>
dialect 属性指定Hibernate应该生成什么样的SQL与数据库交互，hbm2ddl.auto属性告诉Hibernate自动为我们生成数据库sample，如果为create-drop则会自动删除，在DAO中没有关闭session，current_session_context_class属性的值是thread，Hibernate创建session时将其绑定到当前线程，事务结束后自动剥离并关闭，下次调用get方法产生新的，所以应该配合事务一起使用 。
5、看效果
写一个测试类，它用到了 log4j，log4j能格式化一些输出，能看出哪些日志是一段的（时间戳），以及调节日志级别等。
package test;
import java.util.Set;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.hibernate.Session;
import util.HibernateUtil;
import beans.Article;
import beans.Author;
import beans.Column;
import dao.ArticleDao;
import dao.AuthorDao;
import dao.ColumnDao;
public class DemoRunner {
static Logger logger = Logger.getLogger(DemoRunner.class.getName());
private AuthorDao authorDao = new AuthorDao();
private ColumnDao columnDao = new ColumnDao();
private ArticleDao articleDao = new ArticleDao();
public DemoRunner() {
initDB();
}
public static void main(String[] args) {
PropertyConfigurator.configure("DemoRunner.properties");
new DemoRunner().showInfo();
}
/**
* get article informaion and update author info
*
*/
public void showInfo() {
Column column;
Set<Article> articles;
Author author;
Session session = HibernateUtil.getCurrentSession();
try {
session.beginTransaction();
column = columnDao.find(1L);
logger.warn("find column information: id = " + column.getId()
+ ", name = " + column.getName());
articles = column.getArticles();
author = authorDao.find(1L);
for (Article article : articles) {
logger.warn("it has article -> aritlce id: " + article.getId()
+ ", article name: " + article.getName()
+ ", artilce author id: "
+ article.getAuthors().iterator().next().getId());
// add articles that written by author 2 to author whose id is 1
author.getArticles().add(article);
}
// delete all articles of author whose id is 2
authorDao.delete(authorDao.find(2L));
logger
.warn("author whose id is 2 has been deleted, also whose articles...");
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
}
// reopen and scan to verify the articles of author 1 now.
session = HibernateUtil.getSessionFactory().openSession();
column = (Column) session.load(Column.class, 1L);
articles = column.getArticles();
for (Article article : articles) {
logger.warn("article of author whose id is 1 >> article id: "
+ article.getId() + ", name: " + article.getName());
}
session.close();
}
public void initDB() {
Author author;
Column column;
Article article;
Session session = HibernateUtil.getCurrentSession();
try {
session.beginTransaction();
java.util.Set<Author> setOfAuthor = new java.util.HashSet<Author>();
java.util.Set<Column> setOfColumn = new java.util.HashSet<Column>();
java.util.Set<Article> setOfArticle = new java.util.HashSet<Article>();
// create author 1
author = new Author();
author.setName("Daniel");
authorDao.save(author);
logger.warn("Created a new author, [Id = " + author.getId()
+ ". Name = " + author.getName() + ". ]");
setOfAuthor.add(author);
// create author 2
author = new Author();
author.setName("David");
authorDao.save(author);
logger.warn("Created a new author, [Id = " + author.getId()
+ ". Name = " + author.getName() + ". ]");
setOfAuthor.add(author);
// create column 1
column = new Column();
column.setName("catelog.computer");
columnDao.save(column);
logger.warn("Created a new column, {Id = " + column.getId()
+ ". Name = " + column.getName() + ". }");
setOfColumn.add(column);
// create article 1
article = new Article();
article.setName("Think in java");
article.setRefColumn(column);
articleDao.save(article);
setOfArticle.add(article);
logger.warn("aticle [" + article.getName() + "] added to -> "
+ column.getName());
// create article 2
article = new Article();
article.setName("Getting started Jboss");
article.setRefColumn(column);
articleDao.save(article);
setOfArticle.add(article);
logger.warn("aticle [" + article.getName() + "] added to -> "
+ column.getName());
// create column 2
column = new Column();
column.setName("catelog.Math");
columnDao.save(column);
logger.warn("Created a new column, {Id = " + column.getId()
+ ". Name = " + column.getName() + ". }");
setOfColumn.add(column);
// create article 3
article = new Article();
article.setName("middle school of math");
article.setRefColumn(column);
articleDao.save(article);
setOfArticle.add(article);
logger.warn("aticle [" + article.getName() + "] added to -> "
+ column.getName());
// create article 4
article = new Article();
article.setName("math algorithm");
article.setRefColumn(column);
articleDao.save(article);
setOfArticle.add(article);
logger.warn("aticle [" + article.getName() + "] added to -> "
+ column.getName());
// column.setArticles(setOfArticle);
// article.setAuthors(setOfAuthor);
author.setArticles(setOfArticle);
logger.warn("4 articles are added to author 2!!");
session.getTransaction().commit();
} catch (Exception e) {
session.getTransaction().rollback();
e.printStackTrace();
}
}
}
log4j是要有配置文件的：
log4j.rootLogger=WARN, A1 log4j.appender.A1=org.apache.log4j.ConsoleAppender log4j.appender.A1.layout=org.apache.log4j.PatternLayout # It is a PatternLayout # %r means the time from begin. # %p means level # %t means thread # %c logger making the log request # %x nested diagnostic context (NDC) # -%m%n description information log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %20c %3x - %m%n
最终文件的结构就是：
jar tf xxx.jar beans/Column.java beans/Article.java beans/Author.java beans/Article.hbm.xml beans/Author.hbm.xml beans/Column.hbm.xml dao/AuthorDao.java dao/ColumnDao.java dao/ArticleDao.java test/DemoRunner.java util/HibernateUtil.java DemoRunner.properties hibernate.cfg.xml
运行的结果是（应用log4j之前的信息）：
Created a new author, [Id = 1. Name = Daniel. ]
Created a new author, [Id = 2. Name = David. ]
Created a new column, {Id = 1. Name = catelog.computer. }
aticle [Think in java] added to -> catelog.computer
aticle [Getting started Jboss] added to -> catelog.computer
Created a new column, {Id = 2. Name = catelog.Math. }
aticle [middle school of math] added to -> catelog.Math
aticle [math algorithm] added to -> catelog.Math
4 articles are added to author 2!!
find column information: id = 1, name = catelog.computer
it has article -> aritlce id: 1, article name: Think in java, artilce author id: 2
it has article -> aritlce id: 2, article name: Getting started Jboss, artilce author id: 2
author whose id is 2 has been deleted, also whose articles...
article of author whose id is 1 >> article id: 1, name: Think in java
article of author whose id is 1 >> article id: 2, name: Getting started Jboss
6、在hibernate中使用native sql
在Article.hbm.xml中增加如下内容：
<set name="authorNames" table="tb_articles_author">
<key column="article_id" />
<element column="author_id" type="string"
formula="(select tb_authors.name FROM tb_authors where tb_authors.id=author_id)" />
</set>
<element>表达通过关联表连接的，加上formula属性来获得name字段的内容，从中我们可以看到Hibernate对native SQL的支持，这个要注意formula值要加括号（这个是什么原因还有待研究，MySql不加不行，HSQL DB不加可能可以）
并在Article bean类中增加如下部分：
// to store all authors that respond to a article.
public Set<String> getAuthorNames(){
if (authorNames == null)
authorNames = new HashSet<String>();
return this.authorNames;
}
public void setAuthorNames(Set<String> authorNames){
this.authorNames = authorNames;
}
7、简单的缓存
使用缓存是提高效率的一种有效手段，Hibernate在session中就有一个缓存，就是所讲的是JVM级别的二级缓存，默认情况下使用EHCache来实现，也可以通过配置文件中的hibernate.cache.provider_class来指定缓存策略。
修改hibernate.cfg.xml加入
<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
通过在类或集合的映射Author.hbm.xml中加入<cache>来使用缓存，必须加在<class>下面第一行 ！！其有几个选择read-only,read-write,transactional,等然后在执行查询时 注意了 ，如果是条件查询，或者返回所有结果的查询，此时session.find()方法 不会获取缓存中的数据。只有调用query.iterate()方法时才会调缓存的数据。
<cache usage="read-write"/>
总结
通过以上实例对hibernater的一些基本应用有了初步了解，最后有一个概念要说明一下，Session，应用层与持久层进行交互操作的一个生命周期很短的线程对象，其中隐藏了JDBC连接，也是Transcation的工厂，持有一个会话级缓存；SessionFactory，顾名思义就是session工厂，它是编译后的针对单一数据库映射的缓存，SessionFactory是线程安全的，可以在进程或集群层次上提供事务间可重用的数据缓存；Persistent Objects，即持久化对象，是带有持久化状态的且具有业务功能的单线程对象，可以是普通的JavaBean/POJO，唯一不同是它们与一个Session相关联，当Session关闭后这些对象将脱离持久化状态可被应用程序任意使用。更多可以去找Hibernate体系结构图看看。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
