设计模式之工厂模式

工厂模式是一种对象创建模式，它提供了创建对象的最佳实践。在工厂模式下，我们在创建对象时不使用它 new 关键词是通过调用工厂来创建对象。工厂方法是一种定义子类的方法，负责实例对象。工厂方法可以返回不同的对象类型，因此工厂模式可以创建一组相关或不相关的对象。这样，对象的创建和使用就可以解耦。

有三种类型的工厂模式：简单的工厂模式、工厂模式和抽象的工厂模式。

• 简单的工厂模式是最基本的工厂模式，它通过工厂类创建所有需要的对象。简单的工厂模式将对象的创建逻辑包装在工厂类别中，客户端通过调用工厂类别的静态方法来创建对象。
• 工厂方法模式是对简单工厂模式的改进。它定义了一个界面或抽象类来创建对象，这样子类就可以决定哪个类。工厂方法模式将对象的创建过程延迟到子类，从而实现开关原则。

工厂方法模式

• 抽象工厂模式是工厂方法模式的扩展。它提供了一系列相关或相互依赖的界面或抽象类别，而无需指定其特定类别。抽象工厂模式可以创建多个产品系列，每个产品系列由多个特定产品组成。

抽象工厂模式

工厂模式的优点如下：

• 对象的创建和使用可以解耦，从而提高系统的灵活性和可维护性。
• 工厂模式可以隐藏对象创建的细节，使客户只关心对象的使用，从而降低系统的复杂性。
• 工厂模式可以实现开关原则。当需要添加新产品时，只需添加相应的工厂类别，无需修改原始代码。

工厂模式的缺点是：

• 工厂模式会增加系统中类的数量，当产品类型较多时，会导致系统过于庞大和复杂。
• 抽象层需要引入工厂模式，这将增加系统的抽象性和理解难度。
• 工厂模式可能会导致过多的层次，增加系统设计的难度。

以下场景适用于工厂模式：

• 当需要创建更多类型的对象时，可以使用工厂模式来避免大量的new操作。
• 当需要根据不同的条件或参数创建不同类型的对象时，可以使用工厂模式来替换条件分支。
• 当对象的创建和使用需要解耦时，工厂模式可以用来实现依赖倒置的原则。

以下是Java实现的三种工厂模式的代码示例。

假设我们有一个 Shape 接口和三个实现类 Circle、Rectangle 和 Square，我们希望根据给定的形状类型创建相应的对象。

首先，我们定义一个 Shape 接口和三个实现类：

// Shape接口publicichichichape interface Shape {    void draw();}// Circle类public class Circle implements Shape {    @Override    public void draw() {        System.out.println("Draw a circle");    }}// Rectanglepublic class Rectangle implements Shape {    @Override    public void draw() {        System.out.println("Draw a rectangle");    }}// Square类public class Square implements Shape {    @Override    public void draw() {        System.out.println("Draw a square");    }}

然后，我们定义一个 ShapeFactory 类，它有一种静态方法 createShape，根据给定的形状类型返回相应的对象：

// ShapeFactory类型public class ShapeFactory {    // createshape静态方法    public static Shape createShape(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;    }}

最后，我们可以在客户端使用它 ShapeFactory 创建不同类型的形状对象：

// 客户端public class Client {    public static void main(String[] args) {        // 创建圆形对象        Shape circle = ShapeFactory.createShape("circle");        // 调用圆形对象的draw方法        circle.draw();        // 创建矩形对象        Shape rectangle = ShapeFactory.createShape("rectangle");        // 调用矩形对象的draw方法        rectangle.draw();        // 创建正方形对象        Shape square = ShapeFactory.createShape("square");        // 调用正方形对象draw方法        square.draw();    }}

输出结果如下：

Draw a circleDraw a rectangleDraw a square

假设我们仍然有一个Shape接口和三个实现类Circle、Rectangle和Square，我们想根据给定的形状类型创建相应的对象，但我们不想使用一个工厂类来创建所有类型的对象，而是让每个形状类定义一个工厂类来创建自己的对象。

首先，我们将Shape接口和三个实现类定义为简单的工厂模式：

// Shape接口publicichichichape interface Shape {    void draw();}// Circle类public class Circle implements Shape {    @Override    public void draw() {        System.out.println("Draw a circle");    }}// Rectanglepublic class Rectangle implements Shape {    @Override    public void draw() {        System.out.println("Draw a rectangle");    }}// Square类public class Square implements Shape {    @Override    public void draw() {        System.out.println("Draw a square");    }}

然后我们定义了抽象工厂ShapeFactory，它有一种抽象方法createShape，返回Shape对象：

// 抽象工厂ShapeFactorypublictory abstract class ShapeFactory {    // createshape抽象方法    public abstract Shape createShape();}

然后，让每个形状类定义一个工厂类别，继承ShapeFactory，实现createShape方法，返回自己的对象:

// circlefactorpublic class CircleFactory extends ShapeFactory {    @Override    public Shape createShape() {        return new Circle();    }}// Rectanglefactorpublic class RectangleFactory extends ShapeFactory {    @Override    public Shape createShape() {        return new Rectangle();    }}// SquareFactorpublic class SquareFactory extends ShapeFactory {    @Override    public Shape createShape() {        return new Square();    }}

最后，我们可以在客户端使用不同类型的工厂来创建不同类型的形状对象：

// 客户端public class Client {    public static void main(String[] args) {        // 创建一个圆形工厂对象        ShapeFactory circleFactory = new CircleFactory();        // 圆形对象是通过圆形工厂对象创建的        Shape circle = circleFactory.createShape();        // 调用圆形对象的draw方法        circle.draw();        // 创建矩形工厂对象        ShapeFactory rectangleFactory = new RectangleFactory();        // 通过矩形工厂对象创建矩形对象        Shape rectangle = rectangleFactory.createShape();        // 调用矩形对象的draw方法        rectangle.draw();        // 创建一个方形的工厂对象        ShapeFactory squareFactory = new SquareFactory();        // 通过正方形工厂对象创建正方形对象        Shape square = squareFactory.createShape();        // 调用正方形对象draw方法        square.draw();    }}

输出结果如下：

Draw a circleDraw a rectangleDraw a square

假设我们不仅有一个Shape接口和三个实现类Circle、Rectangle和Square，还有一个Color接口和三个实现类Red、Gren和Blue，我们希望根据给定的类型创建相应的形状或颜色对象。

首先，我们定义了一个Shape接口和三个实现类，与前两种模式相同：

// Shape接口publicichichichape interface Shape {    void draw();}// Circle类public class Circle implements Shape {    @Override    public void draw() {        System.out.println("Draw a circle");    }}// Rectanglepublic class Rectangle implements Shape {    @Override    public void draw() {        System.out.println("Draw a rectangle");    }}// Square类public class Square implements Shape {    @Override    public void draw() {        System.out.println("Draw a square");    }}

然后，我们定义了一个Color接口和三个实现类：

// publicolor接口 interface Color {    void fill();}// Red类public class Red implements Color {    @Override    public void fill() {        System.out.println("Fill with red");    }}// Gren类public class Green implements Color {    @Override    public void fill() {        System.out.println("Fill with green");    }}// Blue类public class Blue implements Color {    @Override    public void fill() {        System.out.println("Fill with blue");    }}

然后我们定义了一个抽象工厂Abstractfactory，它有两种抽象方法:createshape和createcolor，分别返回一个shape对象和一个color对象:

// AbstractFactorypublictory abstract class AbstractFactory {    // createshape抽象方法    public abstract Shape createShape(String shapeType);    // createcolororolorolorocreate    public abstract Color createColor(String colorType);}

然后，我们将ShapeFactory定义为三个特定的工厂类别、colorfactoryMixedFactory，他们都继承了AbstractFactory，并实现了抽象方法。其中，ShapeFactory只负责创建形状对象，Colorfactory只负责创建颜色对象，MixedFactory可以创建形状对象和颜色对象：

// ShapeFactory类型public class ShapeFactory extends AbstractFactory {    @Override    public Shape createShape(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;    }    @Override    public Color createColor(String colorType) {        // 不支持颜色对象的创建，回到null        return null;    }}// colorFactorypublic class ColorFactory extends AbstractFactory {    @Override    public Shape createShape(String shapeType) {        // 不支持形状对象的创建，回到null        return null;    }    @Override    public Color createColor(String colorType) {        if (colorType == null) {            return null;        }        if (colorType.equalsIgnoreCase("red")) {            return new Red();        } else if (colorType.equalsIgnoreCase("green")) {            return new Green();        } else if (colorType.equalsIgnoreCase("blue")) {            return new Blue();        }        return null;    }}// MixedFactorypublic class MixedFactory extends AbstractFactory {    @Override    public Shape createShape(String shapeType) {        // 可以创建形状对象，ShapeFactory逻辑        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;    }    @Override    public Color createColor(String colorType) {        // 颜色对象可以创建，ColorFactory逻辑        if (colorType == null) {            return null;        }        if (colorType.equalsIgnoreCase("red")) {            return new Red();        } else if (colorType.equalsIgnoreCase("green")) {            return new Green();        } else if (colorType.equalsIgnoreCase("blue")) {            return new Blue();        }        return null;    }}

最后，我们可以在客户端使用不同的工厂类别来创建不同类型的形状或颜色对象：

// 客户端public class Client {    public static void main(String[] args) {        // 创建一个形状的工厂对象        AbstractFactory shapeFactory = new ShapeFactory();        // 圆形对象是通过形状工厂对象创建的        Shape circle = shapeFactory.createShape("circle");        // 调用圆形对象的draw方法        circle.draw();        // 通过形状工厂对象创建矩形对象        Shape rectangle = shapeFactory.createShape("rectangle");        // 调用矩形对象的draw方法        rectangle.draw();        // 正方形对象是通过形状工厂对象创建的        Shape square = shapeFactory.createShape("square");        // 调用正方形对象draw方法        square.draw();        // 创建一个颜色工厂对象        AbstractFactory colorFactory = new ColorFactory();        // 红色对象是通过颜色工厂对象创建的        Color red = colorFactory.createColor("red");        // 调用红色对象的fill方法        red.fill();        // 通过颜色工厂对象创建绿色对象        Color green = colorFactory.createColor("green");        // 调用绿色对象的fill方法        green.fill();        // 蓝色对象是通过颜色工厂对象创建的        Color blue = colorFactory.createColor("blue");        // 调用蓝色对象的fill方法        blue.fill();        // 创建混合工厂对象        AbstractFactory mixedFactory = new MixedFactory();        // 圆形和红色的组合对象是通过混合工厂对象创建的        Shape circleRed = mixedFactory.createShape("circle");        Color redRed = mixedFactory.createColor("red");        // 调用组合对象的draw和fill方法        circleRed.draw();        redRed.fill();    }}

输出结果如下：

Draw a circleDraw a rectangleDraw a squareFill with redFill with greenFill with blueDraw a circleFill with red

以上抽象工厂代码示在这里 Spring 框架下的改造。

先改造 Shape 加上接口的实现类 @Component 注解

// Shape接口publicichichichape interface Shape {    void draw();}// Circle类@Componentpublic class Circle implements Shape {    @Override    public void draw() {        System.out.println("Draw a circle");    }}// Rectangle@Componentpublic class Rectangle implements Shape {    @Override    public void draw() {        System.out.println("Draw a rectangle");    }}// Square类@Componentpublic class Square implements Shape {    @Override    public void draw() {        System.out.println("Draw a square");    }}

然后在改造 Color 加上接口的三个实现类别 @Component 注解

// publicolor接口 interface Color {    void fill();}// Red类@Componentpublic class Red implements Color {    @Override    public void fill() {        System.out.println("Fill with red");    }}// Gren类@Componentpublic class Green implements Color {    @Override    public void fill() {        System.out.println("Fill with green");    }}// Blue类@Componentpublic class Blue implements Color {    @Override    public void fill() {        System.out.println("Fill with blue");    }}

抽象工厂类 AbstractFactory 的具体工厂 MixedFactory 类加上 @Component 注解

// AbstractFactorypublictory abstract class AbstractFactory {    // createshape抽象方法    public abstract Shape createShape(String shapeType);    // createcolororolorolorocreate    public abstract Color createColor(String colorType);}// MixedFactory@Componentpublic class MixedFactory extends AbstractFactory {    @Autowired    private Map<String, Shape> shapeMap;    @Autowired    private Map<String, Color> colorMap;    @Override    public Shape createShape(String shapeType) {        // 可以创建形状对象，ShapeFactory逻辑        if (shapeType == null) {            return null;        }        return shapeMap.getOrDefault(shapeType, null);    }    @Override    public Color createColor(String colorType) {        // 颜色对象可以创建，ColorFactory逻辑        if (colorType == null) {            return null;        }        return colorMap.getOrDefault(colorType, null);    }}

最后，我们可以在客户端使用不同的工厂类别来创建不同类型的形状或颜色对象：

// 客户端// 测试类@SpringBootTest@RunWith(SpringRunner.class)public class FactoryTest {    // Context对象从Spring容器中获取    @Autowired    private MixedFactory mixedFactory;    @Test    public void test() {        Shape circle = mixedFactory.createShape("circle");        circle.draw();        Shape rectangle = mixedFactory.createShape("rectangle");        rectangle.draw();        Shape square = mixedFactory.createShape("square");        square.draw();        Color red = mixedFactory.createColor("red");        red.fill();        Color green = mixedFactory.createColor("green");        green.fill();        Color blue = mixedFactory.createColor("blue");        blue.fill();    }}

输出结果如下：

Draw a circleDraw a rectangleDraw a squareFill with redFill with greenFill with blue

简而言之，工厂模式可以通过引入其他类别的工厂类别来实现解耦、良好的扩展和提高代码可读性。它是 Java 最常用和最基本的开发设计模式之一。熟练使用工厂模式可以大大提高我们的代码质量和开发效率。

关注我每周分享技术干货、开源项目、实践经验、高效开发工具等，您的关注将是我更新的动力！