Настраиваемый перечисление в Java

Question

Я ищу лучший шаблон для реализации что-то вроде этого:

public static enum Foo { 
    VAL1(new Bar()), 
    VAL2(new FooBar()); 

    private final bar; 

    private Foo(IBar bar) { 
     this.bar = bar; 
    } 

    public IBar getBar() { return bar; } 
} 

Вопрос заключается в том, что доступ к enum вызывает побочные эффекты. Скажем, Bar открывает соединение с БД и тому подобное. Поэтому, даже если мне просто нужно VAL2, я должен заплатить цену за установку VAL1.

OTOH, значение bar плотно связано с enum. Это как статический атрибут, но enum не имеет ленивой инициализации. Я мог бы сделать абстракцию Foo.getBar() и использовать анонимные классы, но тогда мне придется платить за установку каждый раз.

Есть ли дешевый способ добавить ленивый init для атрибутов enum s?

[EDIT] сделать это ясно:

1. getBar() называется миллионы раз. Это должно быть ослепляющим быстро.

2. Мы говорим о синглете здесь (точно так же, как и enum). Должен быть создан только один экземпляр.

   Для дополнительных целей, модульные тесты должны иметь возможность отменить это поведение.

3. Экземпляры должны создаваться лениво.

Одним из решений мы старались, чтобы зарегистрировать значения, как бобы весной:

<bean id="VAL1.bar" class="...." /> 

Это позволило нам определить значения во время выполнения и переопределить их в тестах. К сожалению, это означает, что мы должны ввести ApplicationContext в enum. Поэтому для этого нам нужна глобальная переменная. cringe

Что еще хуже: поиск значения в getBar() слишком медленный. Мы можем synchronizegetBar() и использовать if(bar!= null)bar=context.get(name()+".bar");, чтобы решить эту проблему.

Но есть ли способ без этого, который так же безопасен и быстр, как и сами значения enum?

Answer 1

Попробуйте сохранить не объект, а класс в вашем перечислении, и когда вам нужно, просто создайте его через Class.newInstance().

public static enum Foo { 
    VAL1(Bar.class), 
    VAL2(FooBar.class); 

    private final Class<...> barClass; 

    private Foo(Class<? extends IBar> barClass) { 
     this.barClass = barClass; 
    } 

    public Class< ? extends IBar> getBarClass() { return barClass; } 
} 

/// client code 
try { 
IBar instance = Class.newInstance(Foo.VAL1.getBarClass()); 
} catch (...) { 
... 
} 

Answer 2

Просто замените перечисление на абстрактный шаблон фабрики.

UPD: Вы можете попробовать что-то вроде этого:

public interface Factory { 
    IBar getBar(); 
} 

public class BarFactory implements Factory { 

    private IBar barInstance; 

    public synchronized IBar getBar() { 
     if (barInstance == null) { 
      barInstance = new Bar(); 
     } 
     return barInstance; 
    } 
} 

public class FooBarFactory implements Factory { 

    private IBar barInstance; 

    public synchronized IBar getBar() { 
     if (barInstance == null) { 
      barInstance = new FooBar(); 
     } 
     return barInstance; 
    } 
} 

Вы можете попытаться оптимизировать часть синхронизации в некотором роде, но таким образом может меняться в зависимости от конкретных случаев использования.

Answer 3

Вы можете добавить один уровень косвенности, используя «держатель значения», который делает ленивую инициализацию:

abstract class BarHolder { 
    IBar bar; 

    abstract IBar createBar(); 

    IBar getBar() { 
    if (bar == null) { 
     bar = createBar(); 
    } 
    return bar; 
    } 
} 

Теперь, настроить нумерацию так:

public static enum Foo { 
    VAL1(new BarHolder() { 
    IBar createBar() { return new Bar(); } 
)}, 
    VAL2(new BarHolder() { 
    IBar createBar() { return new FooBar(); } 
)}; 

    private final BarHolder barHolder; 

    private Foo(BarHolder barHolder) { 
    this.barHolder = barHolder; 
    } 

    public IBar getBar() { return barHolder.getBar(); } 
} 

Предупреждение: С это Небезопасный, может быть создано произвольное количество любых IBar. Поэтому это решение не соответствует требованию Singleton (№ 2 в OP). И что еще хуже, getBar() может легко вернуть ссылку на еще не инициализированный экземпляр IBar.

Answer 4

Основываясь на ответе Владимира - это может быть сделано. Это будет только создавать объекты класса, экземпляры должны быть созданы лениво по запросу:

public static enum Foo { 
    VAL1(Bar.class), 
    VAL2(FooBar.class); 

    private Class<? extends IBar> clazz; 
    private IBar bar = null; 

    private Foo(Class<? extends IBar> clazz) { 
     this.clazz = clazz; 
    } 

    public IBar getBar() { 
     if (bar == null) 
     bar = clazz.newInstance(); 
     } 
     return bar; 
    } 
} 

Answer 5

Ниже как поточно- и отложенной инициализации, сочетающий в себе две модели: Enum Singleton и Initialization-On-Demand Holder. Это единственный ленивого способ избежать ненужной синхронизации, что в случае Abstract Factory рисунка происходит за каждый одного getBar() вызова, тогда как в данном случае это происходит только раз в случае Static Nested Class инициализации, которая ленивым по definition:

public enum Foo { 
    VAL1() { 
     @Override 
     public IBar getBar() { 
      return LazyVAL1.BAR; 
     } 
    }, 
    VAL2() { 
     @Override 
     public IBar getBar() { 
      return LazyVAL2.BAR; 
     } 
    }; 

    private static class LazyVAL1 { 
     public static final IBar BAR = new Bar(); 
    } 

    private static class LazyVAL2 { 
     public static final IBar BAR = new FooBar(); 
    } 

    public abstract IBar getBar(); 
}