阿里妹导读
本文通过几种样例展示如何高效优雅的使用java枚举消除冗余代码。
枚举在系统中的地位不言而喻，状态、类型、场景、标识等等，少则十几个多则上百个，相信以下这段代码很常见，而且类似的代码到处都是，目标：消除这类冗余代码。
/**
* 根据枚举代码获取枚举
*
*/
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;
}模块设计图
缓存结构
源码分析
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、当第一次使用某个类或接口的任意非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查询。
2、当静态块已经执行，且静态块里面正常执行了缓存注册，大量的并发执行find查询。
3、当静态块已经执行，但是静态块里面没有调用缓存注册，大量的并发执行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
INITpublic 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
=================总结
1、代码简洁； 2、枚举中实例数越多，缓存模式的性能优势越多；
本文由哈喽比特于1年以前收录，如有侵权请联系我们。
文章来源：https://mp.weixin.qq.com/s/CLr5bcxsG7C8v6qSsagEbw
京东创始人刘强东和其妻子章泽天最近成为了互联网舆论关注的焦点。有关他们“移民美国”和在美国购买豪宅的传言在互联网上广泛传播。然而，京东官方通过微博发言人发布的消息澄清了这些传言，称这些言论纯属虚假信息和蓄意捏造。
日前，据博主“@超能数码君老周”爆料，国内三大运营商中国移动、中国电信和中国联通预计将集体采购百万台规模的华为Mate60系列手机。
据报道，荷兰半导体设备公司ASML正看到美国对华遏制政策的负面影响。阿斯麦（ASML）CEO彼得·温宁克在一档电视节目中分享了他对中国大陆问题以及该公司面临的出口管制和保护主义的看法。彼得曾在多个场合表达了他对出口管制以及中荷经济关系的担忧。
今年早些时候，抖音悄然上线了一款名为“青桃”的 App，Slogan 为“看见你的热爱”，根据应用介绍可知，“青桃”是一个属于年轻人的兴趣知识视频平台，由抖音官方出品的中长视频关联版本，整体风格有些类似B站。
日前，威马汽车首席数据官梅松林转发了一份“世界各国地区拥车率排行榜”，同时，他发文表示：中国汽车普及率低于非洲国家尼日利亚，每百户家庭仅17户有车。意大利世界排名第一，每十户中九户有车。
近日，一项新的研究发现，维生素 C 和 E 等抗氧化剂会激活一种机制，刺激癌症肿瘤中新血管的生长，帮助它们生长和扩散。
据媒体援引消息人士报道，苹果公司正在测试使用3D打印技术来生产其智能手表的钢质底盘。消息传出后，3D系统一度大涨超10%，不过截至周三收盘，该股涨幅回落至2%以内。
9月2日，坐拥千万粉丝的网红主播“秀才”账号被封禁，在社交媒体平台上引发热议。平台相关负责人表示，“秀才”账号违反平台相关规定，已封禁。据知情人士透露，秀才近期被举报存在违法行为，这可能是他被封禁的部分原因。据悉，“秀才”年龄39岁，是安徽省亳州市蒙城县人，抖音网红，粉丝数量超1200万。他曾被称为“中老年...
9月3日消息，亚马逊的一些股东，包括持有该公司股票的一家养老基金，日前对亚马逊、其创始人贝索斯和其董事会提起诉讼，指控他们在为 Project Kuiper 卫星星座项目购买发射服务时“违反了信义义务”。
据消息，为推广自家应用，苹果现推出了一个名为“Apps by Apple”的网站，展示了苹果为旗下产品（如 iPhone、iPad、Apple Watch、Mac 和 Apple TV）开发的各种应用程序。
特斯拉本周在美国大幅下调Model S和X售价，引发了该公司一些最坚定支持者的不满。知名特斯拉多头、未来基金（Future Fund）管理合伙人加里·布莱克发帖称，降价是一种“短期麻醉剂”，会让潜在客户等待进一步降价。
据外媒9月2日报道，荷兰半导体设备制造商阿斯麦称，尽管荷兰政府颁布的半导体设备出口管制新规9月正式生效，但该公司已获得在2023年底以前向中国运送受限制芯片制造机器的许可。
近日，根据美国证券交易委员会的文件显示，苹果卫星服务提供商 Globalstar 近期向马斯克旗下的 SpaceX 支付 6400 万美元（约 4.65 亿元人民币）。用于在 2023-2025 年期间，发射卫星，进一步扩展苹果 iPhone 系列的 SOS 卫星服务。
据报道，马斯克旗下社交平台𝕏（推特）日前调整了隐私政策，允许 𝕏 使用用户发布的信息来训练其人工智能（AI）模型。新的隐私政策将于 9 月 29 日生效。新政策规定，𝕏可能会使用所收集到的平台信息和公开可用的信息，来帮助训练 𝕏 的机器学习或人工智能模型。
9月2日，荣耀CEO赵明在采访中谈及华为手机回归时表示，替老同事们高兴，觉得手机行业，由于华为的回归，让竞争充满了更多的可能性和更多的魅力，对行业来说也是件好事。
《自然》30日发表的一篇论文报道了一个名为Swift的人工智能（AI）系统，该系统驾驶无人机的能力可在真实世界中一对一冠军赛里战胜人类对手。
近日，非营利组织纽约真菌学会（NYMS）发出警告，表示亚马逊为代表的电商平台上，充斥着各种AI生成的蘑菇觅食科普书籍，其中存在诸多错误。
社交媒体平台𝕏（原推特）新隐私政策提到：“在您同意的情况下，我们可能出于安全、安保和身份识别目的收集和使用您的生物识别信息。”
2023年德国柏林消费电子展上，各大企业都带来了最新的理念和产品，而高端化、本土化的中国产品正在不断吸引欧洲等国际市场的目光。
罗永浩日前在直播中吐槽苹果即将推出的 iPhone 新品，具体内容为：“以我对我‘子公司’的了解，我认为 iPhone 15 跟 iPhone 14 不会有什么区别的，除了序（列）号变了，这个‘不要脸’的东西，这个‘臭厨子’。
