catalogue
1, Singleton mode
1. Usage scenario of singleton mode in real life:
Background processing services for printers
Log object for the application
Connection pool for database
Counters for web sites
Configuration object for Web application
Dialog box in application
2. Implementation of singleton mode
A pattern in which a class has only one instance and the class can create the instance itself.
Common implementation methods include lazy mode, hungry mode, double check lock, static internal class, enumeration and so on. Let's take a look at their implementation one by one
Lazy mode:
/**
* @author hz
* @version 1.0
*/
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
//If it has not been instantiated, instantiate one and return
if(instance == null){
instance = new Singleton();
}
return instance;
}
}Hungry man mode:
/**
* @author hz
* @version 1.0
*/
public class Singleton {
//When the class is loaded, instance already points to an instance
private static Singleton instance = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return instance;
}
}Double check lock:
/**
* @author hz
* @version 1.0
*/
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
if(instance == null){
synchronized (Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}Enumeration:
/**
* @author hz
* @version 1.0
*/
public enum Singleton {
INSTANCE;
}3. Advantages of singleton mode:
Singleton mode can ensure that there is only one instance in memory and reduce the memory overhead.
Multiple occupation of resources can be avoided.
Set global access points in singleton mode to optimize and share resource access.
Disadvantages:
The singleton mode generally has no interface and is difficult to expand. If you want to expand, there is no second way except to modify the original code, which violates the opening and closing principle.
In concurrent testing, singleton mode is not conducive to code debugging. During debugging, if the code in the singleton is not executed, a new object cannot be simulated.
The function code of singleton mode is usually written in a class. If the function design is unreasonable, it is easy to violate the principle of single responsibility.
4.
Singleton mode application:
For some classes that need to be created frequently, using singleton can reduce the memory pressure of the system and reduce GC.
A class only requires the generation of an object, such as the monitor in a class, the ID number of everyone.
Some classes occupy more resources when creating instances, or instantiation takes a long time and is often used.
When a class needs frequent instantiation and the created objects are frequently destroyed, such as multi-threaded thread pool, network connection pool, etc.
Objects that frequently access databases or files.
2: Factory mode
1. Composition
- Simple factory: it is the core of the simple factory pattern and is responsible for implementing the internal logic of creating all instances. The method of creating product class of factory class can be directly called by the outside world to create the required product object.
- Abstract Product: it is the parent class of all objects created by a simple factory and is responsible for describing the common interface shared by all instances.
- Concrete product: it is the creation target of simple factory mode.
2. The factory pattern is represented by Java code
/**
* @author hz
* @version 1.0
*/
public class Client {
//Abstract product
public interface Product {
void show();
}
//Specific product: ProductA
static class ConcreteProduct1 implements Product {
public void show() {
System.out.println("Specific product 1 display...");
}
}
//Specific product: ProductB
static class ConcreteProduct2 implements Product {
public void show() {
System.out.println("Specific product 2 display...");
}
}
final class Const {
static final int PRODUCT_A = 0;
static final int PRODUCT_B = 1;
static final int PRODUCT_C = 2;
}
static class SimpleFactory {
public static Product makeProduct(int kind) {
switch (kind) {
case Const.PRODUCT_A:
return new ConcreteProduct1();
case Const.PRODUCT_B:
return new ConcreteProduct2();
}
return null;
}
}
}3. Advantages and disadvantages
advantage:
- The factory class contains the necessary logical judgment to decide when to create an instance of which product. The client can avoid the responsibility of directly creating product objects and easily create corresponding products. The responsibilities of the factory and products are clearly distinguished.
- The client does not need to know the class name of the specific product created, but only needs to know the parameters.
- You can also import a configuration file to replace and add new specific product classes without modifying the client code.
Disadvantages:
- The factory class of simple factory mode is single, which is responsible for the creation of all products. The responsibility is too heavy. Once it is abnormal, the whole system will be affected. Moreover, the factory class code will be very bloated and violate the principle of high aggregation.
- Using the simple factory mode will increase the number of classes in the system (introduce new factory classes), and increase the complexity and understanding difficulty of the system
- It is difficult to expand the system. Once new products are added, the factory logic has to be modified. When there are many product types, the logic may be too complex
- The simple factory mode uses the static factory method, which makes the factory role unable to form an inheritance based hierarchical structure.
4. Factory method mode
/**
* @author hz
* @version 1.0
*/
public class AbstractFactoryTest {
public static void main(String[] args) {
try {
Product a;
AbstractFactory af;
af = (AbstractFactory) ReadXML.getObject();
//Abstract factory contents are put into external configuration files, such as xml/properties, and loaded through I/O streams to create abstract factories
a = af.newProduct();
a.show();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
//Abstract product: provides the interface of the product
interface Product {
public void show();
}
//Concrete product 1: implement abstract methods in abstract products
class ConcreteProduct1 implements Product {
public void show() {
System.out.println("Specific product 1 display...");
}
}
//Concrete product 2: implement abstract methods in abstract products
class ConcreteProduct2 implements Product {
public void show() {
System.out.println("Specific product 2 display...");
}
}
//Abstract factory: provides the generation method of factory products
interface AbstractFactory {
public Product newProduct();
}
//Specific factory 1: the generation method of factory products is realized
class ConcreteFactory1 implements AbstractFactory {
public Product newProduct() {
System.out.println("Specific factory 1 generation-->Specific products 1...");
return new ConcreteProduct1();
}
}
//Specific factory 2: the generation method of factory products is realized
class ConcreteFactory2 implements AbstractFactory {
public Product newProduct() {
System.out.println("Specific plant 2 generation-->Specific products 2...");
return new ConcreteProduct2();
}
}import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
/**
* @author hz
* @version 1.0
*/
public class ReadXML {
//This method is used to extract the specific class name from the XML configuration file and return an instance object
public static Object getObject() {
try {
//Create document object
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;
doc = builder.parse(new File("src/FactoryMethod/config1.xml"));
//Gets the text node containing the class name
NodeList nl = doc.getElementsByTagName("className");
Node classNode = nl.item(0).getFirstChild();
String cName = "FactoryMethod." + classNode.getNodeValue();
//System.out.println("new class name:" + cName);
//Generate an instance object from the class name and return it
Class<?> c = Class.forName(cName);
Object obj = c.newInstance();
return obj;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}5. Advantages and disadvantages of factory method mode
advantage:
- Users only need to know the name of the specific factory to get the desired product, without knowing the specific creation process of the product.
- Flexibility is enhanced. For the creation of new products, you only need to write one more corresponding factory class.
- Typical decoupling framework. The high-level module only needs to know the abstract class of the product, does not need to care about other implementation classes, and meets the Demeter rule, dependency inversion principle and Richter substitution principle.
Disadvantages:
- The number of classes is easy to be too many, which increases the complexity
- It increases the abstraction and understanding difficulty of the system
- Abstract products can only produce one product, which can be solved by using abstract factory mode.
3, Abstract factory pattern
1. Definitions
One is to provide an interface for the access class to create a group of related or interdependent objects, and the access class can obtain the pattern structure of different levels of products of the same family without specifying the specific class of the product. Here, two concepts appear: same family and same level.
2. Meet the conditions
- There are multiple product families in the system. Each specific factory creates products of the same family but belonging to different hierarchical structures.
- The system can only consume one family of products at a time, that is, the products of the same family can be used together.
3. Composition
- Abstract Factory: it provides an interface for creating products. It contains multiple methods for creating products newProduct(), which can create multiple products of different levels.
- Concrete Factory: it mainly implements multiple abstract methods in the abstract factory to complete the creation of specific products.
- Abstract Product: it defines the Product specification and describes the main features and functions of the Product. The abstract factory pattern has multiple Abstract products.
- Concrete product: it implements the interface defined by the abstract product role and is created by the concrete factory. It has a many-to-one relationship with the concrete factory.
4. Code composition
/**
* @author hz
* @version 1.0
*/
public class FarmTest {
public static void main(String[] args) {
try {
Farm f;
Animal a;
Plant p;
//Read the corresponding configuration information for the production plant
f = (Farm) ReadXML.getObject();
a = f.newAnimal();
p = f.newPlant();
a.show();
p.show();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
//Abstract products: Animals
interface Animal {
public void show();
}
//Specific products: Horses
class Horse implements Animal {
public Horse() {
System.out.println("Generation of specific horses");
}
public void show() {
System.out.println("Perform corresponding operations for horses");
}
}
//Specific products: Cattle
class Cattle implements Animal {
public Cattle() {
//Generation of specific cattle
System.out.println("Generation of specific cattle");
}
public void show() {
System.out.println("Perform corresponding operations for horses");
}
}
//Abstract products: Plants
interface Plant {
public void show();
}
//Specific products: Fruits
class Fruitage implements Plant {
public Fruitage() {
System.out.println("Specific fruit generation");
}
public void show() {
System.out.println("Perform corresponding operations for fruits");
}
}
//Specific products: Vegetables
class Vegetables implements Plant {
public Vegetables() {
System.out.println("Specific vegetable generation");
}
public void show() {
System.out.println("Perform the corresponding operations of vegetables");
}
}
//Abstract factory: Farm class
interface Farm {
public Animal newAnimal();
public Plant newPlant();
}
//Specific factory: Farm 1
class SGfarm implements Farm {
public Animal newAnimal() {
System.out.println("A new cow is born!");
return new Cattle();
}
public Plant newPlant() {
System.out.println("Vegetables grow!");
return new Vegetables();
}
}
//Specific factory: Farm 2
class SRfarm implements Farm {
public Animal newAnimal() {
System.out.println("The new horse was born!");
return new Horse();
}
public Plant newPlant() {
System.out.println("Fruit grows!");
return new Fruitage();
}
}
import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.File;
/**
* @author hz
* @version 1.0
*/
public class ReadXML2 {
public static Object getObject() {
try {
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;
doc = builder.parse(new File("src/AbstractFactory/config.xml"));
NodeList nl = doc.getElementsByTagName("className");
Node classNode = nl.item(0).getFirstChild();
String cName = "AbstractFactory." + classNode.getNodeValue();
System.out.println("New class name:" + cName);
Class<?> c = Class.forName(cName);
Object obj = c.newInstance();
return obj;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}5. Advantages and disadvantages
advantage
- 1. The multi-level products associated in the product family can be managed together within the class, instead of introducing multiple new classes for management.
- 2. When a product family is required, the abstract factory can ensure that the client always uses only the product group of the same product.
- 3. The abstract factory enhances the scalability of the program. When adding a new product family, there is no need to modify the original code to meet the opening and closing principle.
shortcoming
- When the objects to be created are a series of interrelated or interdependent product families, such as televisions, washing machines, air conditioners, etc.
- There are multiple product families in the system, but only one of them is used at a time. If someone only likes to wear clothes and shoes of a certain brand.
- The class library of products is provided in the system, and the interfaces of all products are the same. The client does not depend on the creation details and internal structure of product instances.
4, Summary
The singleton pattern is one of the design patterns, and the design pattern is actually a further packaging of the insufficient language features. You can better understand the singleton pattern with more practice. For the case of relatively few product types, consider using the simple factory model. For a product, the caller clearly knows which specific factory service should be used, instantiates the specific factory and produces specific products. Then we can use the factory method model, Both the simple factory model and our factory method model consider a series of products of the same type. Abstract factory mode when adding a new product family, you only need to add a new specific factory without modifying the original code to meet the opening and closing principle. When a new type of product needs to be added to the product family, all factory classes need to be modified, which does not meet the opening and closing principle.