1 场景
本文主要讲下java程序中对于状态数据的状态代码和状态名称如何管理的问题。
对于数据的状态，程序中，经常不会存储状态的名称，而会存储状态对应的代码。
每个java后端开发，面对数据库中的一个字段注释：
del_flag 删除状态（0：正常；1：删除；）
都会纠结一个问题，在java代码中，这个字段delFlag值对应的0和1和分别对应的含义正常、删除，写在java代码的哪个地方比较合适？
很多人认为这个对于很大的项目来说无非是个很小的事，写在哪里，无所谓，都不会影响我们的项目。讲道理，这个无法反驳。
这篇文章，让我们一起剖析下这件微不足道的小事。
在这里，我们为了方便，定义状态代码和状态名称的类型均为字符串。
2 步骤
2.1 直接使用
最简单的用法，就是直接在程序中使用状态的代码，如下。
//（1）设置删除标记为正常
record.setDelFlag("0");
......
//（2）判断删除标志
if("0".equals(record.getDelFlag())){
return "正常";
}
2.1.1 优点
项目初期管理简单，不用花费时间进行代码封装。
2.1.2 缺点
（1）项目中出现大量手写的状态代码和状态名称。代码检查工具会提示魔法值，如项目中对代码检查要求高，此部分代码无法合并主干代码。
（2）如果状态代码对应的状态名称发生了变动，全局更改起来，将是十分致命的。
（3）研发人员水平不一致，手动在代码里写状态代码和状态名称，十分容易写错。
2.2 静态常量
部分项目，会定义一个java类，将状态码定义为其中的静态常量。其中定义了项目中用到的所有状态代码。
public class StateContext{
/**
* 正常
*/
public static final String NORMAL="0";
/**
* 删除
*/
public static final String DEL="1";
//其他状态代码
......
}
静态常亮的使用方式如下：
//（1）设置删除标记为正常
record.setDelFlag(StateContext.NORMAL);
......
//（2）判断删除标志
if(StateContext.NORMAL.equals(record.getDelFlag())){
return "正常";
}
2.2.1 优点
状态代码，可以直接通过类的静态变量使用（状态名称，也可以通过类的静态变量定义）。
2.2.2 缺点
（1）需要在类中大量定义静态变量，使用时，需十分明确使用的变量的名字，勿使用成别的变量。
（2）一般只通过静态变量定义状态代码，状态名称也可这么定义。使用时，对应关系容易对应不上。
2.3 枚举
每种状态信息，定义专门的枚举类。
/**
* 删除标志枚举
*/
public enum DelFlagEnum{
NORMAL("0","正常"),
DEL("1","删除");
private DelFlagEnum(String code,String name){
this.code=code;
this.name=name;
}
/**
* 代码
*/
private String code;
/**
* 名称
*/
private String name;
public String getCode() {
return code;
}
public String getName() {
return name;
}
}
2.3.1 优点
（1）每种状态定义一个专门的枚举类，枚举类中的定义十分明确。
（2）可通过枚举属性准确对应的状态代码和状态名称。
（3）定义的枚举是有属性的，可以在枚举中定义专门的特殊方法，应对特殊的业务。
2.3.2 缺点
枚举主动在代码中使用，是没有问题的。如下：
DelFlagEnum.NORMAL.getCode();
但是状态代码一般都会存储在数据库中，如果通过数据库中获取的状态代码获取枚举对象，基础的枚举信息，无法实现此功能。
故可以在枚举中，定义专门的方法，通过状态代码获取枚举或通过状态名称获取枚举。如下
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.EnumUtils;
import org.apache.commons.lang3.StringUtils;
import java.util.List;
/**
* 删除标志枚举
*/
public enum DelFlagEnum{
NORMAL("0","正常"),
DEL("1","删除");
private DelFlagEnum(String code,String name){
this.code=code;
this.name=name;
}
/**
* 枚举集合
*/
private static final List<DelFlagEnum> ENUM_LIST= EnumUtils.getEnumList(DelFlagEnum.class);
/**
* 通过代码获取枚举
* @param code 枚举代码
* @return 枚举
*/
public static DelFlagEnum getEnumByCode(String code){
if(StringUtils.isNotEmpty(code) && CollectionUtils.isNotEmpty(ENUM_LIST)){
for(DelFlagEnum delFlagEnum:ENUM_LIST){
if(code.equals(delFlagEnum.getCode())){
return delFlagEnum;
}
}
}
return null;
}
/**
* 通过名称获取枚举
* @param name 枚举名称
* @return 枚举
*/
public static DelFlagEnum getEnumByName(String name){
if(StringUtils.isNotEmpty(name) && CollectionUtils.isNotEmpty(ENUM_LIST)){
for(DelFlagEnum delFlagEnum:ENUM_LIST){
if(name.equals(delFlagEnum.getName())){
return delFlagEnum;
}
}
}
return null;
}
/**
* 代码
*/
private String code;
/**
* 名称
*/
private String name;
public String getCode() {
return code;
}
public String getName() {
return name;
}
}
但是，如果每个枚举都是这样写。代码量大大增加，极易出现拷贝导致的低级错误。因此需对此代码进行封装，减少开发人员的工作量。
2.4 枚举+命名空间
此种方式，是对2.3中枚举定义状态值进行了代码封装。
这是作者当前找到的最优的方式，建议使用。
2.4.1 枚举基础接口
定义基础枚举接口。接口中定义枚举中必有的两个方法（获取代码、获取名称）
public interface BaseEnum {
/**
* 获取代码
* @return
*/
String getCode();
/**
* 获取名称
* @return
*/
String getName();
}
2.4.2 枚举实现类
每种状态对应专门的枚举类，每个枚举类均需实现接口BaseEnum（javac编译器，枚举无法继承，所以成员变量、接口方法，还需要手动写）。
枚举类中仍然可以定义专门的方法，来执行特殊业务。
public enum DelFlagEnum implements BaseEnum{
NORMAL("0","正常"),
DEL("1","删除");
/**
* 代码
*/
private String code;
/**
* 名称
*/
private String name;
private DelFlagEnum(String code, String name){
this.code=code;
this.name=name;
}
@Override
public String getCode() {
return this.code;
}
@Override
public String getName() {
return this.name;
}
}
2.4.3 枚举命名空间
可以通过此命名空间实现如下功能：
（1）通过代码获取枚举（时间复杂度O(1)）
（2）通过名称获取枚举（时间复杂度O(n)）
上述两个方法均线程安全，且均为懒加载，即用到方法时才去初始化对应的枚举类缓存。
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 枚举命名空间
*/
public class EnumContext {
/**
* 枚举集合映射
*/
private static final Map<String, Map<String, BaseEnum>> ENUM_MAP = new ConcurrentHashMap<>();
/**
* 初始化枚举map
*/
private synchronized static <T extends BaseEnum> void initEnumMap(Class<T> enumClass) {
if (enumClass != null && enumClass.isEnum()) {
String key = enumClass.getName();
if (!ENUM_MAP.containsKey(key)) {
Map<String, BaseEnum> map = new ConcurrentHashMap<>();
BaseEnum[] baseEnums = enumClass.getEnumConstants();
if (baseEnums != null && baseEnums.length > 0) {
for (final BaseEnum e : baseEnums) {
map.put(e.getCode(), e);
}
}
ENUM_MAP.put(key, map);
}
}
}
/**
* 通过代码获取枚举（时间复杂度O(1)）
*
* @param code 代码
* @param enumClass 枚举类
* @return 枚举
*/
public static <T extends BaseEnum> T getEnumByCode(String code, Class<T> enumClass) {
if (StringUtils.isNotEmpty(code) && enumClass != null) {
String key = enumClass.getName();
if (!ENUM_MAP.containsKey(key)) {
//如果不存在=>初始化
initEnumMap(enumClass);
}
//如果已存在=>判断
Map<String, BaseEnum> map = ENUM_MAP.get(key);
if (MapUtils.isNotEmpty(map)) {
return (T) map.get(code);
}
}
return null;
}
/**
* 通过名称获取枚举（时间复杂度O(n)）
*
* @param name 代码
* @param enumClass 枚举类
* @return 代码
*/
public static <T extends BaseEnum> T getEnumCodeByName(String name, Class<T> enumClass) {
if (StringUtils.isNotEmpty(name) && enumClass != null) {
String key = enumClass.getName();
if (!ENUM_MAP.containsKey(key)) {
//如果不存在=>初始化
initEnumMap(enumClass);
}
//如果已存在=>判断
Map<String, BaseEnum> map = ENUM_MAP.get(key);
if (MapUtils.isNotEmpty(map)) {
for (Map.Entry<String, BaseEnum> entry : map.entrySet()) {
if (entry.getValue() != null && name.equals(entry.getValue().getName())) {
return (T) entry.getValue();
}
}
}
}
return null;
}
}
2.4.3 使用
//直接使用枚举
System.out.println(DelFlagEnum.NORMAL.getCode() + " " + DelFlagEnum.NORMAL.getCode());
//通过代码获取枚举
DelFlagEnum normalEnum = EnumContext.getEnumByCode("0", DelFlagEnum.class);
if (normalEnum != null) {
System.out.println(normalEnum.getCode() + " " + normalEnum.getName());
}
//通过名称获取枚举
DelFlagEnum delEnum = EnumContext.getEnumCodeByName("删除", DelFlagEnum.class);
if (delEnum != null) {
System.out.println(delEnum.getCode() + " " + delEnum.getName());
}
网友评论