SSH框架里的iHiberBaseDAO类与iHiberDAOImpl写法

一、iHiberBaseDAO类

package basic;
import java.util.*;

/**
 * 基于hibernate技术实现的BaseDAO基类
 * @author ZHANGYANTAO
 * @since 2014-12-19
 * @version 2017-4-20
 */
public interface iHiberBaseDAO {
    /**
     * 实现单个的新瞬时实体类对象的持久化操作（添加对象到数据库中）
     * 该hibernate添加方法仅用于对单个的瞬时对象进行持久化操作
     * @param Object 任意的Hibernate的表映射实体类对象
     * @return Object  主键id， null则表示添加失败 
     */
    public Object insert(Object obj);

    /**
     * 实现批量的新瞬时实体类对象的持久化操作（添加对象到数据库中）
     * 该hibernate添加方法仅用于对单个的瞬时对象进行持久化操作
     * @param List<Object> 任意的Hibernate的表映射实体类对象列表
     * @return boolean  true成功，false失败
     */
    public boolean insert(List<Object> list);
    
    /**
     * 执行表数据删除操作
     * 该hibernate删除方法仅用于对单个的瞬时对象使用其id属性进行持久化操作
     * @param Class 给出对应表的Pojo类类型，如User.class
     * @param Serializable 对应表中主键字段的Pojo类的成员属性的值，如用户编号id
     * @return boolean true 成功    false 失败
     */
    public boolean delete(Class cls, java.io.Serializable id);

    /**
     * 执行表数据删除操作
     * 该hibernate删除方法仅用于对单个的瞬时对象进行持久化删除操作
     * @param Object Hibernate的表映射对象 当前为要删除表的实体类对象
     * @return boolean true 成功    false 失败
     */
    public boolean delete(Object obj) ;
    
    /**
     * 修改表记录，使用对应表的实体类对象实现
     * 该hibernate更新方法仅用于对单个的瞬时对象进行持久化操作
     * @param Object Hibernate的表映射对象
     * @return boolean true 成功    false 失败
     */
    public boolean update(Object obj) ;

    /**
     * 使用无参数的hql实现查询的，他将返回基于hql中查询对象的List数组对象
     * @param String 符合hql结构的无参数查询语句
     * @return List  失败返回null
     */
    public List select(String hql) ;
    
    /**
     * 使用无参数的hql实现查询的，他将返回基于hql中查询对象的List数组对象,实现top功能
     * @param String 符合hql结构的无参数查询语句
     * @param String 取List值的开始索引
     * @param String 取List值得结束索引
     * @return List  失败返回null
     */
    public List select(String hql,int startIndex, int length) ;

    /**
     * 使用带有参数的hql实现查询的，他将返回基于hql中查询对象的List数组对象
     * @param String 符合hql结构的有参数查询语句
     * @param Object[] 参数值数组
     * @return List  失败返回null
     */
    public List select(String hql,Object[] para) ;
    
    /**
     * 使用无参数的hql实现查询的，他将返回基于hql中查询对象的List数组对象,实现top功能
     * @param String 符合hql结构的无参数查询语句
     * @param String 取List值的开始索引
     * @param String 取List值得结束索引
     * @return List  失败返回null
     */
    public List select(String hql,Object[] para,
            int startIndex, int length) ;
    
    /**
     * 获取带聚合函数hql语句的查询结果
     * @param hql 带聚合函数的hql结构的无参数查询语句
     * @return List  失败返回null
     */
    public int selectValue(String hql);
    
    /**
     * 使用带有参数的hql,获取聚合函数查询的结果
     * @param hql 带聚合函数的hql结构的有参数查询语句
     * @param para Object[]类型的参数值数组
     * @return List  失败返回null
     */
    public int selectValue(String hql,Object[] para);
    
    /**
     * 分页查询返回总页数
     * 可使用的hql语句为(1)"from DForum" 
     * (2)from DForum order by forumid desc"
     * (3)from DForum where DUser.userid = 'zhangjs' order by forumid desc"
     * @param String hql 分页查询的hql字符串
     * @param String pageSize 每页的结果数量
     * @return int 查询得到的总页数结果
     */
    public int selectPages(String hql,int pageSize);
    
    /**
     * 分页查询返回总页数
     * 可使用的hql语句为(1)"from DForum" 
     * (2)from DForum order by forumid desc"
     * (3)from DForum where DUser.userid = 'zhangjs' order by forumid desc"
     * @param String hql 分页查询的hql字符串
     * @param Object[] para 对应hql中参数的值数组
     * @param String pageSize 每页的结果数量
     * @return int 查询得到的总页数结果
     */
    public int selectPages(String hql,Object[] para, int pageSize);
    
    /**
     * 分页查询
     * 可使用的hql语句为(1)"from DForum" 
     * (2)from DForum order by forumid desc"
     * (3)from DForum where DUser.userid = 'zhangjs' order by forumid desc"
     * @param String hql 分页查询的无参数hql字符串
     * @param int startPage 查询开始的页数
     * @param int pageSize 查询要求的每页的记录数
     * @return List 查询返回的记录队列
     */
    public List selectByPage(String hql,int startPage, int pageSize);
    
    /**
     * 分页查询
     * 可使用的hql语句为(1)"from DForum" 
     * (2)from DForum order by forumid desc"
     * (3)from DForum where DUser.userid = 'zhangjs' order by forumid desc"
     * @param String hql 分页查询的无参数hql字符串
     * @param Object[] para 对应分页查询hql中参数的值数组
     * @param int startPage 查询开始的页数
     * @param int pageSize 查询要求的每页的记录数
     * @return List 查询返回的记录队列
     */
    public List selectByPage(String hql,Object[] para, int startPage, int pageSize);
    
    /**
     * 根据cls对应表的主键属性id来查询并返回cls类型的对象
     * @param Class cls 要查询的Hibernate的表映射类对象名，如User对象的类型为User.class
     * @param java.io.Serializable id 查询所用的对应主键的值
     * @return Object 返回的cls类型的对象
     */
    public Object findById(Class cls, java.io.Serializable id);
    
    /**
     * 利用无参数的sql实现数据表对象的更新操作
     * @param String sql 无参数的update的sql语句
     * @return boolean true 成功   false 失败
     */
    public boolean update(String sql);
    
    /**
     * 利用带参数的sql实现数据表对象的更新操作
     * @param String sql 带参数的update的sql语句
     * @param Object[] para 对应sql语句中的参数值
     * @return boolean true 成功   false 失败
     */
    public boolean update(String hql,Object[] para);
    
    /**
     * 利用sql实现数据表的批量删除
     * @param String sql 无参数的delete的sql语句
     * @return boolean true 成功   false 失败
     */
    public boolean delete(String sql);
    
    /**
     * 利用带参数的sql实现数据表的批量删除
     * @param String sql 带参数的delete的sql语句
     * @param Object[] para 对应sql语句中的参数值
     * @return boolean true 成功   false 失败
     */
    public boolean delete(String sql,Object[] para);
    
    /**
     * 调用数据库存储过程（无参数）
     * 参数：String procName 数据库存储过程名
     * 输出参数:ResultSet rs 返回存储过程中查询的结果
     * 返回值：0 更新语句执行失败   >0 更新语句成功
     */
    public Object executeProduce(String procName);
    
    /**
     * 调用数据库存储过程（带参数）
     * 参数：String procName 数据库存储过程名
     * 输出参数:ResultSet rs 返回存储过程中查询的结果
     * 返回值：0 更新语句执行失败   >0 更新语句成功
     */
    public Object executeProduce(String procName,Object[] para);
    
    /**
     * 执行更新操作的批处理语句，这里将采用多个结果的事务方式，一起提交，一起回滚
     * 
     * @param Object Hibernate的表映射对象 当前为要删除表的实体类对象
     * @return boolean true 成功    false 失败
     */
    public boolean executeBatch(Object[] obj, int[] model);
    
    public boolean executeBatch(List<Object> list,List<Integer> models);
}

二、iHiberDAOImpl类

package basic;

import java.io.Serializable;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class iHiberDAOImpl implements iHiberBaseDAO {
    
    public static final int INSERT = 1; //代表添加操作
    public static final int UPDATE = 2; //代表修改操作
    public static final int DELETE = 3; //代表删除操作

    @Override
    public Object insert(Object obj) {  //obj必须是符合hibernate的pojo对象
        Session session = HibernateSessionFactory.getSession();//每次执行前需引入session对象
        Transaction tx = null;
        try{
        tx = session.beginTransaction(); //开启一个事务
        Serializable key = session.save(obj);
        tx.commit(); //持久化操作
        session.close();
        return key;
        }catch(Exception e){
        e.printStackTrace();
        if(tx!=null) tx.rollback(); //撤销
        if(session!=null) session.close();
        }
        return null;

    }

    @Override
    public boolean insert(List<Object> list) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try{
        tx = session.beginTransaction(); //开启一个事务
        for(Object obj : list){
        session.save(obj);
        }
        tx.commit(); //持久化操作
        session.close();
        return true;
        }catch(Exception e){
        e.printStackTrace();
        if(tx!=null) tx.rollback(); //撤销
        if(session!=null) session.close();
        }
        return false;

    }

    @Override
    public boolean delete(Class cls, Serializable id) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try{
        tx = session.beginTransaction(); //开启一个事务
        //先用cls和id查出要删除的对象
        session.delete(session.get(cls, id));
        tx.commit(); //持久化操作
        session.close();
        return true;
        }catch(Exception e){
        e.printStackTrace();
        if(tx!=null) tx.rollback(); //撤销
        if(session!=null) session.close();
        }
        return false;

    }

    @Override
    public boolean delete(Object obj) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try{
        tx = session.beginTransaction(); //开启一个事务
        session.delete(obj);
        tx.commit(); //持久化操作
        session.close();
        return true;
        }catch(Exception e){
        e.printStackTrace();
        if(tx!=null) tx.rollback(); //撤销
        if(session!=null) session.close();
        }
        return false;

    }

    @Override
    public boolean update(Object obj) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try{
        tx = session.beginTransaction(); //开启一个事务
        session.update(obj);
        tx.commit(); //持久化操作
        session.close();
        return true;
        }catch(Exception e){
        e.printStackTrace();
        if(tx!=null) tx.rollback(); //撤销
        if(session!=null) session.close();
        }
        return false;

    }

    @Override
    public List select(String hql) {
        Session session = HibernateSessionFactory.getSession();
        try{
        Query query = session.createQuery(hql);
        List list = query.list();
        session.close();
        return list;
        }catch(Exception e){
        e.printStackTrace();
        if(session!=null) session.close();
        }
        return null;
    }

    @Override
    public List select(String hql, int startIndex, int length) {
        Session session = HibernateSessionFactory.getSession();
        try {
        Query query =session.createQuery(hql);
        query.setFirstResult(startIndex); //设置起始记录位置
        query.setMaxResults(length); //设置返回记录数
        List list = query.list();
        session.close();
        return list;
        } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.close();
        }
        return null;

    }

    @Override
    public List select(String hql, Object[] para) {
        Session session = HibernateSessionFactory.getSession();
        try {
        Query query =session.createQuery(hql);
        //根据para设置参数
        for(int i=0;i<para.length;i++){
        query.setParameter(i, para[i]);
        }
        List list = query.list();
        session.close();
        return list;
        } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.close();
        }
        return null;

    }

    @Override
    public List select(String hql, Object[] para, int startIndex, int length) {
        Session session = HibernateSessionFactory.getSession();
        try {
        Query query =session.createQuery(hql);
        //根据para设置参数
        for(int i=0;i<para.length;i++){
        query.setParameter(i, para[i]);
        }
        query.setFirstResult(startIndex); //设置起始记录位置
        query.setMaxResults(length); //设置返回记录数
        List list = query.list();
        session.close();
        return list;
        } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.close();
        }
        return null;

    }

    @Override
    public int selectValue(String hql) {
        Session session = HibernateSessionFactory.getSession();
        try {
        Query query = session.createQuery(hql);
        Object obj = query.uniqueResult();
        session.close();
        if(obj instanceof Long)
        return ((Long)obj).intValue();
        else if(obj instanceof Integer)
        return ((Integer)obj).intValue();
        } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.close();
        }
        return 0;

    }

    @Override
    public int selectValue(String hql, Object[] para) {
        Session session = HibernateSessionFactory.getSession();
        try {
        Query query = session.createQuery(hql);
        //根据para设置参数
        for(int i=0;i<para.length;i++){
        query.setParameter(i, para[i]);
        }
        Object obj = query.uniqueResult();
        session.close();
        if(obj instanceof Long)
        return ((Long)obj).intValue();
        else if(obj instanceof Integer)
        return ((Integer)obj).intValue();
        } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.close();
        }
        return 0;

    }

    @Override
    public int selectPages(String hql, int pageSize) {
        Session session = HibernateSessionFactory.getSession();
        long pages_all = 0;
        try {
        Query query = session.createQuery(hql);
        List list = query.list();
        //获得查询记录总数
        long records = list.size();
        //计算分页数
        pages_all =records%pageSize==0?records/pageSize:records/pageSize + 1; //获得总页数
        session.close();
        return (int)pages_all;
        }catch(Exception e){
        e.printStackTrace();
        if(session!=null) session.close();
        }
        return 0;


    }

    @Override
    public int selectPages(String hql, Object[] para, int pageSize) {
        Session session = HibernateSessionFactory.getSession();
        //编程思想：先获得查询记录数，再使用算法来计算出分页的页数
        long pages_all = 0;
        try {
        Query query = session.createQuery(hql);
        //根据para设置参数
        for(int i=0;i<para.length;i++){
        query.setParameter(i, para[i]);
        }
        List list = query.list();
        //获得查询记录总数
        long records = list.size();
        //计算分页数
        pages_all =
        records%pageSize==0?records/pageSize:records/pageSize + 1; //获得总页数
        session.close();
        return (int)pages_all;
        }catch(Exception e){
        e.printStackTrace();
        if(session!=null) session.close();
        }
        return 0;

    }

    @Override
    public List selectByPage(String hql, int startPage, int pageSize) {
        Session session = HibernateSessionFactory.getSession();
        List pList = null;
        int currentPage;
        try {
        Query query = session.createQuery(hql);
        //先求出按照pageSize得到的分页的页数
        List list = query.list();
        //获得查询记录总数
        long records = list.size();
        //获得总页数
        int pages_all =(int)(records%pageSize==0?records/pageSize:records/pageSize + 1); //获得总页数
                
                //设置类成员当前页面的操作页码
                if(startPage<=1){
                currentPage = 1;
                }else if(startPage >=pages_all){
                currentPage = pages_all;
                }else {
                currentPage = startPage;
                }
                Query query2 = session.createQuery(hql);
                query2.setFirstResult((currentPage -1)* pageSize);//从第几条记录开始查询
                
                query2.setMaxResults(pageSize);//每页显示多少条记录
                pList = query2.list();
                session.close();
                } catch (Exception e) {
                e.printStackTrace();
                if(session!=null) session.close();
                }
                return pList;

    }

    @Override
    public List selectByPage(String hql, Object[] para, int startPage, int pageSize) {
        Session session = HibernateSessionFactory.getSession();
        List pList = null;
        int currentPage;
        try {
        Query query = session.createQuery(hql);
        //根据para设置参数
        for(int i=0;i<para.length;i++){
        query.setParameter(i, para[i]);
        }
        List list = query.list();
        //获得查询记录总数
        long records = list.size();
        //获得总页数
        int pages_all =
        (int)(records%pageSize==0?records/pageSize:records/pageSize + 1); //获得总页数
        
        //设置类成员当前页面的操作页码
        if(startPage<=1){
            currentPage = 1;
            }else if(startPage >=pages_all){
            currentPage = pages_all;
            }else {
            currentPage = startPage;
            }
            Query query2 = session.createQuery(hql);
            //根据para设置参数
            for(int i=0;i<para.length;i++){
            query2.setParameter(i, para[i]);
            }
            query2.setFirstResult((currentPage -1)* pageSize);//从第几条记录开始查询
            
            query2.setMaxResults(pageSize);//每页显示多少条记录
            pList = query2.list();
            session.close();
            } catch (Exception e) {
            e.printStackTrace();
            if(session!=null) session.close();
            }
            return pList;

    }

    @Override
    public Object findById(Class cls, Serializable id) {
        Session session = HibernateSessionFactory.getSession();
        try {
        Object obj = session.get(cls, id);
        session.close();
        return obj;
        } catch (Exception e) {
        e.printStackTrace();
        if(session!=null) session.close();
        }
        return null;

    }

    @Override
    public boolean update(String sql) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try{
        tx = session.beginTransaction(); //开启一个事务
        //将会话Session对象转换成jdbc的Connection
        Connection con = session.connection();
        PreparedStatement ptmt = con.prepareStatement(sql);
        int row = ptmt.executeUpdate();
        tx.commit(); //持久化操作
        session.close();
        if(row > 0)
        return true;
        else
        return false;
        }catch(Exception e){
        e.printStackTrace();
        if(tx!=null) tx.rollback(); //撤销
        if(session!=null) session.close();
        }
        return false;

    }

    @Override
    public boolean update(String sql, Object[] para) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try{
        tx = session.beginTransaction(); //开启一个事务
        //将会话Session对象转换成jdbc的Connection
        Connection con = session.connection();
        PreparedStatement ptmt = con.prepareStatement(sql);
        for(int i=0; i<para.length; i++){
        ptmt.setObject(i+1, para[i]);
        }
        int row = ptmt.executeUpdate();
        tx.commit(); //持久化操作
        session.close();
        if(row > 0)
        return true;
        else
        return false;
        }catch(Exception e){
        e.printStackTrace();
        if(tx!=null) tx.rollback(); //撤销
        if(session!=null) session.close();
        }
        return false;

    }

    @Override
    public boolean delete(String sql) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try{
            tx = session.beginTransaction(); //开启一个事务
            //将会话Session对象转换成jdbc的Connection
            Connection con = session.connection();
            PreparedStatement ptmt = con.prepareStatement(sql);
            int row = ptmt.executeUpdate();
            tx.commit(); //持久化操作
            session.close();
            if(row > 0)
            return true;
            else
            return false;
            }catch(Exception e){
            e.printStackTrace();
            if(tx!=null) tx.rollback(); //撤销
            if(session!=null) session.close();
            }
            return false;

    }

    @Override
    public boolean delete(String sql, Object[] para) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try{
        tx = session.beginTransaction(); //开启一个事务
        //将会话Session对象转换成jdbc的Connection
        Connection con = session.connection();
        PreparedStatement ptmt = con.prepareStatement(sql);
        for(int i=0; i<para.length; i++){
        ptmt.setObject(i+1, para[i]);
        }
        int row = ptmt.executeUpdate();
        tx.commit(); //持久化操作
        session.close();
        if(row > 0)
        return true;
        else
        return false;
        }catch(Exception e){
        e.printStackTrace();
        if(tx!=null) tx.rollback(); //撤销
        if(session!=null) session.close();
        }
         
         
        return false;

    }

    @Override
    public Object executeProduce(String procName) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try {
        tx = session.beginTransaction();
        Connection conn=session.connection();
        CallableStatement ctmt=conn.prepareCall("{? = call procName}");
        ctmt.registerOutParameter(1,java.sql.Types.INTEGER);
        boolean type = ctmt.execute();
        tx.commit();
        if(type){ //为true表明存储过程是一个select语句
        ResultSet rs = ctmt.getResultSet();
        //globesession.close();
        return rs;
        }else{ //不是select，则获取返回值
        int isSuccess = ctmt.getInt(1); //获得返回值。
        session.close();
        return new Integer(isSuccess);
        }
        } catch (Exception e) {
        e.printStackTrace();
        if (tx != null) tx.rollback(); //错误时，回滚操作
        if(session!=null) session.close();
        }
        return null;
    }

    @Override
    public Object executeProduce(String procName, Object[] para) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try {
        tx = session.beginTransaction();
        Connection conn=session.connection();
        CallableStatement ctmt=conn.prepareCall("{? = call procName}");
        ctmt.registerOutParameter(1,java.sql.Types.INTEGER);
        for(int i=0;i<para.length;i++){
        ctmt.setObject(i+2, para[i]);
        }
        boolean type = ctmt.execute();
        tx.commit();
        if(type){ //为true表明存储过程是一个select语句
        ResultSet rs = ctmt.getResultSet();
        //globesession.close();
        return rs;
        }else{ //不是select，则获取返回值
        int isSuccess = ctmt.getInt(1); //获得返回值。
        session.close();
        return new Integer(isSuccess);
        }
        } catch (Exception e) {
        e.printStackTrace();
        if (tx != null) tx.rollback(); //错误时，回滚操作
        if(session!=null) session.close();
        }
        return null;

    }

    @Override
    public boolean executeBatch(Object[] obj, int[] model) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        tx = session.beginTransaction();
        try {
        for(int i=0; i<obj.length; i++){
        if(model[i]==INSERT)
        session.save(obj[i]);
        else if(model[i]==UPDATE)
        session.update(obj[i]);
        else if(model[i]==DELETE)
        session.delete(obj[i]);
        }
        tx.commit();
        session.close();
        return true;
        }catch(Exception e){
        e.printStackTrace();
        if (tx != null) tx.rollback(); //错误时，回滚操作
        if (session!=null) session.close();
        }
        return false;

    }

    @Override
    public boolean executeBatch(List<Object> list, List<Integer> models) {
        Session session = HibernateSessionFactory.getSession();
        Transaction tx = null;
        try {
        tx = session.beginTransaction();
        for(int i=0; i<list.size(); i++){
        Object obj = list.get(i);
        Integer model = (Integer)models.get(i);
        if(model.intValue()==INSERT){
        session.save(obj);
        }else if(model.intValue()==UPDATE){
        session.update(obj);
        }else if(model.intValue()==DELETE){
        session.delete(obj);
        }
        }
        tx.commit();
        session.close();
        return true;
        }catch(Exception e){
        e.printStackTrace();
        if (tx != null) tx.rollback(); //错误时，回滚操作
        if (session!=null) session.close();
        }
        return false;
        }

    }

附加给大家一个junit测试方法书写

package Test;

import static org.junit.Assert.*;

import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import basic.*;
import model.TForumTitle;
import model.Tuser;
public class TestHiberBaseDAOImpl {
  iHiberDAOImpl bdao=null;
  
    @Before
    public void init(){
        bdao=new iHiberDAOImpl();
    }
    @After
    public void tearDown() throws Exception {
    }

    @Test
    public void testInsertObject() {
        Tuser user=new Tuser();
        user.setUserid("zhangsanfeng");
        user.setNickname("太极宗师");
        user.setPwd("123456");
        user.setAgend("男");
        user.setUsertype(2);
        System.out.println(bdao.insert(user));
    }

    @Test
    public void testInsertListOfObject() {
        fail("Not yet implemented");
    }

    @Test
    public void testDeleteClassSerializable() {
    bdao.delete(Tuser.class,"zhangsanfeng");
            
    }

    @Test
    public void testDeleteObject() {
        fail("Not yet implemented");
    }

    @Test
    public void testUpdateObject() {
        Tuser user=(Tuser)bdao.findById(Tuser.class, "zhangsanfeng");
        user.setNickname("太极宗师太极拳");
        System.out.println(bdao.update(user));
    }

    @Test
    public void testSelectString() {
        String hql="from Tuser where usertype =2";
        List<Tuser> list =bdao.select(hql);
        for (Tuser user : list) {
            System.out.println(user.getNickname()+" "+user.getRealname());
        }
    }

    @Test
    public void testSelectStringIntInt() {
        fail("Not yet implemented");
    }

    @Test
    public void testSelectStringObjectArray() {
        fail("Not yet implemented");
    }

    @Test
    public void testSelectStringObjectArrayIntInt() {
        fail("Not yet implemented");
    }

    @Test
    public void testSelectValueString() {
        //查询普通用户的数量
        String hql="select count(*) from Tuser where usertype =1";
        System.out.println(bdao.selectValue(hql));
    }

    @Test
    public void testSelectValueStringObjectArray() {
        //查询博主用户数量
        String hql="select count(*) from Tuser where usertype=?";
        Object[] para={2};
        System.out.println(bdao.selectValue(hql,para));
    }

    @Test
    public void testSelectPagesStringInt() {
        fail("Not yet implemented");
    }

    @Test
    public void testSelectPagesStringObjectArrayInt() {
        fail("Not yet implemented");
    }

    @Test
    public void testSelectByPageStringIntInt() {
        //按照分页查询
        String hql= "from TForumTitle where userid='zhangtao' order by titleid desc";
    List<TForumTitle> list =bdao.select(hql,2,5);
    for (TForumTitle obj : list) {
        System.out.println(obj.getTopic());
    }
    }

    @Test
    public void testSelectByPageStringObjectArrayIntInt() {
        fail("Not yet implemented");
    }

    @Test
    public void testFindById() {
        fail("Not yet implemented");
    }

    @Test
    public void testUpdateString() {
    String sql ="update T_User set nickname =' 费柏设' where userid='zhangsanfeng'";
    System.out.println(bdao.update(sql));
    }

    @Test
    public void testUpdateStringObjectArray() {
        fail("Not yet implemented");
    }

    @Test
    public void testDeleteString() {
        fail("Not yet implemented");
    }

    @Test
    public void testDeleteStringObjectArray() {
        fail("Not yet implemented");
    }

    @Test
    public void testExecuteProduceString() {
        fail("Not yet implemented");
    }

    @Test
    public void testExecuteProduceStringObjectArray() {
        fail("Not yet implemented");
    }

    @Test
    public void testExecuteBatchObjectArrayIntArray() {
        //删除对象
        TForumTitle forum =(TForumTitle)bdao.findById(TForumTitle.class, 30);
        //修改对应Tuser的文章数
        Tuser user =(Tuser)bdao.findById(Tuser.class, "zhangtao");
        user.setArticlecounter(user.getArticlecounter()-1);
        Object[] objs={forum,user};
        int[] models={bdao.DELETE,bdao.UPDATE};
        //第一个对象删除，第二个对象修改
        System.out.println(bdao.executeBatch(objs,models));
        
    }

    @Test
    public void testExecuteBatchListOfObjectListOfInteger() {
        fail("Not yet implemented");
    }

}

我对不定期给大家提供java类的编写代码，及方式，敬请期待