反射实现JDBC表单访问万能类

reflect反射机制,大家可能都很熟悉!~现在我们就来显现一个数据表单万能访问类;

承接上一篇文章,Hibernate的表单映射,我们可以看见类类型与表单的访问对应关系,我们不防来实现一下

import java.util.Collection;
import java.util.ArrayList;
import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.lang.reflect.Method;
import java.sql.SQLException;
import java.sql.Types;

public class Result {
    public Result() {
    }

    public Collection getResult(String sql, Class cls) throws Exception {
        BaseDao dao = new BaseDao();
        Collection coll = new ArrayList();
        ResultSet rs = dao.getResultSet(sql);

        try {

            Method[] method = cls.getMethods();
            Field[] field = cls.getFields(); //这里可以是xml文件对应值

            int count = rs.getMetaData().getColumnCount();
            int types[] = new int[count];
            String keys[] = new String[count];
            for (int i = 0; i < count; i++) {
                keys[i] = rs.getMetaData().getColumnName(i);
                types[i] = rs.getMetaData().getColumnType(i);
            }

            while (rs.next()) {
                Object obj = cls.newInstance();
                //通过反射得到o的所有字段!
                for (int j = 0; j < count; j++) {
                    for (int i = 0; i < method.length; i++) {
                        //if ("set".equals(method[i].getName().substring(0, 2))) {
                            //key.substring(0,1).toUpperCase();
                            if (method[i].getName().equals("set" + keys[j])) {
                                //Class[] types = method[i].getParameterTypes();
                                if (types[i] == Types.CHAR ||
                                    types[i] == Types.VARCHAR) {
                                    method[i].invoke(obj,
                                            new Object[] {rs.getString(i)});
                                }
                                if (types[i] == Types.DATE) {
                                    method[i].invoke(obj,
                                            new Object[] {rs.getDate(i)});
                                }
                                if (types[i] == Types.DOUBLE) {
                                    method[i].invoke(obj,
                                            new Object[] {Double.valueOf(i)});
                                }
                                if (types[i] == Types.FLOAT) {
                                    method[i].invoke(obj,
                                            new Object[] {Float.valueOf(i)});
                                }
                                if (types[i] == Types.BOOLEAN) {
                                    method[i].invoke(obj,
                                            new Object[] {Boolean.
                                            valueOf(rs.getBoolean(i))});
                                }
                                if (types[i] == Types.INTEGER) {
                                    method[i].invoke(obj,
                                            new Object[] {Integer.
                                            valueOf(rs.getInt(i))});
                                }
                            }
                        }
                   // }
                }
                //String value = rs.getString();
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            dao.close();
        }
        return coll;

    }
}

这样,我们可以将任何的类型放入进去,我们都可以查出相应的数据.那么我们在jsp中,如果不想声明什么表单映射的类又怎么办呢?那么我们可以用另一种方式去代替反射,虽然反射机制很好用,但是他的效率不高,所以慎用~~我们来看看另一种实现方式(万能容器):

public Collection executeQuery(String sql) {

        BaseDao dao = new BaseDao();

        Collection<Hashtable<String, Object>>
                coll = new ArrayList<Hashtable<String, Object>>();

        ResultSet rs = dao.getResultSet(sql);

        try {
            int count = rs.getMetaData().getColumnCount();
            while (rs.next()) {
                Hashtable<String, Object> hs = new Hashtable<String, Object>();
                for (int i = 0; i < count; i++) {
                    String key = rs.getMetaData().getColumnName(i);
                    int type = rs.getMetaData().getColumnType(i);
                    if (type == Types.CHAR || type == Types.VARCHAR) {
                        hs.put(key, rs.getString(i));
                    }
                    if (type == Types.DATE) {
                        hs.put(key, rs.getDate(i));
                    }
                    if (type == Types.DOUBLE) {
                        hs.put(key, rs.getDouble(i));
                    }
                    if (type == Types.FLOAT) {
                        hs.put(key, rs.getFloat(i));
                    }
                    if (type == Types.BOOLEAN) {
                        hs.put(key, rs.getBoolean(i));
                    }
                }
                coll.add(hs);
            }
        } catch (SQLException e) {
            // TODO 自动生成 catch 块
            e.printStackTrace();
        } finally {
            dao.close();
        }
        return coll;
    }

这样我们就可以实现所有的表单查找.

注意:这里我得数据类型没有给全,如有兴趣,可以来邮件,或者Q我,我可以给你们体构详细的数据库和java数据类型的对应关系文件.