HibernateCRUD基础框架(1)-实体类

HibernateCRUD基础框架包括3篇文章，主要讲述整个CRUD基础框架的思路。

第1篇：讲述最基本的实体类，这些实体类是对SQL语言中的一些概念的封装。

第2篇：在这些实体类的基础上，开发一个“HQL语句构造器-HqlQueryBuilder”。

第3篇：构建一套简单的和较为复杂的标准的CRUD API。

优点：提高代码复用，提升编码效率。

缺点：没有过多考虑性能，具体性能没有去检验。

功能有限，只是针对常用的和较为简单的CRUD功能。

友情提示：注释已经写得比较清楚了，不再过多解释。

有问题，可以留言，抽空答复。

第1篇：实体类

1.常量和基础定义

package cn.fansunion.hibernate.sql;

/**
 * SQL关键字常量“and,like,where”，比较符常量">,<,="等常量。
 *
 * @author LeiWen@FansUnion.cn
 */
public class ConstantBase {

    /**
     * SQL关键字or
     */
    public static final String OR = "or";
    /**
     * SQL关键字and
     */
    public static final String AND = "and";
    /**
     * SQL关键字from
     */
    public static final String FROM = "from";
    /**
     * SQL关键字as
     */
    public static final String AS = "as";
    /**
     * SQL关键字where
     */
    public static final String WHERE = "where";
    /**
     * SQL关键字asc
     */
    public static final String ASC = "asc";
    /**
     * SQL关键字desc
     */
    public static final String DESC = "desc";
    /**
     * SQL关键字in
     */
    public static final String IN = "in";
    /**
     * not in
     */
    public static final String NOT_IN = "not in";
    /**
     * SQL关键字like
     */
    public static final String LIKE = "like";
    /**
     * not like
     */
    public static final String NOT_LIKE = "not like";
    /**
     * order by
     */
    public static final String ORDER_BY = "order by";
    /**
     * group by
     */
    public static final String GROUP_BY = "group by";
    /**
     * SQL关键字limit
     */
    public static final String LIMIT = "limit";
    /**
     * 冒号
     */
    public static final String COLON = ":";
    /**
     * 逗号
     */
    public static final String COMMA = ",";
    /**
     * 一个空格
     */
    public static final String BLANK = " ";
    /**
     * 一个空字符串
     */
    public static final String EMPTY = "";
    /**
     *
     */
    public static final boolean AUTO_ADD = true;
    /**
     * 右括号
     */
    public static final String RIGHT_BRACKET = ")";
    /**
     * 左括号
     */
    public static final String LEFT_BRACKET = "(";
    /**
     * 百分号
     */
    public static final String PERCENT = "%";
    /**
     * 单引号
     */
    public static final String SINGLE_QUOTATION_MARK = "'";
    /**
     * 等号
     */
    public static final String EQUALS = "=";
    /**
     * 不等
     */
    public static final String NOT_EQUALS = "!=";
    /**
     * 大于号
     */
    public static final String GREAT_THAN = ">";
    /**
     * 小于号
     */
    public static final String LESS_THAN = "<";
    /**
     * 大于等于
     */
    public static final String GREAT_THAN_EQUALS = ">=";
    /**
     * 小于等于
     */
    public static final String LESS_THAN_EQUALS = "<=";

    // *************************************
    // **********左右分别加1个空格的常量*****************
    // *************************************
    public static final String EQUALS_WITH_BLANK = buildBlank(EQUALS);
    public static final String NOT_EQUALS_WITH_BLANK = buildBlank(NOT_EQUALS);

    public static final String GREAT_THAN_WITH_BLANK = buildBlank(GREAT_THAN);
    public static final String LESS_THAN_WITH_BLANK = buildBlank(LESS_THAN);

    public static final String GREAT_THAN_EQUALS_WITH_BLANK = buildBlank(GREAT_THAN_EQUALS);
    public static final String LESS_THAN_EQUALS_WITH_BLANK = buildBlank(LESS_THAN_EQUALS);

    public static final String IN_WITH_BLANK = buildBlank(IN);
    public static final String NOT_IN_WITH_BLANK = buildBlank(NOT_IN);

    public static final String LIKE_WITH_BLANK = buildBlank(LIKE);
    public static final String NOT_LIKE_WITH_BLANK = buildBlank(NOT_LIKE);

    public static final String ORDER_BY_WITH_BLANK = buildBlank(ORDER_BY);
    public static final String GROUP_BY_WITH_BLANK = buildBlank(GROUP_BY);

    public static final String LIMIT_WITH_BLANK = buildBlank(LIMIT);
    public static final String WHERE_WITH_BLANK = buildBlank(WHERE);
    public static final String AS_WITH_BLANK = buildBlank(AS);

    /**
     * 返回变量对应的字符串值
     *
     * @param or
     * @return true返回“or”，false返回"and"
     */
    public static String isOr(Boolean or) {
        String str = AND;
        if (or) {
            str = OR;
        }
        return str;
    }

    /**
     * 在字符串的左边加上百分号"%"，在字符串的右边加上百分号"%"
     *
     * @param str
     *            字符串
     * @return 被"%%"包围起来的新的字符串
     */
    public static String buildLike(Object str) {
        String newStr = PERCENT + str + PERCENT;
        return newStr;
    }

    /**
     * 在一个字符串的左边和右边都加上一个空格
     *
     * @param str
     * @return 新的字符串
     */
    public static String buildBlank(Object str) {
        String newStr = BLANK + str + BLANK;
        return newStr;
    }

    /**
     * 在字符串的左边和右边加上单引号"'"
     *
     * @param str
     *            字符串
     * @return 被"''"包围起来的新的字符串
     */
    public static String buildQuota(Object str) {
        String newStr = SINGLE_QUOTATION_MARK + str + SINGLE_QUOTATION_MARK;
        return newStr;
    }

    /**
     * 在字符串的左边加上左括号"("，在字符串的右边加上右括号")"
     *
     * @param str
     *            字符串
     * @return 被"()"包围起来的新的字符串
     */
    public static String buildBracket(Object str) {
        String newStr = LEFT_BRACKET + str + RIGHT_BRACKET;
        return newStr;
    }

    public static void println(Object object) {
        System.out.println(object);
    }

    public static void print(Object object) {
        System.out.print(object);
    }
}

package cn.fansunion.hibernate.sql;

/**
 * 操作符的类型,如"= != > >= < <="。
 *
 * @author LeiWen@FansUnion.cn
 */
public enum Operator {

    EQUALS, NOT_EQUALS, GREAT_THAN, GREAT_THAN_EQUALS, LESS_THAN, LESS_THAN_EQUALS, LIKE, NOT_LIKE, IN, NOT_IN;
    /**
     * 转化为字符串（TODO 放在一个单独的工具类里比较合适）
     */
    public static String toString(Operator operator) {
        String str = "";

        switch (operator) {
        case EQUALS:
            str = ConstantBase.EQUALS;
            break;

        case NOT_EQUALS:
            str = ConstantBase.NOT_EQUALS;
            break;

        case GREAT_THAN:
            str = ConstantBase.GREAT_THAN;
            break;

        case GREAT_THAN_EQUALS:
            str = ConstantBase.GREAT_THAN_EQUALS;
            break;

        case LESS_THAN:
            str = ConstantBase.LESS_THAN;
            break;

        case LESS_THAN_EQUALS:
            str = ConstantBase.LESS_THAN_EQUALS;
            break;

        case LIKE:
            str = ConstantBase.LIKE;
            break;

        case NOT_LIKE:
            str = ConstantBase.NOT_LIKE;
            break;

        case IN:
            str = ConstantBase.IN;
            break;

        case NOT_IN:
            str = ConstantBase.NOT_IN;
            break;

        default:
            break;
        }
        return str;
    }
}

public enum AndOr {
    AND, OR
}

2.实体类

package cn.fansunion.hibernate.sql.entity;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.text.StrBuilder;

import cn.fansunion.hibernate.sql.ConstantBase;

/**
 * From语句，如"from User user"。
 *
 * @author LeiWen@FansUnion.cn
 */
public class From extends ConstantBase {
    /**
     * 实体类的class，如User.class
     */
    private Class<?> modelClazz;
    /**
     * 实体类Class的字符串表示，如User
     */
    private String model;
    /**
     * 别名，如user
     */
    private String alias;

    public From() {
        super();
    }

    public From(Class<?> modelClazz) {
        super();
        this.modelClazz = modelClazz;
    }

    public From(Class<?> modelClazz, String alias) {
        super();
        this.modelClazz = modelClazz;
        this.alias = alias;
    }

    public From(String model) {
        super();
        this.model = model;
    }

    public From(String model, String alias) {
        super();
        this.model = model;
        this.alias = alias;
    }

    //
    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public Class<?> getModelClazz() {
        return modelClazz;
    }

    public void setModelClazz(Class<?> modelClazz) {
        this.modelClazz = modelClazz;
    }

    public String getAlias() {
        return alias;
    }

    public void setAlias(String alias) {
        this.alias = alias;
    }
    /**
     * 转化为字符串
     */
    public String toString() {
        if (modelClazz != null) {
            this.model = modelClazz.getSimpleName();
        }

        StrBuilder builder = new StrBuilder();
        if (StringUtils.isNotEmpty(model)) {
            builder.append(FROM).append(BLANK)
                    .append(modelClazz.getSimpleName());
            if (StringUtils.isNotEmpty(alias)) {
                builder.append(AS_WITH_BLANK).append(alias);
            }
        }

        return builder.toString();
    }

}

package cn.fansunion.hibernate.sql.entity;

import java.util.Date;

import cn.fansunion.hibernate.sql.ConstantBase;
import cn.fansunion.hibernate.sql.Operator;

/**
 * 1个查询条件。由3部分构成，键-操作-值，如 "age > 12 ","email ='LeiWen@FansUnion.cn'"等。
 *
 * @author LeiWen@FansUnion.cn
 */
public class Condition extends ConstantBase {
    /**
     * 条件的键
     */
    private String key;
    /**
     * 条件的操作符
     */
    private Operator operator;
    /**
     * 条件的值
     */
    private Object value;

    public Condition() {

    }

    public Condition(String key, Operator operator) {
        super();
        this.key = key;
        this.operator = operator;
    }

    public Condition(String key, Object value) {
        this.key = key;
        this.value = value;
    }

    public Condition(String key, Operator operator, Object value) {
        this.key = key;
        this.operator = operator;
        this.value = value;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public Operator getOperator() {
        return operator;
    }

    public void setOperator(Operator operator) {
        this.operator = operator;
    }

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    /**
     * 转化为字符串
     */
    public String toString() {
        String str = "";

        String newValue = "";
        // 构造完整的语句
        if (value != null) {
            // 是否需要自动增加"%%","()"
            if (AUTO_ADD) {
                switch (operator) {
                case LIKE:

                case NOT_LIKE:
                    newValue = buildLike(value);
                    break;

                case IN:
                case NOT_IN:
                    newValue = buildBracket(value);
                    break;

                default:
                    break;
                }

                // 需要添加引号的类型
                boolean isString = value instanceof String;
                boolean isDate = value instanceof Date;
                boolean isSqlDate = value instanceof java.sql.Date;
                if (isString || isDate || isSqlDate) {
                    newValue = buildQuota(value);
                } else {
                    newValue = value.toString();
                }

            }
        }
        // 构造带有占位符的语句
        else {
            newValue = COLON + key;
        }
        // "name=a","name like a",统一都加个空格
        str += key + BLANK + Operator.toString(operator) + BLANK + newValue;
        return str;
    }
}

package cn.fansunion.hibernate.sql.entity;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.text.StrBuilder;

import cn.fansunion.hibernate.AndOr;
import cn.fansunion.hibernate.sql.ConstantBase;
import cn.fansunion.hibernate.util.EmptyUtils;

/**
 * 逻辑上属于1个组的条件。
 *
 * @author LeiWen@FansUnion.cn
 */
public class GroupCondition extends ConstantBase {
    /**
     * 多个条件构成的集合
     */
    private List<Condition> conditionList;

    /**
     * 组内各个条件之间的关系：且|或，默认为且
     */
    private List<Boolean> relationList;

    public static final Boolean AND = true;
    public static final Boolean OR = false;

    public GroupCondition() {
        conditionList = new ArrayList<Condition>();
        relationList = new ArrayList<Boolean>();
    }

    public void addCondition(Condition condition) {
        addCondition(condition, true);
    }

    public void addCondition(Condition condition, boolean or) {
        conditionList.add(condition);
        if (EmptyUtils.notEmpty(conditionList)) {
            relationList.add(or);
        }
    }

    public void addCondition(Condition condition, AndOr ao) {
        conditionList.add(condition);
        if (EmptyUtils.notEmpty(conditionList)) {
            if (ao == AndOr.AND) {
                relationList.add(AND);
            } else {
                relationList.add(OR);
            }
        }
    }

    public void addOr(int index, boolean or) {
        relationList.set(index, or);
    }

    /**
     * 转化为字符串
     */
    public String toString() {
        if (EmptyUtils.isEmpty(conditionList)) {
            return EMPTY;
        }

        StrBuilder builder = new StrBuilder();
        int size = conditionList.size();
        for (int index = 0; index < size; index++) {
            if (index == 0) {
                builder.append(conditionList.get(index));
            } else {
                builder.append(BLANK).append(isOr(relationList.get(index)))
                        .append(BLANK).append(conditionList.get(index));
            }
        }
        return builder.toString();
    }

}

package cn.fansunion.hibernate.sql.entity;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.text.StrBuilder;

import cn.fansunion.hibernate.sql.ConstantBase;
import cn.fansunion.hibernate.util.EmptyUtils;

/**
 * 搜索条件（2个组之间，且|或。）
 *
 * @author LeiWen@FansUnion.cn
 */
public class SearchCondition extends ConstantBase {

    /**
     * 多个组条件构成的集合
     */
    private List<GroupCondition> groupConditionList;

    /**
     * 多个组条件之间的关系：且|或，默认为且
     */
    private List<Boolean> and;

    public SearchCondition() {
        groupConditionList = new ArrayList<GroupCondition>();
        and = new ArrayList<Boolean>();

    }

    public void addGroupCondition(GroupCondition groupCondition) {
        addGroupCondition(groupCondition, false);
    }

    public void addGroupCondition(GroupCondition groupCondition, boolean or) {
        groupConditionList.add(groupCondition);
        if (EmptyUtils.notEmpty(groupConditionList)) {
            and.add(or);
        }
    }

    public void addOr(int index, boolean or) {
        and.set(index, or);
    }

    public List<GroupCondition> getGroupConditionList() {
        return groupConditionList;
    }

    public void setGroupConditionList(List<GroupCondition> groupConditionList) {
        this.groupConditionList = groupConditionList;
    }

    public List<Boolean> getAnd() {
        return and;
    }

    public void setAnd(List<Boolean> and) {
        this.and = and;
    }

    /**
     * 转化为字符串
     */
    public String toString() {
        if (EmptyUtils.isEmpty(groupConditionList)) {
            return EMPTY;
        }

        StrBuilder builder = new StrBuilder();

        int size = groupConditionList.size();
        for (int index = 0; index < size; index++) {
            // 1个组的条件用()包起来
            if (index == 0) {
                builder.append(WHERE_WITH_BLANK).append(
                        buildBracket(groupConditionList.get(index)));

            } else {
                builder.append(BLANK).append(isOr(and.get(index)))
                        .append(BLANK)
                        .append(buildBracket(groupConditionList.get(index)));
            }
        }

        return builder.toString();
    }
}

package cn.fansunion.hibernate.sql.entity;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.text.StrBuilder;

import cn.fansunion.hibernate.sql.ConstantBase;

/**
 *
 * 排序语句，如“order by id desc”。
 *
 * @author LeiWen@FansUnion.cn
 */
public class Order extends ConstantBase {
    /**
     * 排序语句的键
     */
    private String key;
    /**
     * 排序语句的升序或降序（字符串形式）
     */
    private String asc;
    /**
     * 排序语句的升序或降序（布尔形式）
     */
    private Boolean isAsc;

    public Order() {

    }

    public Order(String key, String asc) {
        this.key = key;
        this.asc = asc;
    }

    public Order(String key, Boolean isAsc) {
        super();
        this.key = key;
        this.isAsc = isAsc;
    }

    /**
     * 转化为字符串
     */
    public String toString() {
        String finalSort = DESC;

        if (StringUtils.isNotEmpty(asc)) {
            finalSort = asc;
        } else {
            if (isAsc) {
                finalSort = ASC;
            }
        }

        StrBuilder builder = new StrBuilder();
        builder.append(key).append(BLANK).append(finalSort);
        return builder.toString();
    }

}

package cn.fansunion.hibernate.sql.entity;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.text.StrBuilder;

import cn.fansunion.hibernate.sql.ConstantBase;
import cn.fansunion.hibernate.util.ListUtils;

/**
 * 排序组，如"order by id desc,name asc"。
 *
 * @author LeiWen@FansUnion.cn
 */
public class OrderGroup extends ConstantBase {
    /**
     * 多个排序构成的集合
     */
    private List<Order> orderList;

    public OrderGroup() {
        orderList = new ArrayList<Order>();
    }

    public OrderGroup(Order order) {
        this();
        orderList.add(order);
    }

    public OrderGroup(Order order1, Order order2) {
        this();
        orderList.add(order1);
        orderList.add(order2);
    }

    public void addOrder(Order order) {
        orderList.add(order);
    }
    /**
     * 转化为字符串
     */
    public String toString() {
        StrBuilder builder = new StrBuilder();
        if (ListUtils.notEmpty(orderList)) {
            String orders = ListUtils.list2String(orderList);
            builder.append(ORDER_BY_WITH_BLANK).append(orders);
        }
        return builder.toString();
    }

}

package cn.fansunion.hibernate.sql.entity;

import java.util.ArrayList;
import java.util.List;

import cn.fansunion.hibernate.sql.ConstantBase;
import cn.fansunion.hibernate.util.EmptyUtils;
import cn.fansunion.hibernate.util.ListUtils;

/**
 * 分组语句,如"group by id,name"。
 *
 * @author LeiWen@FansUnion.cn
 */
public class GroupBy extends ConstantBase {

    /**
     * 分组的字段名称构成的集合，暂时不支持having子句
     */
    private List<String> group;

    public GroupBy() {
        group = new ArrayList<String>();
    }

    public List<String> getGroup() {
        return group;
    }

    /**
     * 转化为字符串
     */
    public String toString() {
        if (EmptyUtils.notEmpty(group)) {
            String groupStr = ListUtils.list2String(group);
            return GROUP_BY_WITH_BLANK + groupStr;
        }
        return EMPTY;
    }

    public void addGroup(String g) {
        this.group.add(g);
    }
}

原文链接：http://blog.fansunion.cn/articles/3616(小雷博客-blog.fansunion.cn)