Java代码审计-设计模式-工厂模式

最新推荐文章于 2024-08-26 23:57:38 发布

MarginSelf

最新推荐文章于 2024-08-26 23:57:38 发布

阅读量100

点赞数

分类专栏： Java代码审计-设计模式文章标签： java 设计模式开发语言

本文链接：https://blog.csdn.net/ayunlong/article/details/130297293

版权

Java代码审计-设计模式专栏收录该内容

18 篇文章 1 订阅

订阅专栏

Java设计模式-工厂模式(Singleton Pattern)

一、什么是工厂模式

1.1 什么是工厂模式？

工厂模式的出现是为了解决创建对象实例的问题，通常我们使用new关键字创建某个对象，但在特定的情况下，一个对象的创建需要一些列的步骤，依赖其它的模块对象，所以这类对象的创建**更像是一个过程**，而非单个动作。这与工厂的工作模式极为相似，工厂中制造一个汽车，比如要从全世界各地购买零部件，然后组装为一台汽车，而这个组装的过程，就是工厂模式的创建汽车的过程。

工厂模式利用了面向对象的封装特点，对外屏蔽实现过程。

二、3种工厂模式的实现

3.1 简单工厂模式（Simple Factory）

简单工厂模式完成了最原始、最简单的对象创建与业务逻辑的隔离，降低了耦合性，来看一个例子

package org.factory.simpleFactory;

/**
 * 车的抽象类
 */
abstract class Car{
    public Car(){
        this.build();
    }
    public abstract void build();
}
class BMW extends Car {
    public void build(){
        System.out.println("生产一台BMW");
    }
}

class Benz extends Car{
    public void build(){
        System.out.println("生产一台Benz");
    }
}

/**
 * 工厂类
 */
class CarFactory{
    /**
     * 创建汽车
     * @param type 汽车类型
     * @return 汽车实例
     */
    public Car createCar(String type){
        Car car = null;
        if (type == "bmw"){
            car = new BMW();
        } else if (type == "benz") {
            car = new Benz();
        }
        return car;
    }
}

public class Client {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        BMW bmw = (BMW) carFactory.createCar("bmw");
        Benz benz = (Benz) carFactory.createCar("benz");
    }
}

以上就是简单工厂模式的实现，有这么几个特点：

所有的对象都在一个工厂中创建
完成了对象创建功能和对象使用的隔离，封装了创建的过程
根据传递的参数即可创建不同对象，较为灵活

但很显然这种方式有很多问题

违反开闭原则，想要增加新对象，就要修改工厂类
扩展性差，if else太多，不够优雅，而且如果创建几百个类型的对象，工程类的维护会令人发指

但简单工厂模式也有自己的应用场景，例如在相对简单业务场景下，JDK中的Calendar类就使用了简单工厂模式。

3.2 工厂方法模式（Factory Method）

简单工厂的最大缺点在于工厂类不够灵活，工厂方法模式便将工厂进行抽象化，定义创建对象的接口，具体如何实现对象的创建，交给具体的工厂类。那么此时想要新增产品，只需要扩展实现抽象工厂类即可，符合开闭原则。

当使用者想要创建某个对象时，只需要找到对应的工厂，即可创建。工厂方法模式需要以下角色

抽象工厂 AbstractFactory：定义创建对象的接口，具体由具体工厂实现
具体工厂 Factory：实现抽象工厂的接口，实现创建对象的过程
抽象产品 AbstractProduct：所有具体产品的父类，可以满足里氏替换的设计原则
具体产品 Product：工厂所建实例

下面为实例代码

package org.factory.factoryMethod;

/**
 * 车的抽象类
 */
abstract class Car{
    public Car(){
        this.build();
    }
    public abstract void build();
}
class BMW extends Car {
    public void build(){
        System.out.println("生产一台BMW");
    }
}

class Benz extends Car {
    public void build(){
        System.out.println("生产一台Benz");
    }
}
/**
 * 工厂的抽象类
 */
abstract class Factory{
    public abstract Car create();
}

class BMWFactory extends Factory{

    public BMW create() {
        return new BMW();
    }
}

class BenzFactory extends Factory{

    public Benz create() {
        return new Benz();
    }
}

public class Client {
    public static void main(String[] args) {
        BenzFactory benzFactory = new BenzFactory();
        benzFactory.create();

        BMWFactory bmwFactory = new BMWFactory();
        bmwFactory.create();

    }
}

总结下上面的代码UML图

方法工厂有很多优点

扩展性强：方法工厂模式限定了某个工厂只能创建某个对象，只要知道工厂名字就可以知道他创建的对象是什么，而且扩展性极强，如果增加五菱汽车，只需要增加一个五菱工厂类和五菱汽车对象即可。
屏蔽产品：产品的变化与调用者无关，这有点像“中间层理念”，例如Java的JDBC连接，我们只需要更改驱动名称即可，其它的不需要关心，十分强大！
解耦：这个特性是所有的设计模式都有的优点，符合依赖倒置原则，值依赖产品类的抽象；也符合里氏替换原则，可以使用子类替换父类，符合迪米特法则，我只需要操作Factory，不操作触产品类方法。

方法工厂一般在抽象类的实现类会不断变化时会使用，例如信息通知功能，可以短信、可以是邮件、可以是抖音，在未来可能是其它的方式

3.3 抽象工厂模式（Abstract Factory）

抽象模式是最难理解的模式，首先，观察下方法工厂模式，有没有发现方法工厂模式中只用到了一种“产品”？需要Create，直接就创建了一个对象，但我们回想下工厂制造汽车的场景，更多的是在“组装”。例如创建一个汽车需要：轮胎、天窗、底盘等，而这三个都是单独的对象。

这就很明确了：我生成一个宝马需要天窗、底盘等产品，接下来通过代码实现上面的需求（也可以先看代码后面的UML图，再回头看代码，会更高效）

package org.factory.abstractFactory;

/**
 * 轮胎的抽象类
 */
abstract class Tyre{
    public Tyre(){
        this.getName();
        this.getColor();
    }
    public abstract void getColor();
    public abstract void getName();
}

class TyreA extends Tyre {
    public void getColor() {
        System.out.println("轮胎A的颜色是黑色");
    }
    public void getName() {
        System.out.println("轮胎A的名字是轮胎A");
    }
}
class TyreB extends Tyre {
    public void getColor() {
        System.out.println("轮胎B的颜色是红色");
    }
    public void getName() {
        System.out.println("轮胎B的名字是轮胎B");
    }
}
/**
 * 天窗的抽象类
 */
abstract class Window{
    public Window(){
        this.open();
        this.close();
    }
    public abstract void open();
    public abstract void close();
}

class WindowA extends Window {

    public void open() {
        System.out.println("WindowA会开窗");
    }

    public void close() {
        System.out.println("WindowA会关窗");
    }
}

class WindowB extends Window {

    public void open() {
        System.out.println("WindowB会开窗");
    }

    public void close() {
        System.out.println("WindowB会关窗");
    }
}
/**
 * 汽车的抽象类
 * 每个汽车都需要安装Window和Tyre
 */
abstract class Car {
    public abstract void setWindow(Window window);
    public abstract void setTyre(Tyre tyre);
}


class BMW extends Car {

    private Window window;
    private Tyre tyre;

    public void setWindow(Window window) {
        this.window = window;
    }

    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }
}

class Benz extends Car {
    private Window window;
    private Tyre tyre;

    public void setWindow(Window window) {
        this.window = window;
    }

    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }
}
/**
 * 工厂的抽象类
 */
interface Factory{
    public Window createWindow();
    public Tyre createTyre();
    public Car create();
}

class BMWFactory implements Factory {
    public BMW create() {
        System.out.println("开始生产BMW");
        BMW bmw = new BMW();
        bmw.setTyre(createTyre());
        bmw.setWindow(createWindow());
        return bmw;
    }

    public Window createWindow() {
        return new WindowB();
    }

    public Tyre createTyre() {
        return new TyreA();
    }
}

class BenzFactory implements Factory {

    public Benz create() {
        System.out.println("开始生产Benz");
        Benz benz = new Benz();
        benz.setTyre(createTyre());
        benz.setWindow(createWindow());
        return benz;
    }

    public Window createWindow() {
        return new WindowB();
    }

    public Tyre createTyre() {
        return new TyreB();
    }
}

public class Client {
    public static void main(String[] args) {
        BMWFactory bmwFactory = new BMWFactory();
        bmwFactory.create();
        BenzFactory benzFactory = new BenzFactory();
        benzFactory.create();
    }
}
// 运行结果如下
开始生产BMW
轮胎A的名字是轮胎A
轮胎A的颜色是黑色
WindowB会开窗
WindowB会关窗
开始生产Benz
轮胎B的名字是轮胎B
轮胎B的颜色是红色
WindowB会开窗
WindowB会关窗

代码很多，表达出了抽象工厂的使用方法，抽象工厂有很多优点

封装性：Factory屏蔽了技术细节，使得高层模块只关心抽象和接口即可，工厂负责创建实例
产品族内的约束为非公开状态：高层模块只知道工厂会返回我一个宝马，但宝马内部用的什么材料我不清楚，但你给我一个宝马实例即可，具体的产品族内的约束是在工厂内实现的

缺点也很明显，产品（宝马）的扩展很困难，如果在宝马中增加后备箱，想一下需要改哪些地方？

首先Factory接口、BMWFactory肯定要修改，因为要增加createHouBX方法
Car接口以及实现类都要增加setHouBX的方法
增加HouBX类和实现类（这是没什么问题的）

所以主要问题是要修改Factory/Car接口，这是违反开闭原则的。所有实现Factory/Car的类都要修改、测试。

总结下：

在产品中增加零部件是困难的（例如宝马增加后备箱）
增加产品的种类是容易得（增加五菱汽车）
抽象模式比作数据库连接切换的话，可以理解为虽然便于两数据库之间的切换，但是不便于增加需求功能。

对比下三种工厂模式

简单工厂：只有唯一工厂（简单工厂），一个产品接口/抽象类，根据简单工厂中的静态方法来创建具体产品对象。适用于产品较少，几乎不扩展的情景
工厂方法：有多个工厂（抽象工厂+多个具体工厂），一个产品接口/抽象类，根据继承抽象工厂中的方法来多态创建具体产品对象。适用于一个类型的多个产品
抽象方法：有多个工厂（抽象工厂+多个具体工厂），多个产品接口/抽象类，对产品子类进行分组，根据继承抽象工厂中的方法多态创建同组的不同具体产品对象。适用于多个类型的多个产品，例如BenzFactory在创建汽车时，可以使用WindowA也可以使用WindowB。

三、JavaSE中工厂模式的使用

首先列举下使用工厂模式的类（看到名为newInstance的方法，大概率就是工厂模式）

java.util.Calendar 类 getInstance 方法使用了简单工厂
java.lang.Class 类的 newInstance 方法
java.lang.Class 类的 forName 方法
java.lang.reflect.Array 类的 newInstance 方法
java.lang.reflect.Constructor 类的 newInstance 方法
java.lang.reflect.Proxy 类的 newProxyInstance 方法
JDK 中8 种基本类型的包装类 Integer、Long、Short、Character、Byte、Float、Double、Boolean 的 valueOf 方法使用了简单工厂，可以根据参数创建不同的对象

java.util.Calendar 类 getInstance 方法使用了简单工厂

类中有非常多的getInstance方法的重载，用于创建实例

getInstance方法中会调用createCaledar方法去创建不同的日期计算的类

java.lang.Class 类的 newInstance 方法

Class类调用构造器创建对象实例

java.lang.Class 类的 forName 方法

forName方法会调用forName0方法，该方法是一个被native修饰的方法。

native是与C++联合开发的时候用的！使用native关键字说明这个方法是原生函数，也就是这个方法是用C/C++语言实现的，并且被编译成了DLL，由java去调用。

native 是用做java 和其他语言（如c++）进行协作时使用的，也就是native 后的函数的实现不是用java写的。

既然都不是java，那就别管它的源代码了，我们只需要知道这个方法已经被实现即可。

native的意思就是通知操作系统，这个函数你必须给我实现，因为我要使用。所以native关键字的函数都是操作系统实现的， java只能调用。

java.lang.reflect.Array 类的 newInstance 方法

java.lang.reflect包下除了提供Method(方法)、Constructor(构造器)、Filed(成员变量)这三个类，这三个类使我们在学习反射时常用的类，除此之外还提供了Array类，Array对象可以代表所有的数组，可通过Array类来动态创建数组，newInstance用于创建指定元素类型、指定维度的数组。这里的dimensions是可变个数的。

该方法是一个native方法

8种基本类型的valueOf方法

通过valueOf方法，new出实例，其它的基本类型不在一一讲解

java.lang.reflect.Constructor 类的 newInstance 方法

通过构造器创建对象实例

java.lang.reflect.Proxy 类的 newProxyInstance 方法

通过构造器创建对象实例

四、Struts2工厂模式的应用

4.1 InternalFactory类

在Struts2的依赖注入中使用了工厂模式，关于Struts2的容器加载机制，可以浏览《Mark链接-Struts2依赖注入实现原理》

Struts2在依赖注入时定义了InternalFactory接口

// 内部工厂接口
interface InternalFactory<T> extends Serializable {

  /**
   * Creates an object to be injected.
   *
   * @param context of this injection
   * @return instance to be injected
   */
  T create(InternalContext context);
}

在ContainerBuilder类将InternalFactory加入factories列表时，生成内部类实现create方法，create方法中定义了一个对象创建的过程，一个比较简单的工厂模式。

4.2 ObjectFactory类

该类无父类接口，就是一个实现类，完成对Struts2的Action、Bean、Result、Interceptor对象的创建，也是一个比较简单的工厂模式

MarginSelf

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
2
评论
Java代码审计-设计模式-工厂模式

工厂模式的出现是为了解决创建对象实例的问题，通常我们使用new关键字创建某个对象，但在特定的情况下，一个对象的创建需要一些列的步骤，依赖其它的模块对象，所以这类对象的创建**更像是一个过程**，而非单个动作。这与工厂的工作模式极为相似，工厂中制造一个汽车，比如要从全世界各地购买零部件，然后组装为一台汽车，而这个组装的过程，就是工厂模式的创建汽车的过程。工厂模式利用了面向对象的封装特点，对外屏蔽实现过程。抽象模式是最难理解的模式，首先，观察下方法工厂模式，有没有发现方法工厂模式中只用到了一种“产品”？
复制链接

扫一扫