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);
}

}

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。