zoukankan      html  css  js  c++  java
  • ItcastOA_设计BaseDao_设计DAO接口和实现类_写DAO实现类中的方法内容

    3. 基础功能

    3.1. 设计BaseDao接口与BaseDaoImpl类

    每个实体都应有一个对应的Dao,他封装了对这个实体的数据库操作。

     

    实体Dao接口实现类

    ========================================================

    User--> UserDao--> UserDaoImpl

    Role--> RoleDao--> RoleDaoImpl

    Department--> DepartmentDao--> DepartmentDaoImpl

    Article--> ArticleDao--> ArticleDaoImpl

    ...

    设计Dao接口(抽取接口的公共方法)

    BaseDao.java----把每个dao都需要的方法放到这里,好让他们继承

    public interface BaseDao<T> {
        void save(T entity);
        /**
         * 保存实体
         * @param id
         */
        void delete (Long id);
        /**
         * 删除实体
         * @param entity
         */
        void update(T entity);
        /**
         * 更新实体
         * @param id
         * @return
         */
        T getById(Long id);
        /**
         * 按id查询
         * @return
         */
        List<T> getByIds(Long[] id);
        /**
         * 按id查询
         * @return
         */
        List<T> findAll();
        /**
         * 查询所有
         */
    }

    UserDao.java----一些公用的方法继承BaseDao即可

    public interface UserDao extends BaseDao<User>{
        //自己有的特殊方法写在自己这里面
    }

    RoleDao.java

    public interface RoleDao extends BaseDao<Role>{
    
    }

    增删改查等共有方法都有了

    设计Dao实现类(抽取实现类的公共方法)

    //实现RoleDao,实现所有未实现的方法
    public class RoleDaoImpl implements RoleDao{
    
        public void save(Role entity) {        
        }
    
        public void delete(Long id) {        
        }
    
        public void update(Role entity) {        
        }
    
        public Role getById(Long id) {
            return null;
        }
    
        public List<Role> getByIds(Long[] id) {
            return null;
        }
    
        public List<Role> findAll() {
            return null;
        }
    }
    public class UserDaoImpl implements RoleDao{
    
        public void save(Role entity) {        
        }
    
        public void delete(Long id) {        
        }
    
        public void update(Role entity) {        
        }
    
        public Role getById(Long id) {
            return null;
        }
    
        public List<Role> getByIds(Long[] id) {
            return null;
        }
    
        public List<Role> findAll() {
            return null;
        }
    }
     
    public class BaseDaoImpl<T> implements BaseDao<T> {
    
        public void save(T entity) {
        }
    
        public void delete(Long id) {
        }
    
        public void update(T entity) {
        }
    
        public T getById(Long id) {
            return null;
        }
    
        public List<T> getByIds(Long[] id) {
            return null;
        }
    
        public List<T> findAll() {
            return null;
        }
    }
    public class RoleDaoImpl extends BaseDaoImpl<Role> implements RoleDao{
    }
    public class UserDaoImpl extends BaseDaoImpl<User> implements UserDao{
    
    }

    可以看出这两个实现类的很多方法都重复了,我们把它抽取出来,我们写一个类它事先实现了里面的公共方法,让这两个实现类继承即可。

    BaseDaoImpl里方法是有了,但里面还没有内容,接下来写该实现类里面的方法内容

    @SuppressWarnings("unchecked")
    public abstract class BaseDaoImpl<T> implements BaseDao<T> {
    
        @Resource
        private SessionFactory sessionFactory;// 通过注入得到SessionFactory,要把它放到容器里才能注入,在具体的实现类上声明@Repository
    
        private Class<T> clazz;
        
        public BaseDaoImpl() {
            //使用反射技术得到T的真实类型
            ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();//获取当前new类型的泛型的父类类型
            this.clazz = (Class<T>) pt.getActualTypeArguments()[0];//获取第一个类型参数的真实类型,只有一个泛型参数,所以写0
            System.out.println("clazz--->" + clazz);
        }
    
        /**
         * 获取当前可用的session对象,用protected修饰方便子类得到session
         */
        protected Session getSession() {
            return sessionFactory.getCurrentSession();
        }
    
        public void save(T entity) {
            // 不需要自己关事务了,spring框架已经帮我们做了,我们用它的事务管理
            getSession().save(entity);
        }
    
        public void update(T entity) {
            getSession().update(entity);
        }
    
        public void delete(Long id) {
            Object obj = getById(id);
            if (obj != null) {
                getSession().delete(obj);
            }
        }
    
        public T getById(Long id) {
            return (T) getSession().get(clazz, id);
        }
    
        public List<T> getByIds(Long[] ids) {
            return getSession().createQuery(//
                    "FROM User WHERE id=IN(:ids)")//
                    .setParameter("", ids)
                    .list();
        }
        
        public List<T> findAll() {
            return getSession().createQuery(//
                    "FROM " + clazz.getSimpleName())//
                    .list();
        }
    }

     

     

    说明:

    4, 实体的Dao接口要继承BaseDao接口。

    5, Dao的实现类要继承DaoImplBase类。

    6, 也可以不继承指定的接口或类,这样就要自己写相应的方法。

    7, T getById(Long id)与List<T> getByIdList(Long[] idList)不要合并为List getById(Long... ids),因为获取一个对象时也是返回List,不方便。

     

     

    获取 BaseDao的类型参数T的Class

     

    问题:

    1, 有了DaoBase与DaoImplBase,还要用UserDao、RoleDao吗

    答:要用因为UserDao或RoleDao中的方法可以分为有公有的方法与特有的方法两部分。公有的方法是通过继承BaseDao得到的,特有的方法要写在自己里面(BaseDao中是没有的)。

    2, UserDaoImpl已经继承了BaseDaoImpl,就不实现UserDao可以吗?

    答:不可以否则UserDao userDao = new UserDaoImpl(); 就不成立。

     

    使用反射获取类型参数的真实类型的代码如下:

    public DaoBaseImpl () {

      Type type = this.getClass().getGenericSuperclass();

      ParameterizedType pt = (ParameterizedType) type;

      this.clazz = (Class<T>) pt.getActualTypeArguments()[0];

    }

     

     

    说明:

    1, 使用Session时,不要自己创建,也不要管理事务,直接调用getSession()即可。

    2, 暂时不实现getSession()方法,在后面的事务管理中实现
    protected Session getSession(){
        throw new UnsupportedOperationException();
    }

  • 相关阅读:
    还不知道spring的RestTemplate的妙用吗
    【学习笔记】机器学习之特征工程
    《饥饿的盛世》总结
    我是如何解决java.security.cert.CertPathValidatorException异常的
    《机器学习
    2018年总结
    元类实现ORM
    元类
    python中的装饰器
    python中的闭包
  • 原文地址:https://www.cnblogs.com/justdoitba/p/7638599.html
Copyright © 2011-2022 走看看