如下dao层的重用:
关于service层的重用
2. Service层直接继承BaseDaoImpl
这样写增加了复杂度,但是代码看起来比较简洁,简单点的需求采用这种方式真的不错,业务需求多变,而且比较复杂的话。采用这种方式就有点不太好了。
baseDao
public interface BaseDao<T> {
public void saveEntity(T bean);
public void updateEntity(T bean);
public void deleteEntity(Serializable id);
public Collection<T> getAllEntity();
public T getEntityById(Serializable id);
}
public class BaseDaoImpl<T> implements BaseDao<T> {
@Resource(name = "hibernateTemplate")
protected HibernateTemplate hibernateTemplate;
private Class<T> clazz;
public BaseDaoImpl(){
ParameterizedType parameterizedType = (ParameterizedType)this.getClass().getGenericSuperclass();
this.clazz = (Class<T>) parameterizedType.getActualTypeArguments()[0];
}
public void saveEntity(T bean) {
this.hibernateTemplate.save(bean);
}
public void updateEntity(T bean) {
this.hibernateTemplate.update(bean);
}
@SuppressWarnings("unchecked")
public void deleteEntity(Serializable id) {
if(id == null){
return;
}
T t = (T) this.hibernateTemplate.get(this.clazz, id);
if(t == null){
return;
}
this.hibernateTemplate.delete(t);
}
public Collection<T> getAllEntity() {
return this.hibernateTemplate.find("from " + this.clazz.getSimpleName());
}
public T getEntityById(Serializable id) {
return (T) this.hibernateTemplate.get(this.clazz, id);
}
public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
public interface UserDao extends BaseDao<User>{
public User getUserByName(String name);
}
@Repository("userDao")
public class UserDaoImpl extends BaseDaoImpl<User> implements UserDao{
public User getUserByName(String name) {
List<User> list = this.hibernateTemplate.find("from User where uname = ?", name);
return list.size() == 0 ? null : list.get(0);
}
}
关于service层的重用
1. 通过写baseService
public interface BaseService<T> {
void save(T t);
void deleteById(Serializable id);
T getById(Serializable id);
Collection<T> getAll();
void update(T t);
}
public class BaseServiceImpl<T, D extends BaseDao<T>> implements BaseService<T>{
@Resource
protected D baseDao;
private Class clazz;
public BaseServiceImpl(){
ParameterizedType parameterizedType = (ParameterizedType)this.getClass().getGenericSuperclass();
this.clazz = (Class<T>) parameterizedType.getActualTypeArguments()[0];
}
@Transactional(readOnly = false)
public void save(T t) {
this.baseDao.saveEntity(t);
}
@Transactional(readOnly = false)
public void deleteById(Serializable id) {
this.baseDao.deleteEntity(id);
}
public T getById(Serializable id) {
return this.baseDao.getEntityById(id);
}
public Collection<T> getAll() {
return this.baseDao.getAllEntity();
}
@Transactional(readOnly = false)
public void update(T t) {
this.baseDao.updateEntity(t);
}
}
public interface UserService extends BaseService<User>{
public User getUserByName(String name);
}
@Service("userService")
public class UserServiceImpl extends BaseServiceImpl<User, UserDao> implements UserService{
public User getUserByName(String name) {
return this.baseDao.getUserByName(name);
}
}
2. Service层直接继承BaseDaoImpl
public class UserServiceImpl extends BaseDaoImpl<User>{
}
这样写增加了复杂度,但是代码看起来比较简洁,简单点的需求采用这种方式真的不错,业务需求多变,而且比较复杂的话。采用这种方式就有点不太好了。
3. 通过BaseServiceImpl继承BaseDaoImpl
public class BaseService extends BaseDao<User>{
}
public class BaseServiceImpl extends BaseDaoImpl<User> {
}