如果只使用一次，是否应该定义一个字符串常量？

我们正在为Jaxen（Java的XPath库）实现一个适配器，该适配器允许我们使用XPath来访问应用程序的数据模型。

这是通过实现将字符串（从Jaxen传递给我们的）映射到数据模型的元素的类来完成的。我们估计我们将需要大约100个类，总共超过1000个字符串比较。

我认为，执行此操作的最佳方法是将字符串直接写入代码的简单if / else语句-而不是将每个字符串都定义为常量。例如：

public Object getNode(String name) {
    if ("name".equals(name)) {
        return contact.getFullName();
    } else if ("title".equals(name)) {
        return contact.getTitle();
    } else if ("first_name".equals(name)) {
        return contact.getFirstName();
    } else if ("last_name".equals(name)) {
        return contact.getLastName();
    ...

但是，总是有人告诉我，我们不应该将字符串值直接嵌入代码中，而应该创建字符串常量。看起来像这样：

private static final String NAME = "name";
private static final String TITLE = "title";
private static final String FIRST_NAME = "first_name";
private static final String LAST_NAME = "last_name";

public Object getNode(String name) {
    if (NAME.equals(name)) {
        return contact.getFullName();
    } else if (TITLE.equals(name)) {
        return contact.getTitle();
    } else if (FIRST_NAME.equals(name)) {
        return contact.getFirstName();
    } else if (LAST_NAME.equals(name)) {
        return contact.getLastName();
    ...

在这种情况下，我认为这是个坏主意。在该getNode()方法中，该常数将仅使用一次。直接使用字符串与使用常量一样容易阅读和理解，并节省了我们编写至少一千行代码的时间。

那么，是否有任何理由一次定义字符串常量？还是直接使用字符串是否可以接受？

PS。在有人建议使用枚举代替之前，我们对它进行了原型设计，但是枚举转换比简单的字符串比较要慢15倍，因此我们不予考虑。

结论： 下面的答案扩展了这个问题的范围，不仅仅是字符串常量，所以我有两个结论：

• 在这种情况下，直接使用字符串而不是字符串常量可能是可以的，但是
• 有一些方法可以避免使用字符串，这可能更好。

因此，我将尝试完全避免使用字符串的包装技术。不幸的是，我们还不能使用字符串切换语句，因为我们还没有使用Java 7。但最终，我认为对我们来说最好的答案是尝试每种技术并评估其性能。现实情况是，如果一种技术明显更快，那么我们可能会选择它，而不管它的美观或遵循惯例如何。

尝试这个。最初的反射当然很昂贵，但是如果您打算多次使用它（我想您会使用），那么这无疑是您所提议的更好的解决方案。我不喜欢使用反射，但是当我不喜欢反射的替代方法时，我发现自己正在使用它。我确实认为这会为您的团队节省很多麻烦，但是您必须传递方法的名称（小写）。

换句话说，您将传递“ fullname”，而不是传递“ name”，因为get方法的名称是“ getFullName（）”。

Map<String, Method> methodMapping = null;

public Object getNode(String name) {
    Map<String, Method> methods = getMethodMapping(contact.getClass());
    return methods.get(name).invoke(contact);
}

public Map<String, Method> getMethodMapping(Class<?> contact) {
    if(methodMapping == null) {
        Map<String, Method> mapping = new HashMap<String, Method>();
        Method[] methods = contact.getDeclaredMethods();
        for(Method method : methods) {
            if(method.getParameterTypes().length() == 0) {
                if(method.getName().startsWith("get")) {
                    mapping.put(method.getName().substring(3).toLower(), method);
                } else if (method.getName().startsWith("is"))) {
                    mapping.put(method.getName().substring(2).toLower(), method);
                }
            }
        }
        methodMapping = mapping;
    }
    return methodMapping;
}

如果需要访问联系人成员中包含的数据，则可以考虑为联系人构建一个包装器类，该包装器类具有访问所需信息的所有方法。这对于确保访问字段的名称始终保持不变也很有用（即，如果包装器类具有getFullName（）并且您使用全名进行调用，则即使联系人的getFullName（）已重命名，它也将始终有效—会导致编译错误，然后再让您执行此操作）。

public class ContactWrapper {
    private Contact contact;

    public ContactWrapper(Contact contact) {
        this.contact = contact;
    }

    public String getFullName() {
        return contact.getFullName();
    }
    ...
}

该解决方案为我节省了很多时间，即当我想在jsf数据表中使用单个数据表示形式时，以及当需要使用jasper将数据导出到报表中时（根据我的经验，这种方式不能很好地处理复杂的对象访问器） 。

尽可能使用Java 7，它允许您在switch语句中使用字符串。

从http://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html

public class StringSwitchDemo {

    public static int getMonthNumber(String month) {

        int monthNumber = 0;

        if (month == null) {
            return monthNumber;
        }

        switch (month.toLowerCase()) {
            case "january":
                monthNumber = 1;
                break;
            case "february":
                monthNumber = 2;
                break;
            case "march":
                monthNumber = 3;
                break;
            case "april":
                monthNumber = 4;
                break;
            case "may":
                monthNumber = 5;
                break;
            case "june":
                monthNumber = 6;
                break;
            case "july":
                monthNumber = 7;
                break;
            case "august":
                monthNumber = 8;
                break;
            case "september":
                monthNumber = 9;
                break;
            case "october":
                monthNumber = 10;
                break;
            case "november":
                monthNumber = 11;
                break;
            case "december":
                monthNumber = 12;
                break;
            default: 
                monthNumber = 0;
                break;
        }

        return monthNumber;
    }

    public static void main(String[] args) {

        String month = "August";

        int returnedMonthNumber =
            StringSwitchDemo.getMonthNumber(month);

        if (returnedMonthNumber == 0) {
            System.out.println("Invalid month");
        } else {
            System.out.println(returnedMonthNumber);
        }
    }
}

我没有测量，但是我相信switch语句可以编译为跳转表，而不是一长串比较表。这应该更快。

关于您的实际问题：如果只使用一次，则无需使其成为常数。但是请考虑可以在Javadoc中记录并显示常量。这对于非平凡的字符串值可能很重要。

如果您要保持这一点（曾经做过任何不重要的更改），我实际上可能会考虑使用某种注释驱动的代码生成方式（也许通过CGLib），甚至只是使用一个脚本为您编写所有代码。想象一下您正在考虑的方法中可能出现的错别字和错误的数量...

我仍将使用在类顶部定义的常量。它使您的代码更具可维护性，因为在以后（如有必要）更容易看到可以更改的内容。例如，"first_name"可能会"firstName"在以后出现。

如果您的命名是一致的（aka "some_whatever"始终映射到getSomeWhatever()），则可以使用反射来确定并执行get方法。

我想，即使没有注释，注释处理也可能是解决方案。可以为您生成所有无聊代码的东西。缺点是您将获得N个模型类的N个生成的类。您也不能将任何内容添加到现有的类中，而是编写类似

public Object getNode(String name) {
    return SomeModelClassHelper.getNode(this, name);
}

每个班一次应该不是问题。或者，您可以编写类似

public Object getNode(String name) {
    return getHelper(getClass()).getNode(this, name);
}

在一个普通的超类中。

您可以使用反射代替注释处理来生成代码。缺点是您需要先编译代码，然后才能对其进行反射。这意味着除非生成一些存根，否则您不能依赖模型类中生成的代码。

我也考虑直接使用反射。当然，反射很慢，但是为什么会慢呢？这是因为它必须完成您需要做的所有事情，例如，打开字段名称。