📄 querycondition.java
字号:
package com.lily.dap.model;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ToStringBuilder;
/**
* 查询条件实体类，用于传递查询条件内容</p>
* 使用方式：</p>
* QueryCondition queryCondition = new QueryCondition();</p>
* queryCondition.setSelects(new String[]{"class_id", "count(name)"}); //查询给定分类的记录条数
* queryCondition.setGroupbys(new String[]{"class_id"}); //GroupBy分组
* queryCondition.putCondition("id", "-1"); //这个查询条件将忽略</p>
* queryCondition.putCondition("username", "admin"); </p>
* queryCondition.putCondition("name", QueryExpression.OP_IN, "张三,李四,王五");</p>
* queryCondition.putCondition("birthday", QueryExpression.OP_GE, "2005-12-31");</p>
* queryCondition.putCondition("birthday", QueryExpression.OP_LE, "2006-12-31");</p>
* queryCondition.addOrder("username"); //设置查询进行排序</p>
* queryCondition.setPageSize(10); //设置查询结果实现翻页，每页10条记录</p>
* queryCondition.setPageNo(2); //设置查询结果实现翻页，显示第二页记录</p>
* List list = dao.gets(Register.class, queryCondition);</p>
* 将生成查询条件如下：</p>
* from com.lily.dap.model.Register where username = 'admin' and name in ('张三', '李四', '王五') and</p>
* birthday >= '2005-12-31' and birthday <= '2006-12-31' order by username asc</p>
*
* queryCondition.putCondition("cond0", null);
* assertEquals("", queryCondition.getCondition("cond0").getValue());
*
* queryCondition.putCondition("cond1", "value1");
* assertEquals("value1", queryCondition.getCondition("cond1").getValue());
*
* SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
* queryCondition.putCondition("cond2", sdf.parse("2006-12-31"));
* assertEquals("2006-12-31 00:00:00", queryCondition.getCondition("cond2").getValue());
*
* queryCondition.putCondition("cond3", new long[]{1,2,3});
* assertEquals("1,2,3", queryCondition.getCondition("cond3").getValue());
*
* queryCondition.putCondition("cond4", new int[]{100,200,300});
* assertEquals("100,200,300", queryCondition.getCondition("cond4").getValue());
*
* queryCondition.putCondition("cond5", new String[]{"aa", "bb", "cc"});
* assertEquals("aa,bb,cc", queryCondition.getCondition("cond5").getValue());
*
* List list = new ArrayList();
* list.add("aaa");
* list.add(new Long(1234));
* queryCondition.putCondition("cond6", list);
* assertEquals("aaa,1234", queryCondition.getCondition("cond6").getValue());
*
* queryCondition.putCondition("cond7", new Long(123));
* assertEquals("123", queryCondition.getCondition("cond7").getValue());
*
* queryCondition.putCondition("cond8", new Boolean(true));
* assertEquals("true", queryCondition.getCondition("cond8").getValue());
*
* queryCondition.putCondition("cond9", new Float(33.3333f));
* assertEquals("33.3333", queryCondition.getCondition("cond9").getValue());
*
* @author zouxuemo
*/
public class QueryCondition extends BaseObject {
/** Comment for <code>serialVersionUID</code> */
private static final long serialVersionUID = -5970921549911182011L;
/** 选择列数组 */
protected String[] selects = null;
/** Group By 数组 */
protected String[] groupbys = null;
/**
* 查询条件列表，存放QueryExpression对象
*
* <code>conditions</code>
*/
protected List conditions = new ArrayList();
/**
* 排序字段列表，存放QueryOrder对象
*
* <code>orders</code>
*/
protected List orders = new ArrayList();
/**
* 从查询结果返回的页号，默认为0表示不分页
*
* <code>pageNo</code>
*/
protected int pageNo = 0;
/**
* 从查询结果返回的每页记录条数，默认0：表示不分页
*
* <code>pageSize</code>
*/
protected int pageSize = 0;
private Iterator itCondition = null;
private Iterator itOrder = null;
/** @return Returns the selects.
*/
public String[] getSelects() {
return selects;
}
/** @param selects The selects to set.
*/
public QueryCondition setSelects(String[] selects) {
this.selects = selects;
return this;
}
/** @return Returns the groupbys.
*/
public String[] getGroupbys() {
return groupbys;
}
/** @param groupbys The groupbys to set.
*/
public QueryCondition setGroupbys(String[] groupbys) {
this.groupbys = groupbys;
return this;
}
/**
* @return the conditions
*/
public List getConditions() {
return conditions;
}
/**
* @param conditions the conditions to set
*/
public void setConditions(List conditions) {
this.conditions = conditions;
}
/**
* 添加等于操作的条件表达式，指定条件名称、条件值，默认查询操作为"="，并且不覆盖有同样名的查询条件
*
* @param condition_name
* @param condition_value
* @return
*/
public QueryCondition putCondition(String condition_name, Object condition_value) {
return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, false);
}
/**
* 添加等于操作的条件表达式，指定条件名称、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
*
* @param condition_name
* @param condition_value
* @param isReplaceRepeat
* @return
*/
public QueryCondition putCondition(String condition_name, Object condition_value, boolean isReplaceRepeat) {
return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, isReplaceRepeat);
}
/**
* 添加条件表达式，指定条件名称、条件操作、条件值，默认不覆盖有同样名的查询条件
*
* @param condition_name
* @param condition_op
* @param condition_value
* @return
*/
public QueryCondition putCondition(String condition_name, String condition_op, Object condition_value) {
return putCondition(condition_name, condition_op, condition_value, false);
}
/**
* 添加条件表达式，指定条件名称、条件操作、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
*
* @param condition_name
* @param condition_op
* @param condition_value
* @param isReplaceRepeat
* @return
*/
public QueryCondition putCondition(String condition_name, String condition_op, Object condition_value, boolean isReplaceRepeat) {
if (isReplaceRepeat)
removeCondition(condition_name);
if (condition_value == null)
condition_value = "";
conditions.add(new QueryExpression(condition_name, condition_op, condition_value));
return this;
}
/**
* 添加条件表达式，指定条件名称、条件操作、条件值、条件值类型，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
*
* @param condition_name
* @param condition_op
* @param condition_value
* @param conditin_type
* @param isReplaceRepeat
* @return
*/
public QueryCondition putCondition(String condition_name, String condition_op, Object condition_value, String conditin_type, boolean isReplaceRepeat) {
if (isReplaceRepeat)
removeCondition(condition_name);
if (condition_value == null)
condition_value = "";
conditions.add(new QueryExpression(condition_name, condition_op, condition_value, conditin_type));
return this;
}
/**
* 添加等于操作的条件表达式，指定条件名称、条件值，默认查询操作为"="，并且不覆盖有同样名的查询条件
*
* @param condition_name
* @param condition_value
* @return
*/
public QueryCondition putCondition(String condition_name, long condition_value) {
return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, false);
}
/**
* 添加等于操作的条件表达式，指定条件名称、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
*
* @param condition_name
* @param condition_value
* @param isReplaceRepeat
* @return
*/
public QueryCondition putCondition(String condition_name, long condition_value, boolean isReplaceRepeat) {
return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, isReplaceRepeat);
}
/**
* 添加条件表达式，指定条件名称、条件操作、条件值，默认不覆盖有同样名的查询条件
*
* @param condition_name
* @param condition_op
* @param condition_value
* @return
*/
public QueryCondition putCondition(String condition_name, String condition_op, long condition_value) {
return putCondition(condition_name, condition_op, condition_value, false);
}
/**
* 添加条件表达式，指定条件名称、条件操作、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
*
* @param condition_name
* @param condition_op
* @param condition_value
* @param isReplaceRepeat
* @return
*/
public QueryCondition putCondition(String condition_name, String condition_op, long condition_value, boolean isReplaceRepeat) {
if (isReplaceRepeat)
removeCondition(condition_name);
conditions.add(new QueryExpression(condition_name, condition_op, new Long(condition_value)));
return this;
}
/**
* 添加等于操作的条件表达式，指定条件名称、条件值，默认查询操作为"="，并且不覆盖有同样名的查询条件
*
* @param condition_name
* @param condition_value
* @return
*/
public QueryCondition putCondition(String condition_name, int condition_value) {
return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, false);
}
/**
* 添加等于操作的条件表达式，指定条件名称、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
*
* @param condition_name
* @param condition_value
* @param isReplaceRepeat
* @return
*/
public QueryCondition putCondition(String condition_name, int condition_value, boolean isReplaceRepeat) {
return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, isReplaceRepeat);
}
/**
* 添加条件表达式，指定条件名称、条件操作、条件值，默认不覆盖有同样名的查询条件
*
* @param condition_name
* @param condition_op
* @param condition_value
* @return
*/
public QueryCondition putCondition(String condition_name, String condition_op, int condition_value) {
return putCondition(condition_name, condition_op, condition_value, false);
}
/**
* 添加条件表达式，指定条件名称、条件操作、条件值，指定是否覆盖有同样名的查询条件，指定覆盖，则如果条件名称已经存在，覆盖原有条件
*
* @param condition_name
* @param condition_op
* @param condition_value
* @param isReplaceRepeat
* @return
*/
public QueryCondition putCondition(String condition_name, String condition_op, int condition_value, boolean isReplaceRepeat) {
if (isReplaceRepeat)
removeCondition(condition_name);
conditions.add(new QueryExpression(condition_name, condition_op, new Integer(condition_value)));
return this;
}
/* ********************
*
* 暂时屏蔽
* 把浮点数作为查询对象的情况很少见，这里就不对这个特例专门编写方法了
* 如果非要用，可以调用上面提供的方法同样可以实现这种查询
*
* ********************/
// /**
// * 添加等于操作的条件表达式，指定条件名称、条件值，默认查询操作为"="，并且不覆盖有同样名的查询条件
// *
// * @param condition_name
// * @param condition_value
// * @return
// */
// public QueryCondition putCondition(String condition_name, double condition_value) {
// return putCondition(condition_name, QueryExpression.OP_EQ, condition_value, false);
// }
//
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -