hibernate学习(环境配置)
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
hibernate环境配置
1.下载hibernate:http://hibernate.org/orm/
2.添加需要的jar文件
解压下载的hibernate，会有一个required文件夹，将这里边的jar文件是需要的，同时还需要拷贝连接mysql的jar文件
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
hibernate-jpa-2.0-api-1.0.0.Final.jar
hibernate3.jar
javassist-3.12.0.GA.jar
jta-1.1.jar
slf4j-api-1.6.1.jar
mysql-connector-java-5.1.12-bin.jar
2.新建一个java工程，在src下创建一个hibernate.cfg.xml配置文件，用来配置hibernate连接数据库的基本信息。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 驱动 -->
<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
<!-- url -->
<property name="connection.url">
jdbc:mysql://localhost:3306/mydb
</property>
<!-- 用户名 -->
<property name="connection.username">root</property>
<!-- 密码 -->
<property name="connection.password">root</property>
<!-- 方言 -->
<property name="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<!-- 控制打印sql -->
<property name="show_sql">true</property>
<!-- 格式化sql -->
<property name="format_sql">true</property>
<!-- 配置自动根据映射文件更新数据库表 -->
<property name="hbm2ddl.auto">update</property>
<!-- 引入映射文件 -->
<mapping resource="com/mydb/entity/UserInfo.hbm.xml" />
</session-factory>
</hibernate-configuration> 这里需要注意：hbm2ddl.auto是配置的自动生成表，该值可以是create和update，区别如下:
1.create:每次生成新表，覆盖原来的表和数据
2.update：每次更新表，如果有数据或字段新增，都会对原来的表做更新操作。
4.创建实体类和映射文件
新建com.mydb.entity包，在该包下新创建一个UserInfo的类，主要该类需要和hibernate.cfb.xml文件中的映射文件的类名相同的。
package com.mydb.entity;
import java.io.Serializable;
public class UserInfo implements Serializable {
private int userId;
private String userName;
private String userPass;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserPass() {
return userPass;
}
public void setUserPass(String userPass) {
this.userPass = userPass;
}
}注意该类实现了Serializable接口，因为需要在网络上传输该实体类对象。
创建实体类的映射文件如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!-- name="全类名" table="表名" -->
<class name="com.mydb.entity.UserInfo" table="userinfo">
<!-- name="属性名" column="主键"-->
<id name="userId" column="uid">
<!-- 主键的生成策略:native(主键自增),assigned(指派) -->
<generator class="assigned"></generator>
</id>
<!-- name="属性名" column="字段名" -->
<property name="userName" column="uname"></property>
<property name="userPass" column="upass"></property>
</class>
</hibernate-mapping> 5.创建测试代码插入一条数据
//解析hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory(创建连接池)
SessionFactory factory = cfg.buildSessionFactory();
//创建session
Session session = factory.openSession();
UserInfo userInfo = new UserInfo();
userInfo.setUserId(1);
userInfo.setUserName("张三");
userInfo.setUserPass("111");
//创建以及开启事物对象
Transaction transaction = null;
try {
transaction = session.beginTransaction();
//天剑userinfo对象
session.save(userInfo);
transaction.commit();
} catch (HibernateException e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
} finally {
if (session != null) {
session.close();
}
}此时运行测试代码，会自动创建mydb数据库和userinfo表，并且插入一条记录，并且根据hibernate.cfg.xml中的配置，在控制台下也打印出来了一条插入的sql语句：
Hibernate:
insert into userinfo (uname, upass, uid) values (?, ?, ?)6.创建测试代码根据id查询一条数据
//解析hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory(创建连接池)
SessionFactory factory = cfg.buildSessionFactory();
//创建session
Session session = factory.openSession();
//创建以及开启事物对象
Transaction transaction = null;
try {
transaction = session.beginTransaction();
//天剑userinfo对象
UserInfo userInfo = (UserInfo) session.get(UserInfo.class,1);
System.out.println(userInfo.toString());
transaction.commit();
} catch (HibernateException e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
} finally {
if (session != null) {
session.close();
}
}7.根据id删除一条记录
如果需要根据id删除一条记录，我们首先需要根据id查询该条记录，然后删除查询出来的实体类对象即可
//解析hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory(创建连接池)
SessionFactory factory = cfg.buildSessionFactory();
//创建session
Session session = factory.openSession();
//创建以及开启事物对象
Transaction transaction = null;
try {
transaction = session.beginTransaction();
UserInfo userInfo = (UserInfo) session.get(UserInfo.class,1);
session.delete(userInfo);
transaction.commit();
} catch (HibernateException e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
} finally {
if (session != null) {
session.close();
}
}8.根据id更新
//解析hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory(创建连接池)
SessionFactory factory = cfg.buildSessionFactory();
//创建session
Session session = factory.openSession();
//创建以及开启事物对象
Transaction transaction = null;
try {
transaction = session.beginTransaction();
UserInfo userInfo = (UserInfo) session.get(UserInfo.class,1);
userInfo.setUserName("wangwu");
userInfo.setUserPass("333");
transaction.commit();
} catch (HibernateException e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
} finally {
if (session != null) {
session.close();
}
}说明一下：在这里，通过session查询出来的对象是一个持久化对象，就是该对象就存放在session缓存当中，当我们将该对象进行更改的时候，缓存中的对象，会自动同步到数据库当中的。
9.查询结果集
//解析hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//创建SessionFactory(创建连接池)
SessionFactory factory = cfg.buildSessionFactory();
//创建session
Session session = factory.openSession();
//创建以及开启事物对象
Transaction transaction = null;
try {
transaction = session.beginTransaction();
Query query = session.createQuery("from UserInfo");
List<UserInfo>lists = query.list();
for (UserInfo userInfo : lists) {
System.out.println(userInfo);
}
transaction.commit();
} catch (HibernateException e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
} finally {
if (session != null) {
session.close();
}
}说明一下：这里query中传入的字符串是一个hql语句，其实和sql是一样的，就是将表名改为对应的实体类名，将需要查询的字段改为对应的属性即可。
到现在为止，基本的增删改查就到这里了，可是我们上边的代码是有很大的冗余和重复性代码，下面利用单例模式来进行优化。
package com.mydb.factory;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtils {
private static Configuration cfg = null;
private static SessionFactory factory = null;
static {
if (cfg == null) {
cfg = new Configuration().configure();
}
if (factory == null) {
factory = cfg.buildSessionFactory();
}
}
public static SessionFactory getSessionFactory() {
return factory;
}
public static Session getSession() {
return factory.openSession();
}
public static void closeSession(Session session) {
if (session != null) {
session.close();
}
}
}
可以看到，这里我封装了几个方法，分别用来得到session，factory，关闭session等操作。
说了那么多，现在来看看configuration，sessionfactory，session，到底有什么用？？
configuration：负责管理hibernate的配置信息
sessionfactory：缓存了sql语句，和映射的元数据，元数据就是从类中的属性到表里的字段
session：也称之位持久化管理器，session不是线程安全的，他代表与数据库之间的一次或多次操作
总结
hibernate开发分为三个准备和七个步骤：
1.准备hibernate开发需要的jar文件
2.在src下添加hibernate的配置文件(hibernate.cfg.xml)
3.编写实体和映射文件(Xxx.hbm.xml)
七个步骤如下：
//1.创建Configuration对象
Configuration cfg = new Configuration().configure();//解析hibernate.cfg.xml配置文件
//2.创建SessionFactory
SessionFactory sf = cfg.buildSessionFactory();//解析xxx.hbm.xml映射文件
//3.获取Session,类似于jdbc的Connection
Session session = sf.openSession();
//4.开启事务
Transaction tx = session.beginTransaction();
//5.做持久化操作
session.save(user);
//6.提交事务
tx.commit();
//7.关闭session
session.close();好了，hibernate的入门学习就到这里了。
源码下载