Java中可配置的枚举

Question

I'm looking for a better pattern to implement something like this:

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; }
}

The issue is that accessing the enum causes side effects. Say Bar opens a DB connection and the like. So even if I just need VAL2 , I have to pay the price to setup VAL1 .

OTOH, the value of bar is tightly coupled to the enum . It's like an static attribute but enum has no lazy initialization. I could make Foo.getBar() abstract and use anonymous classes but then, I would have to pay the setup price every time.

Is there a cheap way to add lazy init for attributes of enum s?

[EDIT] TO make this clear:

1. getBar() is called millions of times. It must be blinding fast.

2. We're talking singleton here (just like enum itself). Only a single instance must ever be created.

   For additional points, unit tests should be able to override this behavior.

3. Instances must be created lazily.

One solution we tried as to register the values as beans in Spring:

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

That allowed us to specify the values at runtime and override them in tests. Unfortunately, it means we have to inject the ApplicationContext into the enum somehow. So we need a global variable for that. cringe

What's worse: Looking up the value in getBar() is way too slow. We can synchronize getBar() and use if(bar!= null)bar=context.get(name()+".bar"); to solve this.

But is there a way without this that is as safe and fast as using the enum values themselves?

Answer 1

Just replace the enum with an abstract factory pattern.

UPD : You can try something like this:

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;
   }
}

You can try to optimize the synchronization part in some way but that way can vary depending on your concrete use cases.

Answer 2

You can add one level of indirection using a "value holder" which does the lazy initialization:

abstract class BarHolder {
  IBar bar;

  abstract IBar createBar();

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

Now, adjust your enumeration like this:

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(); }
}

Warning: Since this is NOT thread-safe , arbitrarily many instances of any IBar can be created. Therefore, this solution doesn't meet the Singleton requirement (#2 in the OP). And what is worse, getBar() can easily return a reference to a not-yet-initialised instance of an IBar .

Answer 3

Try to store not an object but a class in your enum and when you need, just instantiate it via 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 4

The following is both thread-safe and lazy-initialized , combining two patterns: Enum Singleton and Initialization-On-Demand Holder . It is the only lazy way to avoid unnecessary synchronization , which in the case of Abstract Factory pattern occurs for every single getBar() call, whereas in this case it occurs only once in the event of Static Nested Class initialization, which is lazy by 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();
}

Answer 5

Based on Vladimir's answer - this could do it. It will only create the class objects, the instances should be created lazily on demand:

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;
    }
}