1. Toy模板网首页
  2. >Toy博客

枚举缓存工具

1年前作者：心流时间分类：Toy博客阅读(0)违法举报

这篇具有很好参考价值的文章主要介绍了枚举缓存工具。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

此文章为笔记，为阅读其他文章的感受、补充、记录、练习、汇总，非原创，感谢每个知识分享者。


本文通过几种样例展示如何高效优雅的使用java枚举消除冗余代码。

1. 背景

枚举在系统中的地位不言而喻，状态、类型、场景、标识等等，少则十几个多则上百个，相信以下这段代码很常见，而且类似的代码到处都是，目标：消除这类冗余代码。

/**
     * 根据枚举代码获取枚举
     * 
     */
    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;
    }

2. 枚举缓存

  • 减少代码冗余，代码简洁
  • 去掉for循环，性能稳定高效

模块设计图

枚举缓存工具,Java工具,缓存,开发语言
枚举缓存工具,Java工具,缓存,开发语言

缓存结构

枚举缓存工具,Java工具,缓存,开发语言

源码分析
源码展示

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、当第一次使用某个类或接口的任意非final静态字段时
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())被执行的两个必备条件：

1、缓存中没有枚举class的键，也就是说没有执行过枚举向缓存注册的调用，见EnumCache.find方法对executeEnumStatic方法的调用；
2、executeEnumStatic中的LOADED.put(clazz, true);还没有被执行过，也就是Class.forName(clazz.getName());没有被执行过；

我们看到executeEnumStatic中用到了双重检查锁，所以分析一下正常情况下代码执行情况和性能：

1、当静态块还未执行时，大量的并发执行find查询。
此时executeEnumStatic中synchronized会阻塞其他线程；

第一个拿到锁的线程会执行Class.forName(clazz.getName());同时触发枚举静态块的同步执行；

之后其他线程会逐一拿到锁，第二次检查会不成立跳出executeEnumStatic；

2、当静态块已经执行，且静态块里面正常执行了缓存注册，大量的并发执行find查询。
executeEnumStatic方法不会调用，没有synchronized引发的排队问题；

3、当静态块已经执行，但是静态块里面没有调用缓存注册，大量的并发执行find查询。
find方法会调用executeEnumStatic方法，但是executeEnumStatic的第一次检查通不过；
find方法会提示异常需要在静态块中添加注册缓存的代码；

总结：第一种场景下会有短暂的串行，但是这种内存计算短暂串行相比应用系统的业务逻辑执行是微不足道的，
也就是说这种短暂的串行不会成为系统的性能瓶颈

3. 样例展示

构造枚举

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

4. 性能对比

对比代码，如果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

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

5. 总结

1、代码简洁；
2、枚举中实例数越多，缓存模式的性能优势越多；文章来源地址https://www.toymoban.com/news/detail-646397.html

到了这里，关于枚举缓存工具的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包赞助服务器费用

相关文章

  • Java Web现代化开发：Spring Boot + Mybatis + Redis二级缓存

    Java Web现代化开发：Spring Boot + Mybatis + Redis二级缓存

    Spring-Boot因其提供了各种开箱即用的插件，使得它成为了当今最为主流的Java Web开发框架之一。Mybatis是一个十分轻量好用的ORM框架。Redis是当今十分主流的分布式key-value型数据库，在web开发中，我们常用它来缓存数据库的查询结果。 本篇博客将介绍如何使用Spring-Boot快速搭建一

    2024年01月17日
    浏览(12)

  • 【华为OD机考 统一考试机试C卷】文件缓存系统（C++ Java JavaScript Python C语言）

    2023年11月份，华为官方已经将 华为OD机考：OD统一考试（A卷 / B卷）切换到 OD统一考试（C卷）和 OD统一考试（D卷） 。根据考友反馈：目前抽到的试卷为B卷或C卷/D卷，其中C卷居多 ，按照之前的经验C卷D卷部分考题会复用A卷/B卷题，博主正积极从考过的同学收集C卷和D卷真题，

    2024年02月20日
    浏览(10)
  • GO语言安全工具开发方向探索

    GO语言安全工具开发方向探索

    声明：文章所涉及的代码进攻参考和学习，文章中涉及的程序(方法)可能带有攻击性，仅供安全研究与教学之用，读者将其信息做其他用途，由用户承担全部法律及连带责任，文章作者不承担任何法律及连带责任。 文章目录 前言 一、网络扫描工具 1.并发扫描 2.网络资产发现

    2024年02月15日
    浏览(8)
  • 【C语言】联合和枚举

    【C语言】联合和枚举

    个人主页点这里~ 联合体的定义与结构体相似，但是联合体往往会节省更多的空间，它的特点是所有成员共用一块内存空间，结构体也叫共用体 联合体中给某一成员赋值，其他成员值往往会跟着变化 定义联合体我们用的是union，定义格式与结构体相差不多，大括号里边是成员

    2024年04月14日
    浏览(11)

  • 补充:C语言枚举类型

    1.枚举数据类型是C语言中一种构造数据类型,可以让数据更加简洁,更易读,对于只有 几个特定的数据 ,可以使用枚举类型 2.枚举对应英文enumeration,简写为enum 3.枚举是一组常量的集合,包含一组有限的特定的数据 4.枚举语法的定义格式为 使用枚举表示一个星期 如同结构体（struc

    2024年02月05日
    浏览(10)
  • HBase Java API 开发：表的扫描与扫描的缓存和批量处理 第1关：批量处理

    HBase Java API 开发：表的扫描与扫描的缓存和批量处理 第1关：批量处理

    批量操作 如果我们去查看 HBaseAPI 的源码会发现，在上次实训中我们使用的 delete、get，put 这些批量操作，实际上都是调用了 batch() 方法。 查看 put(ListPut puts) 函数源码： 我们可以发现 put(ListPut puts) 方法最终还是调用的 batch(final List? extends Row actions, final Object[] results, int rpcTi

    2024年02月09日
    浏览(12)
  • 【C语言】位段枚举联合

    【C语言】位段枚举联合

    鹅，鹅，鹅，曲项向天歌。白毛浮绿水，红掌拨清波。 — 唐代·骆宾王《咏鹅》 这篇博客我们会详细介绍位段，以及枚举类型和联合类型 位段的声明和结构是类似的，有两个不同： 1.位段的成员必须是 int、unsigned int 或signed int 以及 char或unsigned char。 2.位段的成员名后边有一

    2024年02月15日
    浏览(11)

  • C 语言结构体和枚举完全指南：成员访问、字符串操作、枚举基础

    要访问结构体的成员，请使用点语法 (.): 现在您可以使用只使用一个结构体，轻松创建多个具有不同值的结构体变量： 请记住，C 语言中的字符串实际上是字符数组，不幸的是，您无法像这样为数组分配值： 会发生错误： prog.c:12:15: error: assignment to expression with array type 但是，

    2024年02月02日
    浏览(15)
  • 中文编程工具免费版下载，中文开发语言工具免费版下载

    中文编程工具免费版下载，中文开发语言工具免费版下载

    中文编程工具免费版下载，中文开发语言工具免费版下载 中文编程工具开发的实际部分案例如下图 编程系统化课程总目录及明细，点击进入了解详情。https://blog.csdn.net/qq_29129627/article/details/134073098?spm=1001.2014.3001.5502

    2024年02月08日
    浏览(55)
  • 中文编程开发语言工具开发的实际软件案例：称重管理系统软件

    中文编程开发语言工具开发的实际软件案例：称重管理系统软件

    中文编程开发语言工具开发的实际软件案例：称重管理系统软件 中文编程开发语言工具开发的实际软件案例：称重管理系统软件，软件可以安装在电脑上，也可以安装在收银机上，支持触摸和鼠标点，想学编程可以关注系统化的编程课程。 中文编程系统化教程，不需英语基

    2024年02月07日
    浏览(17)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包