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

Java 创建具有不同参数的类的多个实例
java design-patterns
Java 创建具有不同参数的类的多个实例,java,design-patterns,Java,Design Patterns,下面是我的初始化器类，我正在其中创建处理程序类的多个实例： @Singleton public class Initializer { private static final Logger logger = Logger.getInstance(Initializer.class); private Handler handlerA; private Handler handlerB; private Handler handlerC; private Handler ha
下面是我的初始化器类，我正在其中创建
处理程序类的多个实例：
@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);
    }
  }

然后在postInit（）
和shutdown（）
方法中添加另一行。看起来还可以，但我想知道是否有更好的方法来写？如果我必须再添加10个处理程序，那么这将是所有这些处理程序的一行
想看看是否有更好的方法在我的初始化器类中编写这些处理程序。我正在使用Java7。
假设Type
是一个枚举，并且您希望每个类型都有一个处理程序
，您可以迭代枚举中的值
，创建一个新的处理程序
并将结果存储在列表中
假设类型
是一个枚举，并且您希望每个类型都有一个处理程序
，您可以迭代枚举中的值
，创建一个新的处理程序
并将结果存储在列表中
为什么不将它们存储在哈希映射中

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

公共类初始值设定项{
私有最终映射处理程序=new HashMap（）；
...
@施工后
公共无效postInit（）{
put（Type.A，新处理程序（Type.A，1））；
put（Type.B，新处理程序（Type.B，1））；
put（Type.C，新处理程序（Type.C，1））；
put（Type.D，新处理程序（Type.D，1））；
put（Type.E，新处理程序（Type.E，1））；
}
...
@发情前期
公共空间关闭（）{
for（处理程序：handlers.values（））{
handler.shutdown（）；
}
}
为什么不将它们存储在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();
        }
    }

公共类初始值设定项{
私有最终映射处理程序=new HashMap（）；
...
@施工后
公共无效postInit（）{
put（Type.A，新处理程序（Type.A，1））；
put（Type.B，新处理程序（Type.B，1））；
put（Type.C，新处理程序（Type.C，1））；
put（Type.D，新处理程序（Type.D，1））；
put（Type.E，新处理程序（Type.E，1））；
}
...
@发情前期
公共空间关闭（）{
for（处理程序：handlers.values（））{
handler.shutdown（）；
}
}
您可以像这样迭代类型
枚举值
 @PostConstruct
  public void postInit() {
    for (Type type : Type.values()) {
      handlersList.add(new Handler(type, 1));
    }
  }

您可以像这样迭代Type
enum值
 @PostConstruct
  public void postInit() {
    for (Type type : Type.values()) {
      handlersList.add(new Handler(type, 1));
    }
  }

当然，您可以使用列表
将处理程序
存储在初始值设定项
类中。

但是，当您还搜索一种方式时，初始值设定项
类在添加处理程序
时的影响较小（我也假设已删除），我认为您应该赋予类型
枚举更多的责任，以便初始值设定项
类将处理程序
实例化任务委托给它们。

正如您所说，您有一个且仅一个按类型划分的处理程序
，您可以在类型
枚举的侧面处理处理程序
的配置和实例化。

每个枚举都应该有一个构造函数来设置创建处理程序所需的属性。

这样，在添加/修改/删除处理程序时，不需要更改初始值设定项类。

此外，您还可以直接在枚举声明中设置poolSize
，并且可以根据您在注释中建议的需要为类型启用或禁用处理程序。

下面是类型
枚举（我已经为示例中的E
值禁用了处理程序
）：
以下是初始化器类：
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();
        }
    }
 }

public类`Initializer`{
私有列表处理程序=新的ArrayList（）；
...
@施工后
公共无效postInit（）{
对于（类型：Type.values（））{
Handler=type.createHandler（）；
if（处理程序！=null）{
添加（handler）；
}
}                      
}
...
@发情前期
公共空间关闭（）{
for（处理程序：处理程序）{
handler.shutdown（）；
}
}
}
您当然可以使用列表
将处理程序
存储在初始值设定项
类中。

但是，当您还搜索一种方式时，初始值设定项
类在添加处理程序
时的影响较小（我也假设已删除），我认为您应该赋予类型
枚举更多的责任，以便初始值设定项
类将处理程序
实例化任务委托给它们。

正如您所说，您有一个且仅一个按类型划分的处理程序
，您可以在类型
枚举的侧面处理处理程序
的配置和实例化。

每个枚举都应该有一个构造函数来设置创建处理程序所需的属性。

这样，在添加/修改/删除处理程序时，不需要更改初始值设定项类。

此外，您还可以直接在枚举声明中设置poolSize
，并且可以根据您在注释中建议的需要为类型启用或禁用处理程序。

下面是类型
枚举（我已经为示例中的E
值禁用了处理程序
）：
以下是初始化器类：
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();
        }
    }
 }

public类`Initializer`{
私有列表处理程序=新的ArrayList（）；
...
@施工后
公共无效postInit（）{
对于（类型：Type.values（））{
Handler=type.createHandler（）；
if（处理程序！=null）{
添加（handler）；
}
}                      
}
...
@发情前期
公共空间关闭（）{
for（处理程序：处理程序）{
handler.shutdown（）；
}
}