枚举是java 5之后添加的一个重要特性，这个特性可以让java程序员写出更优雅、合理的代码。
1. 枚举基本用法
/**
* 消息的类型，是请求还是回应
* @author leo
*/
public enum ReqOrRes {
req,res;
}
这应该是枚举最简单的用法了，即使是这样简单的使用，也能给我们带来便利，
ReqOrRes.req.name() == "req"
ReqOrRes.valueOf("req") == ReqOrRes.req , 通过name 和valueOf这两个枚举内置的方法，可以方便的将枚举在字符串和枚举之间转化。
2. 枚举中带方法，将处理逻辑写在枚举类中，将调用框架和业务逻辑分离
/**
* 列举调度server与slave之间的所有通信报文类型，每个类型的具体描述见com.zdcin.msgbean包，<br>
* 每种消息有两个方法供外部调用，根据消息是在哪里产生，对应一方需实现processReq方法，产生消息的一方需要实现processRes方法。
* @author leo
*
*/
public enum MsgType {// MsgType有两个主要方法，processReq，和processRes， 用于完成处理各种类型的请求消息和响应消息的逻辑
/** slave获取clientid
*
*/
GET_CLIENT_ID {
@Override
public void processReq(String json) {// 覆盖父类MsgType中的同名方法，processRes方法在另外一端实现，这个方法的意思是处理请求，并发回响应信息
GET_CLIENT_ID_req req = MsgUtils.getGson().fromJson(json, GET_CLIENT_ID_req.class);
GET_CLIENT_ID_res res = new GET_CLIENT_ID_res(req);
。。。。。
//用clientid做key找到连接，把消息发回去
Client.sendMsgToSlave(res.clientId, res);
}
},
/** 已经分配过id的slave每次连接到server都要用该命令通知server建立连接 */
CONNECT {
@Override
public void processReq(String json) {
CONNECT_req req = MsgUtils.getGson().fromJson(json, CONNECT_req.class);
。。。。。
}
},
/** 任务指定 */
TASK_ASSIGN {
@Override
public void processRes(String json) {
//不用实现
}
},
/** 心跳 */
HEART_BEAT {
@Override
public void processReq(String json) {
HEART_BEAT_req req = MsgUtils.getGson().fromJson(json, HEART_BEAT_req.class);
if ("00X".equalsIgnoreCase(req.meta.clientId)) {
return;
}
HEART_BEAT_res res = new HEART_BEAT_res(req);
Client.sendMsgToSlave(req.meta.clientId, res);
}
@Override
public void processRes(String json) {
//接收就行，不用处理
}
};
//------------ 到这里，枚举类型定义结束了，下边是各个枚举都可以用的公共方法
/**
* 消息有在调度server产生的，又在slave上产生的，
* 在调度器上产生的消息，slave需要实现processReq方法，并且slave需要返回res消息给调度器，调度器就需要实现processRes方法；
* 如果消息是在slave上产生（如主动上报状态的消息），上述流程就反过来。
* @param json
*/
public void processReq(String json){//父类定义的方法
throw new RuntimeException(this.name() + ".processReq() method not implement.");
}
/**
* 消息有在调度server产生的，又在slave上产生的，
* 在调度器上产生的消息，slave需要实现processReq方法，并且slave需要返回res消息给调度器，调度器就需要实现processRes方法；
* 如果消息是在slave上产生（如主动上报状态的消息），上述流程就反过来。
* @param json
*/
public void processRes(String json){//父类定义的方法
throw new RuntimeException(this.name() + ".processRes() method not implement.");
}
}
上述枚举类的作用是定义消息类型，同时在processReq和processRes方法中实现处理各种请求和响应消息的逻辑，这只是消息一端的代码，一般消息中processReq和processRes只需要出现一次，在消息的另一段，对称的实现缺少的那个方法就可以。
这个枚举类用起来大概是这个样子的：
public class ReciveWork implements Runnable {
private String json;
private Meta meta;
public ReciveWork(Meta meta, String json) {
this.meta = meta;
this.json = json;
}
@Override
public void run() {
try {
switch (meta.reqOrRes) {
case req://根据消息是请求类型还是响应类型，来决定是调用 processReq方法还是 processRes方法。
meta.msgType.processReq(json);// meta.msgType 就是MsgType中的CONNECT, GET_CLIENT_ID等枚举，这里不确定是哪一个，但是可以确定他们会有processReq方法，这样就可以优雅的动态分发消息给合适的处理者了
break;
case res:
// 检查重发队列，如果在队列中，取消重发
Client.notifyToStopRetry(meta);
// 先检查有对方有没有处理错误，有的话，直接记录日志，不调用后续的处理方法了， 相关的错误恢复工作可以在定时任务中进行。
BaseResMsg baseres = MsgUtils.getGson().fromJson(json, BaseResMsg.class);
if (baseres.errCode != 0) {
Main.log.error("error in " + baseres.meta.msgType.name() + "_res, [errCode, errMsg]=["
+ baseres.errCode + ", " + baseres.errMsg + "]");
} else {
meta.msgType.processRes(json);
}
break;
}
} catch (Exception e) {
Main.log.error(
"error in " + meta.msgType.name() + ".process" + meta.reqOrRes.name() + ", " + e.getMessage(), e);
}
}
}
worker类实现了Runnable接口，可以放在线程池里，多线程并行分发处理。
现在看，效果还不错吧，如果不用枚举，估计少不了一堆if else分支判断，或者是基于抽象类的模式，每个消息类型写一个子类，去做实现，应该不会比这简单。
3. 带数值可叠加的枚举
/**
* @author leo
*/
public enum AppMonitorType {
/**读权限*/
read(1),
/** 写权限*/
write(2),
/** 执行权限*/
exec(4),
/** 特殊权限*/
spic(8);
private int bitValue;
private AppMonitorType(int v) {//私有的构造方法，只能类初始化时使用，如exec(4),
this.bitValue = v;
}
public int getBitValue() {// 返回枚举对应的整形值，如 exec（4） 中的4
return this.bitValue;
}
//将数值转换成权限列表, 这个方法是静态的， 直接AppMonitoryType.parseBitValue()
public static List<AppMonitorType> parseBitValue(int bitValue) {
if (bitValue <= 0) {
return null;
}
List<AppMonitorType> list = new ArrayList<AppMonitorType>();
for (AppMonitorType type : AppMonitorType.values()) {
if ((type.bitValue & bitValue) == type.bitValue) {
list.add(type);
}
}
return list;
}
// 将权限列表转换成数值， 注意这个方法是静态的，用的时候 直接AppMonitorType.getBitValue()
public static int getBitValue(List<AppMonitorType> list) {
int i = 0;
for (AppMonitorType type : list) {
i |= type.bitValue;
}
return i;
}
}
你有关于枚举使用的一些奇妙的想法吗，欢迎一起讨论。
