为了少写几句SQL语句而奋斗

于 2006-11-11 13:55:00 发布
阅读量2.4k 收藏 1
点赞数
分类专栏： JAVA技术 文章标签： sql string hashmap import null insert
最近写代码的时候发现经常写一些很简单的SQL语句,比如对一个表的插入,更新,删除或者根据表中某几个字段查询表,下面的这个代码就是我为了帮助程序员改善这种状况想出来的,可以少写几句SQL语句.后来想其实程序员应该80%情况下都是写的这种代码.
    如果数据库结构改变,那么程序员写的这些代码还需要重写一下,最起码要找到对应的SQL再改一下,增加了程序员的工作量.
  下面的这个程序是在Mysql上面测试通过的,其他数据库如果测试有问题,请告诉我,我将会更新代码
  说说这个程序的思路
  1.在程序初始化的时候将数据库表结构,列名称,表的主键名都装入内存.
2. 发现insert语句一般来说应该分为两条语句来插入,一个是在数据库中插入主键,一个是对主键更新,以下的插入insert函数就是基于此思想来做的. 这样写还有一个好处就是可以在程序里面写的时候少写几条代码,可以将数据库数据插入和更新集成到一个更新类中实现,当然是我目前的一个想法了,大家有不同 的想法可以畅所欲言,
 下面是我写的一个insert和update的例子,仅供大家参考, 我感觉这样是代码最起码是看起来简介了不少
      if (reuqest.getParameter( " id " ) == null || reuqest.getParameter( " id " ).trim().equals( "" )) {
            reuqest.setParameter("id", //根据规则生成Id)
             try {
                this.getIbatisHandle().insert(IbatisSQL.COMM_INSERT_HOUSEINFO,request.getParameterMap());
            } catch (SQLException e) {
                
                e.printStackTrace();
            }
         }
          try {
             this.getIbatisHandle().update(IbatisSQL.COMM_UPDATE_HOUSEINFO,request.getParameterMap());
         } catch (Exception e) {
             e.printStackTrace();
         }
         
以下的代码就是具体实现,做一个说明
1.使用了common-dbuitls组件,大家如果要测试请下载此组件再测试,
2.getConnection是得到连接的方法,需要测试请替换成本机的数据库
3.例子是使用jdk1.5写成的,里面有用stringbuilder,范性等,测试时请将编译器设置为jdk1.5
4. 共五个对外被调用的方法,update,delete,insert,selectList和selectMap,第一个参数是需要更新的表的名字,第二 个参数Map里面key是需要更新的列的名字,value是准备更新的列的值,除insert外,主键和对应的值将放入where中,不予更新(主要考虑 是既然是主键,除了删除,是不能更新的,所以就放入到where中)
5.selectList语句,map参数如果为空,返回对应表所有记录
6.selectMap语句,map参数如果为空,返回对应表第一条记录
7.update只支持根据主键更新
8.实现了只取数据表在Map中对应的值,Map中的其他值将自动过滤掉.


import  java.sql.Connection;
 import  java.sql.DatabaseMetaData;
 import  java.sql.DriverManager;
 import  java.sql.ResultSet;
 import  java.sql.SQLException;
 import  java.util.ArrayList;

 import  java.util.HashMap;
 import  java.util.List;
 import  java.util.Map;
 import  java.util.Set;
 import  java.util.Vector;

 import  org.apache.commons.dbutils.QueryRunner;
 import  org.apache.commons.dbutils.handlers.MapHandler;
 import  org.apache.commons.dbutils.handlers.MapListHandler;

 public   class  DbUtil  {

    private static Map<String, Set> PrimaryKeysMap = new HashMap<String, Set>();

    private static Map<String, Set> ColumnsMap = new HashMap<String, Set>();

    public static void insertOnlyIds(String tablename,
            java.util.Map<String, String> map) {
        if (map == null) {
            map = new HashMap<String, String>();
        }
        StringBuilder builder = new StringBuilder();
        builder.append(" insert into ").append(tablename).append(" (");

        StringBuilder end = new StringBuilder(" (");
        List<String> lparam = new ArrayList<String>();

        java.util.Set set = PrimaryKeysMap.get(tablename.toUpperCase());

        int primarykeys = 0;
        for (Map.Entry<String, String> entry : map.entrySet()) {
            // 判断是否需要插入的数据
            if (!set.contains(entry.getKey().toUpperCase())) {
                continue;
            }
            primarykeys++;
            lparam.add(entry.getValue());

            builder.append(entry.getKey());
            end.append(entry.getValue());

            builder.append(",");
            end.append(",");

        }
        if (primarykeys != set.size()) {
            throw new java.lang.RuntimeException("主键不够,不能赋值");
        }
        builder.deleteCharAt(builder.length() - 1);
        end.deleteCharAt(end.length() - 1);
        builder.append(")");
        end.append(")");
        builder.append(" value ").append(end);
        try {
            System.err.println(builder);

            // getSqlHandle().update(builder.toString(), lparam.toArray());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void updateById(String tablename,
            java.util.Map<String, String> map) {
        if (map == null) {
            map = new HashMap<String, String>();
        }
        StringBuilder builder = new StringBuilder();
        List lparam = new ArrayList();
        builder.append(" update ").append(tablename).append(" set ");
        java.util.Set primarykeyset = PrimaryKeysMap.get(tablename
                .toUpperCase());
        java.util.Set columnset = ColumnsMap.get(tablename.toUpperCase());
        StringBuilder end = new StringBuilder(" where ");
        int primarykeys = 0;

        for (Map.Entry<String, String> entry : map.entrySet()) {
            // 判断是否需要插入的数据
            if (!columnset.contains(entry.getKey().toUpperCase())) {
                continue;
            }

            if (primarykeyset.contains(entry.getKey().toUpperCase())) {
                end.append("  ").append(entry.getKey()).append(" = ?  and");
                primarykeys++;
            } else {
                builder.append("  ").append(entry.getKey()).append(" = ?,");

            }
            lparam.add(entry.getValue());
        }

        if (primarykeys != primarykeyset.size()) {
            throw new java.lang.RuntimeException("主键不够,不能赋值");
        }

        end.delete(end.length() - 3, end.length());
        builder.deleteCharAt(builder.length() - 1);
        System.err.println(builder.append(end));
        try{
            QueryRunner runner=new QueryRunner();
            runner.update(builder.toString(),lparam.toArray());
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static void deletesql(String tablename, Map<String, String> params) {
        if (params == null) {
            params = new HashMap<String, String>();
        }
        StringBuilder builder = new StringBuilder();
        builder.append("delete from ").append(tablename.toUpperCase());
        builder.append(" where ");
        Set columnset = ColumnsMap.get(tablename);
        List l = new ArrayList();
        for (Map.Entry<String, String> entry : params.entrySet()) {

            if (!columnset.contains(entry.getKey().toUpperCase())) {
                continue;
            }

            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        builder.delete(builder.length() - 4, builder.length());
        try {
            QueryRunner runner = new QueryRunner();
            runner.update(builder.toString(),l.toArray());
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.err.println(builder);
    }
    public static Map selectMap(String tablename,Map<String,String> params){
        if (params == null) {
            params = new HashMap<String, String>();
        }

        StringBuilder builder = new StringBuilder();
        builder.append("select * from ").append(tablename).append("  where");
        Set columnset = ColumnsMap.get(tablename.toUpperCase());
        List l = new ArrayList();

        boolean hasparam = false;
        for (Map.Entry<String, String> entry : params.entrySet()) {

            if (!columnset.contains(entry.getKey().toUpperCase())) {
                continue;
            }
            hasparam = true;
            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        if (hasparam) {

            builder.delete(builder.length() - 4, builder.length());
        } else {
            builder.delete(builder.length() - 5, builder.length());
        }

        System.err.println(builder);
        try {
             
            
            QueryRunner runner = new QueryRunner();
            Object o = runner.query(getConnection(), builder.toString(), l
                    .toArray(), new MapHandler());
            return (Map)o;
             
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
        
    }
    public static List selectList(String tablename, Map<String, String> params) {

        if (params == null) {
            params = new HashMap<String, String>();
        }

        StringBuilder builder = new StringBuilder();
        builder.append("select * from ").append(tablename).append("  where");
        Set columnset = ColumnsMap.get(tablename.toUpperCase());
        List l = new ArrayList();

        boolean hasparam = false;
        for (Map.Entry<String, String> entry : params.entrySet()) {

            if (!columnset.contains(entry.getKey().toUpperCase())) {
                continue;
            }
            hasparam = true;
            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        if (hasparam) {

            builder.delete(builder.length() - 4, builder.length());
        } else {
            builder.delete(builder.length() - 5, builder.length());
        }

        System.err.println(builder);
        try {
             
            QueryRunner runner = new QueryRunner();
            Object o = runner.query(getConnection(), builder.toString(), l
                    .toArray(), new MapListHandler());
            return (List)o;
         
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Set getPrimaryKeys(java.sql.Connection conn, String schema,
            String table) throws Exception {
        ResultSet set = conn.getMetaData().getPrimaryKeys("", schema, table);
        java.util.Set<String> hashset = new java.util.HashSet<String>();

        while (set.next()) {

            hashset.add(set.getString("COLUMN_NAME").toUpperCase());

        }
        set.close();
        return hashset;
    }

    /**
     * 从数据库中取表结构
     * 
     * @return
     */
    public static Connection getConnection() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection conn = DriverManager
                    .getConnection(
                            "jdbc:mysql://localhost/mydb?user=root&password=111111&characterEncoding=gbk",
                            "root", "111111");
            return conn;
            // Connection conn=IbatisSQL.getSqlHandle().getCurrentConnection();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        Map map = new HashMap();
        // map.put("name", "dddd");
        // map.put("hoteldesc", "ddddddddddddddddddddddddddddd");
        // System.err.println(map.values().getClass());
        // map.put("loginid", "aaaaa");
        // update("USERINFO",map);
        // insertOnlyIds("USERINFO",map);
        System.err.println(selectMap("viewjsplog", map));

        // }
        for (Object o : PrimaryKeysMap.entrySet()) {
            System.err.println(o);
        }
    }

    static {
        try {
            java.sql.Connection conn = getConnection();
            List v = listTables(conn, null, "TABLE");
            for (int i = 0; i < v.size(); i++) {
                Set set = getPrimaryKeys(conn, null, v.get(i).toString());
                PrimaryKeysMap.put(((String) v.get(i)).toUpperCase(), set);
                Set set2 = listColumns(conn, null, "TABLE", v.get(i).toString());
                ColumnsMap.put(((String) v.get(i)).toUpperCase(), set2);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.err.println(PrimaryKeysMap);
        System.err.println(ColumnsMap);
    }

    public static Set listColumns(java.sql.Connection conn, String schema,
            String type, String table) throws Exception {
        java.util.Set<String> hashset = new java.util.HashSet<String>();

        ResultSet set = conn.getMetaData().getColumns("", schema, null, null);
        while (set.next()) {
            hashset.add(set.getString("COLUMN_NAME").toUpperCase());

        }
        set.close();
        return hashset;
    }

    public static List listTables(java.sql.Connection conn, String schema,
            String type) {
        List<String> retVal = new ArrayList<String>();
        try {
            DatabaseMetaData meta = conn.getMetaData();
            ResultSet set = meta.getTableTypes();
            int columnCount = set.getMetaData().getColumnCount();

            set = meta.getTables("", schema, null, null);
            while (set.next()) {
                String name = set.getString("TABLE_NAME");
                String tableType = set.getString("TABLE_TYPE");
                // System.out.println(name + ":" + tableType);
                if (tableType.equals(type)) {
                    retVal.add(name);
                }
            }
            set.close();
        } catch (SQLException e) {
            e.printStackTrace();

        }
        return retVal;
    }

}
 
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值