Quiero saber cuándo necesitamos usar el patrón abstracto de fábrica.cuándo utilizar el patrón abstracto de fábrica?
Aquí hay un ejemplo, quiero saber si es necesario.
lo anterior es el patrón de fábrica abstracta, es recomendado por mi compañero de clase. Lo que sigue es mi implementación. No creo que sea necesario usar el patrón.
Y el siguiente es algunos códigos básicos:
package net;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
public class Test {
public static void main(String[] args) throws IOException, InstantiationException, IllegalAccessException, ClassNotFoundException {
DaoRepository dr=new DaoRepository();
AbstractDao dao=dr.findDao("sql");
dao.insert();
}
}
class DaoRepository {
Map<String, AbstractDao> daoMap=new HashMap<String, AbstractDao>();
public DaoRepository() throws IOException, InstantiationException, IllegalAccessException, ClassNotFoundException {
Properties p=new Properties();
p.load(DaoRepository.class.getResourceAsStream("Test.properties"));
initDaos(p);
}
public void initDaos(Properties p) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
String[] daoarray=p.getProperty("dao").split(",");
for(String dao:daoarray) {
AbstractDao ad=(AbstractDao)Class.forName(dao).newInstance();
daoMap.put(ad.getID(),ad);
}
}
public AbstractDao findDao(String id) {return daoMap.get(id);}
}
abstract class AbstractDao {
public abstract String getID();
public abstract void insert();
public abstract void update();
}
class SqlDao extends AbstractDao {
public SqlDao() {}
public String getID() {return "sql";}
public void insert() {System.out.println("sql insert");}
public void update() {System.out.println("sql update");}
}
class AccessDao extends AbstractDao {
public AccessDao() {}
public String getID() {return "access";}
public void insert() {System.out.println("access insert");}
public void update() {System.out.println("access update");}
}
y el contenido de la Test.properties es sólo una línea:
dao=net.SqlDao,net.SqlDao
Así que cualquier ONT puede decirme si esto es necesario suitation ?
------------------- Se añade lo siguiente a explicar la verdadera suitation --------------
Uso el ejemplo de Dao porque es común, cualquiera lo sabe.
De hecho, lo que estoy trabajando ahora no está relacionado con el DAO, estoy trabajando para construir una web de servicios
, el serivce web contiene algunos algoritmos para chang un archivo a otro formato,
Por ejemplo: net.CreatePDF, net.CreateWord y etc., expone dos interfaces al cliente: getAlgorithms y doProcess.
getAlogrithoms devolverá todos los id. De los algoritmos, cada id. Se aplica al algoritmo correspondiente .
El usuario que llama al método doProcess también le proporcionará el ID de algoritmo que desea.
Todo el algoritmo amplía el AbstractAlgorithm que define un método run().
Puedo usar un AlogrithmsRepository para almacenar todos los algoritmos (de
el archivo de propiedades que config las clases Java concreta de los algoritmos por la web
administrador de servicios) .Es de decir, el DoProcess interfaz expuesta por el servicio web es
ejecutado por el alogrithm concreto.
me puede dar un ejemplo sencillo: 1) el usuario envía la solicitud getAlgorithms:
http://host:port/ws?request=getAlgorithms
A continuación, el usuario recibirá una lista de algoritmos embebidos en un xml.
<AlgorithmsList>
<algorithm>pdf</algorithm>
<algorithm>word<algorithm>
</AlgorithmsList>
2) de usuario a enviar un DoProcess al servidor por:
http://xxx/ws?request=doProcess&alogrithm=pdf&file=http://xx/Test.word
cuando el servidor recieve este tipo de requst, conseguirá la instancia algoritmo de hormigón de acuerdo con el parámetro de "algoritmo" (se pdf en esta solicitud) del AlgorithmRepostory. Y llame al método:
AbstractAlgorithm algo=AlgorithmRepostory.getAlgo("pdf");
algo.start();
A continuación, se enviará un archivo pdf al usuario.
BTW, en este ejemplo, cada algoritmo es similar al sqlDao, AccessDao. Aquí está la imagen:
Ahora, ¿el AlgorithmRepostory necesita usar la fábrica abstracta?
@ rsp-Gracias por solucionar mi problema. De hecho, lo que quiero dejar en claro es que cuando se utiliza una fábrica abstracta, es decir, suponemos que las dos formas mencionadas anteriormente no pueden causar algunos problemas de hilos. bueno, si el problema no existe, ¿por qué usamos Abstract Factory? En el patrón Ab.Fatory, los diferentes productos son creados por diferentes fábricas, de la siguiente manera (la que usted arregló), los productos son creados por un Repositorio (el DaoRepository en el ejemplo), entonces, ¿cuál es la diferencia? Cuando el Repositorio crea una nueva instancia, tampoco sabe qué objeto está creando, ¿no es así? – hguser
@hguser, como siempre depende del contexto. Si necesita crear una instancia de un conjunto de objetos que utiliza la aplicación, no hay nada de malo en un repositorio que crea instancias basadas en la configuración y distribuye referencias a estos objetos. En este caso, la "fábrica" es parte de la inicialización del repositorio.Una fábrica de objetos que crea nuevas instancias es otro caso de uso, que podría cubrir más usos. – rsp
@ rsp-Entonces, para la situación que agregué (el ejemplo del servicio web), si uno quiere usar la fábrica abstracta en el AlgorithmsRepository, ¿cómo implementarlo? Realmente quiero aclarar las diferencias con el mismo ejemplo. Gracias. – hguser