hibernate的初次使用

22 篇文章 0 订阅

转载地址:http://blog.csdn.net/aboy123/article/details/10222675

一、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)
  1. <!DOCTYPE hibernate-configuration PUBLIC  
  2.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  3.     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  4.   
  5. <hibernate-configuration>  
  6.     <session-factory >  
  7.         <!-- mysql数据库驱动 -->  
  8.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>  
  9.         <!-- mysql数据库名称 -->  
  10.         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>  
  11.         <!-- 数据库的登陆用户名 -->  
  12.         <property name="hibernate.connection.username">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>  
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory >
		<!-- mysql数据库驱动 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<!-- mysql数据库名称 -->
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
		<!-- 数据库的登陆用户名 -->
		<property name="hibernate.connection.username">root</property>
		<!-- 数据库的登陆密码 -->
		<property name="hibernate.connection.password">root</property>
		<!-- 方言:为每一种数据库提供适配器,方便转换 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		
	</session-factory>
</hibernate-configuration>

三、HIbernate第一个实例

该实例的目录结构如下
说明:最后一个HIBERNATE3里面包含了所有的需要引用的jar包

1、新建一个普通的java项目,按照上面的步骤引入相关的jar包和配置文件

2、建立User实体类
  1. 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) {  
  20.         this.username = 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. }  
import java.util.Date;

public class User {
	private String id;
	private String username;
	private String password;
	private Date createTime;
	private Date expireTime;
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String userName) {
		this.username = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public Date getCreateTime() {
		return createTime;
	}
	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}
	public Date getExpireTime() {
		return expireTime;
	}
	public void setExpireTime(Date expireTime) {
		this.expireTime = expireTime;
	}
}

2、提供User.hbm.xml文件,完成实体类的映射
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5.       
  6. <hibernate-mapping>  
  7.     <class name="com.example.hibernate.User">  
  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>  
<?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="com.example.hibernate.User">
		<id name="id">
			<generator class="uuid"/>
		</id>
		<property name="username"/>
		<property name="password"/>
		<property name="createTime"/>
		<property name="expireTime"/>
	</class>
</hibernate-mapping>
其中的property标签是将要生成是数据库表中的字段,在这里不用关心各个字段是什么类型的。因为Hibernate会根据上面的实体类中属性的类型来决定将来表中字段的类型

3、配置hibernate.cfg.xml文件
  1. <hibernate-configuration>  
  2.     <session-factory >  
  3.         <!-- mysql数据库驱动 -->  
  4.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>  
  5.         <!-- mysql数据库名称 -->  
  6.         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>  
  7.         <!-- 数据库的登陆用户名 -->  
  8.         <property name="hibernate.connection.username">root</property>  
  9.         <!-- 数据库的登陆密码 -->  
  10.         <property name="hibernate.connection.password">root</property>  
  11.         <!-- 方言:为每一种数据库提供适配器,方便转换 -->  
  12.         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>  
  13.           
  14.         <span style="color: rgb(255, 0, 0);"><mapping resource="com/example/hibernate/User.hbm.xml"/></span>  
  15.     </session-factory>  
  16. </hibernate-configuration>  
<hibernate-configuration>
	<session-factory >
		<!-- mysql数据库驱动 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<!-- mysql数据库名称 -->
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_first</property>
		<!-- 数据库的登陆用户名 -->
		<property name="hibernate.connection.username">root</property>
		<!-- 数据库的登陆密码 -->
		<property name="hibernate.connection.password">root</property>
		<!-- 方言:为每一种数据库提供适配器,方便转换 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		
		<mapping resource="com/example/hibernate/User.hbm.xml"/>
	</session-factory>
</hibernate-configuration>
注意:必须是“/”而不能是“.”。
4、生成表:编写工具类ExoprtDB.java,将hbm生成ddl
  1. import org.hibernate.cfg.Configuration;  
  2. import org.hibernate.tool.hbm2ddl.SchemaExport;  
  3. /** 
  4.  * 将hbm生成ddl 
  5.  * @author BCH 
  6.  * 
  7.  */  
  8. public class ExoprtDB {  
  9.   
  10.     public static void main(String[] args) {  
  11.         //默认读取hibernate.cfg.xml文件  
  12.         Configuration cfr = new Configuration().configure();  
  13.           
  14.         SchemaExport export = new SchemaExport(cfr);  
  15.         export.create(truetrue);  
  16.     }  
  17. }  
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
/**
 * 将hbm生成ddl
 * @author BCH
 *
 */
public class ExoprtDB {

	public static void main(String[] args) {
		//默认读取hibernate.cfg.xml文件
		Configuration cfr = new Configuration().configure();
		
		SchemaExport export = new SchemaExport(cfr);
		export.create(true, true);
	}
}
到这里就可以生成User表了,但是如果直接运行ExoprtDB.java文件是不能生成User表的。因为在mysql数据中还没有建立数据库Hibernate-first。所以在mysql控制台中通过create database hibernate-first; use hibernate-first;之后再执行ExoprtDB.java文件就可以生成表了。

5、向表中添加数据
  1. import java.util.Date;  
  2.   
  3. import org.hibernate.Session;  
  4. import org.hibernate.SessionFactory;  
  5. import org.hibernate.cfg.Configuration;  
  6.   
  7. public class Client {  
  8.     public static void main(String[] args) {  
  9.         //读取配置文件  
  10.         Configuration cfg = new Configuration().configure();  
  11.           
  12.         SessionFactory factory = cfg.buildSessionFactory();  
  13.           
  14.         Session session = null;  
  15.         try{  
  16.             session = factory.openSession();  
  17.             //开启事务  
  18.             session.beginTransaction();  
  19.               
  20.             User user = new User();  
  21.             user.setUsername("用户名");  
  22.             user.setPassword("123");  
  23.             user.setCreateTime(new Date());  
  24.             user.setExpireTime(new Date());  
  25.               
  26.             session.save(user);  
  27.             //提交事务  
  28.             session.getTransaction().commit();  
  29.               
  30.         }catch(Exception e){  
  31.             e.printStackTrace();  
  32.             //回滚事务  
  33.             session.getTransaction().rollback();  
  34.         }finally{  
  35.             if(session != null){  
  36.                 if(session.isOpen()){  
  37.                     //关闭session  
  38.                     session.close();  
  39.                 }  
  40.             }  
  41.         }  
  42.     }  
  43. }  
import java.util.Date;

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

public class Client {
	public static void main(String[] args) {
		//读取配置文件
		Configuration cfg = new Configuration().configure();
		
		SessionFactory factory = cfg.buildSessionFactory();
		
		Session session = null;
		try{
			session = factory.openSession();
			//开启事务
			session.beginTransaction();
			
			User user = new User();
			user.setUsername("用户名");
			user.setPassword("123");
			user.setCreateTime(new Date());
			user.setExpireTime(new Date());
			
			session.save(user);
			//提交事务
			session.getTransaction().commit();
			
		}catch(Exception e){
			e.printStackTrace();
			//回滚事务
			session.getTransaction().rollback();
		}finally{
			if(session != null){
				if(session.isOpen()){
					//关闭session
					session.close();
				}
			}
		}
	}
}

执行该java文件就可以完成向表中增加数据了,效果如下


(四)总结

通过上面的代码我们可以看出,在代码中没有涉及到任何有关JDBC的代码,作为开发人员只需要写好相应的实体类,然后通过配置就可以实现了表的建立以及向表中实现数据的插入。
在代码中有许多Hibernate的核心对象,例如Configuration、SessionFactory、Session等等。这些内容将在以后介绍。


一、什么是映射

在上一篇文章中 新手上路之Hibernate:第一个Hibernate例子,通过一个例子了解了什么是hibernate。而其中最重要的就是通过User.hbm.xml来配置映射。这里所说的映射就是对象关系映射:将对象数据保存到数据库中,同时可以将数据库数据读入对象中,开发人员只对对象进行操作就可以完成对数据库数据的操作。


二、什么是基本映射

知道了什么是映射,那么我们先来看一下最基本的映射关系——基本映射,即根据表结构创建相应实体类


例如:还是以MySQL数据库为例,进行说明。有如下一张表:

建立相应的实体类:User

[java]  view plain  copy
  1. public class User {  
  2.     private String id;  
  3.     private String username;  
  4.       
  5.     public String getId() {  
  6.         return id;  
  7.     }  
  8.     public void setId(String id) {  
  9.         this.id = id;  
  10.     }  
  11.     public String getUsername() {  
  12.         return username;  
  13.     }  
  14.     public void setUsername(String userName) {  
  15.         this.username = userName;  
  16.     }  
  17. }  

对于Hibernate来说,最重要的就是配置文件,即还需要一个User.hbm.xml文件

[html]  view plain  copy
  1. <hibernate-mapping>  
  2.     <class name="com.example.hibernate.User" table="t_user">  
  3.         <id name="id">  
  4.             <generator class="uuid"/>  
  5.         </id>  
  6.         <property name="username"/>  
  7.           
  8.     </class>  
  9. </hibernate-mapping>  

其他部分的代码参照上一篇文章即可。


三、建立User实体类的一些原则

       1、实现无参的默认的构造函数

       2、提供一个标识

       3、建议不要使用fianl修饰实体类

       4、建议为实体类生成setter和getter方法

对于第3条建议,如果使用了fianl关键字,那么延迟加载(load)将会无效。具体含义将会在下一篇文章中给出实例。


四、HIbernate主键生成策略

在上面User.hbm.xml配置文件中有一个标签:<generator>。它表示的是主键生成策略。主键生成策略必须配置,用来为该持久化类的实例生成唯一的标识。它有如下几种策略

    uuid: 用一个128-bit的UUID算法生成字符串类型的标识符,这在一个网络中是唯一的(使用了IP地址),UUID被编码为一个32位16进制数字的字符串,它的生成是由Hibernate生成,一般不会重复UUID包含:IP地址,JVM的启动时间,系统时间和一个计算器值。

    identity:MySql数据库中自增长

    Sequence:Oracle数据库自增长

    native:根据底层数据库能力选择identity、sequence中的一个。

    assigned:手动分配主键.<generator>没有指定时的默认生成策略

    foreign:使用另外一个相关联的对象的标示符。通常和<one-to-one>配合使用

五、总结

概括一下Hibernate的基本映射就是:
实体类——对应了——数据库中表、实体类中的属性——对应了——表中字段。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值