Чи слід визначати константну строку, якщо вона буде використана лише один раз?

Ми реалізуємо адаптер для Jaxen (бібліотека XPath для Java), що дозволяє нам використовувати XPath для доступу до моделі даних нашого додатку.

Це робиться шляхом впровадження класів, які відображають рядки (передані нам від Jaxen) в елементи нашої моделі даних. Ми вважаємо, що нам знадобиться близько 100 класів із понад 1000 порівняннями струн.

Я думаю, що найкращий спосіб зробити це простий, якщо / 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. Перш ніж хтось запропонує використовувати замість цього enums, ми прототипували це, але перетворення enum у 15 разів повільніше, ніж просте порівняння рядків, тому воно не розглядається.

Висновок: Відповіді, наведені нижче, розширили обсяг цього питання за межі просто рядкових констант, тому у мене є два висновки:

• Можливо, добре використовувати рядки в цьому сценарії, а не рядкові константи, але
• Є способи взагалі уникнути використання рядків, що може бути краще.

Тому я спробую обернути техніку, яка повністю уникає струн. На жаль, ми не можемо використовувати оператор перемикання рядків, оскільки ми ще не на Java 7. Зрештою, я думаю, найкраща відповідь для нас - спробувати кожну техніку та оцінити її ефективність. Реальність полягає в тому, що якщо одна техніка явно швидша, ми, ймовірно, виберемо її незалежно від її краси чи дотримання умовності.

Спробуйте це. Початкові роздуми, безумовно, дорогі, але якщо ви збираєтесь використовувати його багато разів, що, на мою думку, ви хочете, це, безумовно, краще рішення того, що ви пропонуєте. Мені не подобається використовувати рефлексію, але я вважаю, що використовую це, коли мені не подобається альтернатива рефлексії. Я думаю, що це допоможе врятувати вашу команду від великого головного болю, але ви повинні ввести назву методу (з малих літер).

Іншими словами, замість того, щоб передати "ім'я", ви б передали "повне ім'я", тому що ім'я методу 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-таблицях даних і коли ці дані потрібно було експортувати у звіт за допомогою яшми (що, на моєму досвіді, не справляється зі складними об'єктами) .

Якщо взагалі можливо, використовуйте Java 7, що дозволяє використовувати Strings у 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);
        }
    }
}

Я не вимірював, але вважаю, що заяви переключення складаються в таблицю стрибків замість довгого списку порівнянь. Це має бути ще швидше.

Що стосується вашого актуального питання: Якщо ви використовуєте його лише один раз, вам не потрібно перетворювати його на постійне значення. Однак врахуйте, що константа може бути задокументована і відображена в Javadoc. Це може бути важливо для нетривіальних значень рядків.

Якщо ви збираєтеся підтримувати це (будь-які нетривіальні зміни будь-коли), я можу насправді використати або якесь генерування коду, орієнтованого на анотацію (можливо, через CGLib ), або навіть просто сценарій, який записує весь код для вас. Уявіть кількість помилок і помилок, які можуть повстати з підходом, який ви розглядаєте ...

Я б все-таки використовував константи, визначені у верхній частині ваших класів. Це робить ваш код більш ретельним, оскільки легше зрозуміти, що можна змінити пізніше (якщо потрібно). Наприклад, "first_name"може стати "firstName"в більш пізній час.

Якщо ваше іменування є послідовним (ака "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);
}

у загальному суперкласі.

Ви можете використовувати відображення замість обробки анотацій для створення коду. Мінус полягає в тому, що вам потрібно зібрати свій код, перш ніж ви зможете використовувати його. Це означає, що ви не можете покладатися на згенерований код у своїх модельних класах, якщо ви не генеруєте деякі заглушки.

Я також розглядаю можливість прямого використання рефлексії. Звичайно, рефлексія повільна, але чому вона повільна? Це тому, що він повинен робити все, що вам потрібно зробити, наприклад, увімкнути ім'я поля.