hibernate的多层优化问题

刚开始接触数据库的时候，连mvc是什么都不到。直到开始学hibernate的时候才开始有了分层的思想。但是，即使有了这最基本的概念，写出来的代码冗余度还是比较高的。

比如说，如果我想要添加一条用户记录，则代码如下

用户类：

package entity;

public class User {

private int user_id;

private String username;

private String password;

public int getUser_id() {
return user_id;
}

public String getUsername() {
return username;
}

public String getPassword() {
return password;
}

public void setUser_id(int user_id) {
this.user_id = user_id;
}

public void setUsername(String username) {
this.username = username;
}

public void setPassword(String password) {
this.password = password;
}

}

dao接口层：

public interface IUserDao {

void save(User user);

User queryUserById(int user_id);

}

dao实现层：

public class UserDaoImpl implements IUserDao {

public void save(User user) {
Session session = null;
Transaction tran = null;
try {
session = HibernateSessionFactory.getSession();
tran = session.beginTransaction();
session.save(user);
tran.commit();
} catch (Exception e) {
tran.rollback();
} finally {
session.close();
}
}

}

这样，一个简单的保存用户的操作就可以完成了。刚开始觉得这样子时没问题的，并且我添加其他类时（比如Product，Order）等也都是这么做。

但是，可以看得出来，这样子时不合理的。很明显嘛，代码冗余度很高，如果是保存一个Product对象，可以想象代码如下：

public class ProductDaoImpl implements IProductDao {

public void save(Product product) {
Session session = null;
Transaction tran = null;
try {
session = HibernateSessionFactory.getSession();
tran = session.beginTransaction();
session.save(product);
tran.commit();
} catch (Exception e) {
tran.rollback();
} finally {
session.close();
}
}

}

比较一下，就是参数变了，把user替换成了product而已。后来，我就想，能不能把这两个方法写成一个方法。既然可以保存user，又可以保存product，那么把参数换成它们的共有父类（没有什么比Object更合适的了）不就可以了吗

于是，代码优化如下：

BaseDao接口：

public interface IBaseDao {

void save(Object object);

}

UserDao接口：

public interface IUserDao {

void save(User user);

}

BaseDao实现类：

public class BaseDaoImpl implements IBaseDao {

public void save(Object object) {
Session session = null;
Transaction tran = null;
try {
session = HibernateSessionFactory.getSession();
tran = session.beginTransaction();
session.save(object);
tran.commit();
} catch (Exception e) {
tran.rollback();
} finally {
session.close();
}
}

}

UserDao实现类：

public class UserDaoImpl extends BaseDaoImpl implements IUserDao {

public void save(User user) {
super.save(user);
}

}

这样，对数据库操作的方法直接写一个就好了，统一放在BaseDao里面。当想要保存product时直接调用BaseDao里面的save方法，将Object参数用Product具体对象替换即可。

删除和修改时一样的道理。

那么，接下来就只有查询了。查询相对来说会比较麻烦一点。

我先以查询单个对象为例，根据Id查询一条记录，返回一个结果。

查询有几个问题分别是：1，参数是不同类型的；2，参数的个数是未知的；3，返回结果的类型是未知的。

因为返回结果的类型未知，所以要查询的对象也不知道，所以只能把查询语句作为参数传进来，因为参数的不同类型，所以不用调用query.setInteger, query.setString等方法了。在这里，有两种方法，一种是将参数列表用一个Map传进来，Map中的参数列表必须是简单对象才行，调用query.setParameter方法。另一种是将参数用一个实体类封装传进来，将实体作为参数可以调用query.setProperty方法。至于返回结果的类型，我想大家估计是想到用Object接收。这也可以，但我个人感觉不好，我建议大家用范型来接收。

以下是部分代码：

BaseDao接口：

public interface IBaseDao {

void save(Object object);

void delete(Object object);

void update(Object object);

/**
* 查询结果返回一个List集合
* @param params Map 参数列表
* @return T 返回结果时将T用List接收
*/
public <T> T queryForList(String hql, Map<String, Object> params);

/**
* 查询结果返回一个List集合
* @param params Map 参数列表
* @return T 返回结果时将T用List接收
*/
public <T> T queryForList(String hql, Object paramBean);

/**
* 查询结果返回单个对象
* @param hql
* @return T 返回结果时将T用实体类接收
*/
public <T> T queryForObject(String hql, Map<String, Object> params);

}

BaseDao实现类：

package dao.impl;

import java.util.Map;
import java.util.Map.Entry;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import util.HibernateSessionFactory;
import dao.IBaseDao;

public class BaseDaoImpl implements IBaseDao {

public void save(Object object) {
Session session = null;
Transaction tran = null;
try {
session = HibernateSessionFactory.getSession();
tran = session.beginTransaction();
session.save(object);
tran.commit();
} catch (Exception e) {
tran.rollback();
} finally {
session.close();
}
}

public void delete(Object object) {
Session session = null;
Transaction tran = null;
try {
session = HibernateSessionFactory.getSession();
tran = session.beginTransaction();
session.delete(object);
tran.commit();
} catch (Exception e) {
tran.rollback();
} finally {
session.close();
}
}

public void update(Object object) {
Session session = null;
Transaction tran = null;
try {
session = HibernateSessionFactory.getSession();
tran = session.beginTransaction();
session.update(object);
tran.commit();
} catch (Exception e) {
tran.rollback();
} finally {
session.close();
}
}

/**
* 参数名必须与对象属性名一致
*
* @param params
* Map 参数列表
* @return List
*/
@SuppressWarnings("unchecked")
public <T> T queryForList(String hql, Map<String, Object> params) {
Session session = null;
Transaction tran = null;
Query query = null;
T result = null;
try {
session = HibernateSessionFactory.getSession();
tran = session.beginTransaction();
query = session.createQuery(hql);
if (params != null) {
for (Entry<String, Object> entry : params.entrySet()) {
query.setParameter(entry.getKey(), entry.getValue());
}
}
result = (T) query.list();
tran.commit();
} catch (Exception e) {
tran.rollback();
} finally {
session.close();
}
return (T) result;
}

/**
* 参数名必须与对象属性名一致
*
* @param paramBean
* 参数对象
*/
@SuppressWarnings("unchecked")
public <T> T queryForList(String hql, Object paramBean) {
Session session = null;
Transaction tran = null;
Query query = null;
T result = null;
try {
session = HibernateSessionFactory.getSession();
tran = session.beginTransaction();
query = session.createQuery(hql);
query.setProperties(paramBean);
result = (T) query.list();
tran.commit();
} catch (Exception e) {
tran.rollback();
} finally {
session.close();
}
return (T) result;
}

/**
* 参数名必须与对象属性名一致
*
* @param params
* 查询结果返回单个对象
* @return T 返回一个实体类对象
*/
@SuppressWarnings("unchecked")
public <T> T queryForObject(String hql, Map<String, Object> params) {
Session session = null;
Transaction tran = null;
Query query = null;
T result = null;
try {
session = HibernateSessionFactory.getSession();
tran = session.beginTransaction();
query = session.createQuery(hql);
for (Entry<String, Object> entry : params.entrySet()) {
query.setParameter(entry.getKey(), entry.getValue());
}
result = (T) query.uniqueResult();
tran.commit();
} catch (Exception e) {
tran.rollback();
} finally {
session.close();
}
return (T) result;
}

}

OrderDao接口:

public interface IOrderDao {

void save(Order order);

void delete(Order order);

void update(Order order);

Order queryOrderById(int order_id);

List<Order> queryOrderByUser(User user);

}

OrderDao实现类：

public class OrderDaoImpl extends BaseDaoImpl implements IOrderDao {

public void save(Order order) {
super.save(order);
}

public void delete(Order order) {
super.delete(order);
}

public void update(Order order) {
super.update(order);
}

/**
* 根据id查询<br>
* 将Map作为参数传输载体
* @param order_id
*/
public Order queryOrderById(int order_id) {
String hql = "from Order order where order.order_id = :order_id";
Map<String, Object> params = new HashMap<String, Object>(1);
params.put("order_id", order_id);
return super.queryForObject(hql, params);
}

/**
* 根据用户查询所拥有订单<br>
* 将实体作为参数传输载体
*/
public List<Order> queryOrderByUser(User user) {
String hql = "from Order order where order.user.user_id = :user_id";
return super.queryForList(hql, user);
}

}