バックグラウンド

システム内の列挙のステータスは自明であり、ステータス、タイプ、シーン、ロゴなど、数十から数百に及びます。次のコードは非常に一般的であり、同様のコードはどこにでもあると思います。目標: このようなコードを排除する冗長なコード。


/**
     * 根据枚举代码获取枚举
     * 
     */
    public static OrderStatus getByCode(String code){
    
    
        for (OrderStatus v : values()) {
    
    
            if (v.getCode().equals(code)) {
    
    
                return v;
            }
        }
        return null;
    }

    /**
     * 根据枚举名称获取枚举
     * 当枚举内的实例数越多时性能越差
     */
    public static OrderStatus getByName(String name){
    
    
        for (OrderStatus v : values()) {
    
    
            if (v.name().equals(name)) {
    
    
                return v;
            }
        }
        return null;
    }

列挙型キャッシュ

コードの冗長性を減らし、コードを簡潔にする
for ループを削除すると、パフォーマンスが安定して効率的になります。

モジュール設計図

キャッシュ構造

画像の説明を追加してください

ソースコード分析


package com.alipay.enumcache;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 枚举缓存
 */
public class EnumCache {
    
    

    /**
     * 以枚举任意值构建的缓存结构
     **/
    static final Map<Class<? extends Enum>, Map<Object, Enum>> CACHE_BY_VALUE = new ConcurrentHashMap<>();
    /**
     * 以枚举名称构建的缓存结构
     **/
    static final Map<Class<? extends Enum>, Map<Object, Enum>> CACHE_BY_NAME = new ConcurrentHashMap<>();
    /**
     * 枚举静态块加载标识缓存结构
     */
    static final Map<Class<? extends Enum>, Boolean> LOADED = new ConcurrentHashMap<>();


    /**
     * 以枚举名称构建缓存，在枚举的静态块里面调用
     *
     * @param clazz
     * @param es
     * @param <E>
     */
    public static <E extends Enum> void registerByName(Class<E> clazz, E[] es) {
    
    
        Map<Object, Enum> map = new ConcurrentHashMap<>();
        for (E e : es) {
    
    
            map.put(e.name(), e);
        }
        CACHE_BY_NAME.put(clazz, map);
    }

    /**
     * 以枚举转换出的任意值构建缓存，在枚举的静态块里面调用
     *
     * @param clazz
     * @param es
     * @param enumMapping
     * @param <E>
     */
    public static <E extends Enum> void registerByValue(Class<E> clazz, E[] es, EnumMapping<E> enumMapping) {
    
    
        if (CACHE_BY_VALUE.containsKey(clazz)) {
    
    
            throw new RuntimeException(String.format("枚举%s已经构建过value缓存,不允许重复构建", clazz.getSimpleName()));
        }
        Map<Object, Enum> map = new ConcurrentHashMap<>();
        for (E e : es) {
    
    
            Object value = enumMapping.value(e);
            if (map.containsKey(value)) {
    
    
                throw new RuntimeException(String.format("枚举%s存在相同的值%s映射同一个枚举%s.%s", clazz.getSimpleName(), value, clazz.getSimpleName(), e));
            }
            map.put(value, e);
        }
        CACHE_BY_VALUE.put(clazz, map);
    }

    /**
     * 从以枚举名称构建的缓存中通过枚举名获取枚举
     *
     * @param clazz
     * @param name
     * @param defaultEnum
     * @param <E>
     * @return
     */
    public static <E extends Enum> E findByName(Class<E> clazz, String name, E defaultEnum) {
    
    
        return find(clazz, name, CACHE_BY_NAME, defaultEnum);
    }

    /**
     * 从以枚举转换值构建的缓存中通过枚举转换值获取枚举
     *
     * @param clazz
     * @param value
     * @param defaultEnum
     * @param <E>
     * @return
     */
    public static <E extends Enum> E findByValue(Class<E> clazz, Object value, E defaultEnum) {
    
    
        return find(clazz, value, CACHE_BY_VALUE, defaultEnum);
    }

    private static <E extends Enum> E find(Class<E> clazz, Object obj, Map<Class<? extends Enum>, Map<Object, Enum>> cache, E defaultEnum) {
    
    
        Map<Object, Enum> map = null;
        if ((map = cache.get(clazz)) == null) {
    
    
            executeEnumStatic(clazz);// 触发枚举静态块执行
            map = cache.get(clazz);// 执行枚举静态块后重新获取缓存
        }
        if (map == null) {
    
    
            String msg = null;
            if (cache == CACHE_BY_NAME) {
    
    
                msg = String.format(
                        "枚举%s还没有注册到枚举缓存中，请在%s.static代码块中加入如下代码 : EnumCache.registerByName(%s.class, %s.values());",
                        clazz.getSimpleName(),
                        clazz.getSimpleName(),
                        clazz.getSimpleName(),
                        clazz.getSimpleName()
                );
            }
            if (cache == CACHE_BY_VALUE) {
    
    
                msg = String.format(
                        "枚举%s还没有注册到枚举缓存中，请在%s.static代码块中加入如下代码 : EnumCache.registerByValue(%s.class, %s.values(), %s::getXxx);",
                        clazz.getSimpleName(),
                        clazz.getSimpleName(),
                        clazz.getSimpleName(),
                        clazz.getSimpleName(),
                        clazz.getSimpleName()
                );
            }
            throw new RuntimeException(msg);
        }
        if(obj == null){
    
    
            return defaultEnum;
        }
        Enum result = map.get(obj);
        return result == null ? defaultEnum : (E) result;
    }

    private static <E extends Enum> void executeEnumStatic(Class<E> clazz) {
    
    
        if (!LOADED.containsKey(clazz)) {
    
    
            synchronized (clazz) {
    
    
                if (!LOADED.containsKey(clazz)) {
    
    
                    try {
    
    
                        // 目的是让枚举类的static块运行，static块没有执行完是会阻塞在此的
                        Class.forName(clazz.getName());
                        LOADED.put(clazz, true);
                    } catch (Exception e) {
    
    
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }

    /**
     * 枚举缓存映射器函数式接口
     */
    @FunctionalInterface
    public interface EnumMapping<E extends Enum> {
    
    
        /**
         * 自定义映射器
         *
         * @param e 枚举
         * @return 映射关系，最终体现到缓存中
         */
        Object value(E e);
    }

}

鍵の解釈

オープンクローズの原理
オープンクローズの原理とは何ですか?
変更は受け付けられていませんが、新しい拡張機能は受け付けられています。オープンとクローズの原則を満たすために、キャッシュが列挙型をアクティブにロードするのではなく、列挙型がアクティブにキャッシュに登録されるように設計されています。この設計の利点は、列挙型を追加するときに、列挙型を個別に登録するだけで済むことです。現在の列挙型の静的ブロックこれだけです。他のコードを変更する必要はありません。
たとえば、新しい状態クラス列挙型を追加したいとします。


public enum StatusEnum {
    
    
    INIT("I", "初始化"),
    PROCESSING("P", "处理中"),
    SUCCESS("S", "成功"),
    FAIL("F", "失败");

    private String code;
    private String desc;

    StatusEnum(String code, String desc) {
    
    
        this.code = code;
        this.desc = desc;
    }

    public String getCode() {
    
    
        return code;
    }

    public String getDesc() {
    
    
        return desc;
    }

    static {
    
    
        // 通过名称构建缓存,通过EnumCache.findByName(StatusEnum.class,"SUCCESS",null);调用能获取枚举
        EnumCache.registerByName(StatusEnum.class, StatusEnum.values());
        // 通过code构建缓存,通过EnumCache.findByValue(StatusEnum.class,"S",null);调用能获取枚举
        EnumCache.registerByValue(StatusEnum.class, StatusEnum.values(), StatusEnum::getCode);
    }
}

登録タイミング
静的ブロックに登録を入れますが、静的ブロックはいつ実行されるのでしょうか？

1. クラスの新しいインスタンスが初めて作成されたとき
2. クラスの静的メソッドが初めて呼び出されたとき
3. クラスまたはインターフェイスの非最終静的フィールドが初めて使用されたとき
4. 最初の Class.forName の場合

列挙を作成するために StatusEnum を入力すると、アプリケーションシステムの起動プロセス中に StatusEnum の静的ブロックが実行されず、列挙キャッシュの登録が失敗するため、登録の遅延を考慮する必要があります。コードは次のとおりです。

private static <E extends Enum> void executeEnumStatic(Class<E> clazz) {
    
    
        if (!LOADED.containsKey(clazz)) {
    
    
            synchronized (clazz) {
    
    
                if (!LOADED.containsKey(clazz)) {
    
    
                    try {
    
    
                        // 目的是让枚举类的static块运行，static块没有执行完是会阻塞在此的
                        Class.forName(clazz.getName());
                        LOADED.put(clazz, true);
                    } catch (Exception e) {
    
    
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }

Class.forName(clazz.getName()) を実行するには、次の 2 つの前提条件があります。

1. キャッシュに列挙クラスキーがありません。つまり、キャッシュに登録するための列挙呼び出しがありません。executeEnumStatic メソッドへの EnumCache.find メソッド呼び出しを参照してください。2.executeEnumStatic の LOADED.put(clazz, true
) ; まだ実行されていません。つまり、Class.forName(clazz.getName()); は実行されていません。

二重チェックロックがexecuteEnumStaticで使用されていることがわかります。そのため、通常の状況でのコードの実行とパフォーマンスを分析します。

静的ブロックがまだ実行されていない場合、多数の検索クエリが同時に実行されます。
- 現時点では、executeEnumStatic での同期により他のスレッドがブロックされます。
- ロックを取得する最初のスレッドは Class.forName(clazz.getName()) を実行し、同時に列挙静的ブロックの同期実行をトリガーします。
- その後、他のスレッドが 1 つずつロックを取得し、2 番目のチェックではexecuteEnumStatic からのジャンプに失敗します。
静的ブロックが実行され、通常、静的ブロック内でキャッシュ登録が実行されると、多数の検索クエリが並行して実行される。
- executeEnumStatic メソッドは呼び出されず、同期によるキューの問題は発生しません。
静的ブロックが実行されたが、静的ブロック内でキャッシュ登録が呼び出されない場合、多数の検索クエリが同時に実行されます。
- find メソッドは、executeEnumStatic メソッドを呼び出しますが、executeEnumStatic の最初のチェックは失敗します。
- find メソッドは、例外が静的ブロックにキャッシュを登録するためのコードを追加する必要があることを要求します。

概要: 最初のシナリオでは、短期間のシリアル化が行われますが、メモリコンピューティングのこの種の短期間のシリアル化は、アプリケーションシステムでのビジネスロジックの実行と比較すると重要ではありません。つまり、この短期間のシリアル化は行われません。システムのパフォーマンスのボトルネックになる

サンプル表示

列挙を構成する


public enum StatusEnum {
    
    
    INIT("I", "初始化"),
    PROCESSING("P", "处理中"),
    SUCCESS("S", "成功"),
    FAIL("F", "失败");

    private String code;
    private String desc;

    StatusEnum(String code, String desc) {
    
    
        this.code = code;
        this.desc = desc;
    }

    public String getCode() {
    
    
        return code;
    }

    public String getDesc() {
    
    
        return desc;
    }

    static {
    
    
        // 通过名称构建缓存,通过EnumCache.findByName(StatusEnum.class,"SUCCESS",null);调用能获取枚举
        EnumCache.registerByName(StatusEnum.class, StatusEnum.values());
        // 通过code构建缓存,通过EnumCache.findByValue(StatusEnum.class,"S",null);调用能获取枚举
        EnumCache.registerByValue(StatusEnum.class, StatusEnum.values(), StatusEnum::getCode);
    }
}

テストクラス

public class Test{
    
    

    public static void main(String [] args){
    
    
        System.out.println(EnumCache.findByName(StatusEnum.class, "SUCCESS", null));
        // 返回默认值StatusEnum.INIT
        System.out.println(EnumCache.findByName(StatusEnum.class, null, StatusEnum.INIT));
        // 返回默认值StatusEnum.INIT
        System.out.println(EnumCache.findByName(StatusEnum.class, "ERROR", StatusEnum.INIT));


        System.out.println(EnumCache.findByValue(StatusEnum.class, "S", null));
        // 返回默认值StatusEnum.INIT
        System.out.println(EnumCache.findByValue(StatusEnum.class, null, StatusEnum.INIT));
        // 返回默认值StatusEnum.INIT
        System.out.println(EnumCache.findByValue(StatusEnum.class, "ERROR", StatusEnum.INIT));
    }
}

の結果


SUCCESS
INIT
INIT
SUCCESS
INIT
INIT

性能比較

コードを比較すると、OrderType のインスタンス数が増えるとパフォーマンスの差が大きくなります


public class Test {
    
    

    enum OrderType {
    
    
        _00("00", "00"),
        _01("01", "01"),
        _02("02", "02"),
        _03("03", "03"),
        _04("04", "04"),
        _05("05", "05"),
        _06("06", "06"),
        _07("07", "07"),
        _08("08", "08"),
        _09("09", "09"),
        _10("10", "10")
        ;
        private String code;
        private String desc;

        OrderType(String code, String desc) {
    
    
            this.code = code;
            this.desc = desc;
        }

        public String getCode() {
    
    
            return code;
        }

        public String getDesc() {
    
    
            return desc;
        }

        static {
    
    
            EnumCache.registerByValue(OrderType.class, OrderType.values(), OrderType::getCode);
        }

        public static OrderType getEnumByCode(String code, OrderType def) {
    
    
            OrderType[] values = OrderType.values();
            for (OrderType value : values) {
    
    
                if (value.getCode().equals(code)) {
    
    
                    return value;
                }
            }
            return def;
        }
    }

    private static final OrderType DEF = OrderType._00;
    private static final int TIMES = 10000000;

    static void compare(String code) {
    
    
        long s = System.currentTimeMillis();
        for (int idx = 0; idx < TIMES; idx++) {
    
    
            OrderType.getEnumByCode(code, DEF);
        }
        long t = System.currentTimeMillis() - s;
        System.out.println(String.format("枚举->%s : %s", code, t));

        s = System.currentTimeMillis();
        for (int idx = 0; idx < TIMES; idx++) {
    
    
            EnumCache.findByValue(OrderType.class, code, DEF);
        }
        t = System.currentTimeMillis() - s;
        System.out.println(String.format("缓存->%s : %s", code, t));
        System.out.println();
    }

    public static void main(String[] args) throws Exception {
    
    
        for (int idx = 0; idx < 2; idx++) {
    
    
            compare("NotExist");
            for (OrderType value : OrderType.values()) {
    
    
                compare(value.getCode());
            }
            System.out.println("=================");
        }
    }
}

の結果


枚举->NotExist : 312
缓存->NotExist : 105

枚举->00 : 199
缓存->00 : 164

枚举->01 : 313
缓存->01 : 106

枚举->02 : 227
缓存->02 : 90

枚举->03 : 375
缓存->03 : 92

枚举->04 : 260
缓存->04 : 92

枚举->05 : 272
缓存->05 : 78

枚举->06 : 284
缓存->06 : 78

枚举->07 : 315
缓存->07 : 76

枚举->08 : 351
缓存->08 : 78

枚举->09 : 372
缓存->09 : 81

枚举->10 : 402
缓存->10 : 78

=================
枚举->NotExist : 199
缓存->NotExist : 68

枚举->00 : 99
缓存->00 : 91

枚举->01 : 141
缓存->01 : 79

枚举->02 : 178
缓存->02 : 77

枚举->03 : 202
缓存->03 : 77

枚举->04 : 218
缓存->04 : 81

枚举->05 : 259
缓存->05 : 90

枚举->06 : 322
缓存->06 : 78

枚举->07 : 318
缓存->07 : 78

枚举->08 : 347
缓存->08 : 77

枚举->09 : 373
缓存->09 : 79

枚举->10 : 404
缓存->10 : 78

=================

要約する

コードは簡潔です。
列挙内のインスタンスの数が増えるほど、キャッシュモードのパフォーマンス上のメリットも大きくなります。

Java 列挙を効率的かつエレガントに使用する方法