你还在为sql语句的拼接而烦恼吗？
sql语句支持表达式了！
package com.newland.bi.webservice.common.manage;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.beanutils.BeanUtils;
import com.newland.bi.util.common.Function;
import com.newland.bi.webservice.common.model.SQLBean;
/**
* 解析sql工具类
* 将 { condition ?[condition_ture]:[condition_false]} 或者 { condition ?[condition_ture]} 根据参数进行解析
* <br/>condition 可以是bean中的一个属性名eg:name，如果属性值不为null或者不等于""就返回condition_true语句，否则返回condition_false
* <br/>也可以是字符串比较的表达式 eg:name ==|!=|>|<|>=|<= wch
* <br/>支持条件的嵌套
* <br/>select * from user where 1=1 {name?[ and name=:name]} {name==wch?[name=:name]:[id=:name]}
* <br/>其中表达式中的name要是bean中属性
* @author wch
* @version 1.0
* @since 2014/05/19
*/
@SuppressWarnings("unchecked")
public class SQLUtils {
/**
* 将普通javabean转换为map,属性的名值对
* @param bean
* @return map bean的属性的键值对
*/
public static Map<String, String> bean2Map(Object bean){
Map<String, String> map = new HashMap<String, String>();
try {
map = BeanUtils.describe(bean);
} catch (Exception e) {
e.printStackTrace();
}
return map;
}
/**
* 进行解析sql语句
* <br/>{ condition ?[condition_ture]:[condition_false]} 或者 { condition ?[condition_ture]}
* <br/>
* @return 根据条件表达式替换后的语句
*/
public static String analyzeSql(Map<String, String> paramMap, String sql) {
if (sql == null) {
return sql;
}
int start = 0, end = 1;
/*循环查找sql中的表达式进行解析*/
while (true) {
start = sql.lastIndexOf("{"); // 条件起始位置
end = sql.indexOf("}",start); // 条件结束位置
if (end <= start) { // 没有条件
return sql;
}
String braces = sql.substring(start, end + 1);// 取得大括号的内容{...}
String braces_trim = braces;
// 处理分界符之间的空格
braces_trim = braces_trim.replaceAll("\?\s*\[", "?[");
braces_trim = braces_trim.replaceAll("\]\s*:\s*\[", "]:[");
braces_trim = braces_trim.replaceAll("\]\s*\}", "]}");
int question_mark_index = braces_trim.indexOf("?["); // 获取问号的位置
int colon_index = braces_trim.indexOf("]:["); // 获取冒号的位置
int end_mark_index = braces_trim.length() - 2; // ]} 的位置
if (question_mark_index == -1) {// 如果不存在问号就不进行解析
return sql;
}
String condition = braces_trim.substring(1, question_mark_index); // 获取条件从{到?
String sql_true = "", sql_false = "";
if (colon_index == -1) { // 不存在冒号
sql_true = braces_trim.substring(question_mark_index + 2,
end_mark_index);// 条件为真时的语句
} else {
sql_true = braces_trim.substring(question_mark_index + 2,
colon_index);// 条件为真时的语句
sql_false = braces_trim.substring(colon_index + 3,
end_mark_index);// 添加为假时的语句
}
if (isConditionTrue(paramMap, condition)) { // 判断条件是否为空
sql = sql.replace(braces, addBothSpace(sql_true));
} else {
sql = sql.replace(braces, addBothSpace(sql_false));
}
}
}
/**
* 进行解析sql语句
* <br/>{ condition ?[condition_ture]:[condition_false]} 或者 { condition ?[condition_ture]}
* @return 根据条件表达式替换后的语句
*/
public static String analyzeSql(Object bean,String sql){
return analyzeSql(bean2Map(bean), sql);
}
/**
* 如果str不为空，在str的两端添加空格，如果不存在的话
* @param str
* @return str
*/
public static String addBothSpace(String str){
if (str == null) {
return str;
}
/*添加前空格*/
if (!str.startsWith(" ")) {
str = " "+str;
}
/*添加后空格*/
if (!str.endsWith(" ")) {
str = str + " ";
}
return str;
}
/**
* 根据map中的值判断condition的真假
* @param map
* @param condition
* @return
*/
private static boolean isConditionTrue(Map<String, String> map,String condition){
/*为空直接返回false*/
if (condition == null || condition.length() == 0) {
return false;
}
//去除空格
condition = condition.trim();
//匹配一个表达式
Pattern pattern = Pattern.compile("(\w+)(?:\s*([!><=]{1,2})\s*(\w+))?");
//进行匹配
Matcher matcher = pattern.matcher(condition);
if (!matcher.matches()) {
return false; //匹配不成功，直接返回false
}else { //匹配成功
String oper_left = matcher.group(1); //捕获组1，左边云算数
String oper_symbol = matcher.group(2);
String oper_right = matcher.group(3);
//属性对应的值
String value = map.get(oper_left);
if (value == null) {
return false;
}
/*存在操作符*/
if (oper_symbol != null && oper_right != null) {
return doOperate(value, oper_symbol, oper_right);
} else {
return true;
}
}
}
/**
* 进行 left symbol right的运算
* @param left
* @param symbol
* @param right
* @return
*/
private static boolean doOperate(String left,String symbol,String right){
/*不等于*/
if ("!=".equals(symbol) || "!".equals(symbol)) {
return left.compareToIgnoreCase(right) != 0;
}
/*等于*/
if ("==".equals(symbol) || "=".equals(symbol)) {
return left.compareToIgnoreCase(right) == 0;
}
/*大于等于*/
if (">=".equals(symbol)) {
return left.compareToIgnoreCase(right) >= 0;
}
/*小于等于*/
if ("<=".equals(symbol)) {
return left.compareToIgnoreCase(right) <= 0;
}
/*大于*/
if (">".equals(symbol) ) {
return left.compareToIgnoreCase(right) > 0;
}
/*小于*/
if ("<".equals(symbol)) {
return left.compareToIgnoreCase(right) < 0;
}
return false;
}
/**
* 将查询sql语句中的查询的列名,不支持*
* @param sql
* @return metaDataList
*/
public static List<String> getMetaData(String sql){
List<String> metaData = new ArrayList<String>();
if (sql == null) {
return metaData;
}
Pattern col_pattern = Pattern.compile("(\w+)\s*,"); // 获取列名的pattern
Pattern row_pattern = Pattern.compile("select(.*?)from"); // 获取所有列名的字符串
Matcher rowMatcher = row_pattern.matcher(sql);
if (rowMatcher.find()) {
String row = rowMatcher.group(1) + ",";
row = removeBrackets(row);
Matcher colMatcher = col_pattern.matcher(row);
// 添加列名
while (colMatcher.find()) {
metaData.add(colMatcher.group(1));
}
}
return metaData;
}
/**
* 将str 中括号里的内容去掉
* @param str
* @return 去掉括号里的内容
*/
private static String removeBrackets(String str){
if (str == null) {
return str;
}
StringBuilder sb = new StringBuilder(str);
int start = -1,end = -1;
/*从后向前查找，支持嵌套*/
start = sb.lastIndexOf("(");
while (start > -1) {
end = sb.indexOf(")", start);
if (end > -1) {
//删除掉括号的内容
sb.delete(start, end+1);
}
start = sb.lastIndexOf("(");
}
return sb.toString();
}
public static void main(String[] args) {
String sql = "{id?[sql_id is not null]:[{sql==wch?[sql_id is wch]:[not wch]}]}";
SQLBean bean = new SQLBean();
bean.setSql("wc");
System.out.println("#"+analyzeSql(bean, sql)+"#");
}
}