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

以下是我的Handler构造函数：

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

我的问题是 - 如果我需要在handlerE课程中添加其他Initializer，那么我需要添加以下内容：

private Handler handlerE;

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

想要查看是否有更好的方法在我的Initializer类中编写这些处理程序。我正在使用Java7。

Answer 1

您当然可以使用List将Handler存储在Initializer课程中。

但是当你搜索Initializer类在添加Handler时影响较小的方式（并且我也假设删除）时，我认为你应该对{{{}}更多的责任{1}}枚举，以便Type类将Initializer实例化任务委托给他们。

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

此外，您还可以直接在枚举声明中设置Initializer，然后您可以根据评论中的建议启用或禁用poolSize类型。{< / p>

以下是Handler枚举（我已为该示例的Type值禁用了Handler）：

这是Initializer类：

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

Answer 2

为什么不将它们存储在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 3

假设Type是枚举，并且您希望每种类型都有Handler，则可以迭代枚举中的values，创建新的Handler并存储结果为List。

Answer 4

您可以迭代这样的Type枚举值。

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

使用不同的参数创建一个类的多个实例

4 个答案: