hibernate第一章：感性认识

主要内容：

1、什么是hibernate?

    简单的说：hibernate是一个优秀的Java持久化层解决方案，是当今主流的对象-关系（ORM）映射工具，它简化了JDBC繁琐的编码。

   说到持久化，有必要说一下，什么是持久化：持久化是将程序中数据在瞬时状态和持久状态间转换的一种机制。

 

2、为什么要用hibernate?

为什么要用hibernate?

    当然，我们知道传统的持久化机制-JDBC，还记得之前操作数据库。

 实例：

SQL脚本：

Create table Vote_user(
    vu_user_id varchar2(20) not null,
    vu_user_name varchar2(20) not null,
    vu_password varchar2(20) not null,
    vu_status number,
    vu_version number
);
insert into vote_user values('admin','admin','admin',1,2)

JDBC访问：

package org.wiksys.chap01.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * JDBC访问数据库
 * @author wiksys
 *
 */
public class JDBCPersitent {
	/**
	 * JDBC访问数据库
	 * @param id 帐号
	 * @param password 密码
	 * @return 是否存在用户 true:存在 false:不存在
	 * 修改后,不用返回。
	 */
	public void login(String id,String password){
		Connection con=null;
		PreparedStatement pst=null;
		ResultSet rs=null;
		
		try {
			//加载驱动
			Class.forName("oracle.jdbc.driver.OracleDriver");
			//获得连接
			con=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "system", "ok");
			//创建SQL语句
			String sql="select 1 from VOTE_USER where VU_USER_ID=? and VU_PASSWORD=?";
			//发送SQL语句
			pst=con.prepareStatement(sql);
			pst.setString(1, id);
			pst.setString(2, password);
			//执行并返回结果集
			rs=pst.executeQuery();
			while(rs.next()){
				System.out.println("OK");
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			//按顺序关闭资源
			try {
				if(rs!=null){
					rs.close();
				}
				if(pst!=null){
					pst.close();
				}
				if(con!=null){
					con.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		JDBCPersitent j=new JDBCPersitent();
		j.login("admin", "admin");
	}
}

 

我们可以看到，即使很简单的登录操作，也需要很多行代码。

3、hibernate开发准备

下面，看看hibernate到底能给我们带来什么样的简化？

做hibernate之前，我们需要知道相关的开发流程。

1.导入相关的jar包

 

 

2.创建主配置文件 hibernate.cfg..xml

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory name="foo">
		<!-- 连接数据库的URL:可以根据你自己的配置修改 -->
		<property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
		<!-- 驱动类，当然，访问不同的数据库驱动类是不同的 -->
		<property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
		<!-- 数据库登陆账号 -->
		<property name="hibernate.connection.username">system</property>
		<!-- 登录密码 -->
		<property name="hibernate.connection.password">ok</property>
		<!-- 数据库方言 -->
		<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
		<!-- 是否在操作数据库时打印SQL语句，便于找错 -->
		<property name="show_sql">true</property>
		<!-- 是否是格式化sql语句 -->
		<property name="format_sql">true</property>
		<!-- 映射文件配置 -->
		<mapping resource="org/wiksys/chap01/hibernate/User.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

 3.创建和数据表映射的实体类及映射文件实体名.hbm.xml
   这里我们的实体为User，当然映射文件即为User.hbm.xml

package org.wiksys.chap01.hibernate;

/**
 * 实体类
 * @author wiksys
 *
 */
public class User {
	private String id;
	private String name;
	private String password;
	private Integer status;
	private Integer version;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public Integer getStatus() {
		return status;
	}
	public void setStatus(Integer status) {
		this.status = status;
	}
	public Integer getVersion() {
		return version;
	}
	public void setVersion(Integer version) {
		this.version = version;
	}

}

映射文件User.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="org.wiksys.chap01.hibernate.User" table="VOTE_USER">
		<id name="id" type="java.lang.String">
			<column name="VU_USER_ID" />
			<!-- id生成策略：有sequence,assigned,native,identify,increment... -->
			<!-- increment对类型为long,short,int的主键，以自增方式生成值 -->
			<!-- identify:对SQL Server,DB2,MySql支持 -->
			<!-- sequence:对Oracle,DB2支持，可以通过parma传参，后续将提到 -->
			<!-- native:hibernate根据底层判读策略 -->
			<!-- assigned：主键由应用程序生成，无需hibernate管理 -->
			<generator class="assigned" />
		</id>
		<!-- property重要属性:name,type,column -->
		<property name="name" type="java.lang.String">
			<!-- column重要属性:name,length(长度),not-null(非空) -->
			<column name="VU_USER_NAME" />
		</property>
		<property name="password" type="java.lang.String">
			<column name="VU_PASSWORD" />
		</property>
		
		<property name="status" type="java.lang.Integer">
			<column name="VU_STATUS" />
		</property>
		<property name="version" type="java.lang.Integer">
			<column name="VU_VERSION" />
		</property>
	</class>
</hibernate-mapping>

4.编写数据库访问代码

package org.wiksys.chap01.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Hibernate访问数据库
 * @author wiksys
 *
 */
public class HibernatePersitent {
	/**
	 * Hibernate操作数据库
	 * 七个步骤：
	 * @param id
	 * @param password
	 */
	public void login(String id,String password){
		//读取并解析配置文件
		Configuration cfg=new Configuration().configure();
		//读取并解析映射信息，创建SessionFactory
		SessionFactory sf=cfg.buildSessionFactory();
		//打开Session
		Session session=sf.openSession();
		/**
		 * 增删改的时候还会需要事物，但这里我们不需要
		 * Transaction
		 */
		User user=(User) session.load(User.class, id);
		if(user!=null && user.getPassword().equals(password)){
			System.out.println("OK");
		}
		//关闭Session
		session.close();
	}
	public static void main(String[] args) {
		HibernatePersitent hp=new HibernatePersitent();
		hp.login("admin", "admin");
	}
}

    到这里，我们就用hibernate完成了持久化，可能会有人说，这也没有简化了。还复杂了呢？我认为，后面你就会感受到他的简单，他的强大。。
    至于中间的原理什么的，我先不说。希望大家先试一试，慢慢的去领会，我不想用一堆历史去改变你对程序的开发。先让她跑一下。。。

4、简单操作

    暂且不一一操作，只是把重要的罗列出来，后续章节都会用到。
        public TransactionbeginTransaction() throws HibernateException   打开事务
        public void clear()   清理Session
        public Connectionclose() throws HibernateException   关闭Session
        public CriteriacreateCriteria(Class persistentClass)    模版查询
        public void delete(Object object) throwsHibernateException    删除操作
        public Objectget(Class clazz,Serializable id) throws HibernateException   查询操作
        public Objectload(Class theClass,Serializable id) throws HibernateException   查询操作
        public Serializablesave(Object object) throwsHibernateException   添加操作
        public void saveOrUpdate(Object object) throwsHibernateException   添加和更新一起，没有就添加，有则更新
        public void update(Object object) throwsHibernateException    更新操作
    在这里就不拿那些api说事了，后续章节会陆续谈到。

5、认识hibernate对象的三种状态
     

    瞬时状态：在使用进行持久化操作钱，实例化User对象，此时，User对象并未与数据库中的数据有任何的关系，此时处于这种状态
    持久状态：当Session中的get方法或者load方法加载数据库中一条数据的时候，返回的User对象与数据库中的一条数据关联，此时处于持久状态
    游离状态：处于持久状态的对象，当对应的Session关闭后，User的各个属性的值与数据库中一条数据的属性值是相应的，但是此时User对象并未受到Session实例的管理，此时的Session处于游离状态。

 
 源码地址：http://download.csdn.net/detail/wiksys/4542878