Condivisione della tecnologia

Modello di progettazione Modello di fabbrica

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Factory Pattern è un modello di progettazione comunemente utilizzato nella programmazione orientata agli oggetti a cui appartienemodello creazionale tipo.Il pattern factory viene utilizzato principalmente per creare oggetti, ma è diverso dall'utilizzarlo direttamente nel codice.new La creazione di parole chiave è diversa in quanto crea oggetti tramite un'interfaccia comune, separando così il processo di creazione dell'oggetto dall'utilizzo del codice client. Quella che segue è un'introduzione dettagliata al modello di fabbrica:

1. Caratteristiche principali del modello di fabbrica

  1. Il processo di creazione di oggetti incapsulati: Incapsula il processo di creazione dell'oggetto in una classe factory. Il client deve solo specificare il tipo di oggetto che deve essere creato, quindi può ottenere l'oggetto richiesto tramite la classe factory senza preoccuparsi dei dettagli specifici di creazione dell'oggetto.
  2. Ridurre l'accoppiamento: Isolando la fabbrica astratta e la fabbrica concreta, l'accoppiamento tra il cliente e l'oggetto viene ridotto, rendendo il programma cliente più facile da espandere e mantenere.
  3. Migliorare la scalabilità del programma: Quando è necessario aggiungere un nuovo prodotto, è sufficiente aggiungere la classe di prodotto specifica corrispondente e la classe di fabbrica corrispondente. Non è necessario modificare il codice originale. È conforme al principio di apertura-chiusura (aperto per espansione e chiuso per la modifica), che migliora la scalabilità del codice.
  4. Facile da mantenere e aggiornare: Poiché il metodo factory concentra il processo di creazione degli oggetti in una classe, se è necessario modificare il metodo di creazione degli oggetti, è necessario modificare solo la classe factory corrispondente e ciò non avrà alcun impatto sul client.
  5. riutilizzo del codice: Il modello factory può astrarre il processo di creazione dell'oggetto, realizzare il riutilizzo del codice e aumentare la flessibilità e la riusabilità del codice.

2. Classificazione del modello di fabbrica

I modelli di fabbrica sono principalmente divisi in tre tipi: modello di fabbrica semplice (modello di fabbrica statico), modello di metodo di fabbrica e modello di fabbrica astratto.

1. Metodo della fabbrica statica
  1. Definire una classe factory per restituire istanze di classi diverse in base ai diversi parametri passati.
  2. Le classi factory solitamente contengono più metodi statici, ciascun metodo corrisponde alla creazione di un prodotto specifico.
  3. Vantaggi: Semplice da implementare e di facile comprensione.
  4. Svantaggi: le responsabilità della classe factory sono troppo pesanti Quando si aggiungono nuovi prodotti, il codice sorgente della classe factory deve essere modificato, il che viola il principio di apertura e chiusura.

Diagramma delle classi del modello di fabbrica semplice

2. Modello del metodo di fabbrica (metodo di fabbrica)
  1. Definire un'interfaccia (fabbrica astratta) per la creazione di oggetti,Ma lasciamo che sia la sottoclasse a decidere quale classe istanziare。
  2. I metodi factory consentono di rinviare l'istanziazione delle classi alle sottoclassi.
  3. Vantaggi: buona scalabilità. Quando è necessario aggiungere nuovi prodotti, è necessario aggiungere solo le categorie di prodotto specifiche e le categorie di fabbrica specifiche corrispondenti.
  4. Svantaggi: ogni volta che viene aggiunto un prodotto, è necessario aggiungere una classe specifica e un factory di implementazione dell'oggetto, raddoppiando il numero di classi nel sistema e aumentando la complessità del sistema.

Modello del metodo di fabbrica

3. Modello di fabbrica astratta (Fabbrica astratta)
  1. Fornisce un'interfaccia per creare una serie di oggetti correlati o interdipendenti senza specificarne le classi concrete.
  2. Il modello di fabbrica astratto può essere visto come l’uso congiunto di più modelli di metodi di fabbrica.
  3. Vantaggi: la famiglia di prodotti può essere vincolata all'interno della classe. Una fabbrica specifica deve essere in grado di creare tutti i prodotti della famiglia di prodotti.
  4. Svantaggi: aumenta l'astrazione e la difficoltà di comprensione del sistema e il numero di classi nel sistema aumenterà in modo significativo.

modello astratto di fabbrica

3. Scenari applicativi del modello di fabbrica

Il modello factory ha un'ampia gamma di applicazioni in fase di sviluppo effettivo, come connessioni di database, controlli dell'interfaccia utente, elaborazione di file, registrazione, comunicazioni di rete, code di messaggi, strutture di dati, crittografia e decrittografia, push di messaggi e pianificazione delle attività. In questi scenari, l'utilizzo del modello factory può separare il processo di creazione dell'oggetto dal processo di utilizzo, migliorando la flessibilità e la scalabilità del sistema.

4. Esempio di modello di fabbrica

1. Esempio di modello di fabbrica semplice

Nel modello factory semplice, definiamo una classe factory che può restituire istanze di tipi diversi in base ai parametri passati.

Di seguito è riportato un esempio di un semplice modello di fabbrica scritto in Java. Creeremo una fabbrica di forme in grado di produrre istanze di cerchi, rettangoli e quadrati. Per prima cosa definiamo un'interfaccia di forma (Shape) e diverse classi concrete (Circle, Rectangle, Square) che implementano questa interfaccia.

  1. // 形状接口  
  2. interface Shape {  
  3.     void draw();  
  4. }  
  5.   
  6. // 圆形类  
  7. class Circle implements Shape {  
  8.     @Override  
  9.     public void draw() {  
  10.         System.out.println("Inside Circle::draw() method.");  
  11.     }  
  12. }  
  13.   
  14. // 矩形类  
  15. class Rectangle implements Shape {  
  16.     @Override  
  17.     public void draw() {  
  18.         System.out.println("Inside Rectangle::draw() method.");  
  19.     }  
  20. }  
  21.   
  22. // 正方形类  
  23. class Square implements Shape {  
  24.     @Override  
  25.     public void draw() {  
  26.         System.out.println("Inside Square::draw() method.");  
  27.     }  
  28. }

Successivamente, definiamo una classe factory (ShapeFactory) che utilizza metodi statici per generare oggetti forma.

  1. // 形状工厂类  
  2. class ShapeFactory {  
  3.   
  4.     // 使用 getShape 方法获取形状类型的对象  
  5.     public static Shape getShape(String shapeType){  
  6.         if(shapeType == null){  
  7.             return null;  
  8.         }          
  9.         if(shapeType.equalsIgnoreCase("CIRCLE")){  
  10.             return new Circle();  
  11.         } else if(shapeType.equalsIgnoreCase("RECTANGLE")){  
  12.             return new Rectangle();  
  13.         } else if(shapeType.equalsIgnoreCase("SQUARE")){  
  14.             return new Square();  
  15.         }  
  16.           
  17.         return null;  
  18.     }  
  19. }

Infine, possiamo utilizzare una classe factory per ottenere oggetti forma e chiamarlidrawmetodo.

  1. public class FactoryPatternDemo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 获取 Circle 的对象，并调用它的 draw 方法  
  5.         Shape shape1 = ShapeFactory.getShape("CIRCLE");  
  6.         shape1.draw();  
  7.   
  8.         // 获取 Rectangle 的对象，并调用它的 draw 方法  
  9.         Shape shape2 = ShapeFactory.getShape("RECTANGLE");  
  10.         shape2.draw();  
  11.   
  12.         // 获取 Square 的对象，并调用它的 draw 方法  
  13.         Shape shape3 = ShapeFactory.getShape("SQUARE");  
  14.         shape3.draw();  
  15.     }  
  16. }

In questo esempio,ShapeFactoryla classe è responsabile della creazioneShape Un'istanza dell'interfaccia.Il codice client esegue questa operazione passando informazioni sul tipo (ad esempio stringa) aShapeFactorymetodo statico di classegetShape per ottenere un'istanza della forma desiderata. In questo modo il client è disaccoppiato dall'implementazione della classe specifica e rispetta il principio di apertura e chiusura, ovvero è possibile estendere nuove classi di forme senza modificare il codice client. Tuttavia, uno dei principali svantaggi del modello di fabbrica semplice è che se il sistema deve essere esteso con nuove famiglie di prodotti (come colori oltre a forme, ecc.), la classe di fabbrica deve essere modificata, il che viola parte del modello aperto -principio chiuso. In questo caso, considera l'utilizzo del modello Factory Method o del modello Abstract Factory.

2. Esempio di modello del metodo di fabbrica

Prendendo ancora forma come esempio, utilizziamo metodi ingegneristici per crearlo.

Per prima cosa definisci l'interfaccia della forma (Prodotto) e crea tre classi di implementazione.

  1. // 形状接口  
  2. interface Shape {  
  3.     void draw();  
  4. }
  5.  
  6. // 圆形类  
  7. class Circle implements Shape {  
  8.     @Override  
  9.     public void draw() {  
  10.         System.out.println("Inside Circle::draw() method.");  
  11.     }  
  12. }  
  13.   
  14. // 矩形类  
  15. class Rectangle implements Shape {  
  16.     @Override  
  17.     public void draw() {  
  18.         System.out.println("Inside Rectangle::draw() method.");  
  19.     }  
  20. }  
  21.   
  22. // 正方形类  
  23. class Square implements Shape {  
  24.     @Override  
  25.     public void draw() {  
  26.         System.out.println("Inside Square::draw() method.");  
  27.     }  
  28. }

Successivamente, definisci l'interfaccia del creatore (Creator) e il creatore concreto (Concrete Creator):

  1. // 创建者接口  
  2. interface ShapeFactory {  
  3.     Shape getShape(String shapeType);  
  4. }  
  5.   
  6. // 具体创建者类  
  7. class RectangleFactory implements ShapeFactory {  
  8.     @Override  
  9.     public Shape getShape(String shapeType) {  
  10.         if (shapeType == null) {  
  11.             return null;  
  12.         }  
  13.         if (shapeType.equalsIgnoreCase("RECTANGLE")) {  
  14.             return new Rectangle();  
  15.         }  
  16.         return null;  
  17.     }  
  18. }  
  19.   
  20. class CircleFactory implements ShapeFactory {  
  21.     @Override  
  22.     public Shape getShape(String shapeType) {  
  23.         if (shapeType == null) {  
  24.             return null;  
  25.         }  
  26.         if (shapeType.equalsIgnoreCase("CIRCLE")) {  
  27.             return new Circle();  
  28.         }  
  29.         return null;  
  30.     }  
  31. }  
  32.   
  33. class SquareFactory implements ShapeFactory {  
  34.     @Override  
  35.     public Shape getShape(String shapeType) {  
  36.         if (shapeType == null) {  
  37.             return null;  
  38.         }  
  39.         if (shapeType.equalsIgnoreCase("SQUARE")) {  
  40.             return new Square();  
  41.         }  
  42.         return null;  
  43.     }  
  44. }

Infine, usa la classe concrete creator per ottenere gli oggetti forma e chiamarlidrawmetodo:

  1. public class FactoryMethodPatternDemo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         ShapeFactory shapeFactory = new CircleFactory();  
  5.   
  6.         // 获取 Circle 的对象，并调用它的 draw 方法  
  7.         Shape shape1 = shapeFactory.getShape("CIRCLE");  
  8.         shape1.draw();  
  9.   
  10.         // 使用 RectangleFactory 来获取 Rectangle 的对象  
  11.         shapeFactory = new RectangleFactory();  
  12.         Shape shape2 = shapeFactory.getShape("RECTANGLE");  
  13.         shape2.draw();  
  14.   
  15.         // 使用 SquareFactory 来获取 Square 的对象  
  16.         shapeFactory = new SquareFactory();  
  17.         Shape shape3 = shapeFactory.getShape("SQUARE");  
  18.         shape3.draw();  
  19.     }  
  20. }

In questo esempio,Creiamo una classe factory corrispondente per ogni classe di forma (Sebbene nelle applicazioni reali, di solito ci sarà una struttura di classi factory più generale, magari attraverso file di configurazione o riflessione per evitare di scrivere classi factory separate per ciascuna classe di prodotto). Questo aiuta a dimostrare i principi di base del modello Factory Method,Cioè, lascia che sia la sottoclasse factory a decidere quale classe istanziare . Tuttavia, per il caso semplice di questo esempio, potresti essere più propenso a utilizzare il modello Simple Factory o a prendere in considerazione altri modelli di progettazione per ridurre la duplicazione del codice.

3. Esempio astratto di fabbrica

Questo esempio prende come esempio i telefoni cellulari, prodotti astratti relativi ai telefoni cellulari (come schermi, batterie, sistemi operativi, ecc.) e crea classi di prodotti specifiche per implementare queste interfacce. Possiamo quindi definire interfacce di fabbrica astratte e classi di fabbrica concrete per produrre questi prodotti. Ecco un esempio semplificato che mostra come utilizzare il modello Abstract Factory per produrre componenti (schermi e batterie) per diverse marche e modelli di telefoni cellulari:

Innanzitutto, definisci l'interfaccia del prodotto e i prodotti specifici:

  1. // 屏幕接口  
  2. interface Screen {  
  3.     void display();  
  4. }  
  5.   
  6.  
  7. // 高端屏幕的实现  
  8. class HighEndScreen implements Screen {  
  9.     @Override  
  10.     public void display() {  
  11.         System.out.println("显示高清屏幕");  
  12.     }  
  13. }  
  14.   
  15. // 低端屏幕的实现  
  16. class LowEndScreen implements Screen {  
  17.     @Override  
  18.     public void display() {  
  19.         System.out.println("显示普通屏幕");  
  20.     }  
  21. }  
  22.  
  23.  
  24. // 电池接口  
  25. interface Battery {  
  26.     void charge();  
  27. }
  28.  
  29.   
  30. // 高效电池的实现  
  31. class HighEfficiencyBattery implements Battery {  
  32.     @Override  
  33.     public void charge() {  
  34.         System.out.println("快速充电");  
  35.     }  
  36. }  
  37.   
  38. // 标准电池的实现  
  39. class StandardBattery implements Battery {  
  40.     @Override  
  41.     public void charge() {  
  42.         System.out.println("标准充电");  
  43.     }  
  44. }

Successivamente, definisci l'interfaccia della fabbrica astratta e la classe della fabbrica concreta:

  1. // 手机组件工厂接口  
  2. interface PhoneFactory {  
  3.     Screen createScreen();  
  4.     Battery createBattery();  
  5. }  
  6.   
  7. // 高端手机工厂  
  8. class HighEndPhoneFactory implements PhoneFactory {  
  9.     @Override  
  10.     public Screen createScreen() {  
  11.         return new HighEndScreen();  
  12.     }  
  13.   
  14.     @Override  
  15.     public Battery createBattery() {  
  16.         return new HighEfficiencyBattery();  
  17.     }  
  18. }  
  19.   
  20. // 低端手机工厂  
  21. class LowEndPhoneFactory implements PhoneFactory {  
  22.     @Override  
  23.     public Screen createScreen() {  
  24.         return new LowEndScreen();  
  25.     }  
  26.   
  27.     @Override  
  28.     public Battery createBattery() {  
  29.         return new StandardBattery();  
  30.     }  
  31. }

Infine, il codice cliente, che utilizza una fabbrica astratta per creare oggetti di prodotto concreti:

  1. public class PhoneFactoryPatternDemo {  
  2.     public static void main(String[] args) {  
  3.         // 使用高端手机工厂  
  4.         PhoneFactory highEndFactory = new HighEndPhoneFactory();  
  5.         Screen highEndScreen = highEndFactory.createScreen();  
  6.         Battery highEndBattery = highEndFactory.createBattery();  
  7.   
  8.         highEndScreen.display();  
  9.         highEndBattery.charge();  
  10.   
  11.         // 使用低端手机工厂  
  12.         PhoneFactory lowEndFactory = new LowEndPhoneFactory();  
  13.         Screen lowEndScreen = lowEndFactory.createScreen();  
  14.         Battery lowEndBattery = lowEndFactory.createBattery();  
  15.   
  16.         lowEndScreen.display();  
  17.         lowEndBattery.charge();  
  18.     }  
  19. }

In questo esempio definiamo due fabbriche di telefoni cellulari (di fascia alta e di fascia bassa), ciascuna in grado di produrre uno specifico tipo di schermo e batteria.Il codice client interagisce con la classe di fabbrica specifica attraverso l'interfaccia della fabbrica astratta, ottenendo così il disaccoppiamento dalla classe di prodotto specifica. . In questo modo, se in futuro avremo bisogno di aggiungere nuovi tipi di telefoni (ad esempio telefoni di fascia media), basterà aggiungere nuove classi di prodotto e corrispondenti classi di fabbrica senza modificare il codice cliente esistente.

5. Riepilogo

Il modello di fabbrica è un modello di progettazione molto utile,Incapsula il processo di creazione degli oggetti, riduce l'accoppiamento, migliora la scalabilità del programma e la facilità di manutenzione, ecc. , è stato ampiamente utilizzato nello sviluppo di software.Tuttavia ne ha anche alcuniSvantaggi, come eccessive responsabilità di fabbrica, difficoltà nell’espansione del sistema, ecc. . Pertanto, nelle applicazioni pratiche, è necessario fare compromessi e scelte in base a scenari ed esigenze specifici.

Se il pattern factory (fabbrica semplice, metodo factory, fabbrica astratta) ti è utile, ricordati di mettere mi piace e collezionarlo.

Profilo personale

Si dedica alla ricerca tecnologica da più di 30 anni ed è esperto in vari linguaggi come Java, Linux, Javascript, php, css, ecc. Ha dato numerosi contributi nel campo dell'open source stazione di documentazione per gli sviluppatori per condividere alcuni problemi nello sviluppo della tecnologia per riferimento futuro

le mie informazioni di contatto

Posta