零基础介绍简单工厂、工厂模式和抽象工厂区别，抽象工厂的优化

最新推荐文章于 2024-10-16 17:27:55 发布
最新推荐文章于 2024-10-16 17:27:55 发布
阅读量617 收藏 14
点赞数 19
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56199449/article/details/141683395
版权

参考书籍《大话设计模式》

案例

假设现在有基于Mysql数据库操作用户的的MysqlUserServiceImpl和基于Oracle数据库操作用户的OracleUserServiceImpl，代码如下：

public class User {

}

public interface UserService {
    void insert(User user);

    User findById(Integer id);
}

public class MysqlUserServiceImpl implements UserService {
    @Override
    public void insert(User user) {
        System.out.println("mysql 插入 user");
    }

    @Override
    public User findById(Integer id) {
        System.out.println("mysql 获取 user");
        return null;
    }
}


public class OracleUserServiceImpl implements UserService {
    @Override
    public void insert(User user) {
        System.out.println("oracle 插入 user");
    }

    @Override
    public User findById(Integer id) {
        System.out.println("oracle 获取 user");
        return null;
    }
}

客户端的代码如下，可以在客户端选择自己需要的数据库对应的服务。

public class Client {
    public static void main(String[] args) {
        // 如果客户端想使用基于Mysql的服务
        // ......这里省略若干代码（在创建对应的产品时，可能有其他逻辑代码）
//        UserService userService = new MysqlUserServiceImpl();

        // 如果客户端想使用基于Oracle的服务
        // ......这里省略若干代码（在创建对应的产品时，可能有其他逻辑代码）
        UserService userService = new OracleUserServiceImpl();
        userService.insert(new User());
        userService.findById(1);
    }
}

对于这样的代码，有许多弊端。

  1. 客户端需要知道具体的服务（产品）。比如这里的MysqlUserServiceImpl和OracleUserServiceImpl
  2. 代码重复。如果有多个客户端，都这样创建服务（产品），因为在创建服务时可能还有其他逻辑代码，就会造成大量代码重复。

这些问题可以使用简单工厂解决。

简单工厂

提供一个工厂类来创建不同类型的产品对象，根据输入的参数决定返回哪个具体的产品。
一个工厂类负责创建所有产品，适用于产品种类较少的情况。

image.png

public interface UserService {
    void insert(User user);

    User findById(Integer id);
}

public class OracleUserServiceImpl implements UserService {
    @Override
    public void insert(User user) {
        System.out.println("oracle 插入 user");
    }

    @Override
    public User findById(Integer id) {
        System.out.println("oracle 获取 user");
        return null;
    }
}

public class MysqlUserServiceImpl implements UserService {
    @Override
    public void insert(User user) {
        System.out.println("mysql 插入 user");
    }

    @Override
    public User findById(Integer id) {
        System.out.println("mysql 获取 user");
        return null;
    }
}

public class UserServiceFactory {

    public static UserService getUserService(String databaseType) {
        UserService userService = null;
        switch (databaseType) {
            case "Mysql":
                userService = new MysqlUserServiceImpl();
                break;
            case "Oracle":
                userService = new OracleUserServiceImpl();
                break;
        }
        return userService;
    }
}

public class Client {
    public static void main(String[] args) {
        UserService userService = UserServiceFactory.getUserService("Mysql");
        userService.insert(new User());
        userService.findById(1);
    }
}

在简单工厂代码中，客户端依旧可以自行选择使用哪种数据库，同时让客户端的代码和业务代码隔离出来，变得更加简洁。
但是简单工厂也有自己的弊端。

  1. 违背了"开闭原则"。如果现在想要增加一个基于SqlServer数据库的服务SqlServerUserServiceImpl，那么我们得去修改工厂，在switch分支中增加代码。这违法了"开闭原则"（对扩展开放，对修改关闭）。
  2. 不同产品的创建都在同一个工厂中，会使这个工厂变得臃肿。每个产品创建时可能有其他逻辑代码（比如在创建MysqlUserServiceImpl后，调用它的set方法设置它的属性），那么这个工厂就会变得庞大复杂。

工厂模式

工厂方法模式将对象的创建延迟到子类中进行。具体的工厂类负责创建产品实例，而客户端只需要依赖抽象工厂接口，具体的工厂实现类会创建相应的具体产品。
通过工厂接口和具体工厂类，允许子类决定创建哪种产品，适用于需要扩展产品类型的情况。

image.png
现在我们把前面的简单工厂类UserServiceFactory定义成一个接口了，然后定义具体的工厂创建对应的产品。这样如果现在要新增一个基于Sqlserver的服务，只要新增一个具体的工厂SqlserverUserServiceFactory实现UserServiceFactory工厂，新增一个具体的产品SqlserverUserServiceImpl实现UserService。

public interface UserServiceFactory {

    UserService getUserService();
}

public class OracleUserServiceFactory implements UserServiceFactory {
    @Override
    public UserService getUserService() {
        // ......这里省略若干代码（在创建对应的产品时，可能有许多前置逻辑代码）
        return new OracleUserServiceImpl();
    }
}

public class MysqlUserServiceFactory implements UserServiceFactory {
    @Override
    public UserService getUserService() {
        // ......这里省略若干代码（在创建对应的产品时，可能有许多前置逻辑代码）
        return new MysqlUserServiceImpl();
    }
}

public class SqlserverUserServiceFactory implements UserServiceFactory {
    @Override
    public UserService getUserService() {
        // ......这里省略若干代码（在创建对应的产品时，可能有许多前置逻辑代码）
        return new SqlServerUserServiceImpl();
    }
}

public class Client {
    public static void main(String[] args) {
        // 客户端想要使用mysql的服务，创建对应的工厂即可
        //        UserServiceFactory userServiceFactory = new MysqlUserServiceFactory();
        // 客户端想要使用oracle的服务，创建对应的工厂即可
        //        UserServiceFactory userServiceFactory = new OracleUserServiceFactory();
        // 客户端想要使用sqlserver的服务，创建对应的工厂即可
        UserServiceFactory userServiceFactory = new SqlserverUserServiceFactory();
        UserService userService = userServiceFactory.getUserService();
        userService.insert(new User());
        userService.findById(1);
    }
}

这就解决了简单工厂中违背“开闭原则”问题。把创建产品放到对应的具体工厂，就能把创建某个产品时的其他逻辑代码维护到具体的工厂，就不会出现所有产品的创建的代码都在一个工厂类（简单工厂就是把所有产品的创建维护在一个工厂中）。
缺陷：

  1. 复杂度增高，新增一个产品时需要新增对应的工厂和产品类。
  2. 客户端需要知道具体的工厂。（这个和一开始没有使用简单工厂案例有点类似，那个是客户端需要知道具体的产品）

抽象工厂

用于创建一系列相关产品，适用于多个产品系列的情况。

image.png
假设现在新增一个专门管理部门的服务。对应代码如下：

public interface DeptService {
    void insert(Dept dept);

    Dept findById(Integer id);
}

public class MysqlDeptServiceImpl implements DeptService {
    @Override
    public void insert(Dept dept) {
        System.out.println("mysql 插入 dept");
    }

    @Override
    public Dept findById(Integer id) {
        System.out.println("mysql 获取 dept");
        return null;
    }
}

public class OracleDeptServiceImpl implements DeptService {
    @Override
    public void insert(Dept dept) {
        System.out.println("oracle 插入 dept");
    }

    @Override
    public Dept findById(Integer id) {
        System.out.println("oracle 获取 dept");
        return null;
    }
}

public interface UserService {
    void insert(User user);

    User findById(Integer id);
}

public class MysqlUserServiceImpl implements UserService {
    @Override
    public void insert(User user) {
        System.out.println("mysql 插入 user");
    }

    @Override
    public User findById(Integer id) {
        System.out.println("mysql 获取 user");
        return null;
    }
}


public class OracleUserServiceImpl implements UserService {
    @Override
    public void insert(User user) {
        System.out.println("oracle 插入 user");
    }

    @Override
    public User findById(Integer id) {
        System.out.println("oracle 获取 user");
        return null;
    }
}


public interface ServiceFactory {

    UserService getUserService();

    DeptService getDeptService();
}

public class MysqlServiceFactory implements ServiceFactory {
    @Override
    public UserService getUserService() {
        // ......这里省略若干代码（在创建对应的产品时，可能有许多前置逻辑代码）
        return new MysqlUserServiceImpl();
    }

    @Override
    public DeptService getDeptService() {
        return new MysqlDeptServiceImpl();
    }
}

public class OracleServiceFactory implements ServiceFactory {
    @Override
    public UserService getUserService() {
        // ......这里省略若干代码（在创建对应的产品时，可能有许多前置逻辑代码）
        return new OracleUserServiceImpl();
    }

    @Override
    public DeptService getDeptService() {
        return new OracleDeptServiceImpl();
    }
}

public class Client {
    public static void main(String[] args) {

        ServiceFactory serviceFactory = new OracleServiceFactory();
        UserService userService = serviceFactory.getUserService();
        DeptService deptService = serviceFactory.getDeptService();

        userService.insert(new User());
        userService.findById(1);

        deptService.insert(new Dept());
        deptService.findById(1);

    }
}

抽象工厂主要管理的是一系列的产品，比如这里基于Mysql的MysqlDeptServiceImpl和MysqlUserServiceImpl就是属于同一系列的产品。
抽象工厂这样做的好处：

  1. 便于切换产品的系列，可以避免依赖导致的错误。假设没有抽象工厂，那你正好使用了基于mysql的MysqlUserServiceImpl和基于oracle的OracleDeptServiceImpl，两个service之间存在某种依赖，会因为数据库的不同可能导致某些错误。
  2. 客户端不需要知道具体的产品。对于客户端来说，只知道是UserService，不需要知道是MysqlUserServiceImpl还是OracleUserServiceImpl

弊端：

  1. 新增产品复杂度变高。假设现在需要增加一个role表，需要创建RoleService、MysqlRoleServiceImpl、OracleRoleServiceImpl。需要改动ServiceFactory、MysqlServiceFactory、OracleServiceFactory。才能实现
  2. 客户端多时，切换产品系列复杂。假设现在有100个客户端，都使用的是ServiceFactory serviceFactory = new OracleServiceFactory();现在要改成Mysql的，那么就要修改100行代码为 ServiceFactory serviceFactory = new MysqlServiceFactory();

简单工厂+反射优化抽象工厂

public interface DeptService {
    void insert(Dept dept);

    Dept findById(Integer id);
}

public class OracleDeptServiceImpl implements DeptService {
    @Override
    public void insert(Dept dept) {
        System.out.println("oracle 插入 dept");
    }

    @Override
    public Dept findById(Integer id) {
        System.out.println("oracle 获取 dept");
        return null;
    }
}


public class MysqlDeptServiceImpl implements DeptService {
    @Override
    public void insert(Dept dept) {
        System.out.println("mysql 插入 dept");
    }

    @Override
    public Dept findById(Integer id) {
        System.out.println("mysql 获取 dept");
        return null;
    }
}

public interface UserService {
    void insert(User user);

    User findById(Integer id);
}

public class OracleUserServiceImpl implements UserService {
    @Override
    public void insert(User user) {
        System.out.println("oracle 插入 user");
    }

    @Override
    public User findById(Integer id) {
        System.out.println("oracle 获取 user");
        return null;
    }
}

public class MysqlUserServiceImpl implements UserService {
    @Override
    public void insert(User user) {
        System.out.println("mysql 插入 user");
    }

    @Override
    public User findById(Integer id) {
        System.out.println("mysql 获取 user");
        return null;
    }
}

public class ServiceFactory {

    private final static String dataType = "Oracle";
    private final static String packedPath = "org.aqiu.design1.demo4";

    public static UserService getUserService() throws Exception {
        return (UserService) Class.forName(packedPath + "."  + dataType + "UserServiceImpl").newInstance();
    }

    public static DeptService getDeptService() throws Exception {
        return (DeptService) Class.forName(packedPath + "."  + dataType + "DeptServiceImpl").newInstance();
    }
}

public class Client {
    public static void main(String[] args) throws Exception {
        UserService userService = ServiceFactory.getUserService();
        DeptService deptService = ServiceFactory.getDeptService();
        userService.insert(new User());
        userService.findById(1);

        deptService.insert(new Dept());
        deptService.findById(1);
    }
}

优化后的代码，去掉了抽象工厂和具体工厂。现在只有一个简单工厂，利用反射机制，复杂不同产品的创建，同时保持了抽象工厂的特点（能够管理一系列产品）。
这样解决了抽象工厂的弊端：

  1. 解决新增产品复杂度变高。现在新增产品，只要创建RoleService、MysqlRoleServiceImpl、OracleRoleServiceImpl，改一下ServiceFactory类，就能实现。
  2. 解决客户端多时，切换产品系列复杂。现在只要修改ServiceFactory类的属性dataType，就能让任意多的客户端从使用mysql改为使用oracle。甚至我们可以编写一个配置文件，让这个字段的值从配置文件中读取。
@阿秋
关注
专栏目录
设计模式 - 抽象工厂模式
菜鸟小码的博客
08-08 1746
抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。这种模式特别适用于需要创建一系列相关产品的情况，而且这些产品的具体实现可能会随着环境的不同而改变。本文将详细介绍抽象工厂模式的概念，并通过具体的Java代码示例来说明如何实现这一模式。
【PHP设计模式03】抽象工厂模式
李维山的博客
02-23 348
前面讲的工厂方法模式，每增加一个产品都需要增加对应的工厂，这样就会存在很多工厂，但是在现实生活中的有些时候，人们并不关心产品是由哪个工厂制造的，就像一个服装厂既可以生产男装，也可以生产女装，我们只需造一个服装厂同时生产一个。抽象工厂模式，则为一个产品族提供了统一的创建接口，当需要这个产品族的一系列相关对象时，就可以为此系列的产品族创建一个具体的工厂类来实现该接口。示例：下面以一个服装厂生成衣服为例，服装厂有两个分厂，分别负责生产男装和女装，每增加一个产品都需要增加对应的工厂。
简单工厂模式、工厂模式、抽象工厂模式和加入反射、配置优化后的抽象工厂模式之间的关系和区别
clover_oreo的博客
11-17 404
工厂方法模式（Factory Method），定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。简单工厂模式和改进版抽象工厂（简单+抽象）都存在不符合开闭原则的问题，而。多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。一个抽象产品类，可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。一个抽象工厂类，可以派生出多个具体工厂类。
C++设计模式--＞工厂模式篇（简单工厂模式、工厂模式、抽象工厂模式）
weixin_71511408的博客
10-20 747
1.定义：将工厂变成一个抽象类，在里面定义一个纯虚函数，具体生成了什么产品交给子类继承去决定（抽象产品类->具体产品类->抽象工厂类->具体工厂类）2.作用：封装函数的创建，解决new耦合的问题（解耦）3.使用场景：用来生产同一等级结构中的固定产品。（支持增加任意产品）4.实例：水果例子；数据库访问；5.优点： 当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体工厂对象，原有工厂对象不需要进行任何修改，符合开闭原则。6.缺点： 每增加一个产品就要增加一个产品工厂的类，增加了额外的开发量。
Spring常用设计模式--抽象工厂模式
热门推荐
想着百万年薪努力的小赵
03-15 3万+
本专栏内容参考自：咕泡学院Tom老师的《Spring5核心原理与30个类手写实战》，仅作个人学习记录使用，如有侵权，联系速删。   抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口，无需指定他们的具体类。客户端（应用层）不依赖于产品实体类如何被创建、如何被实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。   看抽象工厂模式之前，我们要了解两个概念：产品等级结构和产品族.
工厂模式：抽象工厂模式 C++代码实现、场景及优缺点
十年以上编程经验的干货分享
12-06 1472
抽象工厂模式是一种创建型模式，用于提供一个接口以创建一系列相关或相互依赖的对象，而无需指定它们的具体类。在这个流程图中，Client类通过接口创建和对象。接口定义了创建产品的方法，而具体的工厂类实现了这些方法。每个具体的工厂类可以创建一系列相关的产品，比如和，或者和。这个流程图展示了抽象工厂模式的基本结构，通过抽象工厂和抽象产品的定义，可以方便地扩展新的产品系列，并且客户端代码可以方便地切换不同的产品系列。
Android设计模式——工厂模式和抽象工厂模式
2401_84519718的博客
04-30 264
针对Android程序员，我这边给大家整理了一些资料，包括不限于高级UI、性能优化、架构师课程、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！Android前沿技术大纲全套体系化高级架构视频Android高级架构资料、源码、笔记、视频。
设计模式之简单工厂、工厂方法模式、抽象工厂模式解析
weixin_45538589的博客
08-10 229
设计模式之工厂模式 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录设计模式之工厂模式前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内
简单工厂模式、工厂方法模式、抽象工厂模式 之间的对比
墨鱼菜鸡
12-18 148
先看各自的结构： 简单工厂模式(SimpleFactory Mode)： 简单工厂模式的思路是，首先我们把一些共性的东西(算法)拿出来，进行抽象，比如加减乘除。然后我们在定义一个类作为工厂类，工厂类的作用就是根据传过来的字符串或者其他Key值给返回一个相对应的算法的实体。 优点： 方便...
设计模式-简单工厂模式、工厂模式、抽象工厂模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
10-26 756
是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们的具体类。客户端(应用层)不依赖于产品类实例如何被创建、如何被实现等细节，强调的是一系列相关的产品对象(属于同一个产品族)一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。
代理设计模式
2301_80220193的博客
10-14 1342
二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。它是一种设计模式，用于在不修改原始对象的情况下，通过代理对象来间接访问原始对象，并在访问前后执行额外的操作。
设计模式02-桥接模式(Java)
XYX_888的博客
10-13 535
它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。在使用关联关系是，及在抽象类引入实现类接口时可能会出现不适配的情况，这是可以用适配器类型将其转换成抽象类可以适配的类进行关联。扩展抽象化角色 ：是抽象化角色的子类，实现父类中的业务方法， 并通过组合关系调用实现化角色中的业务方法。实现化角色 ：定义实现化角色的接口，供扩展抽象化角色调用。抽象化角色 ：定义抽象类，并包含一个对实现化对象的引用。具体实现化角色 ：给出实现化角色接口的具体实现。实现了对抽象和实现之间的解耦。
【UML】一个UML学习的还不错的几个帖子
最新发布
qq_36634055的博客
10-16 296
https://segmentfault.com/a/1190000042775634
组合模式（C++）
麦克·唐
10-12 293
组合模式（Composite Pattern）是一种结构型设计模式，它将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。文件和文件夹可以看作是一种树形结构，文件夹可以包含文件和子文件夹，而文件则不包含其他对象。使用组合模式可以方便地遍历文件系统。
设计模式03-装饰模式(Java)
XYX_888的博客
10-13 473
不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。
【GeekBand】C++设计模式笔记8_Factory Method_工厂方法
qq_38154295的博客
10-13 467
【GeekBand】C++设计模式笔记8_Factory Method_工厂方法
发布-订阅模式（Publisher-Subscriber）
Zhen0831的博客
10-12 441
但是经过时间的沉淀，似乎他已经强大了起来，已经独立于观察者模式，成为另外一种不同的设计模式。在现在的发布订阅模式中，称为发布者的消息发送者不会将消息直接发送给订阅者，这意味着发布者和订阅者不知道彼此的存在。在发布者和订阅者之间存在第三个组件，称为消息代理或调度中心或中间件，它维持着发布者和订阅者之间的联系，过滤所有发布者传入的消息并相应地分发它们给订阅者。实际上，发布-订阅模式只是观察者模式的一个别称。
建造者模式（C++）
麦克·唐
10-13 372
建造者模式（Builder Pattern）是一种创建型设计模式，它主要用于构建一个复杂对象，并将其构建过程与表示分离，使得同样的构建过程可以创建不同的表示。该模式通过将复杂对象的构建过程分解为多个简单的步骤，每个步骤由独立的建造者对象负责，从而实现了构建过程的可控性和灵活性。
工厂模式详解：简单工厂、抽象工厂与工厂方法
"这篇资源主要介绍了工厂模式的三种类型——简单工厂、抽象工厂和工厂方法，以及它们在不同场景下的应用、优缺点和适用条件。" 在软件设计中，工厂模式是一种常用的设计模式，用于封装对象的创建过程，使得客户端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值