DAO问题讨论的<结束>

上编是关于DAO的讨论问题，通过这个一个讨论在这一过程当中我们每一人持的不同的看法，我想的是不管怎么样的DAO分层与整合的设计，都要依据我们的软件项目来衡量，从软件的角度上来看，就是要开发一个很完美的，效率高，运行很稳定的软件，为我们的每一个客户服务，因为客户关心的是他们的数据与数据的安全，而不是在于你们使用的怎么的代码逻辑设计思想，今天我就来做一个DAO的全面的总结吧，首先通过一个JDBC首先的一个DAO整合方法，在这个DAO的整合方法中，把我们经常定义的小类DAO方法收样到大的DAO整合方法中来，进行他们的执行操作，包含对数据库的SQL的执行控制（指的SQL的执行次数，SQL每秒执行规定的数据量）能实现到这样的，能大大的减少我们的数据库的频繁执行SQL的操作，在这样大DAO方法包含了 数据的增加，删除，更新，修改在每个小DAO的方法中主要直接转进参数进来，大的DAO法执行了在把结果集给小DAO，这里说明，不是Service层，而是DAO，上一编中 有人讲是Serviece层，我在这里说不是它，而是DAO层。假如我们以后的业务修改了，我们的DAO就没有进行大刀的修改与操作，主要关心我们的业务控制逻辑层就是了。竟然我们的DAO可以这样写，那么我们的Service层可以这样写，不过要根据自己的软件要求。就这搁笔吧，请看代码如下：

<!!!-----------DAO--->
public abstract class BaseHibernateDao extends HibernateDaoSupport
{

    public BaseHibernateDao()
    {
    }

    protected abstract Class getEntityClass();

    public Object get(Serializable id)
    {
        Object o = getHibernateTemplate().get(getEntityClass(), id);
        if(o == null)
            throw new ObjectRetrievalFailureException(getEntityClass(), id);
        else
            return o;
    }

    public List getAll()
    {
        return getHibernateTemplate().loadAll(getEntityClass());
    }

    public void removeByHql(String hql)
    {
        Query q = getSession().createQuery(hql);
        q.executeUpdate();
    }

    public void save(Object o)
    {
        getHibernateTemplate().save(o);
    }

    public void update(Object o)
    {
        getHibernateTemplate().update(o);
    }

    public void remove(Serializable id)
    {
        remove(get(id));
    }

    public void remove(int id)
    {
        remove(get(new Integer(id)));
    }

    public void remove(Object o)
    {
        getHibernateTemplate().delete(o);
    }

    public List find(String hsql)
    {
        return getHibernateTemplate().find(hsql);
    }

    public List find(String hsql, Object value)
    {
        return getHibernateTemplate().find(hsql, value);
    }

    public List find(String hsql, Object values[])
    {
        return getHibernateTemplate().find(hsql, values);
    }

    public Object findBy(String name, Object value)
    {
        Criteria criteria = getSession().createCriteria(getEntityClass());
        criteria.add(Restrictions.eq(name, value));
        return criteria.uniqueResult();
    }

    public List findAllBy(String name, Object value)
    {
        Criteria criteria = getSession().createCriteria(getEntityClass());
        criteria.add(Restrictions.eq(name, value));
        return criteria.list();
    }

    public List findAllByLike(String name, Object value)
    {
        Criteria criteria = getSession().createCriteria(getEntityClass());
        criteria.add(Restrictions.like(name, value));
        return criteria.list();
    }

    public List findAllBy(Map filter)
    {
        Criteria criteria = getSession().createCriteria(getEntityClass());
        filterCriteria(criteria, filter);
        return criteria.list();
    }

    public Page pagedQuery(String hql, int pageNo, int pageSize)
    {
        return pagedQuery(hql, null, pageNo, pageSize);
    }

    public Page pagedQuery(String hql, Object args[], int pageNo, int pageSize)
    {
        int end = hql.indexOf("order");
        end = end != -1 ? end : hql.length();
        String sql = (new StringBuilder()).append("select count(*) as total ").append(hql.substring(hql.indexOf("from"), end)).toString();
        int total = 0;
        try
        {
            List l = getHibernateTemplate().find(sql, args);
            total = ((Integer)l.get(0)).intValue();
        }
        catch(Exception ex)
        {
            logger.error(ex);
        }
        return pagedQuery(hql, args, pageNo, pageSize, total);
    }

    public Page pagedQuery(String hql, Object args[], int pageNo, int pageSize, int total)
    {
        if(hql == null)
            throw new IllegalArgumentException("NULL is not a valid HQL string");
        Query query = getSession().createQuery(hql);
        if(args != null)
        {
            for(int i = 0; i < args.length; i++)
                query.setParameter(i, args[i]);

        }
        return HqlPage.getHibernatePageInstance(query, pageNo, pageSize, total);
    }

    public List findAllBy(Map filter, Map sortMap, int rowStart, int rowDisplayed)
    {
        Criteria criteria = getSession().createCriteria(getEntityClass());
        filterCriteria(criteria, filter);
        sortCriteria(criteria, sortMap);
        criteria.setProjection(null);
        criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
        criteria.setFirstResult(rowStart);
        criteria.setMaxResults(rowDisplayed);
        return criteria.list();
    }

    protected void filterCriteria(Criteria criteria1, Map map)
    {
    }

    private void sortCriteria(Criteria criteria, Map sortMap)
    {
        if(!sortMap.isEmpty())
        {
            for(Iterator iterator = sortMap.keySet().iterator(); iterator.hasNext();)
            {
                String fieldName = iterator.next().toString();
                String orderType = sortMap.get(fieldName).toString();
                if("asc".equalsIgnoreCase(orderType))
                    criteria.addOrder(Order.asc(fieldName));
                else
                    criteria.addOrder(Order.desc(fieldName));
            }

        }
    }

    public int getCount(Map filter)
    {
        Criteria criteria = getSession().createCriteria(getEntityClass());
        filterCriteria(criteria, filter);
        Integer count = (Integer)criteria.setProjection(Projections.rowCount()).uniqueResult();
        return count.intValue();
    }

    protected final Log logger = LogFactory.getLog(getClass());
}

<!---DaoSupport---->

public class BaseHibernateSuport extends HibernateDaoSupport
{

    public BaseHibernateSuport()
    {
    }

    public int getCount(String hsql, Object obj[])
        throws HibernateException, SQLException
    {
        int total = 0;
        try
        {
            List l = getHibernateTemplate().find(hsql, obj);
            total = ((Integer)l.get(0)).intValue();
        }
        catch(Exception ex)
        {
            logger.error(ex);
        }
        return total;
    }

    public Vector swap(List list)
    {
        if(list != null)
        {
            Object obj = list.get(list.size() - 1);
            Vector ret = new Vector();
            ret.add(obj);
            list.remove(list.size() - 1);
            ret.addAll(list);
            return ret;
        } else
        {
            return null;
        }
    }
}

<!--DAO--->
public abstract class BaseDAO
{

    public BaseDAO()
    {
        conn = null;
        needClosed = null;
        isSharedCon = false;
        needClosed = new Vector();
        isSharedCon = false;
    }

    public Connection getCurrentConnection()
    {
        if(conn == null)
            conn = getConnection(CURRENTCONNECTIONSTYLE);
        return conn;
    }

    public Connection getConnection()
        throws SQLException
    {
        return getConnection(CURRENTCONNECTIONSTYLE);
    }

    public void setCurrentConnection(Connection conn)
        throws Exception
    {
        if(this.conn == null)
        {
            this.conn = conn;
        } else
        {
            closeConnection();
            this.conn = conn;
        }
    }

    public Connection getConnection(int style)
    {
        try
        {
            if(style == 0)
                conn = OaUtil.getConnection();
            else
            if(style == 1)
            {
                DriverManager.registerDriver(new OracleDriver());
                conn = DriverManager.getConnection((new StringBuilder()).append("jdbc:oracle:thin:@").append(hostname).append(":").append(port).append(":").append(dbSID).toString(), username, password);
            }
        }
        catch(Exception e)
        {
            System.out.println(e.toString());
            return null;
        }
        System.out.println("get database_connection successfully!");
        return conn;
    }

    public boolean begin()
        throws SQLException
    {
        if(isSharedCon)
            return true;
        if(conn == null)
            getCurrentConnection();
        conn.setAutoCommit(false);
        return true;
    }

    public boolean commit()
        throws SQLException
    {
        if(isSharedCon)
            return true;
        if(conn == null)
            getCurrentConnection();
        conn.commit();
        return true;
    }

    public boolean rollback()
        throws SQLException
    {
        if(isSharedCon)
            return true;
        if(conn == null)
            getCurrentConnection();
        conn.rollback();
        return true;
    }

    public ResultSet OpenSQL(String sql)
        throws SQLException
    {
        if(conn == null)
            getCurrentConnection();
        conn.setAutoCommit(true);
        Statement stmt = conn.createStatement(RESULTSETTYLE, RESULTSETCONCURRENCY);
        ResultSet rs = stmt.executeQuery(sql);
        needClosed.addElement(stmt);
        needClosed.addElement(rs);
        return rs;
    }

    public int executeSQL(String sql, boolean CommitAtOnce)
        throws SQLException
    {
        Statement stmt;
        int ret;
        stmt = null;
        ret = 0;
        if(conn == null)
            getCurrentConnection();
        if(CommitAtOnce)
            begin();
        stmt = conn.createStatement();
        ret = stmt.executeUpdate(sql);
        if(CommitAtOnce)
            commit();
        if(stmt != null)
            stmt.close();
        break MISSING_BLOCK_LABEL_106;
        Exception e;
        e;
        if(CommitAtOnce)
            rollback();
        if(stmt != null)
            stmt.close();
        break MISSING_BLOCK_LABEL_106;
        Exception exception;
        exception;
        if(stmt != null)
            stmt.close();
        throw exception;
        return ret;
    }

    public int executeSQL(String sql)
        throws SQLException
    {
        return executeSQL(sql, true);
    }

    public void closeConnection()
    {
        if(conn != null && !isSharedCon)
            try
            {
                for(int i = 0; i < needClosed.size(); i++)
                {
                    Object obj = needClosed.get(i);
                    if(obj instanceof Statement)
                    {
                        ((Statement)obj).close();
                        continue;
                    }
                    if(obj instanceof PreparedStatement)
                    {
                        ((PreparedStatement)obj).close();
                        continue;
                    }
                    if(obj instanceof ResultSet)
                        ((ResultSet)obj).close();
                }

                needClosed.clear();
                conn.close();
                conn = null;
            }
            catch(Exception e)
            {
                System.out.println((new StringBuilder()).append("baseDAO.closeConnection() exception:").append(e.toString()).toString());
            }
    }

    public abstract Object getFromRSCurRow(ResultSet resultset);

    public Vector getBeansFromResultSet(ResultSet rs)
    {
        Vector ret;
        ret = new Vector();
        for(; rs.next(); ret.addElement(getFromRSCurRow(rs)));
        return ret;
        Exception e;
        e;
        System.out.println((new StringBuilder()).append("BaseDAO.getBeansFromResultSet exception:").append(e.toString()).toString());
        return null;
    }

    public Vector getBeansFromResultSet(ResultSet rs, SearchInfo searchinfo)
    {
        if(!rs.next())
            return new Vector();
        Vector ret;
        int page;
        int row;
        int rowcount;
        ret = new Vector();
        page = searchinfo.getCurPage();
        if(page < 1)
            page = 1;
        row = (page - 1) * searchinfo.getPageSize() + 1;
        rowcount = 0;
        rowcount = 1;
_L1:
        if(rowcount >= row)
            break MISSING_BLOCK_LABEL_94;
        if(rs.next())
            break MISSING_BLOCK_LABEL_88;
        searchinfo.setCurPage(0);
        searchinfo.setRowsCount(rowcount);
        return ret;
        rowcount++;
          goto _L1
        int i = 0;
        i = 0;
        do
        {
            if(i >= searchinfo.getPageSize() && searchinfo.getPageSize() != 0)
                break;
            ret.addElement(getFromRSCurRow(rs));
            if(!rs.next())
                break;
            rowcount++;
            i++;
        } while(true);
        if(i != searchinfo.getPageSize())
            searchinfo.setPageSize(++i);
        searchinfo.setCurPage(page);
        while(rs.next())
            rowcount++;
        searchinfo.setRowsCount(rowcount);
        int tmpI = 0;
        if(rowcount == 0)
            tmpI = 0;
        else
        if(searchinfo.getPageSize() == 0)
        {
            tmpI = 1;
        } else
        {
            double tmpD = (double)rowcount / (double)searchinfo.getPageSize();
            tmpI = (int)tmpD;
            if(tmpD > (double)tmpI)
                tmpI++;
        }
        searchinfo.setPageCount(tmpI);
        return ret;
        Exception e;
        e;
        System.out.println((new StringBuilder()).append("BaseDAO.getBeansFromResultSet exception:").append(e.toString()).toString());
        return null;
    }

    public PreparedStatement createUpdateStatement(String sql)
    {
        PreparedStatement ret;
        if(conn == null)
            getCurrentConnection();
        ret = conn.prepareStatement(sql);
        needClosed.addElement(ret);
        return ret;
        Exception e;
        e;
        System.out.println((new StringBuilder()).append("BaseDAO.CreatePreparedStatement exception:").append(e.toString()).toString());
        return null;
    }

    public PreparedStatement createQueryStatement(String sql)
    {
        PreparedStatement ret;
        if(conn == null)
            getCurrentConnection();
        ret = conn.prepareStatement(sql);
        needClosed.addElement(ret);
        return ret;
        Exception e;
        e;
        System.out.println((new StringBuilder()).append("BaseDAO.CreatePreparedStatement exception:").append(e.toString()).toString());
        return null;
    }

    public ResultSet executeQuery(PreparedStatement prstms)
    {
        ResultSet rs;
        rs = prstms.executeQuery();
        needClosed.addElement(rs);
        return rs;
        Exception e;
        e;
        System.out.println((new StringBuilder()).append("BaseDAO. executeQuery exception:").append(e.toString()).toString());
        return null;
    }

    public int executeUpdate(PreparedStatement prstms)
    {
        int ret = prstms.executeUpdate();
        return ret;
        Exception e;
        e;
        System.out.println((new StringBuilder()).append("BaseDAO. executeupdate exception:").append(e.toString()).toString());
        return 0;
    }

    public Vector getNeedClosed()
    {
        return needClosed;
    }

    public void AddNeedClosed(Vector v)
    {
        needClosed.addAll(v);
    }

    public void ConnectTo(BaseDAO dao)
    {
        conn = dao.getCurrentConnection();
        needClosed = dao.getNeedClosed();
        isSharedCon = true;
    }

    public boolean getIsSharedConnection()
    {
        return isSharedCon;
    }