java的枚举常常被用来替代常量值，每个枚举值代表一个特定的常数。

在反序列化时有常常需要用到常数到枚举的转换，这就涉及到枚举的反向查找。

1、从枚举名反向查找枚举

这种方法是最先使用也最为简便的

可以用到枚举的静态方法valueOf(String

name)

valueOf方法为内置方法，使用简便，但在查找不到枚举时会抛出异常。

熟悉异常的同学可能知道异常抛出时，需要收集虚拟机的调用堆栈上下文信息，对性能影响较大。

使用时，常常需要使用这么一个反序列化查找方法

E

find(String name, E defaultValue)，在查找不到时能够返回一个默认值而不是抛出异常

2、从枚举值所包含的描述值反向查找枚举

例如这种枚举定义

public enum SomeEnum{

A("ADes", 1),

B("BDes", 2),

unknown("UNKNWONDes", 3);

private string des;

private int order;

private SomeEnum(string des, int order){

this.des = des;

this.order = order;

}

}

此时可以在枚举类中增加一个HashMap，并在类加载时初始化好。

public enum SomeEnum{

A("ADes"),

B("BDes"),

unknown("UNKNWONDes");

private string des;

private static final map lookup = new hashmap();

static {

for(SomeEnum e : EnumSet.allOf(SomeEnum.class)){

lookup.put(e.des, e);

}

}

private SomeEnum(string des){

this.des = des;

}

public static SomeEnum find(string des, SomeEnum defaultValue){

SomeEnum value = lookup.get(des);

if(value == null){

return defaultValue;

}

return value;

}

}

3、进一步，如果枚举中有多个描述值，并且描述值类型不一样

这时初始化代码和查找代码需要写多遍。

public enum SomeEnum{

A("ADes", 1),

B("BDes", 2),

unknown("UNKNWONDes", 3);

private string des;

private int order;

private static final map lookup = new hashmap();

private static final map lookup_int = new hashmap();

static {

for(SomeEnum e : EnumSet.allOf(SomeEnum.class)){

lookup.put(e.des, e);

lookup_int.put(e.order, e);

}

}

private SomeEnum(string des, int order){

this.des = des;

this.order = order;

}

public static SomeEnum find(string des, SomeEnum defaultValue){

SomeEnum value = lookup.get(des);

if(value == null){

return defaultValue;

}

return value;

}

public static SomeEnum find(int order, SomeEnum defaultValue){

SomeEnum value = lookup_int.get(order);

if(value == null){

return defaultValue;

}

return value;

}

}

不少代码有重复，

枚举类需要自己实现反向查找映射关系在HashMap中的初始化。

根据DRY原则，重复代码地方一般都有一定的坏味道。

4、改进

枚举的反向查找其实只需关注两件事情，

a 提供枚举值描述到枚举值的映射

b 能从枚举值描述查找到枚举值，查找不到能提供默认值

据此，可以提炼出枚举反向查找的帮助类：

public class EnumFindHelper, K> {

protected Map map = new HashMap();

public EnumFindHelper(Class clazz, EnumKeyGetter keyGetter) {

try {

for (T enumValue : EnumSet.allOf(clazz)) {

map.put(keyGetter.getKey(enumValue), enumValue);

}

} catch (Exception e) {

//eror handler

}

}

public T find(K key, T defautValue) {

T value = map.get(key);

if (value == null) {

value = defautValue;

}

return value;

}

}

这里需要一个接口定义：

public static interface EnumKeyGetter, K> {

K getKey(T enumValue);

}

查找帮助类EnumFindHelper构造时需要EnumKeyGetter来提供枚举值到枚举类型的的对应关系。

定义枚举类时实现EnumKeyGetter接口，并传入EnumFindHelper。

修改后的枚举定义可能为：

public enum SomeEnum{

A("ADes", 1),

B("BDes", 2),

unknown("UNKNWONDes", 3);

private String des;

private int order;

private SomeEnum(string des, int order){

this.des = des;

this.order = order;

}

static final EnumFindHelper desptHelper = new EnumFindHelper(

SomeEnum.class, new DesptGetter());

static final EnumFindHelper orderHelper = new EnumFindHelper(

SomeEnum.class, new OrderKeyGetter());

static class DesptGetter implements EnumKeyGetter {

@Override

public String getKey(SomeEnum enumValue) {

return enumValue.des;

}

}

static class OrderKeyGetter implements EnumKeyGetter {

@Override

public String Integer(SomeEnum enumValue) {

return enumValue.order;

}

}

public static SomeEnum find(string despt, SomeEnum defaultValue){

return desptHelper.find(des, defaultValue);

}

public static SomeEnum find(int order, SomeEnum defaultValue){

return orderHelper.find(des, defaultValue);

}

}

EnumFindHelper内部类的定义有些繁琐，不过java8之后用lambda实现后会简便一些。

5 总结

每个枚举类的反向查找功能委托一个帮助类来实现，从枚举类的构造上来看，比较类似GOF的桥接模式。

而从委托类的实现查找功能来看，需要一个EnumKeyGetter接口，每种不同的接口实现不同的查找方式，有根据描述字符查找，有根据枚举顺序值查找。

这又有些类似GOF的策略模式。

当然不需要去纠结于哪种设计模式，代码的设计就是要求代码不冗余，功能的重用，依赖的解耦。

上面的设计中：

1)利用EnumFindHelper做到枚举查找的算法重用，利用一个map提供枚举描述到枚举值的查找。

2)EnumFindHelper初始化时需要构造好查找用的map，所以会依赖于具体的枚举定义。

这里抽象出EnumKeyGetter，EnumFindHelper由依赖于具体的枚举类改为依赖于EnumKeyGetter接口，在构造时注入了EnumKeyGetter的实现。

这么看起来是不是有些DPI(依赖注入)的感觉？！

(转载请注明出处)