MyBatis3下的通用SQL的select语句执行类

文章由LinuxBoy分享于2019-03-30 01:03:53热评（625）

MyBatis3下的通用SQL的select语句执行类

项目中为了使项目的数据库操作从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]
*{*|talbe.*|[table.]field1[AS alias1][,[table.]field2[AS alias2][,…]]}
*FROM tableexpression[,…][IN externaldatabase]
*[WHERE…]
*[GROUP BY…]
*[HAVING…]
*[ORDER BY…]
*[WITH OWNERACCESS OPTION]
*说明：
*用中括号([])括起来的部分表示是可选的，用大括号({})括起来的部分是表示必须从中选择其中的一个。
*
*/
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连接条件
* 切记用了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连接条件
* 切记用了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：连接条件,没有传动态参数的查询条件部分
* 一个静态查询条件必须包含4部分内容：连接规则字段列运算符值
* 连接规则: (and 或者 or)
* 字段名: （field1）
* 运算符: 必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者
* = 或者 <> 或者!= 或者 like 或者 not like 或者 in 或者 not in
* 或者 between 或者 not between )
* 值 : 注意：如果元素符是in,则值部分必须写成 (value1,value2...)的形式。
* 如果元素符是between,则值部分必须为 value1 and value2 的形式，value1为min，value2为max。
* 如果元素符是like,则值部分可以在值的左右两边加上%或者_的通配符。
* %：表示匹配任意个字符；_:表示匹配一个字符。
* @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部分内容：
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符
* 运算符:必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者 = 或者
* <> 或者!= 或者 like 或者 not like 或者 in 或者not in )
* @param value: 参数值,Object对象，支持任何类型
* 注意：如果conditions的运算符是in, 则value部分可以传递一个list的对象,
* list对象至少要包含一个Object类型的元素;如果conditions的运算符是like
* 部分,则value部分可以在"value1"值的左右两边加上%或者_的通配符。
* %：表示匹配任意个字符；_:表示匹配一个字符
* @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部分内容：
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符
* 运算符:必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者
* = 或者 <> 或者!= 或者 like 或者 not like 或者 in 或者 not in )
* @param value: 参数值,Object对象，支持任何类型
* 注意：如果conditions的运算符是in, 则value部分可以传递一个list的对象,list对象至少要包含一个Object类型的元素
* 如果conditions的运算符是like部分,则value部分可以在"value1"值的左右两边加上%或者_的通配符
* %：表示匹配任意个字符；_:表示匹配一个字符
* @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部分内容：
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符
* 运算符:必须以下运算符中的一个( between 或者 not between )
* @param value: 参数值，Object对象，between的参数值左部分，支持任何类型
* @param secondValue 参数值，Object对象，between的参数值右部分，支持任何类型
* @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子语句（一个参数的情况）
* 切记having里面的字段group by里面必须有，不然会触发sql语法错误异常
* @param conditions：连接条件,没有传动态参数的查询条件部分
* 一个静态查询条件必须包含4部分内容：连接规则字段列运算符值
* 连接规则: (and 或者 or)
* 字段名: （field1）
* 运算符: 必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者
* = 或者 <> 或者!= 或者 like 或者 not like 或者 in 或者 not in
* 或者 between 或者 not between )
* 值: 注意：如果元素符是in,则值部分必须写成 (value1,value2...)的形式。
* 如果元素符是between,则值部分必须为 value1 and value2 的形式，value1为min，value2为max。
* 如果元素符是like,则值部分可以在值的左右两边加上%或者_的通配符。
* %：表示匹配任意个字符；_:表示匹配一个字符。
* @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的情况
* 切记having里面的字段group by里面必须有，不然会触发sql语法错误异常
* @param conditions: 连接条件,没有传动态参数的查询条件部分，必须包含3部分内容：
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符
* 运算符:必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者 = 或者
* <> 或者!= 或者 like 或者 not like 或者 in 或者not in )
* @param value: 参数值,Object对象，支持任何类型
* 注意：如果conditions的运算符是in, 则value部分可以传递一个list的对象,
* list对象至少要包含一个Object类型的元素;如果conditions的运算符是like
* 部分,则value部分可以在"value1"值的左右两边加上%或者_的通配符。
* %：表示匹配任意个字符；_:表示匹配一个字符
* @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关闭符号的情况
* 切记having里面的字段group by里面必须有，不然会触发sql语法错误异常
* @param conditions: 连接条件,没有传动态参数的查询条件部分，必须包含3部分内容：
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符
* 运算符:必须以下运算符中的一个( > 或者 >= 或者 < 或者 <= 或者
* = 或者 <> 或者!= 或者 like 或者 not like 或者 in 或者 not in )
* @param value: 参数值,Object对象，支持任何类型
* 注意：如果conditions的运算符是in, 则value部分必须传递一个list的对象,
* list对象至少要包含一个Object类型的元素；
* 如果conditions的运算符是like部分,则value部分可以在"value1"值的左右两边加上%或者_的通配符
* %：表示匹配任意个字符；_:表示匹配一个字符
* @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关闭符号的情况
* 切记having里面的字段group by里面必须有，不然会触发sql语法错误异常
* @param conditions: 连接条件,没有传动态参数的查询条件部分，必须包含3部分内容：
* 连接规则:(and 或者 or)+ 字段列:（field1）+ 运算符
* 运算符:必须以下运算符中的一个( between 或者 not between )
* @param value: 参数值，Object对象，between的参数值左部分，支持任何类型
* @param secondValue: 参数值，Object对象，between的参数值右部分，支持任何类型
* @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;
}
}

推荐文章：

MyBatis3下的通用SQL的select语句执行类

MyBatis3下的通用SQL的select语句执行类

最新Linux教程教程

Linux头条

MyBatis3下的通用SQL的select语句执行类

MyBatis3下的通用SQL的select语句执行类

相关内容

最新Linux教程教程

Linux头条