《从0开始落地一个分布式项目一》framework-common枚举包装

我们几乎每个人都在公司里面，用过公司级的common包。那么common里面应该有什么呢？从我个人的理解和实际应用中发现，common里面，只保留大家都需要（大家都需要）的东西。而只有部分项目或者部分模块需要的，那么应该丢在模块的子common包里。所以我们的common包不要太臃肿。

下面是我的一个common包的例子和里面大概内容的展示。

 下面就大概来介绍几个，比较好用的小工具吧。

1：枚举小工具

我们日常定义枚举，get set操作，通过code和messge这些去获取枚举类型等，都需要自己写代码。这里有一个封装好的，比较好用的枚举封装。参考了一些别人优秀的代码，加上自己的一些改造最终形成。

先看使用例子

import com.gf.framework.common.model.IDict;
import org.junit.Test;

import java.util.Map;
import java.util.function.BiConsumer;

/**
 * @author gaofei
 * @Description
 * @create 2022/5/25 13:26
 */
public class DictTest {
    enum TESTENUM implements IDict<String, String> {

        TEST1("1", "one"),
        TEST2("2", "two");

        TESTENUM(String code, String message) {
            init(code, message);
        }
    }

    @Test
    public void test() {
        System.out.println(TESTENUM.TEST1.getCode());
        System.out.println(TESTENUM.TEST1.getValue());

        System.out.println("getCodeByValue: " + IDict.getCodeByValue(TESTENUM.class, "one"));
        System.out.println("getValueByCode: " + IDict.getValueByCode(TESTENUM.class, "1"));
        System.out.println("getByCode: " + IDict.getByCode(TESTENUM.class, "1"));

        System.out.println("全部");
        for (TESTENUM testenum : TESTENUM.values()) {
            System.out.println(testenum);
        }

        System.out.println("tomap");
        Map<String, String> map = IDict.toMap(TESTENUM.class);
        map.forEach((s, s2) -> System.out.println(String.format("key:%s value:%s", s, s2)));
    }
}

结果展示：

 

枚举封装对象

import lombok.Data;

/**
 * 字典bean
 * 只有code和text，可用于展示下拉框
 *
 * @author gaofei
 * @since 2022-05-22
 */
@Data
public class DictBean<KEY, VALUE> implements IDict<KEY, VALUE> {
    private final KEY code;
    private final VALUE value;
}

枚举包装类

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;


/**
 * 字典接口
 * <p>
 * 自定义的字典枚举类实现本接口后可省略属性code和text，以及对应的get方法
 * 在构造方法中只需调用init方法即可初始化
 *
 * @author gaofei
 * @since 2022-05-22
 */
public interface IDict<KEY, VALUE> {

    /**
     * 通过code获取value
     *
     * @param clazz 枚举class
     * @param code  code
     * @return text
     */
    static <KEY, VALUE> VALUE getValueByCode(Class<? extends IDict<KEY, VALUE>> clazz, KEY code) {
        return Stream.of(clazz.getEnumConstants())
                .filter((IDict<KEY, VALUE> e) -> e.getCode().equals(code))
                .map(IDict::getValue)
                .findAny().orElse(null);
    }

    /**
     * 通过text获取code
     *
     * @param clazz 枚举class
     * @param value  value
     * @return code
     */
    static <KEY, VALUE> KEY getCodeByValue(Class<? extends IDict<KEY, VALUE>> clazz, VALUE value) {
        return Stream.of(clazz.getEnumConstants())
                .filter((IDict<KEY, VALUE> e) -> e.getValue().equals(value))
                .map(IDict::getCode)
                .findAny().orElse(null);
    }

    static <KEY, VALUE> Map<KEY, VALUE> toMap(Class<? extends IDict<KEY, VALUE>> clazz) {
        IDict<KEY, VALUE>[] enums = clazz.getEnumConstants();
        Map<KEY, VALUE> ret = new HashMap<>();
        for (IDict<KEY, VALUE> dict : enums) {
            ret.put(dict.getCode(), dict.getValue());
        }
        return ret;
    }

    /**
     * 通过code获取字典枚举实例
     *
     * @param clazz 枚举class
     * @param code  code
     * @param <KEY>   字典code类型
     * @param <R>   枚举类型
     * @return 字典枚举实例
     */
    @SuppressWarnings("unchecked")
    static <KEY, VALUE, R extends IDict<KEY, VALUE>> R getByCode(Class<? extends IDict<KEY, VALUE>> clazz, KEY code) {
        return Stream.of(clazz.getEnumConstants())
                .filter((IDict<KEY, VALUE> e) -> (e.getCode().equals(code)))
                .map(v -> (R) v)
                .findAny()
                .orElse(null);
    }

    /**
     * 获取给定的字典枚举项（常用下拉框数据请求）
     *
     * @param enums 可指定需要哪些项
     * @return List
     */
    @SafeVarargs
    static <KEY, VALUE, E extends IDict<KEY, VALUE>> List<IDict> getItems(E... enums) {
        return Stream.of(enums)
                .map(DictPool::getDict)
                .collect(Collectors.toList());
    }

    /**
     * 获取所有字典枚举项，除开指定的枚举
     *
     * @param exclude 指定排除的枚举
     * @return List
     */
    @SafeVarargs
    @SuppressWarnings("unchecked")
    static <KEY, VALUE, E extends IDict<KEY, VALUE>> List<IDict> getItemsExclude(E... exclude) {
        Class<IDict> clazz = (Class<IDict>) exclude.getClass().getComponentType();
        IDict<KEY, VALUE>[] allEnum = clazz.getEnumConstants();
        List<IDict> excludeList = Arrays.asList(exclude);
        return Stream.of(allEnum)
                .filter(e -> !excludeList.contains(e))
                .map(DictPool::getDict)
                .collect(Collectors.toList());
    }

    /**
     * 获取所有字典枚举项（常用下拉框数据请求）
     * 枚举值上标记@Deprecated的不会返回
     *
     * @param clazz 字典枚举类
     * @return List
     */
    static <KEY, VALUE> List<IDict<KEY, VALUE>> getAll(Class<? extends IDict<KEY, VALUE>> clazz) {
        Map<String, Field> fieldCache = Arrays.stream(clazz.getDeclaredFields()).
                filter(Field::isEnumConstant).
                collect(Collectors.toMap(Field::getName, Function.identity()));
        IDict<KEY, VALUE>[] allEnum = clazz.getEnumConstants();
        return Stream.of(allEnum)
                .filter(e -> !fieldCache.get(((Enum<?>) e).name()).isAnnotationPresent(Deprecated.class))
                .map(DictPool::getDict)
                .collect(Collectors.toList());
    }

    /**
     * 初始化
     *
     * @param code 字典编码
     * @param value 字典内容
     */
    default void init(KEY code, VALUE value) {
        DictPool.putDict(this, code, value);
    }

    /**
     * 获取编码
     */
    default KEY getCode() {
        return (KEY) DictPool.getDict(this).getCode();
    }

    /**
     * 获取文本
     */
    default VALUE getValue() {
        return DictPool.getDict(this).getValue();
    }


    class DictPool {
        private static final Map<IDict, DictBean> DICT_MAP = new ConcurrentHashMap<>();

        private static final Map<String, Class<? extends IDict>> DICT_NAME_CLASS_MAP = new ConcurrentHashMap<>();

        static <KEY, VALUE> void putDict(IDict<KEY, VALUE> dict, KEY code, VALUE value) {
            DICT_NAME_CLASS_MAP.put(dict.getClass().getName(), dict.getClass());
            DICT_MAP.put(dict, new DictBean<>(code, value));
        }

        public static <KEY, VALUE> List<IDict<KEY, VALUE>> getDict(String dictName) {
            Class<? extends IDict> aClass = DICT_NAME_CLASS_MAP.get(dictName);
            return IDict.getAll((Class<? extends IDict<KEY, VALUE>>) aClass);
        }

        static <KEY, VALUE, K extends IDict<KEY, VALUE>> DictBean<KEY, VALUE> getDict(K dict) {
            return DICT_MAP.get(dict);
        }


    }

}

2：MapBuilder

这是很常见的封装，先看使用例子:

import com.gf.framework.common.utils.MapBuilder;
import org.junit.Test;

import java.util.Map;

/**
 * @author gaofei
 * @Description
 * @create 2022/5/30 16:20
 */
public class MapBuilderTest {
    @Test
    public void t() {
        MapBuilder<Integer, Integer> mapBuilder = new MapBuilder<>();
        Map<Integer, Integer> map = mapBuilder.put(1, 1).
            put(2, 2).put(3, 3).get();
        System.out.println(map);
    }
}

j结果展示