一夏coco
一夏coco

如何优雅的使用Jpa的JpaSpecificationExecutor提供的复杂查询,实现Specification对象的简单操作

首先看一个查询的列子，输入一个名称，模糊匹配username或者nickName

return adminJpa.findAll(
                adminJpa.support().like("username",name).or(support -> support.like("nickName",name)),
                PageRequest.of(pageNum - 1,pageSize)
        );

以上代码所打印的sql

Hibernate: select * from table table0_ where table0_.nick_name like ? or table0_.username like ? limit ?

相信你直接看都能看得懂以上代码所代表的是什么意思，那么这种操作是怎么实现的呢？

可以看到，我们只用了三四行的代码，就实现了原本需要十几行，并且可读性极差的代码所实现的功能

代码块

首先，我们先自定义一个BaseJpa，将原先继承JpaRepository的接口改成此接口，看以下代码，这里最主要的功能由JpaRepository提供，复杂查询由JpaSpecificationExecutor提供

 ps:修复了升级springboot 2.2.0错误

/**
 * @author hexm
 * @date 2019/8/20 10:54
 */
@NoRepositoryBean
public interface BaseJpa extends JpaRepository, JpaSpecificationExecutor {

    /**
     * 批量删除
     * @param ids
     * @return
     */
    int deleteByIdIn(Collection ids);

    /**
     * 提供默认复杂查询支持
     * @return
     */
    default SpecificationSupport support(){
        return SpecificationSupport.of();
    }
}

我们需要做的就是提供一个Specification的实现，这个实现是JpaSpecificationExecutor接口所要求的参数对象，对此我们做了一层简单的封装，以达到平常需要用到的条件查询，如果你找不到你要的方法，可以在原有的基础上进行添加，相信这一定很简单！下面提供Specification实现

ps:由于业务的升级，提供新的支持函数的查询方式

所以查询方式看起来有可能是这样子的？

如何优雅的使用Jpa的JpaSpecificationExecutor提供的复杂查询,实现Specification对象的简单操作_第1张图片

下面还是工具类：

import org.hibernate.query.criteria.internal.CriteriaBuilderImpl;
import org.hibernate.query.criteria.internal.expression.function.BasicFunctionExpression;
import org.springframework.data.jpa.domain.Specification;

import javax.persistence.criteria.*;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigInteger;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.IntFunction;

/**
 * Jpa复杂查询支持
 *
 * @author hexm
 * @date 2019/8/19 15:25
 */
public class SpecificationSupport implements Specification {

    /**
     * 额外添加的or或者and条件
     */
    private Map> AND_OR = new LinkedHashMap<>();

    /**
     * 里面都是and条件
     */
    private List condition = new ArrayList<>();

    /**
     * 被忽略的属性
     */
    private List ignoreColumn = new ArrayList<>();

    /**
     * 忽略大小写
     */
    private List ignoreCase = new ArrayList<>();

    /**构造时的对象*/
    private T t;

    /**
     * 忽略空字符串
     */
    private boolean ignoreNullString = true;

    private SpecificationSupport() {
    }

    /**
     * 得到一个查询构造器
     *
     * @param probe
     * @param 
     * @param 
     * @return
     */
    public static  SpecificationSupport of(K probe) {
        SpecificationSupport s = new SpecificationSupport<>();
        s.t = probe;
        return s;
    }

    /**
     * 得到一个查询构造器
     *
     * @param 
     * @return
     */
    public static  SpecificationSupport of(Class clazz) {
        return new SpecificationSupport<>();
    }

    /**
     * 得到一个查询构造器
     *
     * @param 
     * @return
     */
    public static  SpecificationSupport of() {
        return new SpecificationSupport<>();
    }

    /**
     * 前匹配 like %column
     *
     * @param column
     * @return
     */
    public SpecificationSupport startsLike(String column) {
        addCondition(column, OptionType.STARTS_LIKE);
        return this;
    }

    /**
     * 后匹配 like column%
     *
     * @param column
     * @return
     */
    public SpecificationSupport endLike(String column) {
        addCondition(column, OptionType.END_LIKE);
        return this;
    }

    /**
     * 匹配 like %column%
     *
     * @param column
     * @return
     */
    public SpecificationSupport like(String column) {
        addCondition(column, OptionType.LIKE);
        return this;
    }

    /**
     * 匹配 = column
     *
     * @param column
     * @return
     */
    public SpecificationSupport eq(String column) {
        addCondition(column, OptionType.EQ);
        return this;
    }

    /**
     * 匹配 != column
     *
     * @param column
     * @return
     */
    public SpecificationSupport neq(String column) {
        addCondition(column, OptionType.NOT_EQ);
        return this;
    }

    /**
     * 匹配 not like %column
     *
     * @param column
     * @return
     */
    public SpecificationSupport notStartLike(String column) {
        addCondition(column, OptionType.NOT_STARTS_LIKE);
        return this;
    }

    /**
     * 匹配 not like column%
     *
     * @param column
     * @return
     */
    public SpecificationSupport notEndLike(String column) {
        addCondition(column, OptionType.NOT_END_LIKE);
        return this;
    }

    /**
     * 匹配 not like %column%
     *
     * @param column
     * @return
     */
    public SpecificationSupport notLike(String column) {
        addCondition(column, OptionType.NOT_LIKE);
        return this;
    }

    /**
     * 匹配 > column
     *
     * @param column 字段属性必须为数字类型，或字符串的数字
     * @return
     */
    public SpecificationSupport gt(String column) {
        addCondition(column, OptionType.GT);
        return this;
    }

    /**
     * 匹配 >= column
     *
     * @param column 字段属性必须为数字类型，或字符串的数字
     * @return
     */
    public SpecificationSupport ge(String column) {
        addCondition(column, OptionType.GE);
        return this;
    }

    /**
     * 匹配 < column
     *
     * @param column 字段属性必须为数字类型，或字符串的数字
     * @return
     */
    public SpecificationSupport lt(String column) {
        addCondition(column, OptionType.LT);
        return this;
    }

    /**
     * 匹配 <= column
     *
     * @param column 字段属性必须为数字类型，或字符串的数字
     * @return
     */
    public SpecificationSupport le(String column) {
        addCondition(column, OptionType.LE);
        return this;
    }


    /**
     * 前匹配 like %column
     *
     * @param column
     * @return
     */
    public SpecificationSupport startsLike(String column, String value) {
        addCondition(column, OptionType.STARTS_LIKE, value);
        return this;
    }

    /**
     * 后匹配 like column%
     *
     * @param column
     * @return
     */
    public SpecificationSupport endLike(String column, String value) {
        addCondition(column, OptionType.END_LIKE, value);
        return this;
    }

    /**
     * 匹配 like %column%
     *
     * @param column
     * @return
     */
    public SpecificationSupport like(String column, String value) {
        addCondition(column, OptionType.LIKE, value);
        return this;
    }

    /**
     * 匹配 = column
     *
     * @param column
     * @return
     */
    public SpecificationSupport eq(String column, Object value) {
        addCondition(column, OptionType.EQ, value);
        return this;
    }

    /**
     * 匹配 != column
     *
     * @param column
     * @return
     */
    public SpecificationSupport neq(String column, Object value) {
        addCondition(column, OptionType.NOT_EQ, value);
        return this;
    }

    /**
     * 匹配 not like %column
     *
     * @param column
     * @return
     */
    public SpecificationSupport notStartLike(String column, String value) {
        addCondition(column, OptionType.NOT_STARTS_LIKE, value);
        return this;
    }

    /**
     * 匹配 not like column%
     *
     * @param column
     * @return
     */
    public SpecificationSupport notEndLike(String column, String value) {
        addCondition(column, OptionType.NOT_END_LIKE, value);
        return this;
    }

    /**
     * 匹配 not like %column%
     *
     * @param column
     * @return
     */
    public SpecificationSupport notLike(String column, String value) {
        addCondition(column, OptionType.NOT_LIKE, value);
        return this;
    }

    /**
     * 匹配 > column
     *
     * @param column 字段属性必须为数字类型
     * @return
     */
    public SpecificationSupport gt(String column, Number value) {
        addCondition(column, OptionType.GT, value);
        return this;
    }

    /**
     * 匹配 >= column
     *
     * @param column 字段属性必须为数字类型
     * @return
     */
    public SpecificationSupport ge(String column, Number value) {
        addCondition(column, OptionType.GE, value);
        return this;
    }

    /**
     * 匹配 < column
     *
     * @param column 字段属性必须为数字类型
     * @return
     */
    public SpecificationSupport lt(String column, Number value) {
        addCondition(column, OptionType.LT, value);
        return this;
    }

    /**
     * 匹配 <= column
     *
     * @param column 字段属性必须为数字类型
     * @return
     */
    public SpecificationSupport le(String column, Number value) {
        addCondition(column, OptionType.LE, value);
        return this;
    }

    /**
     * 匹配 between column1 and column2
     *
     * @param column 字段
     * @param value1 继承了比较接口的对象
     * @param value2 继承了比较接口的对象
     * @return
     */
    public SpecificationSupport between(String column, Comparable value1, Comparable value2) {
        addCondition(column, OptionType.BETWEEN, value1, value2);
        return this;
    }

    /**
     * 匹配 in (column)
     *
     * @param column 字段
     * @param value  多个比较值
     * @return
     */
    public SpecificationSupport in(String column, Object... value) {
        addCondition(column, OptionType.IN, value);
        return this;
    }

    /**
     * 匹配 column is null
     *
     * @param column 字段
     * @return
     */
    public SpecificationSupport isNull(String column) {
        addConditionEmptyValue(column, OptionType.IS_NULL);
        return this;
    }

    /**
     * 匹配 column is not null
     *
     * @param column 字段
     * @return
     */
    public SpecificationSupport isNotNull(String column) {
        addConditionEmptyValue(column, OptionType.IS_NOT_NULL);
        return this;
    }

    /**
     * 匹配 column == true
     *
     * @param column 字段
     * @return
     */
    public SpecificationSupport isTrue(String column) {
        addConditionEmptyValue(column, OptionType.TRUE);
        return this;
    }

    /**
     * 匹配 column == false
     *
     * @param column 字段
     * @return
     */
    public SpecificationSupport isFalse(String column) {
        addConditionEmptyValue(column, OptionType.FALSE);
        return this;
    }

    /**
     * 匹配 date_format(column,'format') ?= value
     * 注：由于指定方法名为：date_format只适用于mysql，如果使用oracle需要改为to_char
     * @param column 匹配字段
     * @param value  匹配值
     * @param format 匹配格式
     * @return
     */
    public SpecificationSupport dateFormat(String column, Object value, String format, OptionType optionType) {
        Map argTypeMap = new HashMap<>();
        argTypeMap.put(column, ArgType.ROOT);   //第一个参数读取字段
        argTypeMap.put(format, ArgType.STRING); //第二个参数字符串类型
        function("date_format", new String[]{column, format}, argTypeMap, optionType, false, value);
        return this;
    }

    /**
     * 匹配 date_format(column,'format') = value
     *
     * @param column 匹配字段
     * @param value  匹配值
     * @param format 匹配格式
     * @return
     */
    public SpecificationSupport dateEq(String column, Object value, String format) {
        dateFormat(column, value, format, OptionType.EQ);
        return this;
    }

    /**
     * 匹配 date_format(column,'format') >= value
     *
     * @param column 匹配字段
     * @param value  匹配值
     * @param format 匹配格式
     * @return
     */
    public SpecificationSupport dateGe(String column, Object value, String format) {
        dateFormat(column, value, format, OptionType.GE);
        return this;
    }

    /**
     * 匹配 date_format(column,'format') <= value
     *
     * @param column 匹配字段
     * @param value  匹配值
     * @param format 匹配格式
     * @return
     */
    public SpecificationSupport dateLe(String column, Object value, String format) {
        dateFormat(column, value, format, OptionType.LE);
        return this;
    }

    /**
     * 匹配 function(column) ? value
     *
     * @param functionName 方法名称
     * @param args         参数名
     * @param typeMap      参数类型
     * @param optionType   比较类型
     * @param emptyValue   是否没有参数
     * @param value        参数
     * @return
     */
    public SpecificationSupport function(String functionName, Object[] args, Map typeMap, OptionType optionType, boolean emptyValue, Object... value) {
        Class clazz;
        //不是空参数，根据比较的参数类型，指定函数的返回类型
        if (!emptyValue && value != null && value[0] != null) {
            clazz = value[0].getClass();
        } else {
            clazz = Boolean.class;
        }
        SupportFunction supportFunction = new SupportFunction(functionName, args, typeMap, optionType, clazz);
        addConditions(null, OptionType.FUNCTION, emptyValue, supportFunction, value);
        return this;
    }

    /**
     * 忽略某个字段属性
     *
     * @param columns
     * @return
     */
    public SpecificationSupport ignoreProperty(String... columns) {
        ignoreColumn.addAll(Arrays.asList(columns));
        return this;
    }

    /**
     * 忽略大小写匹配 = lower(column)
     *
     * @param columns
     * @return
     */
    public SpecificationSupport ignoreCase(String... columns) {
        ignoreCase.addAll(Arrays.asList(columns));
        return this;
    }

    /**
     * 添加条件
     *
     * @param column
     * @param optionType
     */
    private void addCondition(String column, OptionType optionType) {
        try {
            addCondition(column, optionType, ObjectUtils.getField(t, column).get(t));
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 添加条件
     *
     * @param column
     * @param optionType
     */
    private void addConditionEmptyValue(String column, OptionType optionType) {
        addConditions(column, optionType, true, null);
    }

    /**
     * 添加条件
     *
     * @param column
     * @param optionType
     */
    @SafeVarargs
    private final  void addCondition(String column, OptionType optionType, K... value) {
        addConditions(column, optionType, false, null, value);
    }

    /**
     * 添加条件
     *
     * @param column
     * @param optionType
     */
    @SafeVarargs
    private final  void addConditions(String column, OptionType optionType, boolean emptyValue, SupportFunction function, K... value) {
        if (emptyValue) {
            condition.add(new FieldOption<>(column, optionType, value, function));
        } else {
            boolean flag = true;
            for (K k : value) {
                if (k == null) {
                    flag = false;
                    break;
                }
                if ("".equals(k) && ignoreNullString) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                condition.add(new FieldOption<>(column, optionType, value, function));
            }
        }
    }

    /**
     * and操作，创建一个消费者，依靠lambed表达式，消费一个创建好的对象，以添加到定义的队列中
     *
     * @param and
     * @return
     */
    public SpecificationSupport and(Consumer> and) {
        if (and != null) {
            SpecificationSupport s = SpecificationSupport.of();
            and.accept(s);
            if (!s.isEmpty()) {
                AND_OR.put(OptionType.AND, s);
            }
        }
        return this;
    }

    /**
     * or操作，创建一个消费者，依靠lambed表达式，消费一个创建好的对象，以添加到定义的队列中
     *
     * @param or
     * @return
     */
    public SpecificationSupport or(Consumer> or) {
        if (or != null) {
            SpecificationSupport s = SpecificationSupport.of();
            or.accept(s);
            if (!s.isEmpty()) {
                AND_OR.put(OptionType.OR, s);
            }
        }
        return this;
    }

    /**
     * @param root
     * @param query
     * @param cb
     * @return
     */
    @Override
    public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
        if (t != null) {
            Map fieldMap = ObjectUtils.getFieldMap(t.getClass());
            fieldMap.forEach((s1, field) -> {
                try {
                    if (!Modifier.isFinal(field.getModifiers())) {
                        if (!condition.contains(new FieldOption<>(field.getName(), null, null))) {
                            addCondition(field.getName(), OptionType.EQ, field.get(t));
                        }
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            });
        }
        Predicate p = null;
        List predicates = new ArrayList<>();
        for (FieldOption option : condition) {
            //不在忽略字段中
            if (!ignoreColumn.contains(option.name)) {
                Predicate predicate = getPredicate(root, cb, option);
                if (predicate != null) {
                    predicates.add(predicate);
                }
            }
        }
        if (!predicates.isEmpty()) {
            p = cb.and(predicates.toArray(new Predicate[0]));
        }
        for (Map.Entry> entry : AND_OR.entrySet()) {
            OptionType optionType = entry.getKey();
            SpecificationSupport specificationSupport = entry.getValue();
            if (optionType == OptionType.AND) {
                if (p == null) {
                    p = cb.and(specificationSupport.toPredicate(root, query, cb));
                } else {
                    p = cb.and(specificationSupport.toPredicate(root, query, cb), p);
                }
            } else {
                if (p == null) {
                    p = cb.or(specificationSupport.toPredicate(root, query, cb));
                } else {
                    p = cb.or(specificationSupport.toPredicate(root, query, cb), p);
                }
            }
        }
        return p;
    }

    /**
     * 设置是否忽略空串
     *
     * @param ignoreNullString
     */
    public void setIgnoreNullString(boolean ignoreNullString) {
        this.ignoreNullString = ignoreNullString;
    }

    /**
     * 判断构造器条件是否为空
     *
     * @return
     */
    protected boolean isEmpty() {
        return condition.isEmpty() && AND_OR.isEmpty();
    }

    /**
     * 判断条件类型，添加到组合中
     *
     * @param root
     * @param cb
     * @param option
     * @return
     */
    @SuppressWarnings("unchecked")
    private Predicate getPredicate(Root root, CriteriaBuilder cb, FieldOption option) {
        switch (option.getOptionType()) {
            case EQ:
                if (ignoreCase.contains(option.getName())) {
                    return cb.equal(cb.lower(root.get(option.getName())), option.getValue()[0].toString().toLowerCase());
                }
                return cb.equal(root.get(option.getName()), option.getValue()[0]);
            case GE:
                return cb.ge(root.get(option.getName()), (Number) option.getValue()[0]);
            case GT:
                return cb.gt(root.get(option.getName()), (Number) option.getValue()[0]);
            case IN:
                if (ignoreCase.contains(option.getName())) {
                    CriteriaBuilder.In in = cb.in(cb.lower(root.get(option.getName())));
                    for (Object o : option.getValue()) {
                        in.value(o.toString().toLowerCase());
                    }
                    return cb.and(in);
                }
                return root.get(option.getName()).in(option.getValue());
            case LE:
                return cb.le(root.get(option.getName()), (Number) option.getValue()[0]);
            case LT:
                Number o = null;
                if (option.getValue()[0] instanceof String) {
                    o = new BigInteger((String) option.getValue()[0]);
                }
                if (o == null) {
                    o = (Number) option.getValue()[0];
                }
                return cb.lt(root.get(option.getName()), o);
            case LIKE:
                if (ignoreCase.contains(option.getName())) {
                    return cb.like(cb.lower(root.get(option.getName())), "%" + option.getValue()[0].toString().toLowerCase() + "%");
                }
                return cb.like(root.get(option.getName()), "%" + option.getValue()[0] + "%");
            case STARTS_LIKE:
                if (ignoreCase.contains(option.getName())) {
                    return cb.like(cb.lower(root.get(option.getName())), "%" + option.getValue()[0].toString().toLowerCase());
                }
                return cb.like(root.get(option.getName()), "%" + option.getValue()[0]);
            case END_LIKE:
                if (ignoreCase.contains(option.getName())) {
                    return cb.like(cb.lower(root.get(option.getName())), option.getValue()[0].toString().toLowerCase() + "%");
                }
                return cb.like(root.get(option.getName()), option.getValue()[0] + "%");
            case IS_NULL:
                return root.get(option.getName()).isNull();
            case IS_NOT_NULL:
                return root.get(option.getName()).isNotNull();
            case NOT_LIKE:
                if (ignoreCase.contains(option.getName())) {
                    return cb.notLike(cb.lower(root.get(option.getName())), "%" + option.getValue()[0].toString().toLowerCase() + "%");
                }
                return cb.notLike(root.get(option.getName()), "%" + option.getValue()[0] + "%");
            case NOT_STARTS_LIKE:
                if (ignoreCase.contains(option.getName())) {
                    return cb.notLike(cb.lower(root.get(option.getName())), "%" + option.getValue()[0].toString().toLowerCase());
                }
                return cb.notLike(root.get(option.getName()), "%" + option.getValue()[0]);
            case NOT_END_LIKE:
                if (ignoreCase.contains(option.getName())) {
                    return cb.notLike(cb.lower(root.get(option.getName())), option.getValue()[0].toString().toLowerCase() + "%");
                }
                return cb.notLike(root.get(option.getName()), option.getValue()[0] + "%");
            case NOT_EQ:
                if (ignoreCase.contains(option.getName())) {
                    return cb.notEqual(cb.lower(root.get(option.getName())), option.getValue()[0].toString().toLowerCase());
                }
                return cb.notEqual(root.get(option.getName()), option.getValue()[0]);
            case BETWEEN:
                return cb.between(root.get(option.getName()), (Comparable) option.getValue()[0], (Comparable) option.getValue()[1]);
            case TRUE:
                return cb.isTrue(root.get(option.getName()));
            case FALSE:
                return cb.isFalse(root.get(option.getName()));
            case FUNCTION:
                SupportFunction function = option.getFunction();
                Expression[] args = Arrays.stream(function.args).map(o1 -> {
                    ArgType o2 = function.getArgType().get(o1);
                    if (o2 != null) {
                        if (o2 == ArgType.ROOT) {
                            return root.get(o1.toString());
                        } else if (o2 == ArgType.STRING) {
                            return cb.literal(o1);
                        } else if (o2 == ArgType.FUNCTION) {
                            return new BasicFunctionExpression((CriteriaBuilderImpl) cb, String.class, o1.toString());
                        }
                    }
                    return cb.literal(o1);
                }).toArray((IntFunction[]>) Expression[]::new);
                Expression expression = cb.function(function.function, function.resultType, args);
                return getExpression(cb, expression, option);
        }
        return null;
    }

    /**
     * 获取方法表达式
     *
     * @param cb
     * @param expression
     * @param option
     * @return
     */
    @SuppressWarnings("unchecked")
    private Predicate getExpression(CriteriaBuilder cb, Expression expression, FieldOption option) {
        switch (option.function.optionType) {
            case EQ:
                return cb.equal(expression, option.getValue()[0]);
            case GE:
                return cb.ge((Expression) expression, (Number) option.getValue()[0]);
            case GT:
                return cb.gt((Expression) expression, (Number) option.getValue()[0]);
            case IN:
                CriteriaBuilder.In in = cb.in(expression);
                for (Object o : option.getValue()) {
                    in.value(o);
                }
                return cb.and(in);
            case LE:
                return cb.le((Expression) expression, (Number) option.getValue()[0]);
            case LT:
                return cb.lt((Expression) expression, (Number) option.getValue()[0]);
            case LIKE:
                return cb.like((Expression) expression, "%" + option.getValue()[0] + "%");
            case STARTS_LIKE:
                return cb.like((Expression) expression, "%" + option.getValue()[0]);
            case END_LIKE:
                return cb.like((Expression) expression, option.getValue()[0] + "%");
            case IS_NULL:
                return cb.isNull(expression);
            case IS_NOT_NULL:
                return cb.isNotNull(expression);
            case NOT_LIKE:
                return cb.notLike((Expression) expression, "%" + option.getValue()[0] + "%");
            case NOT_STARTS_LIKE:
                return cb.notLike((Expression) expression, "%" + option.getValue()[0]);
            case NOT_END_LIKE:
                return cb.notLike((Expression) expression, option.getValue()[0] + "%");
            case NOT_EQ:
                return cb.notEqual(expression, option.getValue()[0]);
            case BETWEEN:
                return cb.between((Expression) expression, (Comparable) option.getValue()[0], (Comparable) option.getValue()[1]);
            case TRUE:
                return cb.isTrue((Expression) expression);
            case FALSE:
                return cb.isFalse((Expression) expression);
        }
        return null;
    }

    public enum OptionType {
        FUNCTION,   //执行函数
        AND,        //添加and
        OR,         //添加or
        BETWEEN,    //between x1 and x2
        STARTS_LIKE,//like %s
        END_LIKE,   //like s%
        LIKE,       //like %s%
        EQ,         //=
        GT,         //>
        LT,         //<
        GE,         //>=
        LE,         //<=
        IN,         //in
        TRUE,
        FALSE,
        REGEXP,     //regexp(column,regex)
        IS_NULL,    // is null
        IS_NOT_NULL,//is not null
        NOT_EQ,     //!=
        NOT_LIKE,   //not like %s%
        NOT_STARTS_LIKE,//not like %s
        NOT_END_LIKE,   //not like s%
        IGNORE_CASE //忽略大小写
    }

    private static class FieldOption {
        private String name;
        private OptionType optionType;
        private T[] value;
        private SupportFunction function;

        FieldOption(String name, OptionType optionType, T[] value) {
            this.name = name;
            this.optionType = optionType;
            this.value = value;
        }

        FieldOption(String name, OptionType optionType, T[] value, SupportFunction function) {
            this.name = name;
            this.optionType = optionType;
            this.value = value;
            this.function = function;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        OptionType getOptionType() {
            return optionType;
        }

        public void setOptionType(OptionType optionType) {
            this.optionType = optionType;
        }

        public T[] getValue() {
            return value;
        }

        public void setValue(T[] value) {
            this.value = value;
        }

        public SupportFunction getFunction() {
            return function;
        }

        public void setFunction(SupportFunction function) {
            this.function = function;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            FieldOption option = (FieldOption) o;
            return Objects.equals(name, option.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name);
        }
    }

    /**
     * 方法对象
     */
    private static class SupportFunction {
        private String function;
        private Class resultType;
        private Object[] args;
        private Map argType;   //key:argName value:argType
        private OptionType optionType;

        SupportFunction(String function, Object[] args, Map argType, OptionType optionType, Class resultType) {
            this.function = function;
            this.args = args;
            this.argType = argType;
            this.optionType = optionType;
            this.resultType = resultType;
        }

        public String getFunction() {
            return function;
        }

        public void setFunction(String function) {
            this.function = function;
        }

        public Class getResultType() {
            return resultType;
        }

        public void setResultType(Class resultType) {
            this.resultType = resultType;
        }

        public Object[] getArgs() {
            return args;
        }

        public void setArgs(Object[] args) {
            this.args = args;
        }

        public Map getArgType() {
            return argType;
        }

        public void setArgType(Map argType) {
            this.argType = argType;
        }

        public OptionType getOptionType() {
            return optionType;
        }

        public void setOptionType(OptionType optionType) {
            this.optionType = optionType;
        }
    }

    //参数类型，是读取字段，还是字符串参数
    enum ArgType {
        ROOT,
        STRING,
        FUNCTION
    }
}
 
  
关于以上代码中用到的其他工具代码：
 
  
/**
 * 获取对象Field属性对象集合ap
 *
 * @param clazz
 * @return
 */
public static Map getFieldMap(Class clazz) {
    Map result = new LinkedHashMap(16);
    for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            result.put(field.getName(), field);
        }
    }
    return result;
}
//ps：之前漏了一些方法的说明，补充一下，关于ObjectUtils中涉及到的方法
//另外补充一下，其实将Field保存为Map，使用key的方式搜索会更好一点
/**
 * 获取对象Field属性对象
 *
 * @param clazz
 * @param name  属性名称
 * @return
 */
public static Field getField(Class clazz, String name) {
    for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (name.equals(field.getName())) {
                field.setAccessible(true);
                return field;
            }
        }
    }
    return null;
}

/**
 * 获取对象Field属性对象
 *
 * @param obj
 * @param name
 * @param 
 * @return
 */
public static  Field getField(T obj, String name) {
    return getField(obj.getClass(), name);
}
 
  
这些你都可以复制后直接使用！
 
  
具体代码实现原理这里不再累赘，网上很多这方面的资料。
 
  
由于时间问题只看了两天的资料，所以有一些疏漏的地方轻喷，请指正。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Jpa)

        

            

                
    
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • Spring Data JPA
                        kjcoder
SpringDataJPA后端
                        
    JPA概述JPA的全称是JavaPersistenceAPI，即Java持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。JPA规范不干活，真正干活的是依托与它的实现方式(例：hibernate)。搭建环境（需求：保存客户）1.创建maven工程导入坐标org.hibernatehibernate-entitymanager2.需要配置jpa的核心配置文件*位
    
                    
    • 
                    
  • 搭建第一个SpringDataJPA工程
                        码来码去（未来可期）
JavaWebjava
                        
    第一步：创建maven工程，导入maven坐标使用SpringDataJPA，需要整合Spring与SpringDataJPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等4.2.4.RELEASE5.0.7.Final1.6.61.2.120.9.1.25.1.6junitjunit4.9testorg.aspect
    
                    
    • 
                    
  • ios runtime 简单路由
                        Mjs

                        
    1.协议本路由通过协议方式实现首先定义一个必须实现的方法typedefvoid(^JCompletionHandler)(id_Nullableresult,NSError*_Nullableerror);@protocolJRouteHandler@required+(void)handleRequestWithParameters:(nullableJParameters)parameters
    
                    
    • 
                    
  • seata基本使用，柚子快报邀请码778899
                        登录成功

                        
    把seata的使用在这里做了一个总结，希望能够帮助到大家。本案例在实施过程中，威哥力求简单明了，希望大家在学习过程中能够掌握其中的每个细节。好了，废话不多说，如果我们要学习seata，首先需要具备如下技术储备：数据库事务的基本知识；maven工具的使用；熟悉SpringCloudAlibaba技术栈；掌握SpringDataJPA简单使用；一.Seata基本概念1.seata是什么Seata是阿里
    
                    
    • 
                    
  • 基于spring boot的旅游管理系统
                        鹿屿二向箔
springboot旅游后端
                        
    一个简单的SpringBoot应用的基础结构示例，以及如何设置一个基本的旅游管理系统。这个例子将包含用户注册和登录的基本功能。首先，你需要设置一个新的SpringBoot项目。可以通过SpringInitializr网站（https://start.spring.io/）来快速生成一个基础项目结构，选择必要的依赖项，比如Web、Thymeleaf、SpringDataJPA和MySQLDriver
    
                    
    • 
                    
  • 如何使用JPA自定义更新的sql语句实现对数据表的修改？——SpringDataJpa实现自定义（更新）update语句
                        海海不掉头发
笔记allsqlitesqlintellijideajapjpa
                        
    文章目录前言一、DAO层/Mapper层二、Service业务处理层三、Controller控制层总结前言有的时候我们在后台管理系统中只需要修改一列的数据时，JPA的操作死对所有字段进行修改，这样就不太方便，而且SpringDataJpa的框架没有线程的更新方法，只能调用save()方法实行保存修改的数据。如果不想把其中一列的数据修改的话，那么JPA就会自动把这一列不想修改的数据默认null，并且
    
                    
    • 
                    
  • SpringBoot操作GBase8s数据库示例
                        迷你世界～爱丽丝

                        
    SpringBoot+Hibernate(Jpa)操作GBase8s数据库示例GBase8s数据库是国产事务型数据库，目前已在各领域广泛应用，本篇使用当下主流的J2EE框架Springboot集成Hibernate（Jpa），对GBasse8S数据库CRUD操作进行讲解。1.技术点JPA是JAVA标准持久化API，是SUN公司推出的一套基于ORM的规范；Hibernate是对JPA（ORM规范）的
    
                    
    • 
                    
  • SpringData JPA之Respository接口的使用
                        OVA_Won
SpringDatamysqljavaspring
                        
    SpringDataJPA之Respository接口的使用Respository：最顶层的接口也是标志接口，目的是为了统一所有Repository的类型，且能让组件扫描的时候自动识别。准备工作导入JAR包：别忘了导入Junit测试包，否则后面没法单元测试编写Spring和数据库配置文件applicationContext.xml文件com.OVA.pojojdbc.propertiesjdbc.
    
                    
    • 
                    
  • 使用Spring Boot集成Spring Data JPA和单例模式构建库存管理系统
                        潘多编程
java
                        
    引言在企业级应用开发中，数据库操作是非常重要的一环。SpringDataJPA提供了一种简化的方式来进行数据库交互，它使得开发者无需编写复杂的JPA代码就可以完成常见的CRUD操作。此外，设计模式如单例模式可以帮助我们更好地管理和控制对象的创建过程，从而提高系统的性能和可维护性。本文将展示如何结合SpringBoot、SpringDataJPA以及单例模式来构建一个基本的库存管理系统。环境准备在开
    
                    
    • 
                    
  • Spring常用中间件
                        贺仙姑
spring中间件java
                        
    1.数据库中间件（1）MySQL:常用的关系型数据库，支持JDBC和JPA。（2）PostgreSQL:功能强大的开源关系型数据库，支持复杂查询。（3）MongoDB:NoSQL数据库，适合存储非结构化数据。（4）Redis:内存数据结构存储，常用于缓存和消息队列。2.消息队列（1）RabbitMQ:开源消息代理，支持多种消息协议，适合异步处理。（2）Kafka:分布式流处理平台，适合处理大规模数
    
                    
    • 
                    
  • 基于Java新媒体运营分析服务平台设计
                        什么任性
java新媒体运营springspringcloudSSM毕业设计html5
                        
    一、引言随着新媒体行业的迅猛发展，内容创作、用户互动、广告投放等数据的分析变得至关重要。一个基于Java的新媒体运营分析服务平台，旨在整合多源数据，通过大数据处理和分析技术，为新媒体运营团队提供全面、实时的运营洞察。本平台设计旨在提高决策效率，优化内容策略，增强用户参与度，并最终提升品牌影响力和变现能力。二、技术栈和框架后端开发：SpringBoot（微服务架构）、SpringDataJPA（数据
    
                    
    • 
                    
  • java开发记录
                        T_Y9943
java开发语言
                        
    24.9.6记录一下今天学到的注解,主要是@Api注解@Param详解SpringDataJPA查询结果为空时遇到的问题一个高级的java写法将list中3的值保存下来,重点在filter，此外还有map。Listintegers=list.stream().filter(e->e%3!=0).collect(Collectors.toList());Javalist移除元素JAP查询到的结果是P
    
                    
    • 
                    
  • SpringBoot学习（5）Spring boot Jpa使用
                        星河漫漫l
springboot开发语言运维开发学习
                        
    SpringBootJpa介绍首先了解Jpa是什么？Jpa(JavaPersistenceAPI)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。值得注意的是，Jpa是在充分吸收了现有Hibe
    
                    
    • 
                    
  • SpringBoot2快速入门05--jpa
                        老鼠AI大米_Java全栈

                        
    本节我们学习使用Jpa，jpa其实是一个规范，在出来之前，都是使用hibernate，hibernate可以使程序员以面向对象的方式操作数据库，我还是喜欢nativesql。先导入相关包，如下：compile('org.springframework.boot:spring-boot-starter-data-jpa')compile('mysql:mysql-connector-java')配置
    
                    
    • 
                    
  • Spring Data JPA-根据表生成代码
                        daqinzl
SpringDataJPA代码自动生成freemarker
                        
    参考资源https://blog.csdn.net/feiying0canglang/article/details/120643968，在此基础上丰富了repository，service，controller的模版。本文下载链接：https://download.csdn.net/download/daqinzl/89713067
    
                    
    • 
                    
  • SpringBoot 中怎么链接数据库并获取数据
                        爱掉发的小龙
javaspringbootspring经验分享后端
                        
    在Spring框架中，有多种方式可以链接数据库并获取数据。常见的方式包括使用SpringJDBC、SpringDataJPA和SpringDataJDBC。以下是每种方式的简要说明和示例代码。###1.使用SpringJDBCSpringJDBC提供了一组方便的类，用于简化数据库访问。以下是使用SpringJDBC的步骤：####配置数据源首先，需要配置数据源。这可以在`application.p
    
                    
    • 
                    
  • JPA简介与实战
                        是Guava不是瓜娃
SSMjpa
                        
    一、什么是JPAJPA：JavaPersistenceAPI，Java持久层API。是JDK5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。类似于JDBC，JPA是一组规范（接口），使应用程序以统一方式访问持久层。具体的实现：HibernateToplink其他ORM框架JPA和Hibernate的关系JPA是规范：JPA本质上就是一种ORM规范，不是ORM框架
    
                    
    • 
                    
  • java.lang.ClassNotFoundException: javax.xml.bind.JAXBException解决方案
                        xujia-Li
问题及解决方案JDK9.0JAXBAPI
                        
    今天在学习springbootspringdatajpa时，出现了这个错误，错误日志如下：java.lang.IllegalStateException:FailedtoloadApplicationContextatorg.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(D
    
                    
    • 
                    
  • SpringBoot2--Spring Data JPA
                        笔记整理
Springboot
                        
    前言SpringData项目的目的是为了简化构建基于Spring框架应用的数据访问技术，包括非关系数据库、Map-Reduce框架、云数据服务等等；另外也包含对关系数据库的访问支持。一、简介1、SpringData特点SpringData为我们提供使用统一的API来对数据访问层进行操作；这主要是SpringDataCommons项目来实现的。SpringDataCommons让我们在使用关系型或者
    
                    
    • 
                    
  • SpringBoot项目中使用SpringData-JPA持久化数据
                        火星刻苦的杏仁
springbootjavamybatis
                        
    目录一、什么是JPA二、SpringData-JPA与MybatisPuls的区别三、项目中使用JPAJPA常用注解JPA进阶使用技巧一、什么是JPAJPA是JavaPersistenceAPI的简称，中文名Java持久层API，其设计目标主要是为了简化现有的持久化开发工作和整合ORM技术。简单地说，JPA就是为POJO（PlainOrdinaryJavaObject）提供持久化的标准规范，即将J
    
                    
    • 
                    
  • SpringBoot--整合JPA
                        吴声子夜歌
SpringBootJPASpringBootJPA整合
                        
    SpringBoot整合JPA创建工程并导入依赖4.0.0pers.zhangspringboot_jpa1.0-SNAPSHOTorg.springframework.bootspring-boot-starter-parent1.5.9.RELEASEorg.springframework.bootspring-boot-starter-weborg.springframework.boots
    
                    
    • 
                    
  • Spring Data：JPA与Querydsl
                        光图强
java
                        
    JPAJPA是java的一个规范，用于在java对象和数据库之间保存数据，充当面向对象领域模型和数据库之间的桥梁。它使用Hibernate、TopLink、IBatis等ORM框架实现持久性规范。SpringDataSpringData是Spring的一个子项目，用于简化数据库访问，支持NoSql数据和关系数据库。支持的NoSql数据库包括：Mongodb、redis、Hbase、Neo4j。Sp
    
                    
    • 
                    
  • Java Hibernate深度解析：11步精通ORM框架的艺术与安全
                        墨瑾轩
Java乐园javahibernate安全
                        
    关注墨瑾轩，带你探索编程的奥秘！超萌技术攻略，轻松晋级编程高手技术宝库已备好，就等你来挖掘订阅墨瑾轩，智趣学习不孤单即刻启航，编程之旅更有趣第1章：引言：JPA与Hibernate的邂逅1.1什么是JPA？Hey，小伙伴们，欢迎来到JPA的奇妙世界！JPA，全称JavaPersistenceAPI，是一个让Java程序和数据库愉快玩耍的桥梁。想象一下，你有一个装满玩具的盒子，JPA就是帮你把玩具（
    
                    
    • 
                    
  • springboot中的@Cacheable缓存来增加手动分页的查询效率 为什么用手动分页业务用的jpa jpa中查了下没有数据库中间件
                        烟雨国度
springboot缓存数据库
                        
    2024/7/319:45:09claude-3-opus-20240229当然可以！我们可以对代码进行进一步的优化，以提高性能。以下是一些优化建议：使用缓存机制：对于频繁查询的关键词或查询条件，可以考虑将查询结果缓存起来，避免重复查询数据库。可以使用Spring提供的缓存抽象（如@Cacheable、@CacheEvict等注解），或者使用第三方缓存库（如Redis）来实现缓存功能。优化正则表达
    
                    
    • 
                    
  • SpringBoot JPA
                        Puny丶微芒

                        
    定义JPA是JavaPersistenceAPI的简称，中文名Java持久层API，是JDK5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA的总体思想和现有Hibernate、TopLink、JDO等ORM框架大体一致。总的来说，JPA包括以下3方面的技术：1.ORM映射元数据JPA支持XML和JDK注解两种元数据的形式，元数据描述对象和表之间的映射关系，
    
                    
    • 
                    
  • 使用jpa的@Query注解查询数据库中datatime类型数据报错Unknown column 'startTime' in 'where clause'
                        JadeHanLiang
遇到的问题javajpa
                        
    今天使用jpa的@Query这个注解查询数据时，sql语句语法出现了错误，记录下来。我的错误写法是这样的@Query(value="select*fromtbwhereDATE_FORMAT(start_time,'%Y-%m-%d')=DATE_FORMAT(startTime,'%Y-%m-%d')",nativeQuery=true)ListfindByStartTime(Datestart
    
                    
    • 
                    
  • Springboot+Mybatis+jpa+thymeleaf实现增删改查
                        柒麒
javaspringbootmybatis
                        
    Springboot+Mybatis+jpa+thymeleaf项目结构pom文件Application配置文件实体类controller层实现类service层接口service层实现类dao层接口启动类index.html首页add.html添加页面update.html更新页面创建user表添加表数据首页展示添加修改删除总结项目结构pom文件配置相关依赖：UTF-8UTF-81.8org.s
    
                    
    • 
                    
  • 关于springboot持久层框架mybatis+jpa组合使用
                        小码农吗
日常栏目javamybatisspringbootmysql
                        
    一、简介JPA和MyBatis各有各的好处，混合食用效果更佳。(hibernate是面向对象的，而MyBatis是面向关系的)个人总结（总结自己的理解）1.表关联较多的项目，优先使用mybatis2.持续维护开发迭代较快的项目建议使用mybatis，因为一般这种项目需要变化很灵活，对sql的灵活修改要求较高3.对于传统项目或者关系模型较为清晰稳定的项目，建议JPA（比如DDD设计中的领域层）4.目
    
                    
    • 
                    
  • SpringBoot + Mybatis/JPA
                        jesus_H
java
                        
    这篇主要讲解SpringBoot结合JPA和Mybatis的使用SpringBoot作为后端框架，必定要对数据库进行crud操作，JPA和Mybatis把这些操作进行了封装，方便了代码的编写。JPA先从比较简单的JPA讲起第一步，添加依赖org.springframework.bootspring-boot-starter-data-jpamysqlmysql-connector-javaorg.
    
                    
    • 
                                
  • [黑洞与暗粒子]没有光的世界
                                    comsci

                                    
         无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算 
 
     但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界.... 
 
     那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的 
 
&nbs
    
                                
    • 
                                
  • jQuery Lazy Load 图片延迟加载
                                    aijuans
jquery
                                    
    基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。 
对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。 
 
 版本： 
 

  jQuery v1.4.4+ 
 

  jQuery Lazy Load v1.7.2 
 
 
 注意事项： 
 
 
 需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
    
                                
    • 
                                
  • 使用Jodd的优点
                                    Kai_Ge
jodd
                                    
    1.  简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。 
2.  简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。 
3.  对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。 
  
使用方法简介
    
                                
    • 
                                
  • jpa Query转hibernate Query
                                    120153216
Hibernate
                                    
    public List<Map> getMapList(String hql,
			Map map) {
		org.hibernate.Query jpaQuery = entityManager.createQuery(hql);
		if (null != map) {
			for (String parameter : map.keySet()) {
				jp
    
                                
    • 
                                
  • Django_Python3添加MySQL/MariaDB支持
                                    2002wmj
mariaDB
                                    
    现状 
首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案 
首先据MySQL文档[3]说，自从MySQL
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗IO最多的SQL
                                    357029540
SQL Server
                                    
    返回做IO数目最多的50条语句以及它们的执行计划。 
select top 50   
 
(total_logical_reads/execution_count) as avg_logical_reads,  
 
(total_logical_writes/execution_count) as avg_logical_writes,  
 
(tot
    
                                
    • 
                                
  • spring UnChecked 异常 官方定义！
                                    7454103
spring
                                    
      如果你接触过spring的 事物管理！那么你必须明白 spring的 非捕获异常！ 即 unchecked 异常！ 因为 spring 默认这类异常事物自动回滚！！ 
 
 
 
 
public static boolean isCheckedException(Throwable ex)
    {
   return !(ex instanceof RuntimeExcep
    
                                
    • 
                                
  • mongoDB 入门指南、示例
                                    adminjun
javamongodb操作
                                    
    一、准备工作 
1、 下载mongoDB 
下载地址：http://www.mongodb.org/downloads 
选择合适你的版本 
相关文档：http://www.mongodb.org/display/DOCS/Tutorial 
2、 安装mongoDB 
A、 不解压模式： 
将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
    
                                
    • 
                                
  • CUDA 5 Release Candidate Now Available
                                    aijuans
CUDA
                                    
    The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
    
                                
    • 
                                
  • Essential Studio for WinRT网格控件测评
                                    Axiba
JavaScripthtml5
                                    
    Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。 
 
 
网格控件功能 
1、
    
                                
    • 
                                
  • java 获取windows系统安装的证书或证书链
                                    bewithme
windows
                                    
      
    有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库  。 
有关证书链的解释可以查看此处 。 
  
public static void main(String[] args) {
		SunMSCAPI providerMSCAPI = new SunMSCAPI();
		S
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(set类型和zset类型)
                                    bijian1013
redis数据库NoSQL
                                    
    4.sets类型 
        Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。 
        sadd：向名称为key的set中添加元
    
                                
    • 
                                
  • 异常捕获何时用Exception，何时用Throwable
                                    bingyingao

                                    
    用Exception的情况 
 try { 
       //可能发生空指针、数组溢出等异常 
        } catch (Exception e) { 
         
    
                                
    • 
                                
  • 【Kafka四】Kakfa伪分布式安装
                                    bit1129
kafka
                                    
    在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证   1. 安装步骤 
  
Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
    
                                
    • 
                                
  • Project Euler
                                    bookjovi
haskell
                                    
    Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。 
    看看problem 1吧： 
 Add all the natural num
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-ArrayDeque
                                    BrokenDreams
Collections
                                    
            表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。 
        这篇要看一下java.util.ArrayDeque。从命名上看
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-装饰模式-Decorator
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.Fi
    
                                
    • 
                                
  • Maven学习(一)
                                    chenyu19891124
Maven私服
                                    
        学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
    
                                
    • 
                                
  • [原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充
                                    comsci
算法工作PHP搜索引擎嵌入式
                                    
    本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点 
 
 节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法) 
 
 需要解决的问题：已知分支
    
                                
    • 
                                
  • Linux中用shell获取昨天、明天或多天前的日期
                                    daizj
linuxshell上几年昨天获取上几个月
                                    
    在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年 
 
 
# 获取昨天 
date -d 'yesterday'  # 或 date -d 'last day' 
# 获取明天 
date -d 'tomorrow'   # 或 date -d 'next day' 
# 获取上个月 
date -d 'last month' 
# 
    
                                
    • 
                                
  • 我所理解的云计算
                                    dongwei_6688
云计算
                                    
          在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说： 
 
        Cloud computing is a phrase used to describe a variety of computing co
    
                                
    • 
                                
  • YII CMenu配置
                                    dcj3sjt126com
yii
                                    
    Adding id and class names to CMenu 
We use the id and htmlOptions to accomplish this. Watch.   
//in your view
$this->widget('zii.widgets.CMenu', array(
	'id'=>'myMenu',
	'items'=>$this-&g
    
                                
    • 
                                
  • 设计模式之静态代理与动态代理
                                    come_for_dream
设计模式
                                    
    静态代理与动态代理 
        代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
    
                                
    • 
                                
  • 【转】理解Javascript 系列
                                    gcc2ge
JavaScript
                                    
    理解Javascript_13_执行模型详解 
 
  摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
    
                                
    • 
                                
  • Subsets II
                                    hcx2013
set
                                    
    Given a collection of integers that might contain duplicates, nums, return all possible subsets. 
Note: 
 
 Elements in a subset must be in non-descending order. 
 The solution set must not conta
    
                                
    • 
                                
  • Spring4.1新特性——Spring缓存框架增强
                                    jinnianshilongnian
spring4
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • shell嵌套expect执行命令
                                    liyonghui160com

                                    
      
  
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧. 
  系统:centos 5.x 
  
1.先安装expect 
yum -y install expect 
  
2.脚本内容: 
cat auto_svn.sh 
  
#!/bin/bash

    
                                
    • 
                                
  • Linux实用命令整理
                                    pda158
linux
                                    
    0. 基本命令   　　linux 基本命令整理   　 
　1. 压缩 解压   　　tar -zcvf a.tar.gz a   #把a压缩成a.tar.gz   　　tar -zxvf a.tar.gz     #把a.tar.gz解压成a   　 
　2. vim小结   　　2.1 vim替换   　　:m,ns/word_1/word_2/gc  
    
                                
    • 
                                
  • 独立开发人员通向成功的29个小贴士
                                    shoothao
独立开发
                                    
      
 概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。  
   
 
 明白你从事独立开发的原因和目的。 
 保持坚持制定计划的好习惯。 
 万事开头难，第一份订单是关键。 
 培养多元化业务技能。 
 提供卓越的服务和品质。 
 谨小慎微。 
 营销是必备技能。 
 学会组织，有条理的工作才是最有效率的。 
 “独立
    
                                
    • 
                                
  • JAVA中堆栈和内存分配原理
                                    uule
java
                                    
    1、栈、堆  
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f
    
                                
    •