Technology Sharing

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

Factory Pattern is a commonly used design pattern in object-oriented programming.Creational PatternsThe factory pattern is mainly used to create objects, but it is different from using it directly in the code.newUnlike creating objects with keywords, it creates objects through a common interface, thus separating the object creation process from the client code. The following is a detailed introduction to the factory pattern:

1. Main features of the factory model

1. Encapsulates the object creation process: The object creation process is encapsulated in the factory class. The client only needs to specify the type of object to be created, and then it can obtain the required object through the factory class without having to worry about the specific creation details of the object.
2. Reduce coupling: Through the isolation of abstract factories and concrete factories, the coupling between clients and objects is reduced, making client programs easier to expand and maintain.
3. Improve the scalability of the program: When a new product needs to be added, you only need to add the corresponding specific product class and the corresponding factory class without modifying the original code. This complies with the open-closed principle (open for extension and closed for modification), and improves the scalability of the code.
4. Easy to maintain and upgrade: Because the factory method concentrates the process of creating objects in one class, if you need to modify the method of creating objects, you only need to modify the corresponding factory class, which has no impact on the client.
5. Code Reuse: The factory pattern can abstract the object creation process, realize code reuse, and increase the flexibility and reusability of the code.

2. Classification of factory patterns

The factory pattern is mainly divided into three types: simple factory pattern (static factory pattern), factory method pattern and abstract factory pattern

1. Static Factory Method

1. Define a factory class that returns instances of different classes based on the different parameters passed in.
2. A factory class usually contains multiple static methods, each of which corresponds to the creation of a specific product.
3. Advantages: Simple to implement and easy to understand.
4. Disadvantages: The factory class has too many responsibilities. When adding new products, the source code of the factory class needs to be modified, which violates the open-closed principle.

Simple factory pattern class diagram

2. Factory Method

1. Define an interface for creating objects (abstract factory),But let the subclass decide which class to instantiate。
2. Factory methods let you defer instantiation of a class to subclasses.
3. Advantages: Good scalability. When you need to add new products, you only need to add the corresponding specific product classes and specific factory classes.
4. Disadvantages: Every time a product is added, a specific class and object implementation factory need to be added, which increases the number of classes in the system exponentially and increases the complexity of the system.

Factory Method Pattern

3. Abstract Factory

1. Provides an interface for creating a set of related or interdependent objects without specifying their concrete classes.
2. The abstract factory pattern can be seen as the combined use of multiple factory method patterns.
3. Advantages: Product families can be constrained within the class, and a specific factory must be able to create all products in the product family.
4. Disadvantages: It increases the abstractness and difficulty of understanding of the system, and the number of classes in the system will increase significantly.

Abstract Factory Pattern

3. Application scenarios of factory mode

The factory pattern is widely used in actual development, such as database connection, UI controls, file processing, logging, network communication, message queues, data structures, encryption and decryption, message push, and task scheduling. In these scenarios, the factory pattern can be used to separate the object creation process from the use process, thereby improving the flexibility and scalability of the system.

4. Factory Pattern Example

1. Simple factory pattern example

In the simple factory pattern, we define a factory class that can return instances of different types based on the parameters passed in.

Below is an example of a simple factory pattern written in Java. We will create a shape factory that can produce instances of circle, rectangle, and square. First, we define a shape interface (Shape) and several concrete classes that implement the interface (Circle, Rectangle, Square).

// 形状接口  
interface Shape {  
    void draw();  
}  
  
// 圆形类  
class Circle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Circle::draw() method.");  
    }  
}  
  
// 矩形类  
class Rectangle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Rectangle::draw() method.");  
    }  
}  
  
// 正方形类  
class Square implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Square::draw() method.");  
    }  
}

Next, we define a factory class (ShapeFactory) that uses static methods to generate shape objects.

// 形状工厂类  
class ShapeFactory {  
  
    // 使用 getShape 方法获取形状类型的对象  
    public static Shape getShape(String shapeType){  
        if(shapeType == null){  
            return null;  
        }          
        if(shapeType.equalsIgnoreCase("CIRCLE")){  
            return new Circle();  
        } else if(shapeType.equalsIgnoreCase("RECTANGLE")){  
            return new Rectangle();  
        } else if(shapeType.equalsIgnoreCase("SQUARE")){  
            return new Square();  
        }  
          
        return null;  
    }  
}

Finally, we can use the factory class to get shape objects and call theirdrawmethod.

public class FactoryPatternDemo {  
  
    public static void main(String[] args) {  
        // 获取 Circle 的对象，并调用它的 draw 方法  
        Shape shape1 = ShapeFactory.getShape("CIRCLE");  
        shape1.draw();  
  
        // 获取 Rectangle 的对象，并调用它的 draw 方法  
        Shape shape2 = ShapeFactory.getShape("RECTANGLE");  
        shape2.draw();  
  
        // 获取 Square 的对象，并调用它的 draw 方法  
        Shape shape3 = ShapeFactory.getShape("SQUARE");  
        shape3.draw();  
    }  
}

In this example,ShapeFactoryThe class is responsible for creatingShapeThe client code passes type information (such as a string) toShapeFactoryStatic methods of a classgetShapeto get an instance of the required shape. In this way, the client is decoupled from the implementation of the concrete class, which complies with the open-closed principle, that is, the new shape class can be extended without modifying the client code. However, a major disadvantage of the simple factory pattern is that if the system needs to expand a new product family (for example, in addition to the shape, there are also colors, etc.), the factory class needs to be modified, which violates part of the open-closed principle. In this case, you can consider using the factory method pattern or the abstract factory pattern.

2. Factory Method Pattern Example

Let’s take shape as an example. We use engineering methods to create it.

First, define the shape interface (Product) and create three implementation classes.

// 形状接口  
interface Shape {  
    void draw();  
}
 
// 圆形类  
class Circle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Circle::draw() method.");  
    }  
}  
  
// 矩形类  
class Rectangle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Rectangle::draw() method.");  
    }  
}  
  
// 正方形类  
class Square implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Square::draw() method.");  
    }  
}

Next, define the creator interface (Creator) and the concrete creator (Concrete Creator):

// 创建者接口  
interface ShapeFactory {  
    Shape getShape(String shapeType);  
}  
  
// 具体创建者类  
class RectangleFactory implements ShapeFactory {  
    @Override  
    public Shape getShape(String shapeType) {  
        if (shapeType == null) {  
            return null;  
        }  
        if (shapeType.equalsIgnoreCase("RECTANGLE")) {  
            return new Rectangle();  
        }  
        return null;  
    }  
}  
  
class CircleFactory implements ShapeFactory {  
    @Override  
    public Shape getShape(String shapeType) {  
        if (shapeType == null) {  
            return null;  
        }  
        if (shapeType.equalsIgnoreCase("CIRCLE")) {  
            return new Circle();  
        }  
        return null;  
    }  
}  
  
class SquareFactory implements ShapeFactory {  
    @Override  
    public Shape getShape(String shapeType) {  
        if (shapeType == null) {  
            return null;  
        }  
        if (shapeType.equalsIgnoreCase("SQUARE")) {  
            return new Square();  
        }  
        return null;  
    }  
}

Finally, use the concrete creator class to get the shape objects and call theirdrawmethod:

public class FactoryMethodPatternDemo {  
  
    public static void main(String[] args) {  
        ShapeFactory shapeFactory = new CircleFactory();  
  
        // 获取 Circle 的对象，并调用它的 draw 方法  
        Shape shape1 = shapeFactory.getShape("CIRCLE");  
        shape1.draw();  
  
        // 使用 RectangleFactory 来获取 Rectangle 的对象  
        shapeFactory = new RectangleFactory();  
        Shape shape2 = shapeFactory.getShape("RECTANGLE");  
        shape2.draw();  
  
        // 使用 SquareFactory 来获取 Square 的对象  
        shapeFactory = new SquareFactory();  
        Shape shape3 = shapeFactory.getShape("SQUARE");  
        shape3.draw();  
    }  
}

In this example,We create a corresponding factory class for each shape class(Although in real applications, you would usually have a more general factory class structure, perhaps using configuration files or reflection to avoid having to write a separate factory class for each product class.) This helps demonstrate the basic principles of the Factory Method pattern,That is, let the factory subclass decide which class to instantiateHowever, for the simple case in this example, you might prefer to use the Simple Factory pattern or consider other design patterns to reduce code duplication.

3. Abstract Factory Example

This example takes mobile phones as an example, abstract products related to mobile phones (such as screens, batteries, operating systems, etc.), and creates specific product classes to implement these interfaces. Then, we can define abstract factory interfaces and specific factory classes to produce these products. The following is a simplified example showing how to use the abstract factory pattern to produce mobile phone components (screens and batteries) of different brands and models:

First, define the product interface and specific products:

// 屏幕接口  
interface Screen {  
    void display();  
}  
  
 
// 高端屏幕的实现  
class HighEndScreen implements Screen {  
    @Override  
    public void display() {  
        System.out.println("显示高清屏幕");  
    }  
}  
  
// 低端屏幕的实现  
class LowEndScreen implements Screen {  
    @Override  
    public void display() {  
        System.out.println("显示普通屏幕");  
    }  
}  
 
 
// 电池接口  
interface Battery {  
    void charge();  
}
 
  
// 高效电池的实现  
class HighEfficiencyBattery implements Battery {  
    @Override  
    public void charge() {  
        System.out.println("快速充电");  
    }  
}  
  
// 标准电池的实现  
class StandardBattery implements Battery {  
    @Override  
    public void charge() {  
        System.out.println("标准充电");  
    }  
}

Next, define the abstract factory interface and concrete factory class:

// 手机组件工厂接口  
interface PhoneFactory {  
    Screen createScreen();  
    Battery createBattery();  
}  
  
// 高端手机工厂  
class HighEndPhoneFactory implements PhoneFactory {  
    @Override  
    public Screen createScreen() {  
        return new HighEndScreen();  
    }  
  
    @Override  
    public Battery createBattery() {  
        return new HighEfficiencyBattery();  
    }  
}  
  
// 低端手机工厂  
class LowEndPhoneFactory implements PhoneFactory {  
    @Override  
    public Screen createScreen() {  
        return new LowEndScreen();  
    }  
  
    @Override  
    public Battery createBattery() {  
        return new StandardBattery();  
    }  
}

Finally, the client code, which uses the abstract factory to create concrete product objects:

public class PhoneFactoryPatternDemo {  
    public static void main(String[] args) {  
        // 使用高端手机工厂  
        PhoneFactory highEndFactory = new HighEndPhoneFactory();  
        Screen highEndScreen = highEndFactory.createScreen();  
        Battery highEndBattery = highEndFactory.createBattery();  
  
        highEndScreen.display();  
        highEndBattery.charge();  
  
        // 使用低端手机工厂  
        PhoneFactory lowEndFactory = new LowEndPhoneFactory();  
        Screen lowEndScreen = lowEndFactory.createScreen();  
        Battery lowEndBattery = lowEndFactory.createBattery();  
  
        lowEndScreen.display();  
        lowEndBattery.charge();  
    }  
}

In this example, we define two mobile phone factories (high-end and low-end), each capable of producing a specific type of screen and battery.The client code interacts with the specific factory class through the abstract factory interface, thereby achieving decoupling from the specific product class.In this way, if we need to add new types of mobile phones in the future (for example, mid-range mobile phones), we only need to add new product classes and corresponding factory classes without modifying existing client code.

V. Conclusion

The factory pattern is a very useful design pattern.It has the advantages of encapsulating the object creation process, reducing coupling, improving the scalability and maintainability of the program, etc., which has been widely used in software development. However, it also has someDisadvantages, such as excessive factory responsibilities and difficulty in system expansion, etc.Therefore, in practical applications, it is necessary to make trade-offs and choices based on specific scenarios and requirements.

If the factory pattern (simple factory, factory method, abstract factory) is useful to you, remember to like and collect it.