设计模式-工厂模式

已于 2024-04-12 14:37:45 修改
阅读量271 收藏 7
点赞数 5
分类专栏： 设计模式 文章标签： 设计模式 抽象工厂模式 简单工厂模式
于 2024-04-12 14:35:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45919491/article/details/137512446
版权

设计模式-工厂模式

1、工厂模式介绍

工厂模式（Factory Pattern）是Java中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时，不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
《设计模式》一书中，工厂模式被分为了三种：简单工厂、工厂方法和抽象工厂。（不过，在书中作者将简单工厂模式看作是工厂方法模式的一种特例。）

2、需求：模拟用户操作数字钥匙

需求：为了让我们的案例更加贴近实际开发，这里我们来模拟一下互联网汽车中数字钥匙操作的场景，在用户购车后可以开通各种类型的数字钥匙：蓝牙钥匙、手表钥匙、分享钥匙

2.1、原始开发方式

在不考虑任何代码的可扩展性的前提下，只为了尽快满足需求，我们可以这样去设计这个业务的代码结构：

实体类

BluetoothKey——蓝牙钥匙实体类
ShareKey——被分享钥匙实体类(蓝牙钥匙可以被分享)
WatchKey——手表钥匙实体类
ResultUtil——响应结果工具类

/**
 * 蓝牙钥匙实体类
 *
 * @author duckquan
 */
public class BluetoothKey {

    /**
     * 蓝牙钥匙唯一id
     */
    private String id;
    /**
     * 车主
     */
    private String userId;
    /**
     * 对应车辆id
     */
    private String carId;
    /**
     * 钥匙状态：未开通、已开通、已失效......
     */
    private Integer status;

}

/**
 * 分享钥匙实体类
 *
 * @author duckquan
 */
public class ShareKey {

    /**
     * 分享钥匙唯一id
     */
    private String id;
    /**
     * 主人钥匙id
     */
    private String masterKeyId;
    /**
     * 钥匙生效时间
     */
    private Date startDate;
    /**
     * 钥匙失效时间
     */
    private Date endDate;
    /**
     * 钥匙权限：开窗、开空调、打开车门......
     */
    private String keyAuthority;
    /**
     * 钥匙状态：未开通、已开通、已失效......
     */
    private Integer status;
    
}

/**
 * 手表钥匙实体类
 *
 * @author duckquan
 */
public class WatchKey {
    //属性信息省略......    
}

import lombok.Data;

@Data
public class ResultUtil<T> {

    private String code;
    private String message;
    private Object data;

    private static final String successCode = "000";
    private static final String successMessage = "操作成功";

    public static <T> ResultUtil<T> successResult(Object data) {
        ResultUtil<T> result = new ResultUtil();
        result.setCode(successCode);
        result.setMessage(successMessage);
        result.setData(data);
        return result;
    }

}

服务层

BluetoothKeyService——boolean openBlueToothKey(String id)——开通蓝牙钥匙
ShareKeyService——boolean openShareKey(String id)——开通分享钥匙
WatchKeyService——boolean openWatchKey(String id)——开通手表钥匙

/**
 * 蓝牙钥匙
 *
 * @author duckquan
 */
public interface BluetoothKeyService {
    
    /**
     * 开通蓝牙钥匙
     *
     * @param id
     * @return
     */
    boolean openBlueToothKey(String id);

}

import org.springframework.stereotype.Service;

/**
 * 蓝牙钥匙
 *
 * @author duckquan
 */
@Service
public class BluetoothKeyServiceImpl implements BluetoothKeyService {

    @Override
    public boolean openBlueToothKey(String id) {
        System.out.println("【蓝牙钥匙】状态已更改为开通，钥匙id：" + id);
        return true;
    }

}

/**
 * 分享钥匙
 *
 * @author duckquan
 */
public interface ShareKeyService {

    /**
     * 开通分享钥匙
     *
     * @param id
     * @return
     */
    boolean openShareKey(String id);

}

import org.springframework.stereotype.Service;

/**
 * 分享钥匙
 *
 * @author duckquan
 */
@Service
public class ShareKeyServiceImpl implements ShareKeyService {
    
    @Override
    public boolean openShareKey(String id) {
        System.out.println("【分享钥匙】状态已更改为开通，钥匙id：" + id);
        return true;
    }
    
}

/**
 * 手表钥匙
 *
 * @author duckquan
 */
public interface WatchKeyService {

    /**
     * 开通手表钥匙
     *
     * @param id
     * @return
     */
    boolean openWatchKey(String id);

}

import org.springframework.stereotype.Service;

/**
 * 手表钥匙
 *
 * @author duckquan
 */
@Service
public class WatchKeyServiceImpl implements WatchKeyService {
    
    @Override
    public boolean openWatchKey(String id) {
        System.out.println("【手表钥匙】状态已更改为开通，钥匙id：" + id);
        return true;
    }
    
}

控制层

KeyController——ResultUtil<<Object> openKey(String id, Integer type)——

import com.alibaba.fastjson.JSONObject;
import com.example.study.service.BluetoothKeyService;
import com.example.study.service.ShareKeyService;
import com.example.study.service.WatchKeyService;
import com.example.study.utils.ResultUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


/**
 * 钥匙controller层
 * 假装有：@RestController，@RequestMapping("/key")
 * 请忽略：@Component
 *
 * @author duckquan
 */
@Component
public class KeyController {

    @Autowired
    private BluetoothKeyService bluetoothKeyService;

    @Autowired
    private ShareKeyService shareKeyService;

    @Autowired
    private WatchKeyService watchKeyService;


    /**
     * 开通钥匙接口，按照类型开通不同的钥匙
     * 假装有：@PostMapping("/openKey")
     *
     * @param id   钥匙id
     * @param type 1-蓝牙钥匙，2-分享钥匙，3-手表钥匙
     * @return
     */
    public ResultUtil<Object> openKey(String id, Integer type) {
        //TODO 这里自行判断参数是否为空
        //--------------------------------
        String resultJson = null;
        if (type == 1) {//蓝牙钥匙
            resultJson = JSONObject.toJSONString(bluetoothKeyService.openBlueToothKey(id));
        }
        if (type == 2) {//分享钥匙
            resultJson = JSONObject.toJSONString(shareKeyService.openShareKey(id));
        }
        if (type == 3) {//手表钥匙
            resultJson = JSONObject.toJSONString(watchKeyService.openWatchKey(id));
        }
        return ResultUtil.successResult(resultJson);
    }

}

测试

import com.example.study.controller.KeyController;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * 工厂模式测试类
 */
@SpringBootTest
public class FactoryTest {

    @Autowired //为了方便测试这样子写，请忽略这里引入controller层类的做法
    private KeyController keyController;

    /**
     * 无任何设计模式测试
     * 按照类型的不同开通钥匙
     * 类型：1-蓝牙钥匙，2-分享钥匙，3-手表钥匙
     */
    @Test
    public void nonDesignTest() {
        //蓝牙钥匙开通
        System.out.println("蓝牙钥匙：" + keyController.openKey("BLUE20240410", 1) + "\n");
        //分享钥匙开通
        System.out.println("分享钥匙：" + keyController.openKey("SHARE20240410", 2) + "\n");
        //手表钥匙开通
        System.out.println("手表钥匙：" + keyController.openKey("WATCH20240410", 3));
    }

}

对于上面的实现方式，如果我们有想要添加新的钥匙类型时，势必要改动KeyController的代码，违反了开闭原则，而且如果有的钥匙接口出现问题，那么对其进行重构的成本会非常高。
除此之外代码中有一组if分支判断逻辑，现在看起来还可以，但是如果经理几次迭代和拓展，后续if else肯定还会增加，到时候接手这段代码的研发将会十分痛苦。

2.2、简单工厂模式

简单工厂不是一种设计模式，反而比较像是一种编程习惯。简单工厂模式又叫做静态工厂方法模式（static Factory Method pattern），它是通过使用静态方法接收不同的参数来返回不同的实例对象。
实现方式：定义一个工厂类，根据传入的参数不同返回不同的实例，被创建的实例具有共同的父类或接口。
适用场景：需要创建的对象较少、客户端不关心对象的创建过程。

简单工厂原理

  • 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能
  • 具体产品 ：实现或者继承抽象产品的子类
  • 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。

简单工厂重构代码
Service

/**
 * 数字钥匙service
 *
 * @author duckquan
 */
public interface KeyService {

    /**
     * 开通数字钥匙
     *
     * @param id
     * @return
     */
    boolean openKey(String id);

}

import org.springframework.stereotype.Service;

/**
 * 蓝牙钥匙
 *
 * @author duckquan
 */
@Service
public class BluetoothKeyServiceImpl implements KeyService {

    @Override
    public boolean openKey(String id) {
        System.out.println("【蓝牙钥匙】状态已更改为开通，钥匙id：" + id);
        return true;
    }

}

import org.springframework.stereotype.Service;

/**
 * 分享钥匙
 *
 * @author duckquan
 */
@Service
public class ShareKeyServiceImpl implements KeyService {

    @Override
    public boolean openKey(String id) {
        System.out.println("【分享钥匙】状态已更改为开通，钥匙id：" + id);
        return true;
    }

}

import org.springframework.stereotype.Service;

/**
 * 手表钥匙
 *
 * @author duckquan
 */
@Service
public class WatchKeyServiceImpl implements KeyService {

    @Override
    public boolean openKey(String id) {
        System.out.println("【手表钥匙】状态已更改为开通，钥匙id：" + id);
        return true;
    }

}

Factory

import com.example.study.service.BluetoothKeyServiceImpl;
import com.example.study.service.KeyService;
import com.example.study.service.ShareKeyServiceImpl;
import com.example.study.service.WatchKeyServiceImpl;
import org.springframework.stereotype.Component;

/**
 * 数字钥匙工厂：生成具体的数字钥匙service
 *
 * @author duckquan
 */
@Component
public class KeySimpleFactory {

    /**
     * 获取数字钥匙service实例
     *
     * @param type 类型：1-蓝牙钥匙，2-分享钥匙，3-手表钥匙
     * @return
     */
    public static KeyService getInstance(Integer type) {
        KeyService service = null;
        if (type == 1) {
            service = new BluetoothKeyServiceImpl();
        }
        if (type == 2) {
            service = new ShareKeyServiceImpl();
        }
        if (type == 3) {
            service = new WatchKeyServiceImpl();
        }
        return service;
    }

}

Controller

import com.alibaba.fastjson.JSONObject;
import com.example.study.design.factory.KeySimpleFactory;
import com.example.study.service.KeyService;
import com.example.study.utils.ResultUtil;
import org.springframework.stereotype.Component;


/**
 * 钥匙controller层
 * 假装有：@RestController，@RequestMapping("/key")
 * 请忽略：@Component
 *
 * @author duckquan
 */
@Component
public class KeyController {

    /**
     * 开通钥匙接口，按照类型开通不同的钥匙
     * 假装有：@PostMapping("/openKey")
     *
     * @param id   钥匙id
     * @param type 1-蓝牙钥匙，2-分享钥匙，3-手表钥匙
     * @return
     */
    public ResultUtil<Object> openKey(String id, Integer type) {
        //TODO 这里自行判断参数是否为空
        //--------------------------------
        KeyService service = KeySimpleFactory.getInstance(type);
        return ResultUtil.successResult(JSONObject.toJSONString(service.openKey(id)));
    }

}

测试

import com.example.study.controller.KeyController;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * 工厂模式测试类
 */
@SpringBootTest
public class FactoryTest {

    @Autowired //为了方便测试这样子写，请忽略这里引入controller层类的做法
    private KeyController keyController;

    /**
     * 无任何设计模式测试
     * 按照类型的不同开通钥匙
     * 类型：1-蓝牙钥匙，2-分享钥匙，3-手表钥匙
     */
    @Test
    public void nonDesignTest() {
        //蓝牙钥匙开通
        System.out.println("蓝牙钥匙：" + keyController.openKey("BLUE20240410", 1) + "\n");
        //分享钥匙开通
        System.out.println("分享钥匙：" + keyController.openKey("SHARE20240410", 2) + "\n");
        //手表钥匙开通
        System.out.println("手表钥匙：" + keyController.openKey("WATCH20240410", 3));
    }

    /**
     * 简单工厂模式测试
     */
    @Test
    public void simpleFactoryTest() {
        //蓝牙钥匙开通
        System.out.println("蓝牙钥匙：" + keyController.openKey("BLUE20240410", 1) + "\n");
        //分享钥匙开通
        System.out.println("分享钥匙：" + keyController.openKey("SHARE20240410", 2) + "\n");
        //手表钥匙开通
        System.out.println("手表钥匙：" + keyController.openKey("WATCH20240410", 3));
    }

}

简单工厂模式总结
优点：封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。
缺点：增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

2.3、工厂方法模式

工厂方法模式（Factory Method pattern）属于创建型模式。
概念：定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。
工厂方法模式的目的很简单，就是封装对象创建的过程，提升创建对象方法的可复用性。
工厂方模式的主要角色：

  • 抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
  • 具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
  • 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

我们直接来看看工厂方法模式的UML图：
在这里插入图片描述

2.3.1、工厂方法模式重构代码

为了提高代码扩展性，我们需要将简单工厂中的if分支逻辑去掉,通过增加抽象工厂（生产工厂的工厂）的方式，让具体工厂去进行实现,由具体工厂来决定实例化哪一个具体的产品对象。

抽象工厂

import com.example.study.service.KeyService;

/**
 * 数字钥匙抽象工厂
 *
 * @author duckquan
 */
public interface KeyMethodFactory {

    /**
     * 获取具体工厂实例
     *
     * @return
     */
    KeyService getInstance();

}

具体工厂

import com.example.study.service.BluetoothKeyServiceImpl;
import com.example.study.service.KeyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 蓝牙钥匙工厂
 *
 * @author duckquan
 */
@Component
public class BluetoothKeyFactory implements KeyMethodFactory {

    @Autowired
    private BluetoothKeyServiceImpl bluetoothKeyService;

    @Override
    public KeyService getInstance() {
        return bluetoothKeyService;
    }

}

import com.example.study.service.KeyService;
import com.example.study.service.ShareKeyServiceImpl;
import org.springframework.stereotype.Component;

/**
 * 分享钥匙工厂
 *
 * @author duckquan
 */
@Component
public class ShareKeyFactory implements KeyMethodFactory {

    @Override
    public KeyService getInstance() {
        return new ShareKeyServiceImpl();
    }

}

import com.example.study.service.KeyService;
import com.example.study.service.WatchKeyServiceImpl;
import org.springframework.stereotype.Component;

/**
 * 手表钥匙工厂
 *
 * @author duckquan
 */
@Component
public class WatchKeyServiceFactory implements KeyMethodFactory {

    @Override
    public KeyService getInstance() {
        return new WatchKeyServiceImpl();
    }

}

这里可以增加一个用来获取具体工厂的类，降低工厂创建与业务代码的耦合，我们姑且称这个类为工厂的工厂。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

/**
 * 用简单方法模式实现: 工厂的工厂，作用是不需要每次创建新的工厂对象
 *
 * @author duckquan
 */
@Component
public class KeyMethodFactoryMap {

    @Autowired
    private BluetoothKeyFactory bluetoothKeyFactory;

    @Autowired
    private ShareKeyFactory shareKeyFactory;

    @Autowired
    private WatchKeyServiceFactory watchKeyServiceFactory;

    //存放具体工厂对象的map集合
    private static final Map<Integer, KeyMethodFactory> cachedFactories = new HashMap<>();

    @PostConstruct
    public void init() {
        cachedFactories.put(1, bluetoothKeyFactory);
        cachedFactories.put(2, shareKeyFactory);
        cachedFactories.put(3, watchKeyServiceFactory);
    }

    /**
     * 获得具体工厂类
     *
     * @param type
     * @return
     */
    public KeyMethodFactory getFactory(Integer type) {
        return cachedFactories.get(type);
    }

}

Controller

import com.alibaba.fastjson.JSONObject;
import com.example.study.design.factory.KeyMethodFactory;
import com.example.study.design.factory.KeyMethodFactoryMap;
import com.example.study.design.factory.KeySimpleFactory;
import com.example.study.service.KeyService;
import com.example.study.utils.ResultUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


/**
 * 钥匙controller层
 * 假装有：@RestController，@RequestMapping("/key")
 * 请忽略：@Component
 *
 * @author duckquan
 */
@Component
public class KeyController {

    @Autowired
    private KeyMethodFactoryMap keyMethodFactoryMap;

    /**
     * 简单工厂模式-开通钥匙接口，按照类型开通不同的钥匙
     * 假装有：@PostMapping("/openKey")
     *
     * @param id   钥匙id
     * @param type 1-蓝牙钥匙，2-分享钥匙，3-手表钥匙
     * @return
     */
    public ResultUtil<Object> openKey(String id, Integer type) {
        //TODO 这里自行判断参数是否为空
        //--------------------------------
        KeyService service = KeySimpleFactory.getInstance(type);
        return ResultUtil.successResult(JSONObject.toJSONString(service.openKey(id)));
    }

    /**
     * 工厂方法模式-开通钥匙接口，按照类型开通不同的钥匙
     * 假装有：@PostMapping("/methodFactoryOpenKey")
     *
     * @param id   钥匙id
     * @param type 1-蓝牙钥匙，2-分享钥匙，3-手表钥匙
     * @return
     */
    public ResultUtil<Object> methodFactoryOpenKey(String id, Integer type) {
        //TODO 这里自行判断参数是否为空
        //--------------------------------
        //获取工厂
        KeyMethodFactory factory = keyMethodFactoryMap.getFactory(type);
        //获取产品
        KeyService service = factory.getInstance();
        return ResultUtil.successResult(JSONObject.toJSONString(service.openKey(id)));
    }

}

测试

import com.example.study.controller.KeyController;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * 工厂模式测试类
 */
@SpringBootTest
public class FactoryTest {

    @Autowired //为了方便测试这样子写，请忽略这里引入controller层类的做法
    private KeyController keyController;

    /**
     * 简单工厂模式测试
     */
    @Test
    public void simpleFactoryTest() {
        //蓝牙钥匙开通
        System.out.println("蓝牙钥匙：" + keyController.openKey("BLUE20240410", 1) + "\n");
        //分享钥匙开通
        System.out.println("分享钥匙：" + keyController.openKey("SHARE20240410", 2) + "\n");
        //手表钥匙开通
        System.out.println("手表钥匙：" + keyController.openKey("WATCH20240410", 3));
    }

    /**
     * 工厂方法模式测试
     * 工厂模式可以结合单例模式一起使用，这里可以在工厂类上加上注解，把实例交给Spring管理(Spring管理的实例默认是单例)
     */
    @Test
    public void methodFactoryTest() {
        //蓝牙钥匙开通
        System.out.println("蓝牙钥匙：" + keyController.methodFactoryOpenKey("BLUE20240410", 1) + "\n");
        //分享钥匙开通
        System.out.println("分享钥匙：" + keyController.methodFactoryOpenKey("SHARE20240410", 2) + "\n");
        //手表钥匙开通
        System.out.println("手表钥匙：" + keyController.methodFactoryOpenKey("WATCH20240410", 3));
    }

}

现在我们的代码已经基本上符合了开闭原则，当有新增的产品时，我们需要做的事情包括：

  1. 创建新的产品类，并且让该产品实现抽象产品接口
  2. 创建产品类对应的具体工厂，并让具体工厂实现抽象工厂
  3. 将新的具体工厂对象，添加到KeyMethodFactoryMap的cachedFactories中即可，需要改动的代码改动的非常少。

工厂方法模式总结
优点：

  • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程
  • 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则

缺点：

  • 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度

什么时候使用工厂方法模式

  • 需要使用很多重复代码创建对象时，比如，DAO层的数据对象、API层的VO对象等。
  • 创建池化对象时，比如，连接池对象、线程池对象、日志对象等。这些对象的特性是：有限、可重用，使用工厂方法模式可以有效节约资源。
  • 希望隐藏对象的真实类型时，比如，不希望使用者知道对象的真实构造函数参数等。
  • 创建对象要访问外部信息或资源时，比如，读取数据库字段，获取访问授权token信息，配置文件等。
  • 创建需要统一管理生命周期的对象时，比如，会话信息、用户网页浏览轨迹对象等。

3、抽象工厂模式

抽象工厂模式比工厂方法模式的抽象程度更高，在工厂方法模式中每一个具体工厂只需要生产一种具体产品，但是在抽象工厂模式中一个具体工厂可以生产一组相关的具体产品，这样一组产品被称为产品族，产品族中的每一个产品都分属于某一个产品继承等级结构。

产品等级结构与产品族
为了更好的理解抽象工厂，我们这里先引入两个概念：

  • 产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
  • 产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。
    在这里插入图片描述

在上图中，每一个具体工厂可以生产属于一个产品族的所有产品，例如海尔工厂生产海尔电视机、海尔空调和海尔冰箱，所生产的产品又位于不同的产品等级结构中。如果使用工厂方法模式，上图所示的结构需要提供9个具体工厂，而使用抽象工厂模式只需要提供3个具体工厂，极大减少了系统中类的个数。

抽象工厂模式描述
抽象工厂模式（Abstract Factory Pattern）原始定义：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
抽象工厂模式为创建一组对象提供了解决方案，与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，而是负责创建一个产品族。如下图：
在这里插入图片描述

3.1、抽象工厂模式原理

在抽象工厂模式中，每一个具体工厂都提供了多个工厂方法，用于产生多种不同类型的产品，这些产品构成了一个产品族。
在这里插入图片描述
抽象工厂模式的主要角色如下：

  • 抽象工厂（Abstract Factory）：它声明了一种用于创建一族产品的方法，每一个方法对应一种产品
  • 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建
  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品
  • 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系

抽象工厂

/**
 * 抽象工厂：在一个抽象工厂中可以声明多个工厂方法，用于创建不同类型的产品
 *
 * @author duckquan
 */
public interface AppliancesFactory {

    /**
     * 创建不同品牌电视机(海尔、海信、TCL)
     *
     * @return
     */
    AbstractTV createTV();

    /**
     * 创建不同品牌冰箱(海尔、海信、TCL)
     *
     * @return
     */
    AbstractFreezer createFreezer();

}

具体工厂：每一个具体工厂的方法，可以返回一个特定的产品对象，而同一个具体的工厂所创建的产品对象构成了一个产品族

/**
 * 具体工厂-海尔工厂
 *
 * @author duckquan
 */
public class HairFactory implements AppliancesFactory {

    @Override
    public AbstractTV createTV() {
        return new HairTV();
    }

    @Override
    public AbstractFreezer createFreezer() {
        return new HairFreezer();
    }

}

/**
 * 具体工厂-海信工厂
 *
 * @author duckquan
 */
public class HisenseFactory implements AppliancesFactory {

    @Override
    public AbstractTV createTV() {
        return new HisenseTV();
    }

    @Override
    public AbstractFreezer createFreezer() {
        return new HisenseFreezer();
    }

}

抽象产品

/**
 * 抽象产品-电视机
 * 
 * @author duckquan
 */
public interface AbstractTV {
}

/**
 * 抽象产品-冰箱
 *
 * @author duckquan
 */
public interface AbstractFreezer {
}

具体产品

/**
 * 具体产品-海尔电视
 *
 * @author duckquan
 */
public class HairTV implements AbstractTV {
}

/**
 * 具体产品-海信电视
 *
 * @author duckquan
 */
public class HisenseTV implements AbstractTV {
}

/**
 * 具体产品-海尔冰箱
 *
 * @author duckquan
 */
public class HairFreezer implements AbstractFreezer {
}

/**
 * 具体产品-海信冰箱
 *
 * @author duckquan
 */
public class HisenseFreezer implements AbstractFreezer {
}

客户端

import lombok.Data;

/**
 * 客户端
 *
 * @author duckquan
 */
@Data
public class Client {

    private AbstractTV tv;

    private AbstractFreezer freezer;

    public Client(AppliancesFactory factory) {
        //在客户端看来就是使用抽象工厂来生产家电
        this.tv = factory.createTV();
        this.freezer = factory.createFreezer();
    }

}

测试

import com.example.study.controller.KeyController;
import com.example.study.design.factory.*;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * 工厂模式测试类
 */
@SpringBootTest
public class FactoryTest {

    @Autowired //为了方便测试这样子写，请忽略这里引入controller层类的做法
    private KeyController keyController;

    /**
     * 简单工厂模式测试
     */
    @Test
    public void simpleFactoryTest() {
        //蓝牙钥匙开通
        System.out.println("蓝牙钥匙：" + keyController.openKey("BLUE20240410", 1) + "\n");
        //分享钥匙开通
        System.out.println("分享钥匙：" + keyController.openKey("SHARE20240410", 2) + "\n");
        //手表钥匙开通
        System.out.println("手表钥匙：" + keyController.openKey("WATCH20240410", 3));
    }

    /**
     * 工厂方法模式测试
     * 工厂模式可以结合单例模式一起使用，这里可以在工厂类上加上注解，把实例交给Spring管理(Spring管理的实例默认是单例)
     */
    @Test
    public void methodFactoryTest() {
        //蓝牙钥匙开通
        System.out.println("蓝牙钥匙：" + keyController.methodFactoryOpenKey("BLUE20240410", 1) + "\n");
        //分享钥匙开通
        System.out.println("分享钥匙：" + keyController.methodFactoryOpenKey("SHARE20240410", 2) + "\n");
        //手表钥匙开通
        System.out.println("手表钥匙：" + keyController.methodFactoryOpenKey("WATCH20240410", 3));
    }

    /**
     * 抽象工厂模式测试
     */
    @Test
    public void abstractFactoryTest() {
        Client client = new Client(new HairFactory());
        AbstractTV tv = client.getTv();
        System.out.println(tv);
        AbstractFreezer freezer = client.getFreezer();
        System.out.println(freezer);
    }

}

3.2、抽象工厂模式总结

从上面代码实现中我们可以看出，抽象工厂模式向使用（客户）方隐藏了下列变化

  • 程序所支持的实例集合（具体工厂）的数目
  • 当前是使用的实例集合中哪一个实例
  • 在任意给定时刻被实例化的具体类型

所以说，在理解抽象工厂模式原理时，你一定要牢牢记住如何找到某一个类产品的正确共性功能这个重点。
抽象工厂模式优点

  • 对于不同产品系列有比较多共性特征时，可以使用抽象工厂模式，有助于提升组件的复用性
  • 当需要提升代码的扩展性并降低维护成本时，把对象的创建和使用过程分开，能有效地将代码统一到一个级别上
  • 解决跨平台带来的兼容性问题

抽象工厂模式缺点
增加新的产品等级结构麻烦，需要对原有结构进行较大的修改，甚至需要修改抽象层代码,这显然会带来较大不变,违背了开闭原则。

栖枫渡
关注
专栏目录
java常用设计模式-工厂模式
08-26
Java常用设计模式-工厂模式 工厂模式（Factory Pattern）是一种常用的设计模式，它通过一个工厂类来实现对象的创建，而无需直接暴露对象的创建逻辑给客户端。这种模式可以使客户端代码与具体的产品类解耦，提高代码...
设计模式-工厂模式.pdf
04-11
### 设计模式之工厂模式详解 #### 一、概述 工厂模式是一种常用的设计模式，属于创建型模式之一。它的核心思想在于将对象的创建过程封装起来，并通过特定的工厂类来实现对象的创建，以此达到降低系统耦合度的目的...
Java设计模式-工厂模式
m0_62946761的博客
12-09 5784
介绍简单工厂模式，工厂方法模式，抽象工厂模式。
PHP 设计模式 - 工厂模式
weixin_43844718的博客
09-26 1727
一个抽象产品类，可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类可以创建多个具体产品类的实例。三种工厂的比较简单工厂 ：用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力[修改原方法]）工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）
C++设计模式-工厂模式
IT1995的博客
06-13 6734
目录 基本概念 代码及实例 基本概念 工厂方法模式（Factory Method）：定义一个用于创建对象的接口，让字类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类； 简单工厂模式的最大优点在用户工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了具体产品的依赖。 工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实...
设计模式 - 工厂模式、建造者模式，就该这样学！
CYK_byte的博客
10-08 2752
简单工厂不是一种设计模式，反而比较像是一种编程习惯.抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。具体产品 ：实现或者继承抽象产品的子类具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。
设计模式-工厂模式三种类型
活到老学到老
04-03 2787
1.简单工厂模式 （1）简单工厂模式时属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式 （2）简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为（代码） （3）在软件开发中，当我们会用到大量的创建某种，某类或者某批对象时，就会使用到工厂模式 2.工厂模式 定义了一个创建对象的抽象方法，有子类决定要实例化的类。工厂方发模式将对象的实例化推迟到子类 3.抽象工厂模式 （1）定义了一个interface
大话设计模式-工厂模式
每天一个前端小知识~
07-13 4448
工厂模式 Spring IOC就是使用了工厂模式，对象的创建交给一个工厂去创建。 概念：工厂模式（Factory Pattern）使用一个共同的接口指向新创建的对象。 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类 主要解决：解决接口的选择问题 何时使用：不同条件创建不同实例时 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品 关键点：创建过程在其子类执行 应用实例：当你需要一辆汽车，可以直接去工厂提货，而不用管这辆车是怎们做出来的，以及汽车里面的具体实现 优点： 1.调用者创建对
Java进阶-SpringCloud设计模式-工厂模式的设计与详解
踏雨歌青春，诗酒趁年华
05-13 1万+
本文详细介绍了设计模式中的工厂模式，旨在为软件开发人员提供清晰的理解和应用指南。工厂模式是一种创建型设计模式，用于在不直接指定具体类的情况下创建对象，从而增强代码的灵活性和可扩展性。我们探讨了工厂模式的三种主要形式：简单工厂模式、工厂方法模式和抽象工厂模式。每种模式都通过其结构、代码示例和类图进行了解释，以展示它们在实际开发中如何减少系统的依赖性、提高可维护性和支持易变需求。此外，本文还讨论了每种模式的优势、适用场景以及的实际应用，帮助开发者面对不同业务场景时，能选择最合适的模式。
设计模式－工厂模式
热门推荐
勿在浮沙筑高台
03-17 1万+
工厂模式： 简单工厂模式 工厂方法模式 抽象工厂模式 工厂模式属于设计模式的创建型 设计模式。 一般分为： 产品类 工厂类一. 简单工厂模式 （是工厂方法的一种特例） 二. 工厂方法模式产品类： abstract class Animal{ abstract void run(); }class Dog extends Animal{ void run(){
C++设计模式----工厂模式
精致的灰的博客
08-31 4892
三种工厂模式
《设计模式-工厂模式》中代码示例
07-05
总之，工厂模式是一种基础且实用的设计模式，它在软件开发中扮演着重要角色，帮助我们构建更加健壮、易维护的系统。通过理解并应用工厂模式，开发者可以更好地管理和控制对象的创建过程，提升代码的可读性和可扩展性...
2.设计模式-工厂模式1
08-03
工厂模式是软件设计模式中的核心模式之一，它在软件开发中扮演着重要的角色，特别是在需要创建一系列相关或相互依赖的对象时。工厂模式的主要目的是将对象的创建过程封装起来，使得客户端在使用对象时，无需关心对象...
23种设计模式具体实现方法
晴山の博客
10-16 511
前期疑问：适配器模式的优点主要包括：（1）提高类的透明性和复用性： 适配器模式可以让类在现有的基础上进行复用，而不需要做出任何改变，这有助于避免大规模改写现有代码。（2）解耦目标类和适配器类： 通过使用适配器模式，目标类和适配器类可以实现解耦，从而提高程序的扩展性。这符合开闭原则，即对扩展开放，对修改关闭。（3）更好的扩展性： 在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能。（4）灵活性好： 适配器并没有影响原有功能，如果不想使用，可以直接删除。
代理设计模式
2301_80220193的博客
10-14 1336
二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。它是一种设计模式，用于在不修改原始对象的情况下，通过代理对象来间接访问原始对象，并在访问前后执行额外的操作。
设计模式，面试级别的详解(持续更新中)--单例模式
最新发布
qq_51321722的博客
10-16 447
其实很简单，第一重判断，如果实例已经存在，那么就不再需要进行同步操作，而是直接返回这个实例，如果没有创建，才会进入同步块，同步块的目的与之前相同，目的是为了防止有多个线程同时调用时，导致生成多个实例，有了同步块，每次只能有一个线程调用访问同步块内容，当第一个抢到锁的调用获取了实例之后，这个实例就会被创建，之后的所有调用都不会进入同步块，直接在第一重判断就返回了单例。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。，这种方式比较常用，但容易产生垃圾对象，浪费内存空间。
设计模式02-桥接模式(Java)
XYX_888的博客
10-13 522
它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。在使用关联关系是，及在抽象类引入实现类接口时可能会出现不适配的情况，这是可以用适配器类型将其转换成抽象类可以适配的类进行关联。扩展抽象化角色 ：是抽象化角色的子类，实现父类中的业务方法， 并通过组合关系调用实现化角色中的业务方法。实现化角色 ：定义实现化角色的接口，供扩展抽象化角色调用。抽象化角色 ：定义抽象类，并包含一个对实现化对象的引用。具体实现化角色 ：给出实现化角色接口的具体实现。实现了对抽象和实现之间的解耦。
设计模式解析：工厂模式详解
"这篇文章除了介绍设计模式中的工厂模式外，还涵盖了简单工厂模式、工厂方法模式和抽象工厂模式的基本概念，并给出了相应的代码示例。文章通过ICourse接口和其实现类JavaCourse来说明简单工厂模式的实现，接着讨论了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值