Qual è il modello di progettazione della fabbrica?

Il modello di progettazione factory (o metodo factory) è specializzato nella delega e nell’incapsulamento. Questo modello consente a una superclasse di rinviare l’istanza alle sottoclassi. Questo perché la classe che contiene il pattern del metodo factory primario è astratta.

La versione originale del metodo factory assume la forma di un metodo non implementato perché non conosce il prodotto che creerà. Il metodo factory potrebbe sapere che sta creando un prodotto, ma non conosce le caratteristiche specifiche del prodotto che creerà. Questa conoscenza è disponibile solo per le rispettive sottoclassi. Pertanto, la responsabilità di implementare il metodo factory e creare oggetti appropriati è esclusivamente quella di una sottoclasse.

Implementazione del Factory Design Pattern in Java

Questo articolo utilizza un’applicazione di generazione di report di feedback di esempio. Questa applicazione utilizza i diversi tipi di feedback ricevuti da un’azienda (per una nuova merenda) per creare report specifici (utilizzando il metodo factory). Pertanto, il modello di fabbrica creerà un feedback specifico (o rapporto di feedback), utilizzando come base la seguente classe di prodotto principale:

public abstract class Feedback {


   private String reviewerName;
   private String reviewMessage;
   private int reviewRatings;

  public String getReviewerName() {
      return reviewerName;
  }
  public void setReviewerName(String reviewerName) {
      this.reviewerName = reviewerName;
  }
  public String getReviewMessage() {
      return reviewMessage;
  }
  public void setReviewMessage(String reviewMessage) {
      this.reviewMessage = reviewMessage;
  }
  public int getReviewRatings() {
      return reviewRatings;
  }
  public void setReviewRatings(int reviewRatings) {
      this.reviewRatings = reviewRatings;
  }
}


Ogni feedback avrà tre proprietà obbligatorie, un nome del recensore, un messaggio di recensione e un punteggio numerico (da uno a cinque) per il nuovo spuntino. I diversi tipi di feedback che l’azienda riceverà proverranno da uno dei tre canali:

Classe di feedback via e-mail

public class EmailFeedback extends Feedback {


  private String reviewerEmail;

  public EmailFeedback(String reviewerName, String reviewMessage, int reviewRatings, String reviewerEmail) {
     super(reviewerName, reviewMessage, reviewRatings);
     this.reviewerEmail = reviewerEmail;
  }
  public String getReviewerEmail() {
     return reviewerEmail;
  }
  public void setReviewerEmail(String reviewerEmail) {
     this.reviewerEmail = reviewerEmail;
  }
}


Classe di feedback sulla posta

public class MailFeedback extends Feedback {


   private String returnAddress;

   public void setReturnAddress(String returnAddress) {
       this.returnAddress = returnAddress;
     }
}


Classe di feedback sui social media

public class SocialMediaFeedback extends Feedback {


   private String reviewerHandle;

   public void setReviewerHandle(String reviewerHandle) {
       this.reviewerHandle = reviewerHandle;
     }
}

Noterai che ogni sottoclasse di feedback ha una proprietà univoca. Ciò significa che dovrai creare il report per ogni tipo di feedback utilizzando almeno una proprietà univoca per quel tipo.

La fabbrica semplice

Una fabbrica semplice è un approccio popolare all’utilizzo del modello di progettazione della fabbrica. Questo approccio comporta il raggruppamento di tutti i diversi feedback (o prodotti) in un metodo (la fabbrica semplice) e la selezione del feedback appropriato in base a un parametro.

public class FeedbackReportFactory {


    public Feedback makeFeedback(String feedbackType) {
         Feedback feedback = null;

         if(feedbackType.equals("email")) {
               feedback = new EmailFeedback();
         }else if (feedbackType.equals("mail")) {
               feedback = new MailFeedback();
         }else if (feedbackType.equals("social")) {
               feedback = new SocialMediaFeedback();
         }
     return feedback;
     }
}

Tuttavia, il semplice approccio di fabbrica non è il modello di progettazione della fabbrica, né è un modello di progettazione. È più come un concetto di design.

Il metodo di fabbrica

Il metodo factory è la vera rappresentazione del design pattern. Utilizzando il metodo factory, la classe Java FeedbackReportFactory riformata ora conterrà il seguente codice:

public abstract class FeedbackReportFactory {
    public abstract void makeFeedbackReport(Feedback feedback);
}

È possibile definire la struttura del modello di progettazione di fabbrica con il seguente diagramma di classe:

Dal diagramma sopra vedrai che una classe astratta (o interfaccia) conterrà una versione astratta del metodo factory. Quindi, le classi factory concrete che estendono la classe astratta implementeranno il metodo factory, utilizzando proprietà univoche per il prodotto che si desidera creare. Dovresti anche notare che qualsiasi classe di fabbrica concreta dovrebbe creare uno o più prodotti.

L’applicazione di esempio ha tre prodotti correlati ma univoci. Ogni tipo di feedback ha almeno una proprietà univoca. Quindi, l’applicazione dovrà avere tre fabbriche di cemento per costruire ogni prodotto.

Fabbrica di feedback via e-mail

public class EmailFeedbackReport extends FeedbackReportFactory{


    EmailFeedback feedback;

        System.out.println("\nReport For Feedback Via Email"+
                  "\nReviewer Name: " +this.feedback.getReviewerName() +
                  "\nFeedback: " + this.feedback.getReviewMessage() +
                  "\nRatings: " + this.feedback.getReviewRatings() +
                  "\nEmal Address: " + this.feedback.getReviewerEmail());
     }
}

Fabbrica di feedback per posta

public class MailFeedbackReport extends FeedbackReportFactory {
    MailFeedback feedback;


    @Override
    public void makeFeedbackReport(Feedback feedback) {
         this.feedback = (MailFeedback) feedback;

         System.out.println("\nReport For Feedback Via Mail"+
                     "\nReviewer Name: " +this.feedback.getReviewerName() +
                     "\nFeedback: " + this.feedback.getReviewMessage() +
                     "\nRatings: " + this.feedback.getReviewRatings() +
                     "\nMailing Address: " + this.feedback.getReturnAddress());
     }
}

Fabbrica di feedback sui social media

public class SocialMediaFeedbackReport extends FeedbackReportFactory {
    SocialMediaFeedback feedback;


    @Override
    public void makeFeedbackReport(Feedback feedback) {
        this.feedback = (SocialMediaFeedback) feedback;

        System.out.println("\nReport For Feedback Via Social Media"+
                      "\nReviewer Name: " + this.feedback.getReviewerName() +
                      "\nFeedback: " + this.feedback.getReviewMessage() +
                      "\nRatings: " + this.feedback.getReviewRatings() +
                      "\nReviewer Social Media Handle: " + this.feedback.getReviewerHandle());
           }
}

Test dell’applicazione di esempio

Ora puoi utilizzare i rispettivi metodi di fabbrica per creare report in miniatura sui feedback ricevuti dai diversi canali. Puoi testare l’applicazione utilizzando JUnit oppure puoi creare una classe di driver:

public class Main {


   public static void main(String[] args) {
       Feedback feedback = new EmailFeedback("Nick", "Great product!", 5, "nick@email.com");
       Feedback feedback2 = new MailFeedback("john", "The product is good but not something I would buy regularly", 4, "first Street");
       Feedback feedback3 = new SocialMediaFeedback("Jane", "It's not for me", 2, "@janey");

       factory.makeFeedbackReport(feedback);
       factory2.makeFeedbackReport(feedback2);
       factory3.makeFeedbackReport(feedback3);
   }


La classe Main sopra utilizza le rispettive factory per creare tre report, producendo il seguente output nella console:

Vantaggi dell’utilizzo del modello di progettazione di fabbrica

Il modello di progettazione di fabbrica promuove la flessibilità di progettazione, in cui si utilizzano interfacce (o classi astratte) per creare classi concrete. Promuove inoltre la scalabilità attraverso il polimorfismo, consentendo a nuove classi di implementare l’interfaccia esistente man mano che l’applicazione si espande.

Quando utilizzi il modello di progettazione di fabbrica, stai utilizzando due importanti principi di progettazione: aperto-chiuso e inversione del controllo (IoC).