patterns - java parametrizada fábrica estática genérica

pool design pattern

Question

¿Es posible en Java crear un método / clase estático de fábrica que utilice una interfaz como tipo parametrizado y devolver una clase de implementación de esta interfaz dada?

Aunque mi conocimiento de Generics es limitado, esto es lo que quiero hacer:

// define a base interface:
public interface Tool {
    // nothing here, just the interface.
}

// define a parser tool:
public interface Parser extends Tool {
    public ParseObject parse(InputStream is); 
}

// define a converter tool:
public interface Converter extends Tool {
    public ConvertObject convert(InputStream is, OutputStream os);
}

// define a factory class
public class ToolFactory {
    public static <? extends Tool> getInstance(<? extends Tool> tool) {
       // what I want this method to return is:
       // - ParserImpl class, or
       // - ConverterImpl class
       // according to the specified interface.
       if (tool instanceof Parser) {
          return new ParserImpl();
       }
       if (tool instanceof Converter) {
          return new ConverterImpl();
       }
    }
}

Quiero restringir el código del cliente para que solo inserte una interfaz ''tipo'' en el método getInstance () que se extiende desde la interfaz de la Herramienta que especifiqué. De esta manera, estoy seguro de que el tipo de herramienta que se inserta es una herramienta legítima.

El código del cliente debería verse así:

public class App {
   public void main(String[] args) {

      Parser parser = null;
      Converter converter = null;

      // ask for a parser implementation (without knowing the implementing class)
      parser = ToolFactory.getInstance(parser);

      // ask for a converter implementation
      converter = ToolFactory.getInstance(converter);

      parser.parse(...);
      converter.convert(... , ...);
   }
}

La fábrica debe activar el tipo de interfaz (descuidada si es nula o no), definida antes de que se solicite de fábrica. Sé que esto no va a funcionar de la manera en que escribí esto, pero espero que uno de los lectores sepa lo que quiero lograr.

El tipo de retorno del método getInstance es el mismo que el parámetro entrante, de modo que cuando se pasa una interfaz del analizador, también devuelve un analizador p = new ParserImpl (); return p;

Gracias de antemano por ayudarme.

Answer 1

Un par de cosas:

1. Su fábrica casi seguramente tomará una clase para instanciar, en lugar de un objeto Tool. Hacer que alguien cree un Parser para pasar a su método para obtener un Parser es un poco de pollo y huevo.
2. No sé si se te permite tener parámetros genéricos para los métodos que son comodines; Supongo que no, ya que esto sería absurdo e inútil. Cuando parametriza un método, debe darle un nombre al parámetro genérico para que pueda consultarlo más adelante.

Poniendo todo esto junto, su método de fábrica podría verse más como esto:

public static <T extends Tool> T getInstance(Class<T> toolClass) {
   if (Parser.class.isAssignableFrom(toolClass) {
      return new ParserImpl();
   }
   else if (Converter.class.isAssignableFrom(toolClass) {
      return new ConverterImpl();
   }

   // You''ll always need to have a catch-all case else the compiler will complain
   throw new IllegalArgumentException("Unknown class: " + toolClass.getName());
}

Si desea restringir el tipo de toolClass para que sea una interfaz, no puede hacerlo en tiempo de compilación, pero puede, por supuesto, introducir un control de tiempo de ejecución toolClass.isInterface() .

Por cierto, esta conmutación estática y codificada no es muy buena en general. En mi opinión, sería más agradable poner la relación clase-constructor en un Map y buscar el proceso de construcción de forma dinámica. Tal vez incluso almacenar el valor como un Callable<? extends Tool> Callable<? extends Tool> y agrega un método protegido que permite a otras clases registrar mapeos.

Eso no quiere decir que su versión actual no funciona, solo que no se escala muy bien, y en este momento no creo que esté haciendo mucho para justificar tener una fábrica separada en lugar de la persona que llama simplemente invocando toolClass.newInstance() ellos mismos.