是否有完善的方法来记录Java“属性”文件内容，包括：
目前，我（手动）维护一个默认的.properties文件，我在之前的评论中写了每个键的数据类型和描述的散文描述。这不会导致以编程方式访问的属性文件。
我想我正在寻找的是属性文件的“getopt”等价物......
[编辑：相关]
答案 0 :(得分：3)
您可以使用Apache Commons Configuration包中的某些功能。它至少提供对您的属性的类型访问。
传统的java属性文件中只有约定。我见过的一些包括像你说的那样提供一个示例属性文件。另一种方法是提供具有所有属性的默认配置，但已注释掉。
如果你真的想要一些东西，也许你不是在寻找一个属性文件。您可以使用XML配置文件并指定具有数据类型和要求的模式。你可以使用jaxb将模式编译成java并以这种方式读取它。通过验证，您可以确保所需的属性存在。
您可以期待的最好的是当您执行应用程序时，它会读取，解析和验证文件中的属性。如果你绝对不得不保留属性并且不想去xml，但需要这个解析。您可以拥有一个辅助属性文件，其中列出了可以包含的每个属性，其类型以及是否需要它。然后，您必须编写一个属性文件验证程序，该验证程序将接受要验证的文件以及类似验证架构的属性文件。像
这样的东西#list of required properties
required=prop1,prop2,prop3
#all properties and their types
prop1.type=Integer
prop2.type=String
我没有浏览过所有的Apache配置包，但它们通常都有这样的实用工具。如果你能在那里找到能够简化这一点的东西，我不会感到惊讶。
答案 1 :(得分：2)
签出的另一个选项是名为OWNER的项目。在那里，您可以使用类型和注释定义用作应用程序中配置对象的接口。然后，OWNER查找并解析正确的Properties文件。因此，您可以为您的接口编写 javadoc 并将其用作文档。
答案 2 :(得分：1)
一种简单的方法是使用示例属性文件分发项目，例如：我的项目在svn中有一个“build.properties.example”，必要时会对属性进行注释。本地正确的属性不会进入svn。
既然你提到“getopt”，我想知道你是否真的想到cmd行参数？如果存在需要特定属性的“main”，我通常会在“useage”消息中输入相关指令，如果参数不正确或“-h”则打印出来。
答案 3 :(得分：1)
我从未见过这样做的标准方式。我可能会做的是：
除了你可以用一种可能更容易处理的不同方式管理信息之外，它不会让你得到任何关于你正在做什么的东西 - 例如你可以有一个程序吐出评论到读入。它可能会为您提供所需的程序化访问权限，但这是一种自己动手的事情。
或者它可能只是太多的工作而太少无法获得（这就是为什么没有明显的东西）。
如果你可以指定你希望看到的评论类型我可以尝试写一些东西，如果我感到无聊:-)（这是我喜欢做的有趣的事情，生病我知道:-)
好的......我感到无聊......这里至少是一个开始： - ）
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
public class PropertiesVerifier
{
private final Map<String, PropertyInfo> optionalInfo;
private final Map<String, PropertyInfo> requiredInfo;
{
optionalInfo = new HashMap<String, PropertyInfo>();
requiredInfo = new HashMap<String, PropertyInfo>();
}
public PropertiesVerifier(final PropertyInfo[] infos)
{
for(final PropertyInfo info : infos)
{
final Map<String, PropertyInfo> infoMap;
if(info.isRequired())
{
infoMap = requiredInfo;
}
else
{
infoMap = optionalInfo;
}
infoMap.put(info.getName(), info);
}
}
public void verifyProperties(final Properties properties)
{
for(final Entry<Object, Object> property : properties.entrySet())
{
final String key;
final String value;
key = (String)property.getKey();
value = (String)property.getValue();
if(!(isValid(key, value)))
{
throw new IllegalArgumentException(value + " is not valid for: " + key);
}
}
}
public boolean isRequired(final String key)
{
return (requiredInfo.get(key) != null);
}
public boolean isOptional(final String key)
{
return (optionalInfo.get(key) != null);
}
public boolean isKnown(final String key)
{
return (isRequired(key) || isOptional(key));
}
public Class getType(final String key)
{
final PropertyInfo info;
info = getPropertyInfoFor(key);
return (info.getType());
}
public boolean isValid(final String key,
final String value)
{
final PropertyInfo info;
info = getPropertyInfoFor(key);
return (info.verify(value));
}
private PropertyInfo getPropertyInfoFor(final String key)
{
PropertyInfo info;
info = requiredInfo.get(key);
if(info == null)
{
info = optionalInfo.get(key);
if(info == null)
{
// should be a better exception maybe... depends on how you
// want to deal with it
throw new IllegalArgumentException(key + "
is not a valid property name");
}
}
return (info);
}
protected final static class PropertyInfo
{
private final String name;
private final boolean required;
private final Class clazz;
private final Verifier verifier;
protected PropertyInfo(final String nm,
final boolean mandatory,
final Class c)
{
this(nm, mandatory, c, getDefaultVerifier(c));
}
protected PropertyInfo(final String nm,
final boolean mandatory,
final Class c,
final Verifier v)
{
// check for null
name = nm;
required = mandatory;
clazz = c;
verifier = v;
}
@Override
public int hashCode()
{
return (getName().hashCode());
}
@Override
public boolean equals(final Object o)
{
final boolean retVal;
if(o instanceof PropertyInfo)
{
final PropertyInfo other;
other = (PropertyInfo)o;
retVal = getName().equals(other.getName());
}
else
{
retVal = false;
}
return (retVal);
}
public boolean verify(final String value)
{
return (verifier.verify(value));
}
public String getName()
{
return (name);
}
public boolean isRequired()
{
return (required);
}
public Class getType()
{
return (clazz);
}
}
private static Verifier getDefaultVerifier(final Class clazz)
{
final Verifier verifier;
if(clazz.equals(Boolean.class))
{
// shoudl use a singleton to save space...
verifier = new BooleanVerifier();
}
else
{
throw new IllegalArgumentException("Unknown property type: " +
clazz.getCanonicalName());
}
return (verifier);
}
public static interface Verifier
{
boolean verify(final String value);
}
public static class BooleanVerifier
implements Verifier
{
public boolean verify(final String value)
{
final boolean retVal;
if(value.equalsIgnoreCase("true") ||
value.equalsIgnoreCase("false"))
{
retVal = true;
}
else
{
retVal = false;
}
return (retVal);
}
}
}
一个简单的测试：
import java.util.Properties;
public class Main
{
public static void main(String[] args)
{
final Properties properties;
final PropertiesVerifier verifier;
properties = new Properties();
properties.put("property.one", "true");
properties.put("property.two", "false");
// properties.put("property.three", "5");
verifier = new PropertiesVerifier(
new PropertiesVerifier.PropertyInfo[]
{
new PropertiesVerifier.PropertyInfo("property.one",
true,
Boolean.class),
new PropertiesVerifier.PropertyInfo("property.two",
false,
Boolean.class),
// new PropertiesVerifier.PropertyInfo("property.three",
// true,
// Boolean.class),
});
System.out.println(verifier.isKnown("property.one"));
System.out.println(verifier.isKnown("property.two"));
System.out.println(verifier.isKnown("property.three"));
System.out.println(verifier.isRequired("property.one"));
System.out.println(verifier.isRequired("property.two"));
System.out.println(verifier.isRequired("property.three"));
System.out.println(verifier.isOptional("property.one"));
System.out.println(verifier.isOptional("property.two"));
System.out.println(verifier.isOptional("property.three"));
System.out.println(verifier.getType("property.one"));
System.out.println(verifier.getType("property.two"));
// System.out.println(verifier.getType("property.tthree"));
System.out.println(verifier.isValid("property.one", "true"));
System.out.println(verifier.isValid("property.two", "false"));
// System.out.println(verifier.isValid("property.tthree", "5"));
verifier.verifyProperties(properties);
}
}