創建具有不同參數的類的多個實例

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