Hibernate複習1-配置使用hibernate

導入jar包

1.      antlr-2.7.7.jar

2.      dom4j-1.6.1.jar

3.      hibernate-commons-annotations-4.0.5.Final.jar

4.      hibernate-core-4.3.11.Final.jar

5.      hibernate-jpa-2.1-api-1.0.0.Final.jar

6.      jandex-1.1.0.Final.jar

7.      javassist-3.18.1-GA.jar

8.      jboss-logging-3.1.3.GA.jar

9.      jboss-logging-annotations-1.2.0.Beta1.jar

10.  jboss-transaction-api_1.2_spec-1.0.0.Final.jar

hibernate.cfg.xml配置文件

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
  "-//Hibernate/Hibernate Configuration DTD//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>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123456</property>

        <!-- JDBC connection pool 數據庫最大連接池(use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect 配置數據庫方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout 顯示SQL語句-->
        <property name="show_sql">true</property>

        <!-- 
        Drop and re-create the database schema on startup
        	配置根據映射文件 *.hbm.xml創建數據庫表結構
        	create 每次執行Hibernate都刪除原有表，然後創建新表
        	create-drop 每次執行Hibernate創建表，執行Hibernate後刪除表
        	update 執行Hibernate代碼時檢查是否有對應的表，如果有則不改變表，如果沒有則創建表
         -->
        <property name="hbm2ddl.auto">update</property>

<!-- 		<property name="hibernate.search.default.directory_provider">filesystem</property>
		<property name="hibernate.search.default.indexBase">target/indexes</property> -->
		
		 <mapping resource="user.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

*.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!-- 
<hibernate-mapping>一般不去配置，採用默認即可。
default-cascade="none"：默認的級聯風格，表與表聯動。
default-lazy="true"：默認延遲加載
-->
<hibernate-mapping>
<!-- 
<class>：使用class元素定義一個持久化類。
name="cn.javass.user.vo.UserModel"：持久化類的java全限定名；
table="tbl_user"：對應數據庫表名；
mutable="true"：默認爲true，設置爲false時則不可以被應用程序更新或刪除；
dynamic-insert="false"：默認爲false，動態修改那些有改變過的字段，而不用修改所有字段；
dynamic-update="false"：默認爲false，動態插入非空值字段；
select-before-update="false"：默認爲false，在修改之前先做一次查詢，與用戶的值進行對比，有變化都會真正更新；
optimistic-lock="version"：默認爲version(檢查version/timestamp字段)，取值：all(檢查全部字段)、dirty(只檢查修改過的字段)、
none(不使用樂觀鎖定)，此參數主要用來處理併發，每條值都有固定且唯一的版本，版本爲最新時才能執行操作；
-->
<class name="entity.User" table="tb_user" dynamic-insert="true" dynamic-update="true" optimistic-lock="version">

<!-- 
<id>：定義了該屬性到數據庫表主鍵字段的映射。
name="userId"：標識屬性的名字；
column="userId"：表主鍵字段的名字，如果不填寫與name一樣；
-->
<id name="id">
<!-- <generator>：指定主鍵由什麼生成，推薦使用uuid，assigned指用戶手工填入。 -->
<generator class="native"/>
</id>

<!-- 
<version/>：使用版本控制來處理併發，要開啓optimistic-lock="version"和dynamic-update="true"。
name="version"：持久化類的屬性名，column="version"：指定持有版本號的字段名；
-->
<!-- <version name="version" column="version"/> -->

<!-- 
<property>：爲類定義一個持久化的javaBean風格的屬性。
name="name"：標識屬性的名字，以小寫字母開頭；
column="name"：表主鍵字段的名字，如果不填寫與name一樣；
update="true"/insert="true"：默認爲true，表示可以被更新或插入；
-->
<property name="name" column="name" />
<property name="age" column="age"/>

<!-- 
組件映射：把多個屬性打包在一起當一個屬性使用，用來把類的粒度變小。
<component name="屬性，這裏指對象">
<property name="name1"></property>
<property name="name2"></property>
</component>
-->

<!-- 
<join>:一個對象映射多個表，該元素必須放在所有<property>之後。
<join table="tbl_test：子表名">
<key column="uuid：子表主鍵"></key>
<property name="name1：對象屬性" column="name：子表字段"></property>
</join>
-->

</class>

</hibernate-mapping>

實體類User

package entity;

public class User {
	private Integer id;
	private String name;
	private int age;
	private String gender;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age
				+ ", gender=" + gender + "]";
	}
	public User(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	public User() {
		super();
	}
	
}

測試Hibernate是否配置成功

		//1.創建配置對象，讀取核心配置文件hibernate.cfg.xml
		Configuration cfg=new Configuration().configure();
		//2.創建註冊對象，註冊對象用於註冊服務信息，註冊對象爲Hibernate4版本特有的內容
		  ServiceRegistry serviceRegistry =new ServiceRegistryBuilder().
				  applySettings(cfg.getProperties()).buildServiceRegistry();
		//3.構建會話工廠，會話工廠配置對象構建，需要進行服務註冊
		  SessionFactory sessionFactory=cfg.buildSessionFactory(serviceRegistry);
		//4.通過會話工廠構建會話，會話對象Session可以理解爲強化了JDBC的Connection
		  Session session=sessionFactory.openSession();
		//開啓事務
		  Transaction transaction=session.beginTransaction();
		//準備要保存的數據對象
		  User user=new User("張三",20,"男");
		//保存數據
		  session.save(user);
		//提交事務
		  transaction.commit();
		//回收資源
		  session.close();

封裝一個Hibernate的工具類

package util;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateUtil {
	private static SessionFactory sessionFactory=null;
	static{
		try{
			//1.創建配置對象，讀取核心配置文件hibernate.cfg.xml
			Configuration cfg=new Configuration().configure();
			//2.創建註冊對象，註冊對象用於註冊服務信息，註冊對象爲Hibernate4版本特有的內容
			ServiceRegistry serviceRegistry =new ServiceRegistryBuilder().
					  applySettings(cfg.getProperties()).buildServiceRegistry();
			//3.構建會話工廠，會話工廠配置對象構建，需要進行服務註冊
			 sessionFactory=cfg.buildSessionFactory(serviceRegistry);
		}catch(HibernateException e){
			//在靜態初始化代碼塊中出現了異常，當前代碼無法應用，拋出錯誤
			//且在靜態初始化代碼塊中只能排除唯一一種錯誤，ExceptionInInitializerError
			throw new ExceptionInInitializerError(e);
		}
	}
	
	public static Session getSession(){
		
		return sessionFactory.openSession();
	}
}

工具類調用案例：

package test;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import util.HibernateUtil;
import entity.User;

public class testUtils {
	
	@Test
	public void testSave(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtil.getSession();
			transaction =session.beginTransaction();
			User user=new User("李四1",23,"男");
			//保存數據
			session.save(user);
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally{
			if(session!=null&&session.isOpen()){
				session.close();
			}
		}
	}
	
	/**
	 * Object get(Class clazz,Serializable id)方法：用於根據主鍵查詢對象的方法
	 * 參數clazz：要查詢的數據的類對象
	 * 參數id:要查詢的數據的主鍵值
	 * 返回值Object,需要手工強制類型轉換
	 */
	@Test
	public void testGet(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtil.getSession();
			transaction =session.beginTransaction();
			User user=(User)session.get(User.class,1);
			System.out.println(user);
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally{
			if(session!=null&&session.isOpen()){
				session.close();
			}
		}
	}
	/**
	 * Object load(Class clazz,Serializable id)方法:用於根據逐漸數據查詢對象的方法
	 * 參數clazz：要查詢的數據的類對象
	 * 參數id:要查詢的數據的主鍵值
	 * 返回值Object,需要手工強制類型轉換
	 */
	@Test
	public void testLoad(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtil.getSession();
			transaction =session.beginTransaction();
			User user=(User)session.load(User.class,1);
			System.out.println(user);
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally{
			if(session!=null&&session.isOpen()){
				session.close();
			}
		}
	}
	/**
	 * 查詢列表數據
	 */
	@Test
	public void testList(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtil.getSession();
			transaction =session.beginTransaction();
			List<User> users=session.createCriteria(User.class).list();
			System.out.println(users);
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally{
			if(session!=null&&session.isOpen()){
				session.close();
			}
		}
	}
	/**
	 * 數據修改
	 */
	@Test
	public void testUpdate(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtil.getSession();
			transaction =session.beginTransaction();
			User user=(User)session.load(User.class, 1);
			user.setGender("女");
			session.update(user);
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally{
			if(session!=null&&session.isOpen()){
				session.close();
			}
		}
	}
	/**
	 * 數據刪除
	 */
	@Test
	public void testDelete(){
		Session session=null;
		Transaction transaction=null;
		try {
			session=HibernateUtil.getSession();
			transaction =session.beginTransaction();
			User user=(User)session.load(User.class, 1);
			session.delete(user);
			transaction.commit();
		} catch (Exception e) {
			e.printStackTrace();
			transaction.rollback();
		}finally{
			if(session!=null&&session.isOpen()){
				session.close();
			}
		}
	}
	
}