创建具有不同参数的类的多个实例

Question

下面是我的初始化类中，我创建Handler类的多个实例：

@Singleton 
public class Initializer { 
    private static final Logger logger = Logger.getInstance(Initializer.class); 
    private Handler handlerA; 
    private Handler handlerB; 
    private Handler handlerC; 
    private Handler handlerD; 
    // add another handler 

    private Initializer() { 

    } 

    @PostConstruct 
    public void postInit() { 
    handlerA = new Handler(Type.A, 1); 
    handlerB = new Handler(Type.B, 1); 
    handlerC = new Handler(Type.C, 1); 
    handlerD = new Handler(Type.D, 1); 
    // add another handler instance 
    } 

    @PreDestroy 
    public void shutdown() { 
    handlerA.shutdown(); 
    handlerB.shutdown(); 
    handlerC.shutdown(); 
    handlerD.shutdown(); 
    // add another handler shutdown 
    } 
} 

而下面是我的处理程序的构造函数：

public Handler(Type type, int poolSize) { 
    this.executorService = Executors.newFixedThreadPool(poolSize); 
    for (int i = 0; i < poolSize; i++) { 
     Loop loop = HandlerFactory.getInstance().create(type); 
     loops.add(loop); 
     executorService.submit(loop); 
    } 
    } 

我问题是 - 如果我需要在我的Initializer课程中添加另一个handlerE，那么我需要添加以下行：

private Handler handlerE; 

然后在postInit()和shutdown()方法中再添加一行。它看起来不错，但我想知道是否有更好的方式来写这个？如果我不得不增加10个处理程序，那么对于所有这些处理程序来说，这将是一条线。

想知道是否有更好的方法来在我的初始化类中编写这些处理程序。我正在使用Java7。

Answer 1

你可以使用过程中List到Handler 4S店在Initializer类。

但你还可以搜索的方式，其中Initializer类将有当加入Handler S（和删除我假设太）影响较小，我认为你应该为了让更多责任到Type枚举的Initializer类委托给他们Handler实例化任务。

正如你说，你有且只有不同Handler的类型，你可以处理配置和Handler在Type枚举一侧的实例。
每个枚举应该有一个构造函数来设置所需的属性来创建一个Handler。
通过这种方式，当您添加/修改/删除处理程序时，不需要更改Initializer类。

此外，您还可以直接设置poolSize在枚举声明中，你可以可以启用或一类禁用Handler正如你提到的这个需求在注释中。

这里是Type枚举（我已禁用Handler为E值为例）：

public enum Type { 

    A(1, true), B(1, true), C(1, true), D(1, true), E(1, false); 

    private int poolSize; 
    private boolean isHandlerEnabled; 

    Type(int poolSize, boolean isHandlerEnabled) { 
     this.poolSize = poolSize; 
     this.isHandlerEnabled = isHandlerEnabled; 
    } 

    public int getPoolSize() { 
     return poolSize; 
    } 

    public boolean isHandlerEnabled() { 
     return isHandlerEnabled; 
    } 
    public createHandler(){ 
     if (!isHandlerEnabled){ 
      return null; 
     } 
     return new Handler(this, poolSize); 
    }  
} 

这里是初始化类：

public class `Initializer` { 
    private List<Handler> handlers = new ArrayList<>(); 
    ... 
    @PostConstruct 
    public void postInit() { 
     for (Type type : Type.values()){ 
      Handler handler = type.createHandler(); 
      if (handler != null){ 
      handlers.add(handler); 
      } 
     }      
    } 
    ... 

    @PreDestroy 
    public void shutdown() { 
     for(Handler handler : handlers) { 
      handler.shutdown(); 
     } 
    } 
} 

Answer 2

假设Type是一个枚举，你想对每一种类型Handler，你可以遍历在枚举的values，创建一个新的Handler和结果存储在List。

Answer 3

为什么不把它们存储在HashMap？

public class Initializer { 
    private final Map<Type, Handler> handlers = new HashMap<>(); 
    ... 
    @PostConstruct 
    public void postInit() { 
     handlers.put(Type.A, new Handler(Type.A, 1)); 
     handlers.put(Type.B, new Handler(Type.B, 1)); 
     handlers.put(Type.C, new Handler(Type.C, 1)); 
     handlers.put(Type.D, new Handler(Type.D, 1)); 
     handlers.put(Type.E, new Handler(Type.E, 1)); 
    } 
    ... 

    @PreDestroy 
    public void shutdown() { 
     for(Handler handler : handlers.values()) { 
      handler.shutdown(); 
     } 
    } 

Answer 4

您可以遍历Type这样的枚举值。

@PostConstruct 
    public void postInit() { 
    for (Type type : Type.values()) { 
     handlersList.add(new Handler(type, 1)); 
    } 
    }