FilterParam.java

package com.mycim.valueobject.sorter;

import com.mycim.framework.utils.lang.StringUtils;
import com.mycim.framework.utils.lang.collections.ListUtils;
import com.mycim.framework.utils.lang.collections.MapUtils;

import java.util.List;
import java.util.Map;

/**
 * 参数过滤整合对象
 * @author yibing.liu
 * @version 1.0
 * @date 2021/06/29
 */
public class FilterParam<T> {

    //是否需要过滤关键key的内容
    private boolean filter;

    //需要过滤的关键key列
    private String keyColumn;

    //自定义的列名，用于当 keyColumn 匹配成功过后，需要以另外列名作为标记列
    private String customColumn;

    //关键字符，用于对关键key列的匹配
    private String keyCharacter;

    //判断是否有值 或者判断是否包含关键字符
    private boolean isEmpty;

    //需要标记的符号
    private String mark = "1";

    //是否需要补齐空白位置
    private boolean fillBlank = true;

    //返回值的类型，目前只需要：String 和 List
    private Class<T> outType;

    //槽位数默认为25
    private int slotCount = 25;

    //position、unitId、unitRrn、lotId、lotid(兼容此key)、lotRrn、chooseFlag
    // 可通过 addStringColumn()自定义添加需要过滤的列名
    private List<Column> columnArrayList = ListUtils.newArrayList(new Column("unitId"), new Column("unitRrn"),
                                                                  new Column("lotId"), new Column("lotRrn"), new Column("chooseFlag"));

    //可以确定唯一数字的列名
    private String integerColumn = "position";

    //唯一数字的列名
    private String seqColumn = "position";

    public FilterParam() {
        this.outType = (Class<T>) String.class;
        this.filter = false;
    }

    public FilterParam(Class<T> tClass) {
        this.outType = tClass;
        this.filter = false;
    }

    /**
     * 判断 指定对象中的 keyColumn 属性值是否为空
     * @param keyColumn     指定对象中的属性
     */
    public FilterParam(String keyColumn) {
        this.filter = true;
        this.keyColumn = keyColumn;
        this.isEmpty = true;
    }

    public FilterParam(String keyColumn, Class<T> tClass) {
        this.filter = true;
        this.keyColumn = keyColumn;
        this.isEmpty = true;
        this.outType = tClass;
    }
    /**
     * 判断 指定对象中的 keyColumn 属性是否包含 关键字符 keyCharacter
     * @param keyColumn     指定对象中的属性
     * @param keyCharacter  关键字符 keyCharacter
     */
    public FilterParam(String keyColumn, String keyCharacter) {
        this.filter = true;
        this.keyColumn = keyColumn;
        this.keyCharacter = keyCharacter;
    }

    public FilterParam(String keyColumn, String keyCharacter, Class<T> tClass) {
        this.filter = true;
        this.keyColumn = keyColumn;
        this.keyCharacter = keyCharacter;
        this.outType = tClass;
    }

    public String getKeyColumn() {
        return StringUtils.isEmpty(customColumn) ? keyColumn : customColumn;
    }

    public void setKeyColumn(String keyColumn) {
        this.keyColumn = keyColumn;
    }

    public String getKeyCharacter() {
        return keyCharacter;
    }

    public void setKeyCharacter(String keyCharacter) {
        this.keyCharacter = keyCharacter;
    }

    public void setCustomColumn(String customColumn) {
        this.customColumn = customColumn;
    }

    public boolean isFilter() {
        return filter;
    }

    public String canMark(Object object, String mark){
        if (isEmpty){
            if (keyColumn == null || object == null) return StringUtils.EMPTY;
        } else {
            if (keyCharacter == null || keyColumn == null || object == null) return StringUtils.EMPTY;
        }

        if (object instanceof Map){
            if (isEmpty){ //判断条件为是否有值
                if (((Map) object).get(keyColumn) != null && !StringUtils
                        .equalsIgnoreCase(MapUtils.getString((Map)object, keyColumn), StringUtils.EMPTY)) return mark;
            } else { //判断条件为是否包含关键字符
                if (MapUtils.getString((Map)object, keyColumn, StringUtils.EMPTY).contains(keyCharacter)) return mark;
            }
        }
        if (object instanceof String){
            if (isEmpty){
                if (StringUtils.isNotEmpty((String)object))return mark;
            } else {
                if (StringUtils.defaultIfEmpty((String)object, StringUtils.EMPTY).contains(keyCharacter)) return mark;
            }
        }
        return StringUtils.EMPTY;
    }

    public int getSlotCount() {
        return slotCount;
    }

    public void setSlotCount(int slotCount) {
        this.slotCount = slotCount;
    }

    public List<Column> getColumnArrayList() {
        return columnArrayList;
    }

    public String getIntegerColumn() {
        return integerColumn;
    }

    public void setIntegerColumn(String integerColumn) {
        if (StringUtils.isNotEmpty(integerColumn)){
            this.integerColumn = integerColumn;
        }
    }

    public String getSeqColumn() {
        return seqColumn;
    }

    public void setSeqColumn(String seqColumn) {
        if (StringUtils.isNotEmpty(seqColumn)) {
            this.seqColumn = seqColumn;
        }
    }

    public Class<T> getOutType(){
        //默认返回String
        return outType == null? (Class<T>) String.class :outType;
    }

    public void addColumn(String keyColumn){
        //可以自定添加需要转换key
        Column column = new Column(keyColumn, keyColumn);
        if (StringUtils.isNotEmpty(keyColumn) && !columnArrayList.contains(column)){
            columnArrayList.add(column);
        }
    }

    public void addColumn(String matchColumn, String actualColumn){
        //可以自定添加需要转换key
        Column column = new Column(matchColumn, actualColumn);
        if (StringUtils.isNotEmpty(matchColumn) && !columnArrayList.contains(column)){
            columnArrayList.add(column);
        }
    }

    public String getMark() {
        return mark;
    }

    public void setMark(String mark) {
        this.mark = mark;
    }

    public boolean isFillBlank() {
        return fillBlank;
    }

    public void setFillBlank(boolean fillBlank) {
        this.fillBlank = fillBlank;
    }

    public static class Column {
        private String matchColumn;
        private String actualColumn;

        Column(String column){
            this.matchColumn = column;
            this.actualColumn = column;
        }

        Column(String matchColumn, String actualColumn){
            this.matchColumn = matchColumn;
            this.actualColumn = actualColumn;
        }

        public String getMatchColumn() {
            return matchColumn;
        }

        public String getActualColumn() {
            return actualColumn;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Column){//需要区分大小写
                return StringUtils.equals(matchColumn, ((Column) obj).getMatchColumn())
                        && StringUtils.equals(actualColumn, ((Column) obj).getActualColumn());
            }
            return false;
        }

    }
}