项目中为了使项目的数据库操作从dao层转移到service层，只好写一个通用的sql语句拼接类和相应的mapper类和mapper的xml文件，自定义的SelectBuilder.java的代码如下：
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import com.util.StringHelper;
/**
* SelectBuilder：SQL条件拼接类，该类只做sql语句的拼接
* @author LMH 修改
* @notice 注意：为了用好该类，必须熟悉掌握sql语句完整语法
* @SQLGrammar SELECT语句的完整语法为：
*SELECT[ALL|DISTINCT|DISTINCTROW|TOP] <br/>
*{*|talbe.*|[table.]field1[AS alias1][,[table.]field2[AS alias2][,…]]} <br/>
*FROM tableexpression[,…][IN externaldatabase] <br/>
*[WHERE…] <br/>
*[GROUP BY…] <br/>
*[HAVING…] <br/>
*[ORDER BY…] <br/>
*[WITH OWNERACCESS OPTION] <br/>
*说明： <br/>
*用中括号([])括起来的部分表示是可选的，用大括号({})括起来的部分是表示必须从中选择其中的一个。 <br/>
*
*/
public class SelectBuilder
{
private static final String AND = ") \nAND (";
private static final String OR = ") \nOR (";
List<String> select = new ArrayList<String>();
List<String> from = new ArrayList<String>();
List<String> join = new ArrayList<String>();
List<String> innerJoin = new ArrayList<String>();
List<String> outerJoin = new ArrayList<String>();
List<String> leftOuterJoin = new ArrayList<String>();
List<String> rightOuterJoin = new ArrayList<String>();
List<Criterion> where = new ArrayList<Criterion>();
List<Criterion> having = new ArrayList<Criterion>();
List<String> groupBy = new ArrayList<String>();
List<String> orderBy = new ArrayList<String>();
List<String> lastList = new ArrayList<String>();
boolean distinct;
/**
* 设置SQL语句中从select到from的部分
* @param conditons 查詢的内容，可以写字段，聚合函数等
* @example 参数例子：" table1.id as id,table2.mc as mc ",
* @notice 注意：如果要查询的字段名有相同的，必须用as **的方式进行区分，不然会不能正确set进hashmap里
*
*/
public void SELECT(String conditons)
{
select.add(conditons);
}
/**
* 设置SQL语句中从select distinct到from的部分，可以写字段，聚合函数等
* @param columns 查詢的字段列表
* @example 参数例子：" table1.id as id,table2.mc as mc ",
* @notice 注意：如果要查询的字段名有相同的，必须用as **的方式进行区分，不然会不能正确set进hashmap里
*
*/
public void SELECT_DISTINCT(String columns)
{
distinct = true;
SELECT(columns);
}
/**
* 设置SQL语句中从from到where的部分
* @param table： 表名列表，可以是要查询的表名列表，或者直接加上join连接
* @example 参数例子：" table1 " 或者" table1,table2 "
*/
public void FROM(String table)
{
from.add(table);
}
/**
* 设置JOIN连接条件 <br/>
* 切记用了join相关的链接，则form里只能有一个表，而且，join函数之后，后面不得再加from函数
* @param join：JOIN连接条件，由3部分组成：表名 别名 + on +连接条件
* @example join参数例子：" bmd_mss b on b.bmd_h=loc.x_h "
*/
public void JOIN(String join)
{
this.join.add(join);
}
/**
* 设置INNER_JOIN连接条件 <br/>
* 切记用了join相关的链接，则form里只能有一个表，而且，join函数之后，后面不得再加from函数
* @param join：INNER_JOIN连接条件，由3部分组成：表名 别名 + on +连接条件
* @example join参数例子：" bmd_mss b on b.bmd_h=loc.x_h "
*/
public void INNER_JOIN(String join)
{
innerJoin.add(join);
}
/**
* 设置LEFT_OUTER_JOIN连接条件
* 用了join相关的链接，则form里只能有一个表，而且，join之后，后面不得再加form函数
* @param join：LEFT_OUTER_JOIN连接条件，由3部分组成：表名 别名 + on +连接条件
* @example join参数例子：" bmd_mss b on b.bmd_h=loc.x_h "
*/
public void LEFT_OUTER_JOIN(String join)
{
leftOuterJoin.add(join);
}
/**
* 设置RIGHT_OUTER_JOIN连接条件
* 用了join相关的链接，则form里只能有一个表，而且，join之后，后面不得再加form函数
* @param join：RIGHT_OUTER_JOIN连接条件，由3部分组成：表名 别名 + on +连接条件
* @example join参数例子：" bmd_mss b on b.bmd_h=loc.x_h "
*/
public void RIGHT_OUTER_JOIN(String join)
{
rightOuterJoin.add(join);
}
/**
* 设置OUTER_JOIN连接条件
* 用了join相关的链接，则form里只能有一个表，而且，join之后，后面不得再加form函数
* @param join：OUTER_JOIN连接条件，由3部分组成：表名 别名 + on +连接条件
* @example join参数例子：" bmd_mss b on b.bmd_h=loc.x_h "
*/
public void OUTER_JOIN(String join)
{
outerJoin.add(join);
}
//为了适应动态参数而重写的where方法（没有参数的情况）
/**
*设置where子语句（一个参数的情况）
* @param conditions： 连接条件,没有传动态参数的查询条件部分<br/>
* 一个静态查询条件必须包含4部分内容：连接规则 字段列 运算符 值 <br/>
* 连接规则: (and 或者 or)<br/>
* 字段名: （field1）<br/>
* 运算符: 必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者 <br/>
* = 或者 <> 或者!= 或者 like 或者 not like 或者 in 或者 not in <br/>
* 或者 between 或者 not between ) <br/>
* 值 : 注意：如果元素符是in,则值部分必须写成 (value1,value2...)的形式。<br/>
* 如果元素符是between,则值部分必须为 value1 and value2 的形式，value1为min，value2为max。<br/>
* 如果元素符是like,则值部分可以在值的左右两边加上%或者_的通配符。<br/>
* %：表示匹配任意个字符；_:表示匹配一个字符。<br/>
* @example conditions参数例子：" and table1.id=table2.id or table1.mc=table2.mc and table1.id like '%1%' "
*/
public void WHERE(String conditions)
{
if(StringHelper.isNotBlank(conditions))
where.add( new Criterion(conditions));
}
//为了适应动态参数而重写的where方法，（单个参数或者in的情况）
/**
* 设置where子语句（两个参数的情况）支持单个参数或者in的情况
* @param conditions: 连接条件,没有传动态参数的查询条件部分，必须包含3部分内容：<br/>
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符 <br/>
* 运算符:必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者 = 或者 <br/>
* <> 或者!= 或者 like 或者 not like 或者 in 或者not in ) <br/>
* @param value: 参数值,Object对象，支持任何类型<br/>
* 注意：如果conditions的运算符是in, 则value部分可以传递一个list的对象,<br/>
* list对象至少要包含一个Object类型的元素;如果conditions的运算符是like<br/>
* 部分,则value部分可以在"value1"值的左右两边加上%或者_的通配符。<br/>
* %：表示匹配任意个字符；_:表示匹配一个字符<br/>
* @example conditions参数例子：" and table1.id= " 或者" and table1.id like "
*/
public void WHERE(String conditions,Object value)
{
if(value!=null) //如果非空
{
if (value instanceof List<?>) //如果为list
{
if(!((List)value).isEmpty() ) //如果list非空
where.add( new Criterion(conditions,value));
}
else //如果为其他直接添加
where.add( new Criterion(conditions,value));
}
}
//为了适应动态参数而重写的where方法（单个参数或者in的情况）,有close关闭符号的情况
/**
* 设置where子语句（三个参数的情况）支持单个参数或者in的情况,有close关闭符号的情况
* @param conditions: 连接条件,没有传动态参数的查询条件部分，必须包含3部分内容：<br/>
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符 <br/>
* 运算符:必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者 <br/>
* = 或者 <> 或者!= 或者 like 或者 not like 或者 in 或者 not in ) <br/>
* @param value: 参数值,Object对象，支持任何类型<br/>
* 注意：如果conditions的运算符是in, 则value部分可以传递一个list的对象,list对象至少要包含一个Object类型的元素<br/>
* 如果conditions的运算符是like部分,则value部分可以在"value1"值的左右两边加上%或者_的通配符<br/>
* %：表示匹配任意个字符；_:表示匹配一个字符<br/>
* @example conditions参数例子：" and table1.id= " 或者" and table1.id like "
* @param close： 关闭符号，只有在处理or条件的时候才会用到，其他时候设置null或者""
*/
public void WHERE(String conditions,Object value,String close)
{
if(value!=null) //如果非空
{
if (value instanceof List<?>) //如果为list
{
if(!((List)value).isEmpty() ) //如果list非空
where.add( new Criterion(conditions,value,close));
}
else //如果为其他直接添加
where.add( new Criterion(conditions,value,close));
}
}
//为了适应动态参数而重写的where方法(between的情况),有close关闭符号的情况
/**
* 设置where子语句（四个参数的情况）支持between的情况,有close关闭符号的情况
* @param conditions: 连接条件,没有传动态参数的查询条件部分，必须包含3部分内容：<br/>
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符 <br/>
* 运算符:必须以下运算符中的一个( between 或者 not between )<br/>
* @param value: 参数值，Object对象，between的参数值左部分，支持任何类型<br/>
* @param secondValue 参数值，Object对象，between的参数值右部分，支持任何类型<br/>
* @example conditions参数例子：" and table1.id= " 或者" and table1.id like "
* @param close： 关闭符号，只有在处理or条件的时候才会用到，其他时候设置null或者""
*/
public void WHERE(String conditions,Object value,Object secondValue,String close)
{
if(value!=null&&secondValue!=null)
where.add( new Criterion(conditions,value,secondValue,close));
}
/**
* 设置分组字段列表
* 切记GROUP_BY里面的字段select里面的字段必须有，不然会触发sql语法错误异常
* @param columns: 分组字段
* @example columns参数例子："table1.id,table2.mc "
*/
public void GROUP_BY(String columns)
{
groupBy.add(columns);
}
//为了适应动态参数而重写的having方法（没有参数的情况）
/**
*
* 设置having子语句（一个参数的情况）<br/>
* 切记having里面的字段group by里面必须有，不然会触发sql语法错误异常<br/>
* @param conditions： 连接条件,没有传动态参数的查询条件部分<br/>
* 一个静态查询条件必须包含4部分内容：连接规则 字段列 运算符 值 <br/>
* 连接规则: (and 或者 or)<br/>
* 字段名: （field1）<br/>
* 运算符: 必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者 <br/>
* = 或者 <> 或者!= 或者 like 或者 not like 或者 in 或者 not in <br/>
* 或者 between 或者 not between ) <br/>
* 值: 注意：如果元素符是in,则值部分必须写成 (value1,value2...)的形式。<br/>
* 如果元素符是between,则值部分必须为 value1 and value2 的形式，value1为min，value2为max。<br/>
* 如果元素符是like,则值部分可以在值的左右两边加上%或者_的通配符。<br/>
* %：表示匹配任意个字符；_:表示匹配一个字符。<br/>
* @example conditions参数例子：" and table1.id=table2.id or table1.mc=table2.mc and table1.id like '%1%' "
*/
public void HAVING(String conditions)
{
if(StringHelper.isNotBlank(conditions))
having.add( new Criterion(conditions));
}
//为了适应动态参数而重写的having方法（单个参数或者in的情况）
/**
* 设置having子语句（两个参数的情况）支持单个参数或者in的情况<br/>
* 切记having里面的字段group by里面必须有，不然会触发sql语法错误异常<br/>
* @param conditions: 连接条件,没有传动态参数的查询条件部分，必须包含3部分内容：<br/>
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符 <br/>
* 运算符:必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者 = 或者 <br/>
* <> 或者!= 或者 like 或者 not like 或者 in 或者not in ) <br/>
* @param value: 参数值,Object对象，支持任何类型<br/>
* 注意：如果conditions的运算符是in, 则value部分可以传递一个list的对象,<br/>
* list对象至少要包含一个Object类型的元素;如果conditions的运算符是like<br/>
* 部分,则value部分可以在"value1"值的左右两边加上%或者_的通配符。<br/>
* %：表示匹配任意个字符；_:表示匹配一个字符<br/>
* @example conditions参数例子：" and table1.id= " 或者" and table1.id like "
*/
public void HAVING(String conditions,Object value)
{
if(value!=null) //如果非空
{
if (value instanceof List<?>) //如果为list
{
if(!((List)value).isEmpty() ) //如果list非空
having.add( new Criterion(conditions,value));
}
else //如果为其他直接添加
having.add( new Criterion(conditions,value));
}
}
//为了适应动态参数而重写的having方法（单个参数或者in的情况）,有close关闭符号的情况
/**
* 设置having子语句（三个参数的情况）支持单个参数或者in的情况,有close关闭符号的情况 <br/>
* 切记having里面的字段group by里面必须有，不然会触发sql语法错误异常<br/>
* @param conditions: 连接条件,没有传动态参数的查询条件部分，必须包含3部分内容：<br/>
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符 <br/>
* 运算符:必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者 <br/>
* = 或者 <> 或者!= 或者 like 或者 not like 或者 in 或者 not in ) <br/>
* @param value: 参数值,Object对象，支持任何类型<br/>
* 注意：如果conditions的运算符是in, 则value部分必须传递一个list的对象,<br/>
* list对象至少要包含一个Object类型的元素；<br/>
* 如果conditions的运算符是like部分,则value部分可以在"value1"值的左右两边加上%或者_的通配符<br/>
* %：表示匹配任意个字符；_:表示匹配一个字符<br/>
* @example conditions参数例子：" and table1.id= " 或者" and table1.id like "
* @param close： 关闭符号，只有在处理or条件的时候才会用到，其他时候设置null或者""
*/
public void HAVING(String conditions,Object value,String close)
{
if(value!=null) //如果非空
{
if (value instanceof List<?>) //如果为list
{
if(!((List)value).isEmpty() ) //如果list非空
having.add( new Criterion(conditions,value,close));
}
else //如果为其他直接添加
having.add( new Criterion(conditions,value,close));
}
}
//为了适应动态参数而重写的having方法(between的情况),有close关闭符号的情况
/**
* 设置having子语句（四个参数的情况）支持between的情况,有close关闭符号的情况<br/>
* 切记having里面的字段group by里面必须有，不然会触发sql语法错误异常<br/>
* @param conditions: 连接条件,没有传动态参数的查询条件部分，必须包含3部分内容：<br/>
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符 <br/>
* 运算符:必须以下运算符中的一个( between 或者 not between )<br/>
* @param value: 参数值，Object对象，between的参数值左部分，支持任何类型<br/>
* @param secondValue: 参数值，Object对象，between的参数值右部分，支持任何类型<br/>
* @example conditions参数例子：" and table1.id= " 或者" and table1.id like "
* @param close： 关闭符号，只有在处理or条件的时候才会用到，其他时候设置null或者""
*/
public void HAVING(String conditions,Object value,Object secondValue,String close)
{
if(value!=null&&secondValue!=null)
having.add( new Criterion(conditions,value,secondValue,close));
}
/**
* 设置排序子语句
* 切记ORDER_BY里面的字段select里面的字段必须有，不然会触发sql语法错误异常
* @param conditions: 排序条件
* @example conditions参数例子："table1.id decs"
*/
public void ORDER_BY(String conditions)
{
orderBy.add(conditions);
}
private StringBuilder selectClause( String keyword,
List<String> parts, String open, String close, String conjunction)
{
StringBuilder builder=new StringBuilder();
if (!parts.isEmpty())
{
if (builder.length() > 0)
builder.append("\n");
builder.append(keyword);
builder.append(" ");
builder.append(open);
String last = "________";
for (int i = 0, n = parts.size(); i < n; i++)
{
String part = parts.get(i);
if (i > 0 && !part.equals(AND) && !part.equals(OR) && !last.equals(AND)
&& !last.equals(OR))
{
builder.append(conjunction);
}
builder.append(part);
last = part;
}
builder.append(close);
}
return builder;
}
private void whereClause()
{
if(where.size()>0)
{
System.out.print(" WHERE 1=1 ");
for(Criterion cri:where)
{
if(cri.isNoValue())
System.out.print(cri.getCondition());
if(cri.isSingleValue())
System.out.print(cri.getCondition()+" '"+cri.getValue()+"'");
if(cri.isBetweenValue())
System.out.print(cri.getCondition()+" '"+cri.getValue()+"' and '"+cri.getSecondValue()+"'");
if(cri.isListValue())
{
StringBuilder strb= new StringBuilder();
strb.append(cri.getCondition());
strb.append(" (");
List list=(List)cri.getValue();
for(int i=0;i<list.size();i++)
{
Object o=list.get(i);
strb.append("'"+o+"'");
if(i<list.size()-1)
strb.append(",");
}
strb.append(")");
System.out.print(strb);
}
//处理关闭符号的代码
if(cri.close==null||cri.close.equals(""))
System.out.println();
else
System.out.println(cri.close);
}
}
}
private void havingClause()
{
if(having.size()>0)
{
System.out.print(" HAVING 1=1 ");
for(Criterion cri:having)
{
if(cri.isNoValue())
System.out.print(cri.getCondition());
if(cri.isSingleValue())
System.out.print(cri.getCondition()+" '"+cri.getValue()+"'");
if(cri.isBetweenValue())
System.out.print(cri.getCondition()+" '"+cri.getValue()+"' and '"+cri.getSecondValue()+"'");
if(cri.isListValue())
{
StringBuilder strb= new StringBuilder();
strb.append(cri.getCondition());
strb.append(" (");
List list=(List)cri.getValue();
for(int i=0;i<list.size();i++)
{
Object o=list.get(i);
strb.append("'"+o+"'");
if(i<list.size()-1)
strb.append(",");
}
strb.append(")");
System.out.print(strb);
}
//处理关闭符号的代码
if(cri.close==null||cri.close.equals(""))
System.out.println();
else
System.out.println(cri.close);
}
}
}
/**
* 打印由各部分组合起来的SQL语句
*/
public void printSQL()
{
if(!select.isEmpty())
System.out.println(selectClause( "SELECT", this.select, "", "", ", "));
if(!from.isEmpty())
System.out.println(selectClause( "FROM", this.from, "", "", ", "));
if(!innerJoin.isEmpty())
System.out.println(selectClause("INNER JOIN", this.innerJoin, "", "", "\nINNER JOIN "));
if(!outerJoin.isEmpty())
System.out.println(selectClause("OUTER JOIN", this.outerJoin, "", "", "\nOUTER JOIN "));
if(!leftOuterJoin.isEmpty())
System.out.println(selectClause(" LEFT OUTER JOIN", this.leftOuterJoin, "", "", "\nLEFT OUTER JOIN "));
if(!rightOuterJoin.isEmpty())
System.out.println(selectClause(" RIGHT OUTER JOIN", this.rightOuterJoin, "", "", "\nRIGHT OUTER JOIN "));
whereClause();
if(!groupBy.isEmpty())
System.out.println(selectClause(" GROUP BY", this.groupBy, "", "", ", "));
havingClause();
if(!orderBy.isEmpty())
System.out.println(selectClause(" ORDER BY", this.orderBy, "", "", ", "));
}
/**
* Criterion ：where或者having的子语句条件类
* @author LMH 修改
*
*/
public class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String close; //为了解决or要有括号括起来而添加的属性
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
public String getClose() {
return close;
}
public void setClose(String close) {
this.close = close;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value) {
this.condition = condition;
this.value = value;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value,String close) {
this.condition = condition;
this.value = value;
this.close=close;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value, Object secondValue, String close) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.close = close;
this.betweenValue = true;
}
}
public static void main(String[] args) throws IOException {
SelectBuilder sql=new SelectBuilder();
sql.SELECT("l.mc,l.id");
System.out.println(sql.selectClause( "SELECT", sql.select, "", "", ", "));
sql.FROM("bmd l,user u");
System.out.println(sql.selectClause( "FROM", sql.from, "", "", ", "));
sql.INNER_JOIN("DEPARTMENT D on D.ID = P.DEPARTMENT_ID");
System.out.println(sql.selectClause("INNER JOIN", sql.innerJoin, "", "", "\nINNER JOIN "));
sql.WHERE(" l.id=u.id");
List l=new ArrayList();
l.add("1");
l.add("2");
sql.WHERE("or( l.id in",l);
sql.WHERE("and l.id between",1,2,")");
sql.whereClause();
sql.GROUP_BY("l.id,u.id");
System.out.println(sql.selectClause( "GROUP BY", sql.groupBy, "", "", ", "));
sql.HAVING(" l.id=u.id");
List l2=new ArrayList();
l2.add("1");
l2.add("2");
sql.HAVING("or( l.id in",l2);
sql.HAVING("and l.id between","1","2",")");
sql.havingClause();
}
/**********get方法*******/
public List<String> getSelect() {
return select;
}
public List<String> getFrom() {
return from;
}
public List<String> getJoin() {
return join;
}
public List<String> getInnerJoin() {
return innerJoin;
}
public List<String> getOuterJoin() {
return outerJoin;
}
public List<String> getLeftOuterJoin() {
return leftOuterJoin;
}
public List<String> getRightOuterJoin() {
return rightOuterJoin;
}
public List<Criterion> getWhere() {
return where;
}
public List<Criterion> getHaving() {
return having;
}
public List<String> getGroupBy() {
return groupBy;
}
public List<String> getOrderBy() {
return orderBy;
}
public boolean isDistinct() {
return distinct;
}
}
SqlMapper.xml的映射文件如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.SqlMapper">
<!-- 方法一：支持單表或者多表的通用查詢方法 By 梁敏鸿 2012年2月24日 -->
<select id="selectBySql" resultType="map" parameterType="com.common.SelectBuilder">
<!-- 1.SQL语句的基本部分 -->
<if test="distinct">
<if test="!select.empty">
SELECT DISTINCT
</if>
<foreach collection="select" item="select_content" open=" " separator="," close=" " >
${select_content}
</foreach>
</if>
<if test="!distinct">
<if test="!select.empty">
SELECT
</if>
<foreach collection="select" item="select_content" open=" " separator="," close=" " >
${select_content}
</foreach>
</if>
<if test="!from.empty">
FROM
<foreach collection="from" item="from_content" open=" " separator="," close=" " >
${from_content}
</foreach>
</if>
<!-- 2.join 查询部分-->
<if test="!join.empty">
JOIN
<foreach collection="join" item="join_content" open=" " separator="\n JOIN" close=" " >
${join_content}
</foreach>
</if>
<if test="!innerJoin.empty">
INNER JOIN
<foreach collection="innerJoin" item="innerJoin_content" open=" " separator="\n INNER JOIN" close=" " >
${innerJoin_content}
</foreach>
</if>
<if test="!outerJoin.empty">
OUTER JOIN
<foreach collection="outerJoin" item="outerJoin_content" open=" " separator="\n OUTER JOIN" close=" " >
${outerJoin_content}
</foreach>
</if>
<if test="!leftOuterJoin.empty">
LEFT OUTER JOIN
<foreach collection="leftOuterJoin" item="leftOuterJoin_content" open=" " separator="\n LEFT OUTER JOIN" close=" " >
${leftOuterJoin_content}
</foreach>
</if>
<if test="!rightOuterJoin.empty">
RIGHT OUTER JOIN
<foreach collection="rightOuterJoin" item="rightOuterJoin_content" open=" " separator="\n RIGHT OUTER JOIN" close=" " >
${rightOuterJoin_content}
</foreach>
</if>
<!-- 3.SQL语句WHERE部分 -->
<if test="!where.empty">
where 1=1
<foreach collection="where" item="where_Criterion" open=" " separator=" " close=" " >
<choose >
<when test="where_Criterion.noValue" >
${where_Criterion.condition}
</when>
<when test="where_Criterion.singleValue" >
${where_Criterion.condition} #{where_Criterion.value}
</when>
<when test="where_Criterion.betweenValue" >
${where_Criterion.condition} #{where_Criterion.value} and #{where_Criterion.secondValue}
</when>
<when test="where_Criterion.listValue" >
${where_Criterion.condition}
<foreach collection="where_Criterion.value" item="listItem" open="(" close=")" separator="," >
#{listItem}
</foreach>
</when>
</choose>
<!-- 加上close关闭符号，为了处理or的括号包含的情况 -->
<if test="where_Criterion.close!=null and where_Criterion.close!=''">
${where_Criterion.close}
</if>
</foreach>
</if>
<!-- 4.SQL语句GROUP BY部分 -->
<if test="!groupBy.empty">
GROUP BY
<foreach collection="groupBy" item="groupBy_content" open=" " separator="," close=" " >
${groupBy_content}
</foreach>
</if>
<!-- 5.SQL语句HAVING部分 -->
<if test="!having.empty">
HAVING 1=1
<foreach collection="having" item="having_Criterion" open=" " separator=" " close=" " >
<choose >
<when test="having_Criterion.noValue" >
${having_Criterion.condition}
</when>
<when test="having_Criterion.singleValue" >
${having_Criterion.condition} #{having_Criterion.value}
</when>
<when test="having_Criterion.betweenValue" >
${having_Criterion.condition} #{having_Criterion.value} and #{having_Criterion.secondValue}
</when>
<when test="having_Criterion.listValue" >
${having_Criterion.condition}
<foreach collection="having_Criterion.value" item="listItem" open="(" close=")" separator="," >
#{listItem}
</foreach>
</when>
</choose>
<!-- 加上close关闭符号，为了处理or的括号包含的情况 -->
<if test="having_Criterion.close!=null and having_Criterion.close!=''">
${having_Criterion.close}
</if>
</foreach>
</if>
<!-- 6.SQL语句ORDER BY部分 -->
<if test="!orderBy.empty">
ORDER BY
<foreach collection="orderBy" item="orderBy_content" open=" " separator="," close=" " >
${orderBy_content}
</foreach>
</if>
</select>
<!-- 方法二：支持單表或者多表的通用统计方法 By lmh 2012年2月24日 -->
<select id="countBySql" resultType="int" parameterType="com.common.SelectBuilder">
<if test="distinct">
<if test="!select.empty">
SELECT DISTINCT
</if>
COUNT(*)
</if>
<if test="!distinct">
<if test="!select.empty">
SELECT
</if>
COUNT(*)
</if>
<if test="!from.empty">
FROM
<foreach collection="from" item="from_content" open=" " separator="," close=" " >
${from_content}
</foreach>
</if>
<if test="!join.empty">
JOIN
<foreach collection="join" item="join_content" open=" " separator="\n JOIN" close=" " >
${join_content}
</foreach>
</if>
<if test="!innerJoin.empty">
INNER JOIN
<foreach collection="innerJoin" item="innerJoin_content" open=" " separator="\n INNER JOIN" close=" " >
${innerJoin_content}
</foreach>
</if>
<if test="!outerJoin.empty">
OUTER JOIN
<foreach collection="outerJoin" item="outerJoin_content" open=" " separator="\n OUTER JOIN" close=" " >
${outerJoin_content}
</foreach>
</if>
<if test="!leftOuterJoin.empty">
LEFT OUTER JOIN
<foreach collection="leftOuterJoin" item="leftOuterJoin_content" open=" " separator="\n LEFT OUTER JOIN" close=" " >
${leftOuterJoin_content}
</foreach>
</if>
<if test="!rightOuterJoin.empty">
RIGHT OUTER JOIN
<foreach collection="rightOuterJoin" item="rightOuterJoin_content" open=" " separator="\n RIGHT OUTER JOIN" close=" " >
${rightOuterJoin_content}
</foreach>
</if>
<if test="!where.empty">
where 1=1
<foreach collection="where" item="where_Criterion" open=" " separator=" " close=" " >
<choose >
<when test="where_Criterion.noValue" >
${where_Criterion.condition}
</when>
<when test="where_Criterion.singleValue" >
${where_Criterion.condition} #{where_Criterion.value}
</when>
<when test="where_Criterion.betweenValue" >
${where_Criterion.condition} #{where_Criterion.value} and #{where_Criterion.secondValue}
</when>
<when test="where_Criterion.listValue" >
${where_Criterion.condition}
<foreach collection="where_Criterion.value" item="listItem" open="(" close=")" separator="," >
#{listItem}
</foreach>
</when>
</choose>
<if test="where_Criterion.close!=null and where_Criterion.close!=''">
${where_Criterion.close}
</if>
</foreach>
</if>
<if test="!groupBy.empty">
GROUP BY
<foreach collection="groupBy" item="groupBy_content" open=" " separator="," close=" " >
${groupBy_content}
</foreach>
</if>
<if test="!having.empty">
HAVING 1=1
<foreach collection="having" item="having_Criterion" open=" " separator=" " close=" " >
<choose >
<when test="having_Criterion.noValue" >
${having_Criterion.condition}
</when>
<when test="having_Criterion.singleValue" >
${having_Criterion.condition} #{having_Criterion.value}
</when>
<when test="having_Criterion.betweenValue" >
${having_Criterion.condition} #{having_Criterion.value} and #{having_Criterion.secondValue}
</when>
<when test="having_Criterion.listValue" >
${having_Criterion.condition}
<foreach collection="having_Criterion.value" item="listItem" open="(" close=")" separator="," >
#{listItem}
</foreach>
</when>
</choose>
<if test="having_Criterion.close!=null and having_Criterion.close!=''">
${having_Criterion.close}
</if>
</foreach>
</if>
<if test="!orderBy.empty">
ORDER BY
<foreach collection="orderBy" item="orderBy_content" open=" " separator="," close=" " >
${orderBy_content}
</foreach>
</if>
</select>
</mapper> 望大家指出设计的不足和程序存在的漏洞和错误。
745
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
