Devdiaries

• Das Fabrikmuster
  • Absicht
  • Problemlösung
  • Struktur des Fabrikmusters
  • Abstraktes Fabrikmuster
  • Implementierung des Fabrikmusters im Frühjahr
  • Fabrikmuster beliebte Verwendung fälle im Spring Framework
• Das Builder-Muster
  • Absicht
  • Problemlösung
  • Struktur des Builder-Musters
  • Implementierung des Builder-Musters im Frühjahr
• Das Singleton-Muster
  • Absicht
  • Problemlösung
  • Struktur des Singleton-Musters
  • Singleton-Muster beispielhafte Implementierung im Frühjahr
  • Singleton-Muster vs Spring Singletons
• Das Prototypmuster
  • Absicht
  • Problemlösung
  • Struktur des Prototypmusters
  • PrototypePattern Implementierung im Frühjahr
• Fazit

Creational Design Patterns befassen sich mit Objekterstellungsmechanismen und versuchen, Objekte situationsgerecht zu erstellen. In diesem Artikel werde ich die beliebtesten Muster in dieser Kategorie beschreiben und wie Spring sie verwendet!

Das Factory-Muster

Spring ist an sich bereits eine Beispielimplementierung des Factory-Musters. Das Muster wird im gesamten Framework verwendet. Einer der primären Orte, an denen es verwendet wird, ist die BeanFactory -Klasse.

Absicht

• Factory-Muster ermöglicht die Erstellung ähnlicher Klassen verschiedener Typen mithilfe einer Factory-Methode
• Methodenaufruf erstellt das Objekt für Sie
• Erstellte Objekte sind Instanzen von Klassen, die eine Schnittstelle oder Unterklasse gemeinsam nutzen

Problemlösung

• Danke um Factory Design Pattern zu verwenden, müssen Sie sich nicht an mehr als einem Ort um die Klassenkonstruktion kümmern.
• Sie können die Schnittstelle für sich wiederholende Vorgänge nutzen.
• Copy-Paste-Fehler sind weniger wahrscheinlich.

Struktur des Factory-Musters

Zunächst müssen Sie eine gemeinsame Schnittstelle erstellen, die Sie in der Factory verwenden möchten. Dann müssen Sie eine Klasse erstellen, die Instanzen Ihres inteface erstellt. In dieser Klasse müssen Sie eine Methode implementieren, die konkrete Klassen verwendet, die Sie dann über die Schnittstelle selbst implementieren. Wir haben also wieder eine Klasse mit einer Methode, die Instanzen der Schnittstelle erstellt, wenn sie unter der Annahme steht, dass tatsächlich Instanzen in der konkreten Klasse erstellt werden.

Abstraktes Fabrikmuster

Abstraktes Fabrikmuster ist ein Muster, das dem Fabrikmuster sehr ähnlich ist. Sie können sagen, dass es Fabrik von Fabriken ist. Kurz gesagt, es gibt zwei Hauptunterschiede zwischen dem Fabrikmuster und der abstrakten Fabrik:

• Abstraktes Fabrikdesignmuster erzeugt Fabrik
• Fabrikdesignmuster erzeugt Produkte

 public abstract class AbstractFactory { public abstract Product1Base CreateProduct1(); public abstract Product2Base CreateProduct2(); } class ConcreteFactory1 extends AbstractFactory{ @Override public Product1Base CreateProduct1() { return new ConcreteProduct1(); } @Override public Product2Base CreateProduct2() { return new ConcreteProduct2(); } } class ConcreteFactory2 extends AbstractFactory{ @Override public Product1Base CreateProduct1() { return new ConcreteAnotherProduct1(); } @Override public Product2Base CreateProduct2() { return new ConcreteAnotherProduct2(); } } 

Die AbstractFactory -Klasse ist für die Erstellung verschiedener Typen verantwortlich (im Gegensatz zum Factory-Muster). Wie Sie im obigen Beispiel sehen können, kann jede der Fabriken verschiedenen Objekten innerhalb derselben Gruppe zugeordnet werden (in diesem Fall Produkten).

Factory Pattern Implementierung im Frühjahr

Schauen wir uns die obige Schnittstelle an:

 public interface Animal { void setName(String name); String getName(); String getType(); void makeASound(); }

Animal schnittstelle hat mehrere Methoden, die allen Tieren gemeinsam sind (jedes Tier hat einen Typ und Namen). Jetzt müssen Sie eine neue Klasse erstellen: AnimalFactory

 @Component public class AnimalFactory { public Animal createAnimal(String type) { switch (type) { case "bird": return new Bird(); case "cat": return new Cat(); default: throw new UnsupportedOperationException("Unsupported animal type!"); } } }

Ich habe die Annotation @Component hinzugefügt, weil ich möchte, dass die Feder diese Factory verwaltet. Es gibt eine Methode (Factory-Methode), die ein Tier zurückgibt – createAnimal . Es ist eine sehr einfache Fabrik, die nur zwei Arten von Tieren (Katze, Vogel) unterstützt. Wenn ein anderer Typ angegeben wird, wird eine Ausnahme ausgelöst.

Lassen Sie uns Spring Controller erstellen – FactoryController:

 @RestController @RequestMapping("/") public class FactoryController { private AnimalFactory factory; @Autowired public FactoryController(AnimalFactory factory) { this.factory = factory; } @PostMapping("addAminal/{type}/{name}") public Animal addAnimal(@PathVariable String type, @PathVariable String name) { Animal animal = this.factory.createAnimal(type); animal.setName(name); animal.makeASound(); return animal; } }

Ich habe eine @PostMapping -Methode hinzugefügt, die wir durch den @PathVariable -Typ und den Namen des Tieres führen werden. Als Antwort erhalten wir das neue Tierobjekt, das von der Fabrik erstellt wurde. Testen wir es mit einem Postboten: Anwendungsprotokolle:

Wie Sie sehen, haben wir gerade ein neues Objekt erstellt – einen Vogel mit unserer Factory.

Factory Pattern beliebte Anwendungsfälle im Spring Framework

Das Spring Framework verwendet das Factory Design Pattern für die Erstellung der Objekte mit zwei Ansätzen:

• Spring BeanFactory Container (zB org.springframework.beans.factory.BeanFactory) – Es ist der einfachste Container im Spring Framework, der die grundlegende Unterstützung für DI
• Spring ApplicationContext Container (zB.g ) – t ist ein weiterer Container im Spring-Container, der zusätzliche unternehmensspezifische Funktionen hinzufügt, z. B. das Veröffentlichen von Anwendungsereignissen in den Spring-Ereignis-Listenern oder das Laden von Nachrichten aus einer Eigenschaftendatei.

Wie Sie sehen können, ist der gesamte Frühling bereits eine Beispielimplementierung des Factory-Musters (der Anwendungskontext einer Spring-Anwendung ist nur eine riesige Factory)

Das Builder-Muster

Ein weiteres häufiges Erstellungsmuster ist das Builder-Muster. Die beliebte Verwendung von Builder im Frühjahr ist ResultAction. Diese Klasse ist Teil des MockMcv – wird zum Testen von Webanwendungen verwendet.

Intent

• Jede Methode gibt die Objektreferenz zurück, von der sie aufgerufen wird.
• Es gibt build() Methode, die ein vollständig konstruiertes Objekt zurückgibt (basierend auf allen Zwischenaufrufen).

Problemlösung

• Verbessert die Lesbarkeit des Codes, wenn die Objekterstellung viele Parameter hat.
• Nützlich, wenn einige oder alle Parameter optional sind.

Struktur des Builder-Musters

Zunächst müssen Sie eine Basisklasse mit allen Args-Konstruktoren definieren. Dann müssen Sie eine Builder-Klasse mit Attributen und Setzern für jedes Argument der Basisklasse erstellen. Jeder Setter sollte den Builder zurückgeben. Dann müssen Sie eine build() methid erstellen, die ein Objekt der Basisklasse erstellt und zurückgibt.

Builder Pattern Implementierung im Frühjahr

Ich habe meine Implementierung mit einer einfachen Java-Klasse begonnen – Employee.java:

 public class Employee { private String firstName; private String lastName; private String employeeId; private String email; public Employee(String firstName, String lastName, String employeeId, String email) { this.firstName = firstName; this.lastName = lastName; this.employeeId = employeeId; this.email = email; } public Employee() { } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } public String getEmployeeId() { return employeeId; } public String getEmail() { return email; } }

Es gibt ein paar Attribute, Konstruktor und automatisch generierte Getter. Es ist Zeit für die Implementierung des Builder-Musters! Erstellen Sie dazu die EmployeeBuilder -Klasse mit denselben Feldern wie die Employee-Klasse. Generieren Sie Setter – einen für jedes unserer Felder. Wenn Sie Setter per IDE generieren, müssen Sie daran denken, den von setter (void) zurückgegebenen Typ in EmployeeBuilder zu ändern.

 public class EmployeeBuilder { private String firstName; private String lastName; private String employeeId; private String email; // Each setter returns EmployeBuilder object. public EmployeeBuilder setFirstName(String firstName) { this.firstName = firstName; return this; } public EmployeeBuilder setLastName(String lastName) { this.lastName = lastName; return this; } public EmployeeBuilder setEmployeeId(String employeeId) { this.employeeId = employeeId; return this; } public EmployeeBuilder setEmail(String email) { this.email = email; return this; } public Employee buildEmployee() { return new Employee(firstName,lastName, employeeId, email); } }

Am Ende verwende ich die public Employee buildEmployee() -Methode, die den Mitarbeiter erstellt. Der Vorteil dieser Lösung besteht darin, dass null ausgefüllt wird, wenn eines unserer Felder null ist. Wir müssen nicht wirklich darüber nachdenken, wohin die Nullen gehen. Schauen wir uns die Aktion an. Ich habe BuilderController Spring Controller erstellt, der zwei Endpunkte hat. Der erste erstellt einen Mitarbeiter mit allen Feldern, der zweite einen Mitarbeiter ohne E-Mail:

 @RestController @RequestMapping("/builder") public class BuilderController { @GetMapping("employee1") public Employee getEmployee1() { return new EmployeeBuilder() .setEmployeeId("1234") .setEmail("[email protected]") .setFirstName("John") .setLastName("smith") .buildEmployee(); } @GetMapping("employee2") public Employee getEmployee2() { return new EmployeeBuilder() .setEmployeeId("4321") .setFirstName("Jeff") .setLastName("Freeman") .buildEmployee(); } }

Wie Sie wahrscheinlich erwarten, gibt die GET-Anforderung für den ersten Endpunkt Folgendes zurück:

Der zweite Endpunkt gibt den Mitarbeiter mit einer Null als E-Mail zurück:

Das Singleton-Muster

Singleton ist ein Muster, das von jedem Java-Entwickler verwendet wird, der Spring verwendet. Jede Bean ist standardmäßig ein Singleton. Ihr Zweck besteht darin, die Möglichkeit zu bieten, nur ein Objekt einer bestimmten Klasse zu erstellen und globalen Zugriff darauf zu gewähren.

Intent

• Es gibt nur einen privaten Konstruktor.
• Klasse speichert Verweis auf die Instanz von sich selbst.
• Es gibt die getInstance() -Methode, die eine Referenz der Singleton-Klasseninstanz zurückgibt oder ein neues Objekt erstellt, wenn es nicht erstellt wird.

Im Singleton-Muster wird Java new Class für die Klasse außer getInstance case nie aufgerufen. Sie sollten diese Methode mit einigen Sperrfunktionen umschließen, um die Sicherheit mehrerer Threads zu gewährleisten.

Problemlösung

Singleton kann in Fällen verwendet werden:

• Die Objekterstellung ist teuer.
• Die Klasse, die die Anwendungskonfiguration speichert. Von überall im System können wir es ändern und wir möchten, dass die Änderungen von überall sichtbar sind. Gleichzeitig können wir nicht zulassen, dass verschiedene Versionen von Konfigurationen im System verwaltet werden.
• Sie müssen den statischen Status für mehrere Teile der Anwendung speichern.
• Sie müssen steuern, wer Zugriff auf ein Objekt hat (Concurrency Controlling).

Struktur des Singleton-Musters

Es gibt viele Möglichkeiten, einen Singleton zu implementieren, aber alle können auf drei Hauptpunkte reduziert werden:

• Zuerst müssen Sie einen privaten Konstruktor in Ihrer Singleton-Klasse
• erstellen und dann ein Instanz-Handle erstellen, das in der Klasse
• Create static getInstance() gespeichert ist, die einen synchronisierten Block für das Objekt verwendet, um das Thread-Sicherheitsrisiko zu verringern.

Singleton Pattern beispielhafte Implementierung im Frühjahr

Im folgenden Beispiel implementieren wir unseren eigenen Singleton. Dann werden wir beweisen, dass die Federkomponenten standardmäßig Singletons sind. Beginnen wir mit der Erstellung einiger Klassen. Die erste, die wir erstellen werden, ist die Singleton.java -Klasse, die ein traditioneller Singleton sein wird (im vorherigen Punkt beschrieben):

public class Singleton { private static Singleton instance; private Singleton(){} public static Singleton getInstance() { if(null == instance){ synchronized (Singleton.class){ if(null==instance) { instance = new Singleton(); } } } return instance; } }

Erstellen Sie nun eine einfache Spring @Component -Klasse ohne Logik:

@Component public class SpringSingleton { }

Als nächstes testen wir, ob unsere Singletons sicherstellen, dass nur ein Objekt erstellt wird. Ich habe den JUnit-Test verwendet (automatisch generiert beim Erstellen eines Spring Boot-Projekts im Spring Initializer):

@RunWith(SpringRunner.class) @SpringBootTest public class SpringDesignPatternsApplicationTests { @Autowired SpringSingleton springSingleton1; @Autowired SpringSingleton springSingleton2; @Test public void singletonObjectsShouldBeEquals() { Singleton singleton1 = Singleton.getInstance(); Singleton singleton2 = Singleton.getInstance(); // Checking if the Singleton objects are definitely one, the same object Assert.assertSame(singleton1, singleton2); // Checking if the spring components are definitely singletons Assert.assertSame(springSingleton1, springSingleton2); } }

assertSame() methode prüft, ob Argumente dieselben Objekte sind. Testergebnis: bestanden – alles war gleich. So können Sie traditionelle Singletons oder Singletons im Frühling schreiben.

Singleton Pattern vs Spring Singletons

Es gibt noch eine Sache, die Sie wissen sollten. Wie ich schrieb – alle Spring Beans sind standardmäßig Singletons. Dies sind jedoch nicht die gleichen Singletons wie die traditionellen Singletons. Das traditionelle Singleton-Muster geht davon aus, dass es in dem von Java Classloader verwalteten Bereich nur eine Instanz einer bestimmten Klasse gibt. Im Frühjahr gibt es nur eine Instanz von Bean für jede gegebene context (_org.springframework.context.ApplicationContext) Instanz. Wenn Sie also mehr als einen Kontext haben, der alle vom selben Java-Klassenlader verwaltet wird, haben Sie wahrscheinlich mehr als eine Instanz einer Bean.

Das Prototypmuster

Der Prototyp ist ein Muster, dessen Zweck es ist, Objekte aus dem übergeordneten Objekt zu kopieren. Im Prototypmuster wird ein neues Objekt erstellt, indem ein vorhandenes Objekt geklont wird. In Java ist die clone() -Methode eine Implementierung dieses Entwurfsmusters.

Intent

• Die Instanz wird zur Laufzeit geklont, um neue Instanzen mit demselben Status zu erhalten
• In Java geschieht dies mit der Cloneable -Schnittstelle/

Problemlösung

Der Prototyp kann in folgenden Fällen verwendet werden:

• Sie müssen viele Instanzen derselben oder ähnlicher Objekte erstellen, und das Klonen ist effizienter als das Erstellen von Instanzen von Objekten mit dem Schlüsselwort new Java.
• Nützlich bei Objekten, die threadsicher sein müssen und den Status speichern müssen (z.g Einkaufswagen – wo Sie das gleiche Verhalten haben möchten, aber die einzelnen Artikel im Warenkorb unterschiedlich sind)

Struktur des Prototypmusters

• Erstellen Sie eine abstrakte Basisklasse, die Cloneable implementiert.
• Abstrakte Klasse in Prototypinstanzen erweitern.
• Überschreiben Sie die clone() -Methode in diesen Prototypinstanzen – fügen Sie das klassenspezifische Verhalten hinzu.

PrototypePattern-Implementierung im Frühjahr

Ich werde den traditionellen Java-Prototyp nicht implementieren. Ich werde Ihnen jedoch zeigen, wie Sie im Frühjahr eine Prototyp-Bean erstellen. Ich habe eine dumme Klasse erstellt: SpringPrototype.java

 public class SpringPrototype { }

In der Hauptanwendungsklasse im Frühjahr habe ich eine neue Prototyp-Bean definiert, indem ich @Scope auf prototype:

 @Bean @Scope("prototype") public SpringPrototype prototype(){ return new SpringPrototype(); }

JUnit-Test:

 @Autowired SpringPrototype prototype1; @Autowired SpringPrototype prototype2; @Test public void prototypeObjectsShouldNotBeEquals() { Assert.assertNotSame(prototype1, prototype2); }

Ich habe zwei Instanzen der SpringPrototype-Klasse mit @Autowired injiziert. Genau wie im Singleton-Beispiel habe ich die statische Methode von Assert verwendet, um zu überprüfen, ob die erstellten Instanzen nicht identisch sind. Mein Test ist grün. Es ist ein Beweis dafür, dass es zwei verschiedene Instanzen desselben Objekts gibt.

Fazit

Ich hoffe dir hat der Beitrag gefallen. Wir haben die wichtigsten Gestaltungsmuster des Frühlings kennengelernt. Im nächsten Beitrag erfahren wir mehr über strukturelle Muster im Spring Framework!