netty系列之:我有一個可擴展的Enum你要不要看一下?
簡介
很多人都用過java中的枚舉，枚舉是JAVA 1.5中引用的一個新的類型，用來表示可以列舉的範圍，但是可能很少有人知道java中的enum到底是怎麼工作的，enum和Enum有什麼關係？Enum可不可以擴展？
一起來看看吧。
enum和Enum
JAVA1.5中引入了枚舉類，我們通常使用enum關鍵字來定義一個枚舉類：
public enum StatusEnum {
START(1,"start"),
INPROCESS(2,"inprocess"),
END(3,"end");
private int code;
private String desc;
StatusEnum(int code, String desc){
this.code=code;
this.desc=desc;
}
}
上面的枚舉類中，我們自定義了構造函數，並且定義了3個枚舉對象。
接下來看下怎麼來使用這個枚舉類：
public static void main(String[] args) {
StatusEnum start = START;
System.out.println(start.name());
System.out.println(start.ordinal());
System.out.println(start.code);
System.out.println(start.desc);
}
可以輸出code和desc很好理解，因為這是我們自定義的枚舉類中的屬性，但是name和ordinal是什麼呢？他們是哪裡來的呢？
這裡就要介紹java.lang.Enum類了，它是JAVA中所有enum枚舉類的父類,name()和ordinal()方法就是在這個類中定義的：
public final int ordinal() {
return ordinal;
}
public final String name() {
return name;
}
其中ordinal表示的是枚舉類中枚舉的位置，那麼就是枚舉類中枚舉的名字。在上面的例子中，START的兩個值分別是1和START。
我們來看下Enum類的定義：
public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable
輸入它是一個抽象類，但是編譯器是不允許你繼承這個類的。如果你強行繼承，則會拋錯：
Classes cannot directly extend 'java.lang.Enum'
所以說，強扭的瓜不甜，大家一定要記住。
事實上，不僅僅Enum類本身不能被繼承，上面創建的enum類StatusEnum也是不能被繼承的。
這會造成一個什麼問題呢?
如果這個enum是包含在一個外部jar包中的時候，你就沒法對該enum進行擴展，在某些特定的情況下，這樣的限制可能會帶來一些不便。
還好，netty也意識到了這個問題，接下來，我們看下netty是怎麼解決的。
netty中可擴展的Enum:ConstantPool
netty中的表示常量的類叫做Constant，它有兩個屬性，分別是ID和name：
public interface Constant<T extends Constant<T>> extends Comparable<T> {
int id();
String name();
}
存儲這些Constant的就叫做ConstantPool。ConstantPool中有一個ConcurrentMap用來保存具體的Constant。 我們看一下ConstantPool
的工廠類方法valueOf：
public T valueOf(String name) {
return getOrCreate(checkNonEmpty(name, "name"));
}
valueOf方法傳入創建的Constant的名字。然後調用getOrCreate方法來創建新的Constant：
private T getOrCreate(String name) {
T constant = constants.get(name);
if (constant == null) {
final T tempConstant = newConstant(nextId(), name);
constant = constants.putIfAbsent(name, tempConstant);
if (constant == null) {
return tempConstant;
}
}
return constant;
}
可以看到getOrCreate就是向constants Map中創建和獲取新創建的constant對象。
使用ConstantPool
ConstantPool是一個抽象類，如果我們需要新建一個枚舉類池，可以直接繼承ConstantPool，然後實現其中的newConstant方法。下面是一個使用的具體例子：
public final class Foo extends AbstractConstant<Foo> {
Foo(int id, String name) {
super(id, name);
}
}
public final class MyConstants {
private static final ConstantPool<Foo> pool = new ConstantPool<Foo>() {
@Override
protected Foo newConstant(int id, String name) {
return new Foo(id, name);
}
};
public static Foo valueOf(String name) {
return pool.valueOf(name);
}
public static final Foo A = valueOf("A");
public static final Foo B = valueOf("B");
}
private final class YourConstants {
public static final Foo C = MyConstants.valueOf("C");
public static final Foo D = MyConstants.valueOf("D");
}
在上面的例子中，我們創建的枚舉類繼承自AbstractConstant，然後自定義了ConstantPool，從pool中可以返回新創建的Foo對象。
實時上，在netty channel中經常使用的ChannelOption就是AbstractConstant的子類，我們簡單來看下其中的實現：
public class ChannelOption<T> extends AbstractConstant<ChannelOption<T>> {
private static final ConstantPool<ChannelOption<Object>> pool = new ConstantPool<ChannelOption<Object>>() {
@Override
protected ChannelOption<Object> newConstant(int id, String name) {
return new ChannelOption<Object>(id, name);
}
};
public static <T> ChannelOption<T> valueOf(String name) {
return (ChannelOption<T>) pool.valueOf(name);
}
public static <T> ChannelOption<T> valueOf(Class<?> firstNameComponent, String secondNameComponent) {
return (ChannelOption<T>) pool.valueOf(firstNameComponent, secondNameComponent);
}
public static boolean exists(String name) {
return pool.exists(name);
}
public static <T> ChannelOption<T> newInstance(String name) {
return (ChannelOption<T>) pool.newInstance(name);
}
可以看到，ChannelOption中定義了ConstantPool，然後通過ConstantPool的valueOf和newInstance方法來創建新的ChannelOption對象。
總結
如果你也想要對枚舉類進行擴展，不妨使用Constant和ConstantPool試試。
本文的例子可以參考：learn-netty4
更多內容請參考 //www.flydean.com/49-netty-extensible-enum/
最通俗的解讀，最深刻的乾貨，最簡潔的教程，眾多你不知道的小技巧等你來發現！
歡迎關注我的公眾號:「程式那些事」,懂技術，更懂你！
