Question

是否可以将属性文件转换为枚举。

我有一个有很多设置的propoerty文件。例如

equipment.height
equipment.widht
equipment.depth 
and many more like this and not all are as simple as the example

开发者必须知道密钥才能获得属性的值。相反，它可以做一些事情，开发人员可以输入MyPropertyEnum。并且键列表将显示在IDE中，就像它显示为Enum

一样

MyPropertyEnum.height

Answer 1

我经常使用属性文件+枚举组合。这是一个例子：

public enum Constants {
    PROP1,
    PROP2;

    private static final String PATH            = "/constants.properties";

    private static final Logger logger          = LoggerFactory.getLogger(Constants.class);

    private static Properties   properties;

    private String          value;

    private void init() {
        if (properties == null) {
            properties = new Properties();
            try {
                properties.load(Constants.class.getResourceAsStream(PATH));
            }
            catch (Exception e) {
                logger.error("Unable to load " + PATH + " file from classpath.", e);
                System.exit(1);
            }
        }
        value = (String) properties.get(this.toString());
    }

    public String getValue() {
        if (value == null) {
            init();
        }
        return value;
    }

}

现在你还需要一个属性文件（我将它放在src中，因此它被打包到JAR中），其属性与你在枚举中使用的属性一样。例如：

constants.properties：

#This is property file...
PROP1=some text
PROP2=some other text

现在我经常在我想使用常量的类中使用静态导入：

import static com.some.package.Constants.*;

示例用法

System.out.println(PROP1);

Answer 2

Java具有静态类型。这意味着，您无法动态创建类型。所以答案是不。您无法将属性文件转换为枚举。

您可以做的是从该属性文件生成enum。或者，使用词典（地图）访问您的属性，例如：

equipment.get("height");

Answer 3

不，我不这么认为。枚举在编译时创建，因此它们的元素数量不会因属性文件中的内容而异。

你更有可能需要一个在运行时灵活构建的结构 - 可能是一个关联数组。

Answer 4

没有。好吧，如果您可以将属性文件编译为Java类（或枚举），我想您可以。我找不到那样的东西（但会非常酷）

Answer 5

我可以想象，在IDE中获取所有属性的一种方法是定义一个包含所有属性的枚举，如下所示：

public enum Settings
{
   EQUIPMENT_HEIGHT("equipment.height", "0"),

   EQUIPMENT_WIDTH("equipment.width", "0"),

   EQUIPMENT_DEPTH("equipment.depth", "0");

   private String property;

   private String value;

   Settings(final String aProperty, final String aValue)
   {
      property = aProperty;
      value = aValue;
   }

   public String getProperty()
   {
      return property;
   }

   public String getValue()
   {
      return value;
   }

   private void setValue(final String aValue)
   {
      value = aValue;
   }

   public static void initialize(final Properties aPropertyTable)
   {
      for(final Settings setting : values())
      {
         final String key = setting.getProperty();
         final String defaultValue = setting.getValue();
         setting.setValue(aPropertyTable.getProperty(key, defaultValue));
      }
   }
}

枚举的初始化是自解释的（方法initialize（））。

之后，您可以像这样使用它：

Settings.EQUIPMENT_HEIGHT.getValue();

添加新属性只是添加新的枚举 - 常量。

Answer 6

public enum ErrorCode{


    DB_ERROR( PropertiesUtil.getProperty("DB_ERRROR_CODE"), PropertiesUtil.getProperty("DB_ERROR")),
    APP_ERROR(PropertiesUtil.getProperty("APPLICATION_ERROR_CODE"), PropertiesUtil.getProperty("APPLICATION_ERROR")),
    ERROR_FOUND(PropertiesUtil.getProperty("ERROR_FOUND_CODE"), PropertiesUtil.getProperty("ERROR_FOUND"));


    private final String errorCode;
    private final String errorDesc;



    private ErrorCode(String errorCode, String errorDesc) {
        this.errorCode = errorCode;
        this.errorDesc = errorDesc;
    }

    public String getErrorDesc() {
        return errorDesc;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public static String getError(String errorCode)
    { 
        System.out.println("errorCode in Enum"+errorCode);
        System.out.println(java.util.Arrays.asList(ErrorCode.values()));
        for (ErrorCode errorEnum : ErrorCode.values()) {
            System.out.println(errorEnum.errorCode);
            System.out.println(errorEnum.errorDesc);
        if ((errorEnum.errorCode).equals(errorCode)) {
            return errorEnum.getErrorDesc();
        }
        }
        return ERROR_FOUND.getErrorDesc();

    }


public class PropertiesUtil {
static  Properties prop = new Properties();

    static{

        try {

              InputStream inputStream =
                      PropertiesUtil.class.getClassLoader().getResourceAsStream("db.properties");

             prop.load(inputStream);
    }catch(Exception e)
        {
        e.printStackTrace();
        }
    }



        public static PropertiesUtil getInstance()
        {

            return new PropertiesUtil();
        }

        public Properties getProperties()
        {
            return prop;
        }

        public static String getProperty(String key)
        {
            return prop.getProperty(key);
        }


}

Answer 7

您可以使用生成的代码将属性文件转换为枚举。您可以在编译程序之前静态地执行此操作，也可以在运行时使用编译器API执行此操作。这样做会增加很多复杂性，并且通常使用Map更简单。

Answer 8

有人询问有关枚举的问题，我想创建一个基于属性的枚举。我放弃了这个想法，因为这个枚举需要是动态的，如果我们得到一个新的错误代码，它应该被添加到属性文件中。可悲的是，我认为没有办法用enum做到这一点所以我选择了不同的路径，因为我读到每个人都建议基于地图的解决方案。我创建了一个只读取属性文件的单例，而不是枚举，并响应关键字以返回值。

属性文件：

C102 = Blablabla1
C103 = Blablabla2
C104 = Blablabla3

单身代码：

package mypackage;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Properties;

public class ResponseValidationTypeCodes {

private final HashMap<String, String> codes;

private static ResponseValidationTypeCodes instance;

public static ResponseValidationTypeCodes getInstance() {
    if (instance == null) {
        instance = new ResponseValidationTypeCodes();
    }
    return instance;
}

private ResponseValidationTypeCodes() {
    super();
    codes = new HashMap<String, String>();
    initEntry();
}

private void initEntry() {
    Properties prop = new Properties();
    try {
        prop.load(new FileInputStream(
                "src/main/resources/validationcodes.properties"));
        for (Entry<Object, Object> element : prop.entrySet()) {
            codes.put(element.getKey().toString(), element.getValue()
                    .toString());
        }

    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

public String getValueByCode(String code) {
    return codes.get(code);
}
}

获取值，只需调用：

ResponseValidationTypeCodes.getInstance()
            .getValueByCode("C102");

初始属性读取仅运行一次。因此，当您进行某些更改时，只需展开属性，然后重新部署您的内容。我希望对那些愿意使用枚举替代品的人有所帮助。

java属性文件作为枚举

8 个答案: