import jar package
1. antlr-2.7.7.jar
2. dom4j-1.6.1.spring
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 configuration file
<?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>Entity class 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();
}
}
Test whether Hibernate is configured successfully
//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();Encapsulate a Hibernate tool class
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();
}
}Tool class call case:
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();
}
}
}
}