标签：
刚开始接触数据库的时候，连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);
}
}
标签：
原文地址：http://www.cnblogs.com/zhulantiaoshui/p/4488975.html
