底层方法封装

      项目开发中面向接口编程，D层进行数据库的操作，一般都是一个接口对应一个实现类。

      但是各个接口中有公共的方法如：增删改查等基本操作。我们把这些基本的操作抽象出来放在公共的接口实现D层代码的简化。

1.原先项目开发 D层结构

UserDao

public interface UserDao{
void save(User user);
void delete(long id);
void update(User user);
......
}

RoleDao

public interface RoleDao{
void save(Role role);
void delete(long id);
void update(Role role);
......
}

然后是各自的实现
UserDaoImpl

@Repository
public class UserDaoImpl implements UserDao {

@Override
public void save(User user) {
getSession().save(user);
}

@Override
public void update(User user) {
getSession().update(user);

}
@Override
public void delete(long id) {
...
}
}

RoleDaoImpl

@Repository
public class RoleDaoImpl implements RoleDao {
@Override
public void save(Role role) {
getSession().save(role);
}

@Override
public void update(Role role) {
getSession().update(role);

}
@Override
public void delete(long id) {
...
}
}

       D层使用的hibernate，各个接口中的方法基本相同只是操作的实体不同而已 ，我们抽象出公共的接口BaseDao和具体的实现BaseDaoImpl来实现这些公共的方法，然后让每个接口继承BaseDao，显示代码复用和简化。

2.优化后D层结构



具体的代码实现为
BaseDao
//（接口中的方法抽取为公共的 接口BaseDao ，而实现类中的方法也是重复的不能每个dao都在写一遍这6个方法。
//所以我们抽取为功能的实现类BaseDaoImpl，然后让每个具体的类来继承实现类）

public interface BaseDao<T> {

void save(T entity);

void delete(long id);

void update(T entity);

T getById(long id);

List<T> getByIds(long[] ids);

List<T> findAll();
}
BaseDaoImpl
package cn.tgb.oa.base;

import java.lang.reflect.ParameterizedType;
import java.util.List;
import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

@SuppressWarnings("unchecked")
public abstract class BaseDaoImpl<T> implements BaseDao<T> {

@Resource
private SessionFactory sessionFactory;
private Class<T> clazz = null; //这是个问题

public BaseDaoImpl(){
//使用反射技术得到T的真实的类型
ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass(); //获取当前new的对象的泛型的父类类型
this.clazz = (Class<T>) pt.getActualTypeArguments()[0]; //获取第一个类型参数的真实类型
System.out.println("class--->"+clazz);
}

protected Session getSession(){
return sessionFactory.getCurrentSession();
}

@Override
public void save(T entity) {
getSession().save(entity);

}

@Override
public void delete(long id) {
Object object = getById(id);
if(object!= null){
getSession().delete(object);
}
}

@Override
public void update(T entity) {
getSession().update(entity);

}

@Override
public T getById(long id) {
return (T) getSession().get(clazz, id);
}

@Override
public List<T> getByIds(long[] ids) {
return getSession().createQuery("from " + clazz.getSimpleName() +" where id in (:ids)").setParameter("ids", ids).list();
}

@Override
public List<T> findAll() {
return getSession().createQuery("from " + clazz.getSimpleName()).list();
}

}
现在D层具体的接口：
UserDao
package cn.tgb.oa.dao;

import cn.tgb.oa.base.BaseDao;
import cn.tgb.oa.domain.User;

public interface UserDao extends BaseDao<User>{

}
RoleDao
package cn.tgb.oa.dao;

import cn.tgb.oa.base.BaseDao;
import cn.tgb.oa.domain.Role;

public interface RoleDao extends BaseDao<Role> {

}UserDaoImpl
package cn.tgb.oa.dao.Impl;

import org.springframework.stereotype.Repository;
import cn.tgb.oa.base.BaseDaoImpl;
import cn.tgb.oa.dao.UserDao;
import cn.tgb.oa.domain.User;

@Repository
public class UserDaoImpl extends BaseDaoImpl<User> implements UserDao {
//getSession().save(arg0);父类中有了getSession这个方法，子类就可以直接使用。

}
RoleDaoImpl
package cn.tgb.oa.dao.Impl;

import org.springframework.stereotype.Repository;
import cn.tgb.oa.base.BaseDaoImpl;
import cn.tgb.oa.dao.RoleDao;
import cn.tgb.oa.domain.Role;

@Repository
public class RoleDaoImpl extends BaseDaoImpl<Role> implements RoleDao {

}

业务层调用的时候就可以直接通过roleDao调用公共的6个方法。当时这个接口特有的方法时可以直接在具体的接口中添加。
@Service
@Transactional
public class roleServiceImpl implements roleService {

@Resource
private RoleDao roleDao;

@Override
public void save(Role role) {
roleDao.save(role);
}
}