反射应用

package com.venushalo.dao;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.letben.tag.PageBean;
import com.venushalo.util.JDBCTemplate;
/**
 * v 1.0 有三个 查询方法，查询所有用户，根据id查询一个 用户，根据用户名和密码 查询一个用户
 * v 2.0 增加了 增删改三个 方法
 * v 3.0 不断做了各种修改，忘记都做了什么了
 * v 4.0 就算目前这个 版本吧。
 * v 5.0 jdbc模板里面，不能关闭资源，要在 这里面关闭。
 * v 5.1 真实关闭资源。
 * v 5.2 得到 表中元组数量判定是否是 子表。
 * v 5.21 修复了一个小bug。分页查询结果为零时，返回1避免报错。//事实上这个 bug应该由分页来实现，并且也已经实现了
 * 
 * javaBean名：User.
 * @author Letben 
 * TaughtBy Salmon
 *
 */
public class BaseDao {
    /*
     * 得到列表，查询某一个id都是十分必要的。
     * 可以做login的，
     * id的，
     * allObject全部列表的。
     * 修改的话，就aoe修改。
     * 删除做一个@deprecated。表示不建议使用。
     * insert？
     * 
     * 用就用，不用就放里面，他只是一个方法。
     * 
     * */
    protected JDBCTemplate jt;
    /**
     * 构造方法，得到JDBC模板
     */
    public BaseDao(){
        jt = new JDBCTemplate();
    }
    /**
     * 没有实现
     * 因为不建议删除所以我们这样写了一句话，以强调，你确定要删除，但是我们仍然允许使用。
     * 最好提供一个重载，利用id
     * TODO
     * @param object
     * @return
     */
    @Deprecated
    public boolean deleteItem(Object object){
        return false;
    }
    /**
     * sql = "delete from c对应的表 where idInTable=id";
     * sql = "delete from user_tb where user_id=1";
     * 可是这样都不知道从哪个表里面删，还需要传一个Class
     * 因为不建议删除所以我们这样写了一句话，以强调，你确定要删除，但是我们仍然允许使用。
     * @param id
     * @return
     */
    @Deprecated
    public boolean deleteItem(Class c,String id,String primaryIdInTable){
        
        //sql = "delete from user_tb where user_id=?";
        String tableName = getTableName(c);
        String sql = "delete from "+tableName+" where "+primaryIdInTable+"=?";
        List params = new ArrayList();
        params.add(id);
        System.out.println(sql.toString());
        boolean flag = jt.updateData(sql, params);
        jt.closeRes();
        return flag;
    }
    /**
     * 更新一个对象，只要传入一个对象。这是 那个 有bug的方法啊！！！，如果 id不重复的话 这样修改 是可以的。
     * 消除了外键关键字的bug。
     * 并未考虑到如果当前对象不存在的情况。
     * @param object
     * @return
     */
    public boolean updateItem(Object object){//传一个对象，就能够修改对象的值，当然前提是，这个对象是完整的。
        
        //update user_tb set user_name=?,user_password=?,user_type=?,user_age=?,user_address where user_id=?
        //看来需要修改addItem里面的方法了。因为感觉这个不能，在用list一个一个添加了。  试试看
        StringBuffer sql = new StringBuffer("update ");
        Class c = object.getClass();
        String tableName = getTableName(c);
        sql.append(tableName+" set ");//update user_tb set 
        //拼出来需要属性，这样的话就得拿到 数据库中的列名，也就是对应bean中的 属性名。
        Method[] methods = c.getMethods();
        List fieldNames = new ArrayList();
        List fieldValues = new ArrayList();
        for (Method method : methods) {
            String methodName = method.getName();
            if(methodName.startsWith("get")&&!methodName.equalsIgnoreCase("getclass")){//从object属性里面取得值。不过是用get好还是 set好？针对于修改来讲，我认为是set好，因为那个getAllPrice()方法,allPrice并非是一个可以被设置的值。一定要取到可以被设置的方法。
                String fieldName = methodName.substring(3);//属性名
                fieldNames.add(fieldName);
                try {
                    fieldValues.add(method.invoke(object, new Object[]{}));//不过，还是有bug那就只能不允许getAllPrice()的出现或者 自定义标签来实现，后面慢慢再想办法。
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
        String fieldId = null;
        String fieldIdValue = null;
        int commaCount=0;
        int fieldCount = fieldNames.size();
        for(int i=0;i<fieldCount;i++){
            {    
                // 拼接字符串方法一。
                //这个在不同的版本里面这个 计数的方式 不一样！！！，不是不一样因为读取的顺序是随机的
                //所以有时候就读到了带id的方法，有时候没有读到，结果是，有时候就多一个 有时候就少一个。
                if(!fieldNames.get(i).toString().contains("id")&&i<fieldNames.size()-2){//如果该字段不包含id,前面的字段，加","
                    sql.append(fieldNames.get(i)+"=‘"+fieldValues.get(i)+"‘,");
                }else if(!fieldNames.get(i).toString().contains("id")&&i==fieldNames.size()-2){//最后一个要被修改的字段
                    sql.append(fieldNames.get(i)+"=‘"+fieldValues.get(i)+"‘");
                }else{
                    //sql.append(" where "+fieldNames.get(i)+"=‘"+fieldValues.get(i)+"‘");
                    //update user_tb set  where User_id=‘1‘User_name=‘lifei‘,User_type=‘1‘,User_age=‘23‘,User_address=‘北京‘,User_password=‘111111‘
                    fieldId=fieldNames.get(i).toString();
                    fieldIdValue = fieldValues.get(i).toString();
                    //本来在下面想再遍历一次的，但是觉得这样的话，代价稍微小一点。减轻了一次遍历。
                }
                /*update user_tb set User_address=‘北京‘,User_password=‘111111‘, where User_id=‘1‘User_type=‘1‘,User_name=‘lifei‘ where User_age=‘23‘
                如果直接上面那种写法不稳定
                update user_tb set User_address=‘北京‘,User_password=‘111111‘,User_type=‘1‘,User_name=‘lifei‘,User_age=‘23‘*/
                
            }
            //上面的方法不稳定，换一个可行的方法，这个 不靠谱的概率太大了。
            /*{//拼接字符串方法二
                //终于知道为啥了！！！这里面有一个 posi_id这个 id是一个bug。所以 有必要传一个idInTable
                if(!fieldNames.get(i).toString().equalsIgnoreCase(idInTable)){//不包含id就说明是普通的要被更改的属性。
                    sql.append(fieldNames.get(i)+"=‘"+fieldValues.get(i)+"‘");
                        if(commaCount<fieldCount-2){
                            //System.out.println("commaCount:"+commaCount+"  fieldCount: "+fieldCount);
                            sql.append(",");
                            //System.out.println(sql.toString());
                            commaCount++;
                        }
                    
                }else{
                    fieldId=fieldNames.get(i).toString();
                    fieldIdValue = fieldValues.get(i).toString();
                }
            }*/
        }
        sql.append(" where "+fieldId+"=‘"+fieldIdValue+"‘");
        //稳定了
        String string = sql.toString();
        System.out.println(string);
        boolean flag = jt.updateData(string, null);
        jt.closeRes();
        return flag;
    }
    
    /**
     * 更新一个对象，只要传入一个对象。
     * 消除了外键关键字的bug。
     * 一定要使用这个 方法！！！！！！！！！！！！！！
     * 并未考虑到如果当前对象不存在的情况。
     * @param object
     * @return
     */
    public boolean updateItem(Object object,String primaryIdInTable){//传一个对象，就能够修改对象的值，当然前提是，这个对象是完整的。
        
        //update user_tb set user_name=?,user_password=?,user_type=?,user_age=?,user_address where user_id=?
        //看来需要修改addItem里面的方法了。因为感觉这个不能，在用list一个一个添加了。  试试看
        StringBuffer sql = new StringBuffer("update ");
        Class c = object.getClass();
        String tableName = getTableName(c);
        sql.append(tableName+" set ");//update user_tb set 
        //拼出来需要属性，这样的话就得拿到 数据库中的列名，也就是对应bean中的 属性名。
        Method[] methods = c.getMethods();
        List fieldNames = new ArrayList();
        List fieldValues = new ArrayList();
        for (Method method : methods) {
            String methodName = method.getName();
            if(methodName.startsWith("get")&&!methodName.equalsIgnoreCase("getclass")){//从object属性里面取得值。不过是用get好还是 set好？针对于修改来讲，我认为是set好，因为那个getAllPrice()方法,allPrice并非是一个可以被设置的值。一定要取到可以被设置的方法。
                String fieldName = methodName.substring(3);//属性名
                fieldNames.add(fieldName);
                try {
                    fieldValues.add(method.invoke(object, new Object[]{}));//不过，还是有bug那就只能不允许getAllPrice()的出现或者 自定义标签来实现，后面慢慢再想办法。
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
        String fieldId = null;
        String fieldIdValue = null;
        int commaCount=0;
        int fieldCount = fieldNames.size();
        for(int i=0;i<fieldCount;i++){
            /*{    
                // 拼接字符串方法一。
                //这个在不同的版本里面这个 计数的方式 不一样！！！，不是不一样因为读取的顺序是随机的
                //所以有时候就读到了带id的方法，有时候没有读到，结果是，有时候就多一个 有时候就少一个。
                if(!fieldNames.get(i).toString().contains("id")&&i<fieldNames.size()-2){//如果该字段不包含id,前面的字段，加","
                    sql.append(fieldNames.get(i)+"=‘"+fieldValues.get(i)+"‘,");
                }else if(!fieldNames.get(i).toString().contains("id")&&i==fieldNames.size()-2){//最后一个要被修改的字段
                    sql.append(fieldNames.get(i)+"=‘"+fieldValues.get(i)+"‘");
                }else{
                    //sql.append(" where "+fieldNames.get(i)+"=‘"+fieldValues.get(i)+"‘");
                    //update user_tb set  where User_id=‘1‘User_name=‘lifei‘,User_type=‘1‘,User_age=‘23‘,User_address=‘北京‘,User_password=‘111111‘
                    fieldId=fieldNames.get(i).toString();
                    fieldIdValue = fieldValues.get(i).toString();
                    //本来在下面想再遍历一次的，但是觉得这样的话，代价稍微小一点。减轻了一次遍历。
                }
                update user_tb set User_address=‘北京‘,User_password=‘111111‘, where User_id=‘1‘User_type=‘1‘,User_name=‘lifei‘ where User_age=‘23‘
                如果直接上面那种写法不稳定
                update user_tb set User_address=‘北京‘,User_password=‘111111‘,User_type=‘1‘,User_name=‘lifei‘,User_age=‘23‘
                
            }*/
            //上面的方法不稳定，换一个可行的方法，这个 不靠谱的概率太大了。
            {//拼接字符串方法二
                //终于知道为啥了！！！这里面有一个 posi_id这个 id是一个bug。所以 有必要传一个idInTable
                if(!fieldNames.get(i).toString().equalsIgnoreCase(primaryIdInTable)){//不包含id就说明是普通的要被更改的属性。
                    sql.append(fieldNames.get(i)+"=‘"+fieldValues.get(i)+"‘");
                        if(commaCount<fieldCount-2){
                            //System.out.println("commaCount:"+commaCount+"  fieldCount: "+fieldCount);
                            sql.append(",");
                            //System.out.println(sql.toString());
                            commaCount++;
                        }
                    
                }else{
                    fieldId=fieldNames.get(i).toString();
                    fieldIdValue = fieldValues.get(i).toString();
                }
            }
        }
        sql.append(" where "+fieldId+"=‘"+fieldIdValue+"‘");
        //稳定了
        String string = sql.toString();
        //System.out.println(string);
        boolean flag = jt.updateData(string, null);
        jt.closeRes();
        return flag;
    }
    /**
     * 向数据库中添加一个对象。添加对象的时候id一定要重新获取对嘛？对的！
     * @param object
     * @return
     */
    public boolean addItem(Object object){
        
        
        Class c = object.getClass();
        /*String className = c.getName();
        String tableName = className.substring(className.lastIndexOf(".")+1);*/
        String tableName = getTableName(object.getClass());
        //insert into user_tb () values ();
        StringBuffer sql = new StringBuffer("insert into ");//后置空格
        sql.append(tableName+" ");
        List fieldsNames =new ArrayList();
        List fieldsValues = new ArrayList();
        //对应添加值
        Method[] methods = c.getMethods();
        for (Method method : methods) {
            String methodName = method.getName();
            if(methodName.startsWith("get")&&!methodName.equalsIgnoreCase("getClass")){
                String fieldName = methodName.substring(3);
                fieldsNames.add(fieldName);
                try {
                fieldsValues.add(method.invoke(object, new Object[]{}));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
        //组拼
        sql.append("(");
        //value
        for(int i=0;i<fieldsNames.size();i++){//前面这里还不能加"‘"
            if(i==fieldsNames.size()-1){
                sql.append(fieldsNames.get(i));
            }else{
                sql.append(fieldsNames.get(i)+",");
            }
        }
        sql.append(")");
        sql.append(" values ");
        sql.append("(");
        for(int i=0;i<fieldsValues.size();i++){//这里记得加"‘"
            //Unknown column ‘北京‘ in ‘field list‘
            //sql:insert into user_tb (User_address,User_password,User_id,User_name,User_type,User_age) values (北京,111111,3,shenxiuhua,1,23)
            //这是一个多正常的语句。看都不知道哪里出了问题。所以不管怎么样，一定要让这句话首先在数据库里面跑一遍，如果能跑说明没有问题。
            if(i==fieldsNames.size()-1){
                sql.append("‘"+fieldsValues.get(i)+"‘");
            }else {
                sql.append("‘"+fieldsValues.get(i)+"‘,");
            }
            
        }
        /*
         *TODO
         * 这种方式是行得通的，上面获得参数个数，然后每添加一个，就计数+1，然后拼对应数量的"?",上面这种方式，也是可取的。 
        List params = new ArrayList(); 
        for (Object fieldValue : fieldsValues) {
            params.add(fieldValue);
        }*/
        sql.append(")");
        String sqlString = sql.toString();
        System.out.println(sqlString);
        boolean flag = jt.updateData(sqlString, null);
        jt.closeRes();
        return flag;
    }
    
    /**
     * 再添加新用户的时候，得到 这个对象应该得到的id。
     * @param object 
     */
    protected int getObjectId(Object object,String primaryIdInTable) {
        Class c = object.getClass();
        String tableName = getTableName(c);
        String sql = "select max("+primaryIdInTable+") from "+tableName;
        System.out.println(sql);
        ResultSet resultSet = jt.query(sql, null);
        int lastId = 1;
        try {
            if(resultSet.next()){
                lastId = resultSet.getInt(1);
            }
        } catch (SQLException e) {
            System.out.println("获得 当前表最后一个对象的id时 出现异常");
            e.printStackTrace();
        }finally{
            jt.closeRes();
        }
        return lastId+1;
    }
    
    /**
     * 通过 用户名和密码得到对象
     * sql = "select * from "+tableName+" where "+nameInTable+"=? and "+passwordInTable+"=?";
     * sql = "select * from user_tb where user_name=? and user_password=?";
     * 
     * @param c 对应的 javaBean的名字
     * @param name 用户名
     * @param password 密码
     * @param nameInTable 对应数据库表中name的字段名称
     * @param passwordInTable 对应数据库表中password的字段名称
     * @return
     */
    public Object loginByNAP(Class c,String name,String password,String nameInTable,String passwordInTable){
        String tableName = getTableName(c);
        String sql = "select * from "+tableName+" where "+nameInTable+"=? and "+passwordInTable+"=?";
        //System.out.println(sql);
        List params = new ArrayList();
        params.add(name);
        params.add(password);
        ResultSet resultSet = jt.query(sql, params);
        Object object = null;
        try {
            if(resultSet.next()){
                    object = setValueForObject(object, c, resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        jt.closeRes();
        return object;
    }
    
    /**
     * 通过一个 字符串形式表现的 表，得到  对应 类  对象的所有信息。 
     * @param string
     * @param c
     * @return
     */
    public List getAllObjectsInfoByClass(String string, Class c){
        
        ResultSet resultSet = jt.query(string, null);
        List list = new ArrayList();//被返回的对象。
        Object object = null;//得到的每一个对象存储在这里。
        try {
            //得到该类的对象，并给该类的对象赋值。
            while(resultSet.next()){//如果查到一条结果,报出sql异常
                object = setValueForObject(object, c, resultSet);
                list.add(object);
                object= null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            jt.closeRes();
        }
        return list;
    }
    /**
     * 得到数据库中的所有元素
     * @param c
     * @return
     */
    public List getAllObjects(Class c){
        String tableName = getTableName(c);
        String sql="select * from "+tableName;
//        List params = new ArrayList();
//        params.add(tableName);
        //无论怎么样都要用预状态通道，因为安全性更高(能够防止sql注入)，执行效率更高。
        ResultSet resultSet = jt.query(sql, null);
        List list = new ArrayList();//被返回的对象。
        Object object = null;//得到的每一个对象存储在这里。
        try {
            //得到该类的对象，并给该类的对象赋值。
            while(resultSet.next()){//如果查到一条结果,报出sql异常
                object = setValueForObject(object, c, resultSet);
                list.add(object);
                object= null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            jt.closeRes();
        }
        return list;
    }
    
    public List getAllObjects(Class c,String whereClause){
        String tableName = getTableName(c);
        String sql="select * from "+tableName+" "+whereClause;
//        List params = new ArrayList();
//        params.add(tableName);
        //无论怎么样都要用预状态通道，因为安全性更高(能够防止sql注入)，执行效率更高。
        ResultSet resultSet = jt.query(sql, null);
        List list = new ArrayList();//被返回的对象。
        Object object = null;//得到的每一个对象存储在这里。
        try {
            //得到该类的对象，并给该类的对象赋值。
            while(resultSet.next()){//如果查到一条结果,报出sql异常
                object = setValueForObject(object, c, resultSet);
                list.add(object);
                object= null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            jt.closeRes();
        }
        return list;
    }
    /**
     * 通过id查找到对应用户，
     * sql ="select * from "+tableName+" where "+idInTable+"=?";
     * sql ="select * from user_tb where user_id=?";
     * @param c javaBean.class
     * @param id  要被查找的id
     * @param idInTable 在数据库表中id对应的名字。
     * @return
     */
    public Object getObjectById(Class c,String id,String primaryIdInTable){
        String tableName = getTableName(c);
        String sql ="select * from "+tableName+" where "+primaryIdInTable+"=?";
        List params = new ArrayList();
        params.add(id);
        ResultSet resultSet = jt.query(sql, params);
        Object object = null;
        try {
            if(resultSet.next()){
                //为属性添加值
                object = setValueForObject(object, c, resultSet);
            }else{
                System.out.println("该记录不存在");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            jt.closeRes();
        }
        return object;
    }
    
    /**
     * 根据类型名获得表名，私有方法不对外暴露
     * @param c
     * @return
     */
    private String getTableName(Class c) {
        String tableName=null;
        //这个名称转换做一个私有的函数。给如一个类名，给出一个表名
        String className = c.getName();
        //先实现，在优化！写多了自然优化了
        //先考虑一个单词的情况，切词技术~还更麻烦
        //System.out.println("类全名，大概是一个：com.letben.bean.User 的形式："+className);
        //字符串儿这里的操作大都是包含头的不包含尾的操作，所以取得最后一个“.”的位置后，+1，就能渠道对应的javaBean的名字。
        String beanName = className.substring(className.lastIndexOf(".")+1);//User
        //全部变小写
        beanName = beanName.toLowerCase();//user
        //字符串儿拼接
        tableName = beanName+"_tb";//user_tb
        return tableName;
    } 
    
    
    /**
     * 内部方法，用来实现对象参数的设置。
     * @param object
     * @param c
     * @param resultSet
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     * @throws SQLException
     */
    private Object setValueForObject(Object object,Class c,ResultSet resultSet) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, SQLException {
        //就新建一个c类对象的实例
        object= c.newInstance();//初始化异常，非法权限异常
        //注意体会c.getDeclaredMethods();与c.getMethods();的区别。
        Method[] methods = c.getMethods();//得到所有public的方法。
        for (Method method : methods) {//遍历所有方法
            String methodName = method.getName();//得到当前遍历的方法的名字
            if(methodName.startsWith("set")){//如果方法是以set开头的。说明这个类的对象在初始化时需要这么一个对象的设置
                //这里跟取值那个地方有点儿不同，在取值的时候注意排除，getClass的方法
                //记不记得后面有通过反射，拿到根本不需要设置的属性的名比如allPrice，我们只是写了一个getAllPrice的方法。
                //后面跟的必然是属性名:
                String fieldName = methodName.substring(3);//把前面3个截掉。
                Class[] parameterTypes = method.getParameterTypes();//得到当前方法，所需参数的名字们。
//                System.out.println(methodName);
                if(parameterTypes[0] == String.class){
                    method.invoke(object, new Object[]{resultSet.getString(fieldName)});//会报非法参数异常和调用目标异常
                    /*String s =null;
                    s="";
                    System.out.println(s.getClass());
                    System.out.println(String.class);
                    这两个结果是一致的。
                    */
                }else if(parameterTypes[0]==int.class){//注意int.class!=Integer.class
                    //int.class         ->        int
                    //Integer.class     ->        class java.lang.Integer
                    method.invoke(object, new Object[]{resultSet.getInt(fieldName)});
                }else if(parameterTypes[0]==double.class){
                    method.invoke(object, new Object[]{resultSet.getDouble(fieldName)});
                }else{
                    System.out.println("还有属性没有考虑到。属性名称为：   "+method.getName()+"   。参数类型为：   "+parameterTypes[0]);
                }
            }
        }//for完一圈儿，说明对象已经完整赋过值了
        return object;
        /*
         * 
        简体版
        object = c.newInstance();//初始化异常，非法权限异常
                    //接下来就是对应赋值
                    //跟c.getDeclaredMethods()的区别？
                    Method[] methods = c.getMethods();
                    for (Method method : methods) {
                        String methodName = method.getName();
                        if(methodName.startsWith("set")){
                            String fieldName = methodName.substring(3);
                            Class[] parameterTypes = method.getParameterTypes();//我们的get就都只有一个参数
                            if(parameterTypes[0]==String.class){
                                method.invoke(object, new Object[]{resultSet.getString(fieldName)});
                            }else if(parameterTypes[0]==int.class){
                                method.invoke(object, new Object[]{resultSet.getInt(fieldName)});
                            }else{
                                System.out.println("未考虑到的属性");
                            }
                        }
                    }
         */
    }
    
    /**
     * 为了逻辑删除后面加一个 whereClause,也可以传 null
     * 单表传递类名，得到数量。
     * @param c
     * @param whereClause
     * @return
     */
    public int getAllObjectsCount(Class c,String whereClause) {
        String tableName = getTableName(c);
        String sql=null;
        if(whereClause==null){
            sql = "select count(*) from "+tableName;
        }else {
            sql = "select count(*) from "+tableName+" "+whereClause;
        }
        System.out.println(sql);
        ResultSet resultSet = jt.query(sql, null);
        int count = 0;
        try {
            if(resultSet.next()){
                count = resultSet.getInt(1);
            }
        } catch (SQLException e) {
            System.out.println("查询所有元组数量时，出现异常");
            e.printStackTrace();
        }finally{
            jt.closeRes();
        }
        return count;
    }
    
    
    /**
     * 多表查询元组总数量。
     * @param childTableName
     * @param whereClause
     * @param isChildTable
     * @return
     */
    public int getAllObjectsCount(String childTableName,String whereClause,boolean isChildTable) {
        String sql =null;
        if(isChildTable){
            sql = "select count(*) from ("+childTableName+") alias "+whereClause;
        }else {
            sql = "select count(*) from "+childTableName+" "+whereClause;
        }
        System.out.println(sql);
        ResultSet resultSet = jt.query(sql, null);
        int count = 0;
        try {
            if(resultSet.next()){
                count = resultSet.getInt(1);
            }
        } catch (SQLException e) {
            System.out.println("查询所有元组数量时，出现异常");
            e.printStackTrace();
        }finally{
            jt.closeRes();
        }
        return count;
    }
    
    /** 
     * 分页得到条目信息。 select alias.* from ( "+childTableName+" ) alias limit 0,3
     * @param childTableName  子表
     * @param c    子表对应的javabean
     * @param pageBean 分页情况
     * @param isChildName 是否是子表
     * @return
     */
    public List getAllInfosByPage(String childTableName,
            Class c, PageBean pageBean,boolean isChildTable) {
        String sql=null;
        if(isChildTable){
            sql = "select alias.* from ( "+childTableName+" ) alias limit "+(pageBean.getCurrentPage()-1)*pageBean.getPageSize()+" ,"+pageBean.getPageSize()+" ";
        }else{
            sql = "select alias.* from  "+childTableName+"  alias limit "+(pageBean.getCurrentPage()-1)*pageBean.getPageSize()+" ,"+pageBean.getPageSize()+" ";
        }
        System.out.println(sql);
        ResultSet resultSet = jt.query(sql, null);
        Object object=null;
        try {
            object = c.newInstance();
        } catch (InstantiationException | IllegalAccessException e1) {
            System.out.println("分页查询时 创建对象出现异常");
            e1.printStackTrace();
        }
        List objects = new ArrayList();
        try {
            while(resultSet.next()){
                object = setValueForObject(object, c, resultSet);
                objects.add(object);
                object = null;    
            }
        } catch (Exception e) {
            System.out.println("分页获取信息时 出现异常");
            e.printStackTrace();
        }finally{
            jt.closeRes();
        }
        return objects;
    }
}