Hibernate入门4.核心技能

2022-10-24 11:24:59

Hibernate入门4.核心技能 20131128

代码下载链接: http://pan.baidu.com/s/1Ccuup 密码: vqlv

前言：

前面学习了Hibernate3的基本知识，并且应用在简单的实践中。这些知识Hibernate的基本知识，只能说是会使用简单的hibernate了。这一章学习的是Hibernate的核心技能。主要知识点：

Hibernate中持久化类的关联关系、Hibernate的批量处理技术、Query接口的核心方法和使用、HQL语言的查询、Criteria接口的核心方法以及查询技巧、Restrictions的使用方法、DetachedCriteria离线查询的技巧、Hibernate事务处理

1.Hibernate中的关联关系

关联关系指的是类之间的引用关系，是实体对象之间普遍存在的一种关系。使用Hibernate框架可以完整的表述这种关联关系，如果映射的十分恰当，Hibernate的关联映射将在很大程度上简化对于持久层数据的访问。

1.1一对多的关联关系

单项的N-1的关系，只能够从N访问到1的一端，在类与类的各种关联关系中，单项N-1关联和关系数据库中的外检参照关系最为相似。比如Customer和Order，使用的是N-1的单项关联，即从Order到Customer的关联关系。（其实这里已经买下一个地雷了，我们使用Order表示订单，在数据库中，对应的表的名字可以是order，当然是不可以的，因为order是关键字。在数据库的创建表的过程中，我习惯使用小写字母，这里就会出现非常隐蔽的错误，我们不断的调试程序，却始终找不到错误。）

Customer.java

package com.yang.hib.model;

public class Customer {

private int id;

private String userName;

private String password;

private String realName;

private String address;

private String mobile;

private String email;

public Customer(){}

public Customer(String userName, String password, String realName,

String address, String mobile, String email) {}

//getter & setter

}

Order.java:

package com.yang.hib.model;

import java.util.Date;

public class Order {

private int id;

private String orderNo;

private Date date;

private double total;

private Customer customer;

public Order(){}

public Order(String orderNo, Date date, double total, Customer customer) {}

//getter & setter

public void setCustomer(Customer customer){this.customer = customer;}

public Customer getCustomer(){return this.customer;}

}

Customer.hbm.xml //没有什么特别的地方

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.yang.hib.model">

<!—参考之前的代码-->

</class>

</hibernate-mapping>

Order.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.yang.hib.model">

<!—注意这里的数据表不可以是order，关键字一般情况下不能够用作表名-->

</id>

<property name="date" column="orderdate" type="timestamp"/>

<property name="total" column="total" type="double"/>

<many-to-one name="customer" column="customer_id" class="Customer" cascade="save-update"/>

<!—这一句是最为核心的配置信息，实现多对一的级联关系-->

</class>

</hibernate-mapping>

HibernateUtil.java

package com.yang.hib.util;

public class HibernateUtil {

private static String HIBERNATE_CONFIG_FILE = "hibernate.cfg.xml";

private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();

private static Configuration configuration = new Configuration();

private static SessionFactory sessionFactory ;

/*静态代码段，在该类加载的时候，执行这一段代码，这里使用的是单例模式，同时为了在多线程中使用session，使用了线程的局部变量，之前在Java进阶中的关于线程同步的知识中，最后一种方式便是使用的这一种线程局部变量将他保护起来的方式*/

static{

try{

configuration.configure(ClassLoader.getSystemResource(HIBERNATE_CONFIG_FILE));

sessionFactory = configuration.buildSessionFactory();

}catch(Exception e){

System.err.println("%%%%%Error Creating session factory %%%%%%%%");

e.printStackTrace();

}

//禁止外部创建该类型的对象

private HibernateUtil(){}

public static Session getSession() throws HibernateException{

Session session = threadLocal.get();

if(session == null || !session.isOpen()){

if(sessionFactory == null){

sessionFactory = configuration.buildSessionFactory();

}

session = (sessionFactory != null)?sessionFactory.openSession():null;

threadLocal.set(session);

}

return session;

}

public static void reBuildSessionFactory(){

try{

configuration.configure(HIBERNATE_CONFIG_FILE);

sessionFactory = configuration.buildSessionFactory();

}catch(Exception e){

System.err.println("%%%%Error Creating SessionFactory %%%%%");

e.printStackTrace();

}

public static void closeSession() throws HibernateException{

Session session = threadLocal.get();

threadLocal.set(null);

if(session != null){

session.close();

}

public static SessionFactory getSessionFactory(){

return sessionFactory;

}

public static void setHibernateConfigFile(String hibernateConfigFile){

HIBERNATE_CONFIG_FILE = hibernateConfigFile;

}

public static Configuration getConfiguration(){

return configuration;

}

TeatMain.java

package com.yang.main;

public class TestMain {

public static void addCustomerAndOrder(){

Customer customer = new Customer("yang","12345","杨腾飞","广州","15800027127","1076906529@qq.com");

System.out.println("add customer to database");

addCustomer(customer);

Order order1 = new Order("A1",new Date(),42.8,customer);

System.out.println("add order to database");

addOrder(order1);

order1 = new Order("A2",new Date(),35.9,customer);

System.out.println("add antother order to database");

addOrder(order1);

}

public static void addCustomer(Customer customer){

Session session = HibernateUtil.getSession();

Transaction trans = session.beginTransaction();

session.save(customer);

trans.commit();

HibernateUtil.closeSession();

}

public static void addOrder(Order order){

Session session = HibernateUtil.getSession();

Transaction trans = session.beginTransaction();

session.save(order);

trans.commit();

HibernateUtil.closeSession();

}

public static void main(String[] args) {

// TODO Auto-generated method stub

addCustomerAndOrder();

}

我们可以根据订单查询出数据库中的对应的顾客的信息，修改TestMain.java函数：

public static void findOrder(int id){

Session session = HibernateUtil.getSession();

Order order = (Order) session.get(Order.class, id);

Customer customer = order.getCustomer();

System.out.println( "Id:"+order.getId()+

"\ntotal:" + order.getTotal()+

"\norderdate:" + order.getDate().toLocaleString() +

"\nrealName:"+customer.getRealName()+

"\nmobile:" + customer.getMobile());

HibernateUtil.closeSession();

}

public static void main(String[] args) {

// TODO Auto-generated method stub

//addCustomerAndOrder();

findOrder(1);

}

这个时候，我们发现在控制台中是执行了两个SQL语句，对于两个表的查询，我们可以使用连接的形式使用一条SQL语句便可以完成这些查询：

在hibernate-mapper配置信息中，对于<many-to-one>元素中可以使用指定的属性来让hibernate使用连接的方式：

<many-to-one name=”customer” fetch=”join” column=”customer_id” class=”Customer”/>实现。对于many-to-one元素的fetch属性也可以使用outer-join属性替代，默认情况之下使用的是fetch=”select”。

1.2单项的1-N的关系

Customer与Order就是一对多的关系，我们可以在Order中添加orders集合属性

Customer.java

private Set<Order> orders=new HashSet<Order>();

public void setOrders(Set<Order> orders){ this.orders = orders;}

public Set<Order> getOrders(){return this.orders;}

配置文件中添加如下配置信息：

Customer.hbm.xml

<one-to-many class="Order"/>

</set>

在Hibernate中通过比较两个持久化对象的标识符属性ID来判断两者是否是相等的，这需要在实体类中对equals()和hashCode()方法重写。

重写hashCode()

public int hashCode(){

final int prime = 31;

int result = 1;

result = result*prime + ((id==null)?0:id.hashCode());

return result;

}

也就是将id+prime作为其对象的hashCode

同时对已比较两个对象是否相等，如果两者的引用是同一个对象的话，那么无论怎样都是相等的，否则如果对象是null的话，那么两者肯定不相等，因为如果两个都是null的话，那么在前面的判断中两者引用都是null则相等。继而继续判断：将obj转换成为目标类型的对象，这个时候原始的对象的id如果是null，也就是数据库中没有该数据，另一个对象也是没有持久化的，内容虽然不相同，但是两者的都没有id，则判断两者是相等的。

参考代码:

Customer c1 = new Customer("yang","12345","杨腾飞","广州","15800027127","1076906529@qq.com");

Customer c2 = new Customer("yang","134545","杨腾飞","广州","15800027127","1076906529@qq.com");

System.out.println(c1.equals(c2));

正常情况之下，两者是不想等的，但是在Hibernate重写equals函数之后，两者就是相等的。很诡异的吧，其实我现在也不是很理解。但是这是在Hibernate中比较数据库中的两个对象，就只会根据id来判断。

public boolean equals(Object obj){

if(this == obj){ return true; }

if(obj == null){ return false;}

if(getClass() != obj.getClass()){ return false;}

Customer other = (Customer) obj;

if(id == null){

if(other.id != null){return false;}

}else if( ! id.equals(other.id)){

return false;

}

return true;

}

下面查询执行用户的订单：

public static void findOrderByCustomer(Integer id){

Session session = HibernateUtil.getSession();

Customer customer = (Customer) session.get(Customer.class, id);

Set<Order> orders = customer.getOrders();

for(Order order : orders){

System.out.println( "id:"+ order.getId()+

",\torderNo:"+order.getOrderNo()+

",\ttotal:" + order.getTotal()+

",\tdate:"+order.getDate().toLocaleString());

}

一般使用的技术是双向的1-N级联，也就是在两个里面都配置级联关系，形成双向的级联。

YangTengfei

2013.11.28

码农公寓

相关文章