[JAVA] Modèle d'usine abstraite
Qu'est-ce que le modèle Abstract Factory?
Créez un produit abstrait en combinant des parties abstraites. Concentrez-vous sur l'interface (API), pas sur l'implémentation spécifique du composant. Ensuite, les pièces sont assemblées en utilisant uniquement l'interface (API) et le produit est assemblé.
Le rôle du produit abstrait
Le rôle Produit abstrait définit l'interface des pièces abstraites et des produits créés par le rôle Usine abstraite.
package factory;
/**
*Une classe qui exprime de manière abstraite les hyperliens HTML
*
*/
public abstract class Link extends Item{
//Pour contenir l'URL de la destination du lien
protected String url;
public Link(String caption, String url) {
super(caption);
this.url = url;
}
}
package factory;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
/**
*Une classe qui représente de manière abstraite la page HTML entière
*
*/
public abstract class Page {
protected String title;
protected String author;
protected ArrayList<Item> content = new ArrayList<>();
public Page(String title, String author) {
this.title = title;
this.author = author;
}
public void add(Item item) {
content.add(item);
}
public void output() {
try {
String fileName = title + ".html";
Writer writer = new FileWriter(fileName);
writer.write(this.makeHtml());
writer.close();
System.out.println(fileName + "est créé.");
} catch (IOException e) {
e.printStackTrace();
}
}
public abstract String makeHtml();
}
package factory;
import java.util.ArrayList;
/**
*Une classe qui représente une collection de plusieurs liens et plateau
*
*/
public abstract class Tray extends Item{
protected ArrayList<Item> tray = new ArrayList<>();
public Tray(String caption) {
super(caption);
}
public void add(Item item) {
tray.add(item);
}
}
Le rôle de Abstract Factory
Le rôle AbstractFactory définit l'interface de création d'une instance du rôle AbstractProduct.
package factory;
/**
*Une classe qui crée un instant d'usine spécifique en spécifiant un nom de classe
*
*/
public abstract class Factory {
public static Factory getFactory(String className) {
Factory factory = null;
try {
factory = (Factory)Class.forName(className).newInstance();
} catch (ClassCastException e) {
System.out.println("classe" + className + "Ne peut être trouvé.");
} catch (Exception e) {
e.printStackTrace();
}
return factory;
}
public abstract Link createLink(String caption, String url);
public abstract Tray createTray(String caption);
public abstract Page createPage(String title, String author);
}
Le rôle du client
Le rôle Client est un rôle qui fonctionne en utilisant uniquement l'interface entre le rôle Abstract Factory et le rôle Abstract Product. Le rôle du client ne connaît pas les pièces, produits ou usines spécifiques.
import factory.Factory;
import factory.Link;
import factory.Page;
import factory.Tray;
public class Main {
public static void main(String[] args) {
if (args.length != 1) {
System.out.println("Usage: java Main class.mame.of.ConcreateFactory");
System.out.println("Example 1: java Main listfactory,ListFactory");
System.out.println("Example 2: java Main tablefactory,TableFactory");
System.exit(0);
}
Factory factory = Factory.getFactory(args[0]);
Link asahi = factory.createLink("Asahi Shimbun", "http://www.asahi.com/");
Link yomiuri = factory.createLink("Yomiuri Shimbun", "http://www.yomiuri.co.jp/");
Link usYahoo = factory.createLink("Yahoo!", "http://www.yahoo.com/");
Link jpYahoo = factory.createLink("Yahoo!Japan", "http://www.yahoo.co.jp");
Link excite = factory.createLink("Excite", "http://www.excite.com/");
Link google = factory.createLink("Google", "http://www.google.com/");
Tray trayNews = factory.createTray("journal");
trayNews.add(asahi);
trayNews.add(yomiuri);
Tray trayYahoo = factory.createTray("Yahoo!");
trayYahoo.add(usYahoo);
trayYahoo.add(jpYahoo);
Tray traySearch = factory.createTray("Moteur de recherche");
traySearch.add(trayYahoo);
traySearch.add(excite);
traySearch.add(google);
Page page = factory.createPage("LinkPage", "Taro Tanaka");
page.add(trayNews);
page.add(traySearch);
page.output();
}
}
Le rôle du produit en béton
Dans le rôle de Conctete Product, l'interface (API) du rôle de Abstract est implémentée.
package listFactory;
import factory.Link;
public class ListLink extends Link{
public ListLink(String caption, String url) {
super(caption, url);
}
public String makeHtml() {
return " <li><a href=\"" + url + "\">" + caption + "</a></li>\n";
}
}
package listFactory;
import java.util.Iterator;
import factory.Item;
import factory.Page;
public class ListPage extends Page{
public ListPage(String title, String author) {
super(title, author);
}
@Override
public String makeHtml() {
StringBuffer buffer = new StringBuffer();
buffer.append("<html><head><title>" + title + "</title></head>\n");
buffer.append("<body>\n");
buffer.append("<h1>" + title + "</h1>\n");
buffer.append("<ul>\n");
Iterator<Item> it = content.iterator();
while (it.hasNext()) {
Item item = it.next();
buffer.append(item.makeHtml());
}
buffer.append("</ul>\n");
buffer.append("<hr><address>" + author + "</address>");
buffer.append("</body></html>\n");
return buffer.toString();
}
}
package listFactory;
import java.util.Iterator;
import factory.Item;
import factory.Tray;
public class ListTray extends Tray {
public ListTray(String caption) {
super(caption);
}
public String makeHtml() {
StringBuffer buffer = new StringBuffer();
buffer.append("<li>\n");
buffer.append(caption + "\n");
buffer.append("<ul>\n");
Iterator<Item> it = tray.iterator();
while (it.hasNext()) {
Item item = it.next();
buffer.append(item.makeHtml());
}
buffer.append("</ul>\n");
buffer.append("</li>\n");
return buffer.toString();
}
}
Le rôle de Concrete Factory
Le rôle Concrete Factory définit l'interface (API) du rôle Abstract Factory.
package listFactory;
import factory.Factory;
import factory.Link;
import factory.Page;
import factory.Tray;
public class ListFactory extends Factory {
@Override
public Link createLink(String caption, String url) {
return new ListLink(caption, url);
}
@Override
public Tray createTray(String caption) {
return new ListTray(caption);
}
@Override
public Page createPage(String title, String author) {
return new ListPage(title, author);
}
}
Un fichier html créé en passant tableFactory.TableFactory comme argument et en l'exécutant
Ajouter une autre usine de béton
C'était facile d'ajouter une usine. Parce qu'il est clair quel type de classe doit être créé et quel type de méthode doit être implémenté.
package tableFactory;
import factory.Link;
public class TableLink extends Link {
public TableLink(String caption, String url) {
super(caption, url);
}
@Override
public String makeHtml() {
return "<td><a href=\"" + url + "\">" + caption + "</a></td>\n";
}
}
package tableFactory;
import java.util.Iterator;
import factory.Item;
import factory.Page;
public class TablePage extends Page {
public TablePage(String title, String author) {
super(title, author);
}
@Override
public String makeHtml() {
StringBuffer buffer = new StringBuffer();
buffer.append("<html><head><title>" + title + "</title></head>\n");
buffer.append("<body>\n");
buffer.append("<h1>" + title + "</h1>\n");
buffer.append("<table width=\"80%\" border=\"3\">\n");
Iterator<Item> it = content.iterator();
while (it.hasNext()) {
Item item = it.next();
buffer.append("<tr>" + item.makeHtml() + "</tr>");
}
buffer.append("</table>\n");
buffer.append("<hr><address>" + author + "</address>");
buffer.append("</body></html>\n");
return buffer.toString();
}
}
package tableFactory;
import java.util.Iterator;
import factory.Item;
import factory.Tray;
public class TableTray extends Tray {
public TableTray(String caption) {
super(caption);
}
@Override
public String makeHtml() {
StringBuffer buffer = new StringBuffer();
buffer.append("<td>");
buffer.append("<table width=\"100%\" border=\"1\"><tr>");
buffer.append("<td bgcolor=\"#cccccc\" align=\"center\" colspan=\"" + tray.size() + "\"><b>" + caption + "</b></td>");
buffer.append("</tr>\n");
buffer.append("<tr>\n");
Iterator<Item> it = tray.iterator();
while (it.hasNext()) {
Item item = it.next();
buffer.append(item.makeHtml());
}
buffer.append("</tr></table>");
buffer.append("</td>");
return buffer.toString();
}
}
package tableFactory;
import factory.Factory;
import factory.Link;
import factory.Page;
import factory.Tray;
public class TableFactory extends Factory {
@Override
public Link createLink(String caption, String url) {
return new TableLink(caption, url);
}
@Override
public Tray createTray(String caption) {
return new TableTray(caption);
}
@Override
public Page createPage(String title, String author) {
return new TablePage(title, author);
}
}
Le fichier html créé en s'exécutant avec l'argument à l'exécution défini sur tableFactory.TableFactory sans modifier Main, qui est le rôle de Client.
https://github.com/aki0207/abstractFactory
Je l'ai utilisé comme référence. Édition révisée augmentée Introduction aux modèles de conception appris en langage Java
Recommended Posts