对sql的查询语句做成对象式,简单实现。查询参数实现一

这里我就不想多说应该能看懂代码的都应该知道什么意思了。

这个类暂时应该就是这样子了。

package net.zz.zjf.plugin;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * Created by ZaoSheng on 2015/7/15.
 */
public class QueryParams {
    private Integer pageIndex = 1;
    private Integer pageSize = 10;
    private List<String> groups = new ArrayList<String>();
    private Map<String, Object> likes = new HashMap<String, Object>();
    private Map<String, Object> orders = new HashMap<String, Object>();
    private Map<String, List<String>> ins = new HashMap<String, List<String>>();
    protected String sql = " where 1=1 ";
    private Map<String, Object> value = new HashMap<String, Object>();
    private List<Object> paras = new ArrayList<Object>();
//    private Map<String, List<Object>> mutValues = new HashMap<String, List<Object>>();
    public void addOrder(String key, OrderAD ad) {
        orders.put(key, ad.name());
    }
    public void addOrder(String key) {
        orders.put(key, OrderAD.DESC.name());
    }
    public enum OrderAD {
        DESC, ASC
    }
    public Map<String, Object> getSqlLikes() {
        return likes;
    }
    public QueryParams addGroup(String group) {
        this.groups.add(group);
        return this;
    }
    public QueryParams addIn(String propertyName, List<String> values) {
        if (null != values && values.size() > 0) {
            ins.put(propertyName, values);
        }
        return this;
    }
    public Map<String, Object> getLikes() {
        return likes;
    }
    public Map<String, List<String>> getIns() {
        return ins;
    }
    public List<Object> getParas() {
        return paras;
    }
    public QueryParams like(String propertyName, String value, MatchMode matchMode) {
        this.likes.put(propertyName, matchMode.toMatchString(value));
        return this;
    }
    public QueryParams like(String propertyName, String value) {
        like(propertyName, value, MatchMode.ANYWHERE);
        return this;
    }
    public List<String> getGroups() {
        return groups;
    }
    private String prefix(String prefix) {
        if (prefix != null && !"".equals(prefix.trim())) {
            return prefix += ".";
        }
        return "m.";
    }
    public String toGroupSQL(String prefix) {
        prefix = prefix(prefix);
        if (groups != null && groups.size() >= 1) {
            StringBuilder g = new StringBuilder();
            for (String group : groups) {
                g.append(prefix).append(group).append(", ");
            }
            g.deleteCharAt(g.length() - 2);
            return String.format(" GROUP BY %s ", g.toString());
        }
        return "";
    }
    public String toLikeSQL(String prefix) {
        prefix = prefix(prefix);
        if (likes != null && !likes.isEmpty()) {
            StringBuilder g = new StringBuilder();
            for (String like : likes.keySet()) {
                String _sql = " and  %s%s like :%s ";
                g.append(String.format(_sql, prefix, like, like));
            }
            return g.toString();
        }
        return "";
    }
    public String toInSQL(String prefix) {
        prefix = prefix(prefix);
        if (ins != null && !ins.isEmpty()) {
            StringBuilder g = new StringBuilder();
            for (String in : ins.keySet()) {
                String _sql = " and  %s%s in( :%s )";
                g.append(String.format(_sql, prefix, in, in));
            }
            return g.toString();
        }
        return "";
    }
    public Integer getPageIndex() {
        return pageIndex;
    }
    public void setPageIndex(Integer pageIndex) {
        this.pageIndex = pageIndex;
    }
    public Integer getPageSize() {
        return pageSize;
    }
    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }
    public QueryParams add(String key, Object _value) {
        if (_value == null) {
            value.remove(key);
        } else {
            value.put(key, _value);
        }
        return this;
    }
    public Map<String, Object> getSqlValue() {
        return value;
    }
    public String toOrderSQL() {
        return toOrderSQL("");
    }
    public String toOrderSQL(String prefix) {
        prefix = prefix(prefix);
        if (!orders.isEmpty()) {
            StringBuffer sb = new StringBuffer();
            sb.append("Order BY ");
            for (String order : orders.keySet()) {
                System.out.println( orders.get(order));
                sb.append(String.format("  %s%s %s, ", prefix, order, orders.get(order)));
            }
            sb.deleteCharAt(sb.length() - 2);
            return sb.toString();
        }
        return "";
    }
    public String toWhereSQL() {
        return toWhereSQL("");
    }
    public String toWhereSQL(String prefix) {
        prefix = prefix(prefix);
        String _sql = " and %s%s = :%s ";
        Set<String> keys = value.keySet();
        Map<String, Object> _value = new HashMap<String, Object>();
        StringBuffer sb = new StringBuffer();
        sb.append(sql);
        for (String key : keys) {
            String filterDotKey = key.replaceAll("\\.", "_");
            //    String filterDotKey = key;
            _value.put(filterDotKey, value.get(key));
            sb.append(String.format(_sql, prefix, key, filterDotKey));
        }
        this.value = _value;
        return sb.toString();
    }
    public String toFormatSQL(String hsql) {
        Matcher matcher = Pattern.compile(":(\\w+)").matcher(hsql);
       while ( matcher.find()){
            String rexp = null;
           String group = matcher.group(1);
           Object ov = value.get(group);
           if (ov instanceof List)
           {
               StringBuilder sb = new StringBuilder();
               List vs = (List) ov;
               for (Object v : vs)
               {
                   sb.append("?,");
                   paras.add(v);
               }
               sb.deleteCharAt(sb.length() - 1);
               rexp = sb.toString();
           }else
           {
               paras.add(ov);
               rexp = "?";
           }
           hsql = hsql.replace(String.format(":%s", group), rexp);
       }
        return hsql;
    }
    public String toSqlExceptSelect(String tableName, String prefix ) {
        String hsql = " from " + tableName +  "  " + prefix + toWhereSQL(prefix) + toInSQL(prefix) + toLikeSQL(prefix) + toGroupSQL(prefix) + toOrderSQL(prefix);
        getSqlValue().putAll(getSqlLikes());
        getSqlValue().putAll(getIns());
        return toFormatSQL(hsql);
    }
    public static void main(String[] args) {
        QueryParams params = new QueryParams();
        params.add("id", 1);
        params.addGroup("cc");
        List<String> names = new ArrayList<String>();
        names.add("张三");
        names.add("李四");
        params.addIn("name", names);
        params.like("nick", "张");
        params.addOrder("time");
        String hsql = " from  user"  +  " t " + params.toWhereSQL("t") + params.toInSQL("t") + params.toLikeSQL("t") + params.toGroupSQL("t") + params.toOrderSQL("t");
        System.out.println("hsql:" + hsql);
        params.getSqlValue().putAll(params.getSqlLikes());
        params.getSqlValue().putAll(params.getIns());
        String sql = params.toFormatSQL(hsql);
//        System.out.println("sql:" + sql);
        params.atts(params.getParas().toArray());
    }
    public void atts(Object ... os)
    {
        System.out.println("参数:");
        for (Object o : os)
        {
            System.out.print(o);
            System.out.print(",");
        }
    }
}

上面这个参数类main函数的运行结果为

hsql: from  user t  where 1=1  and t.id = :id  and  t.name in( :name ) and  t.nick like :nick  GROUP BY t.cc  Order BY   t.time DESC 
sql: from  user t  where 1=1  and t.id = ?  and  t.name in( ?,? ) and  t.nick like ?  GROUP BY t.cc  Order BY   t.time DESC 
参数:
1,张三,李四,%张%,

其实这个类的很好的用法应该是每个实体对象都匹配一个DaoParams类然后继承这个类。在对应的set方法里面调用add方法,将对应的字段匹配进行。DaoParams类的字段可用枚举

接下来就是所依赖的类

/**
 * Created by ZaoSheng on 2015/7/15.
 */
/**
 * Represents an strategy for matching strings using "like".
 *
 * @author Gavin King
 * @see (MatchMode)
 */
public enum MatchMode {
    /**
     * Match the entire string to the pattern
     */
    EXACT {
        @Override
        public String toMatchString(String pattern) {
            return pattern;
        }
    },
    /**
     * Match the start of the string to the pattern
     */
    START {
        @Override
        public String toMatchString(String pattern) {
            return pattern + ‘%‘;
        }
    },
    /**
     * Match the end of the string to the pattern
     */
    END {
        @Override
        public String toMatchString(String pattern) {
            return ‘%‘ + pattern;
        }
    },
    /**
     * Match the pattern anywhere in the string
     */
    ANYWHERE {
        @Override
        public String toMatchString(String pattern) {
            return ‘%‘ + pattern + ‘%‘;
        }
    };
    /**
     * Convert the pattern, by appending/prepending "%"
     *
     * @param pattern The pattern for convert according to the mode
     *
     * @return The converted pattern
     */
    public abstract String toMatchString(String pattern);
}

接下来这个类也是对应依赖的类

package net.zz.zjf.plugin;

/**
 * Created by ZaoSheng on 2015/7/30.
 */
public enum Restriction {

    /**
     * 等于查询(from Object o where o.property = ?)
     */
    EQ {
        public String toMatchString(String pattern) {
            return "= :" + pattern;
        }
    },

    /**
     * 非等于查询(from Object o where o.property <> ?)
     */
    NE {
        public String toMatchString(String pattern) {
            return "<> :" + pattern;
        }
    },

    /**
     * 大于等于查询(from Object o where o.property >= ?)
     */
    GE {
        public String toMatchString(String pattern) {
            return ">= :" + pattern;
        }

    },

    /**
     * 大于查询(from Object o where o.property > ?)
     */
    GT {
        @Override
        public String toMatchString(String pattern) {
            return "> :" + pattern;
        }
    },

    /**
     * 小于等于查询(from Object o where o.property <= ?)
     */
    LE {
        @Override
        public String toMatchString(String pattern) {
            return "> :" + pattern;
        }
    },

    /**
     * 小于查询(from Object o where o.property < ?)
     */
    LT {
        @Override
        public String toMatchString(String pattern) {
            return "> :" + pattern;
        }
    },

    /**
     * 包含查询(from Object o where o.property in(?,?,?))
     */
    IN {
        @Override
        public String toMatchString(String pattern) {
            return "> :" + pattern;
        }
    },

    /**
     * 非包含查询(from Object o where o.property not in(?,?,?))
     */
    NIN {
        @Override
        public String toMatchString(String pattern) {
            return "> :" + pattern;
        }
    },

  /*  *//**
     * 左模糊查询(from Object o where o.property like %?)
     *//*
    LLIKE {
        @Override
        public String toMatchString(String pattern) {
            return ‘%‘ + pattern;
        }
    },

    *//**
     * 右模糊查询(from Object o where o.property like ?%)
     *//*
    RLIKE {
        @Override
        public String toMatchString(String pattern) {
            return pattern + ‘%‘;
        }
    },

    *//**
     * 模糊查询(from Object o where o.property like %?%)
     *//*
    LIKE {
        @Override
        public String toMatchString(String pattern) {
            return ‘%‘ + pattern + ‘%‘;
        }
    }*/;

    public abstract String toMatchString(String pattern);
    }

差不多就是这样子吧,本人小菜一枚,表达能力也不是很好。请大神们见谅。初学者还有很多要学的,请大神多指教。

继续对JFinal的Model部分包装一下,github地址:https://github.com/cnzzs/zjf

时间: 2024-10-23 20:10:47

对sql的查询语句做成对象式,简单实现。查询参数实现一的相关文章

对sql的查询语句做成对象式,简单实现。Where部分

最近比较懒,所以进度很慢很慢. 在此之前我已经有对sql查询语句的包装,连接地址:http://7041393.blog.51cto.com/7031393/1680736 sql的包装先定义了一个简单的接口 package net.zz.zjf.plugin;     /**      * Created by ZaoSheng on 2015/7/15.     */     public interface SQLParams {        String toFormatSQL(); 

sql查询语句如何解析成分页查询?

我们公司主要mysql存储数据,因此也封装了比较好用mysql通用方法,然后,我们做大量接口,在处理分页查询接口,没有很好分查询方法.sql查询 语句如何解析成“分页查询”和“总统计”两条语句.可能,很多人在处理“总统计”是这样:“select count(*) from (<sql原查询语句>) ”,而不是把原sql查询语句中columns替换成“count(*)”:相比前者统计查询效率高不高,大家心知肚明.“分页查询”很简单,对于mysql语句就是在原sql查询语句后面加上“limit 数

sql查询语句学习,多表查询和子查询以及连接查询

一.交叉连接查询 这种查询方式基本不会使用,原因就是这种查询方式得到的是两个表的乘积(笛卡儿集) 语法就是select * from a,b: 二.内连接查询,可以有效的去除笛卡尔集现象 内连接查询分为两类: 隐式内连接 select * from A,B where 条件 隐式连接使用别名:select * from A 别名1,B 别名2 where 别名1.xx=别名2.xx: 显示内连接 select * from A inner join B on 条件 (inner可以省略) 显示连

T-SQL查询语句 第二部分 (多表查询)

T-SQL查询语句大总结 防伪码:有志者事竟成,破釜沉舟,百二秦关终属楚 案例六:表如下图所示 在数据库中显示为: 实验需求: 1.两个表查询 select 学生表.姓名,学生表1.电话,学生表1.家庭住址 from 学生表,学生表1 where 学生表.学生id=学生表1.学生id 2.三个表的查询 select 学生表.姓名,课程表.课程名,成绩表.分数 from 学生表,课程表,成绩表 where 学生表.学生id=成绩表.学生id AND 成绩表.课程ID=课程表.课程ID 3.合并两个

mysql查询语句 和 多表关联查询 以及 子查询

原文地址: http://blog.csdn.net/github_37767025/article/details/67636061 1.查询一张表: select * from 表名: 2.查询指定字段:select 字段1,字段2,字段3-.from 表名: 3.where条件查询:select 字段1,字段2,字段3 frome 表名 where 条件表达式: 例:select * from t_studect where id=1; select * from t_student wh

hibernate查询语句hql中的占位符?参数与命名参数:name设值方式搞混

先贴出异常 Struts has detected an unhandled exception: Messages: Position beyond number of declared ordinal parameters. Remember that ordinal parameters are 1-based! Position: 1 File: org/hibernate/engine/query/spi/ParameterMetadata.java Stacktraces org.h

T-SQL简单查询语句(模糊查询)

1 T-SQL简单查询语句 2 3 简单查询: 4 5 1.最简单查询(查所有数据) 6 select * from 表名: 注:* 代表所有列 7 select * from info 8 9 2.查询指定列 10 select code,name from info 11 12 3.修改结果集的列名 13 select code as '代号',name as '姓名' from info 14 15 4.条件查询 16 select * from info where code='p003

MySQL学习——SQL查询语句(连接查询&amp;子查询)(三)

一:连接查询: 连接查询是将俩个或者俩个以上的表按照某个条件连接起来,从中选择需要的数据,连接查询同时查询俩个或者俩个以上的表时使用,当不同的表中存在表示相同意义的字段时,可以通过该字段来连接这几个表,例如,学生表中有course_id字段来表示所学课程的课程号,课程表中有num字段来表示课程号,那么可以通过学生表中的course_id字段与课程表中的num字段来进行连接查询,连接查询包括内连接查询和外连接查询. 1.1 内连接查询 内连接查询是一种常用的连接查询,内连接查询可以查询俩个或者以上

Hibernate HQL查询语句总结

Hibernate HQL查询语句总结 1. 实体查询:有关实体查询技术,其实我们在先前已经有多次涉及,比如下面的例子:String hql="from User user ";List list=session.CreateQuery(hql).list();上面的代码执行结果是,查询出User实体对象所对应的所有数据,而且将数据封装成User实体对象,并且放入List中返回.这里需要注意的是,Hibernate的实体查询存在着对继承关系的判定,比如我们前面讨论映射实体继承关系中的E