[大话设计模式C++版] 第15章 就不能不换DB吗？ —— 抽象工厂模式

最新推荐文章于 2022-12-13 23:12:57 发布
最新推荐文章于 2022-12-13 23:12:57 发布
阅读量428 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 数据库 设计模式 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40743639/article/details/127353391
版权

源码可以在这里找到 大话设计模式C++版

最基本的数据访问程序

//User.h
#include <QString>

class User
{
private:
    int m_id;
    QString m_name;

public:
    int getId() {
        return m_id;
    }
    void setId(int id) {
        m_id = id;
    }
    QString getName() {
        return m_name;
    }
    void setName(QString name) {
        m_name = name;
    }
};

//SqlserverUser.h
#pragma execution_character_set("utf-8")
#include "User.h"
#include <memory>
#include <QDebug>
using namespace std;

class SqlserverUser
{
public:
    void insertUser(shared_ptr<User> user) {
        qDebug() << "在SQL Server中给User表增加一条记录";
    }
    shared_ptr<User> getUser(int id) {
        qDebug() << "在SQL Server中根据ID得到User表一条记录";
        return nullptr;
    }
};

//main.cpp
#include "User.h"
#include "SqlserverUser.h"

int main(int argc, char *argv[])
{
    auto user = shared_ptr<User>(new User());
    auto su = shared_ptr<SqlserverUser>(new SqlserverUser());  //与SQL Server耦合
    su->insertUser(user);  //插入用户
    su->getUser(1);  //得到ID为1的用户

    return 0;
}

运行结果：

在SQL Server中给User表增加一条记录
在SQL Server中根据ID得到User表一条记录

问题：这里之所以不能换数据库，原因就在于 auto su = shared_ptr<SqlserverUser>(new SqlserverUser()); 使得su这个对象被框死在 SQL Server 上了。如果这里是灵活的，多态的，那么在执行 su->insertUser(user); 和 su->getUser(1); 时就不用考虑是在用 SQL Server 还是 Access 了。

解决方案：用 工厂方法模式 来封装 new SqlserverUser() 所造成的变化，工厂方法模式是定义一个用于创建对象的接口，让子类决定实例化哪一个类。

用了工厂方法模式的数据访问程序

在这里插入图片描述

//IUser.h 用户接口类，用于客户端访问，解除与具体数据库访问的耦合
#include "User.h"
#include <memory>
using namespace std;

class IUser
{
public:
    IUser();
    virtual void insertUser(shared_ptr<User> user) = 0;
    virtual shared_ptr<User> getUser(int id) = 0;
};

//SqlserverUser.h 具体数据库类
#pragma execution_character_set("utf-8")
#include "IUser.h"
#include <QDebug>

using namespace std;

class SqlserverUser : public IUser
{
public:
    virtual void insertUser(shared_ptr<User> user) override {
        qDebug() << "在SQL Server中给User表增加一条记录";
    }
    virtual shared_ptr<User> getUser(int id) override {
        qDebug() << "在SQL Server中根据ID得到User表一条记录";
        return nullptr;
    }
};

//AccessUser.h 具体数据库类
#pragma execution_character_set("utf-8")
#include "IUser.h"
#include <QDebug>

using namespace std;

class AccessUser : public IUser
{
public:
    virtual void insertUser(shared_ptr<User> user) override {
        qDebug() << "在Access中给User表增加一条记录";
    }
    virtual shared_ptr<User> getUser(int id) override {
        qDebug() << "在Access中根据ID得到User表一条记录";
        return nullptr;
    }
};

//IFactory.h 抽象工厂接口
#include "IUser.h"

class IFactory
{
public:
    virtual shared_ptr<IUser> createUser() = 0;
};

//SqlServerFactory.h 具体工厂类
#include "IFactory.h"

class SqlServerFactory : public IFactory
{
public:
    virtual shared_ptr<IUser> createUser() override {
        return shared_ptr<IUser>(new SqlserverUser());
    }
};

//AccessFactory.h 具体工厂类
#include "IFactory.h"

class AccessFactory : public IFactory
{
public:
    virtual shared_ptr<IUser> createUser() override {
        return shared_ptr<IUser>(new AccessUser());
    }
};

//main.cpp 客户端代码
#include "User.h"
#include "IFactory.h"
#include "SqlServerFactory.h"

int main(int argc, char *argv[])
{
    shared_ptr<User> user = shared_ptr<User>(new User());
    //若要更改成Access数据库，只需要将本句改成shared_ptr<AccessFactory>(new AccessFactory());
    shared_ptr<IFactory> factory = shared_ptr<SqlServerFactory>(new SqlServerFactory());
    auto iu = factory->createUser();
    iu->insertUser(user);
    iu->getUser(1);

    return 0;
}

现在如果要换数据库，只需更换 SqlServerFactory类 为 AccessFactory类 就可以了。但是数据库里通常不会只有一个 User表 ，如果要增加部门表 Department表 ，怎么办？

用了抽象工厂模式的数据访问程序

在这里插入图片描述

//Department.h 
#include <QString>

class Department
{
private:
    int m_id;
    QString m_name;

public:
    int getId() {
        return m_id;
    }
    void setId(int id) {
        m_id = id;
    }
    QString getName() {
        return m_name;
    }
    void setName(QString name) {
        m_name = name;
    }
};

//IDepartment.h 部门接口类，用于客户端访问，解除与具体数据库访问的耦合
#include "Department.h"
#include <memory>
using namespace std;

class IDepartment
{
public:
    virtual void insertDepartment(shared_ptr<Department> department) = 0;
    virtual shared_ptr<Department> getDepartment(int id) = 0;
};

//SqlserverDepartment.h
#pragma execution_character_set("utf-8")
#include "IDepartment.h"
#include <QDebug>

class SqlserverDepartment : public IDepartment
{
public:
    virtual void insertDepartment(shared_ptr<Department> department) override {
        qDebug() << "在SQL Server中给Department表增加一条记录";
    }
    virtual shared_ptr<Department> getDepartment(int id) override {
        qDebug() << "在SQL Server中根据ID得到Department表一条记录";
        return nullptr;
    }
};

//AccessDepartment.h
#pragma execution_character_set("utf-8")
#include "IDepartment.h"
#include <QDebug>

class AccessDepartment : public IDepartment
{
public:
    virtual void insertDepartment(shared_ptr<Department> department) override {
        qDebug() << "在Access中给Department表增加一条记录";
    }
    virtual shared_ptr<Department> getDepartment(int id) override {
        qDebug() << "在Access中根据ID得到Department表一条记录";
        return nullptr;
    }
};

//IFactory.h 抽象工厂接口
#include "IUser.h"
#include "IDepartment.h"

class IFactory
{
public:
    virtual shared_ptr<IUser> createUser() = 0;
    virtual shared_ptr<IDepartment> createDepartment() = 0;
};

//SqlServerFactory.h
#include "IFactory.h"

class SqlServerFactory : public IFactory
{
public:
    virtual shared_ptr<IUser> createUser() override {
        return shared_ptr<IUser>(new SqlserverUser());
    }
    virtual shared_ptr<IDepartment> createDepartment() override {
        return shared_ptr<IDepartment>(new SqlserverDepartment());
    }
};

//AccessFactory.h
#include "IFactory.h"

class AccessFactory : public IFactory
{
public:
    AccessFactory();
    virtual shared_ptr<IUser> createUser() override {
        return shared_ptr<IUser>(new AccessUser());
    }
    virtual shared_ptr<IDepartment> createDepartment() override {
        return shared_ptr<AccessDepartment>(new AccessDepartment());
    }
};

//main.cpp 客户端代码
#include "User.h"
#include "Department.h"
#include "IFactory.h"
#include "AccessFactory.h"

int main(int argc, char *argv[])
{
    shared_ptr<User> user = shared_ptr<User>(new User());
    shared_ptr<Department> dept = shared_ptr<Department>(new Department());

    shared_ptr<IFactory> factory = shared_ptr<AccessFactory>(new AccessFactory());

    auto iu = factory->createUser();  //此时已与具体的数据库访问解除了依赖
    iu->insertUser(user);
    iu->getUser(1);

    auto id = factory->createDepartment();  //此时已与具体的数据库访问解除了依赖
    id->insertDepartment(dept);
    id->getDepartment(1);

    return 0;
}

运行结果：

在Access中给User表增加一条记录
在Access中根据ID得到User表一条记录
在Access中给Department表增加一条记录
在Access中根据ID得到Department表一条记录

上面就是抽象工厂模式的代码了，大话设计模式中，还用简单工厂对抽象工厂进行改造，并用 反射 代替简单工厂的 switch-case ，这使用 C#语言 是很容易实现的，C++ 原生不支持 反射 ，因此等以后学会 C++反射 之后再来实现这部分的代码。

Abstract Factory抽象工厂模式 [李建忠C++笔记]

  • 通过“对象创建”模式绕开 new ，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
  • 典型模式
    • Factory Method
    • Abstract Factory
    • Prototype
    • Builder

动机（Motivation）

  • 在软件系统中，经常面临着"一系列相互依赖的对象"创建工作；由于需求的变化，需要创建的对象的具体类型经常变化。
  • 如何应对这种变化？如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？
//数据库访问有关的基类
class IDBConnection {};
class IDBCommand {};
class IDBDataReader {};
class IDBFactory {
public:
	virtual IDBConnection* CreateDBConnection() = 0;
	virtual IDBCommand* CreateDBCommand() = 0;
	virtual IDBDataReader* CreateDBDataReader() = 0;
};

//支持SQL Server
class SqlConnection : public IDBConnection {};
class SqlCommand : public IDBCommand {};
class SqlDataReader : public IDBDataReader {};
class SqlFactory : public IDBFactory {
public:
	virtual IDBConnection* CreateDBConnection() override {
		return new SqlConnection();
	}
	virtual IDBCommand* CreateDBCommand() override {
		return new SqlCommand();
	}
	virtual IDBDataReader* CreateDBDataReader() override {
		return new SqlDataReader();
	}
};

//支持Oracle
class OracleConnection : public IDBConnection {};
class OracleCommand : public IDBCommand {};
class OracleDataReader : public IDBDataReader {};

class EmployeeDA0
{
	IDBFactory* dbFactory;
public:
	vector<EmployeeDA0> GetEmployees() {
		IDBConnection* connection = dbFactory->CreateDBConnection();
		connection->ConnectionString("...");
		
		IDBCommand* command = dbFactory->CreateDBCommand();
		command->CommandText("...");
		command->SetConnect(connection);  //关联性
		
		IDBDataReader* reader = command->ExecuteReader();  //关联性
		while (reader->Read()) {
			
		}
	}
};

模式定义

提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。——《设计模式》GoF

在这里插入图片描述

要点总结

  • 如果没有应对“多系列对象构建”的需求变化，则没有必要使用 Abstract Factory 模式，这时候使用简单的工厂完全可以。
  • “系列对象”指的是再某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖。
  • Abstract Factory 模式主要再于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。
一个小黑酱
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
大话设计模式C++实现-第12章-外观模式
西青年·部落格
12-17 1745
一、UML图 二、概念 外观模式：为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。 三、说明 Q：外观模式在什么时候使用呢？ A：分为三个阶段： （1）首先，在设计初期阶段，应该要有意识的将不同的两个层分离。 （2）第二，在开发阶段，子系统往往因为不断的重构演化而变得越来越复杂，大多数的模式使用时也会产生很
Python设计模式之抽象工厂模式原理与用法详解
01-20
本文实例讲述了Python设计模式之抽象工厂模式原理与用法。分享给大家供大家参考，具体如下： 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的类 下面是一个...
[大话设计模式C++版] 第8章 雷锋依然在人间 —— 工厂方法模式
weixin_40743639的博客
10-08 280
[大话设计模式C++版] 第8章 雷锋依然在人间 —— 工厂方法模式 李建忠C++设计模式 工厂方法模式笔记
大话设计模式C++版本-09-建造者模式
wkd_007的博客
07-09 206
概述 建造者模式：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 建造者模式其实就是在创建复杂对象时，使用一个Builder类(建造者类)来规范了必要的步骤，并且使用一个Director类(指挥类)来规范建造过程。 应用场景 一些基本部件不会变，而其组合经常变化的时候。例如：画一个小人，小人的基本部件(头、身体、两只手、两只脚)以及画的过程一般都不会变的；而画瘦子或胖子就就需要改变画的方法了。 一般步骤 写一个Builder类来规范必要的步骤，每个步骤都是纯虚函数，所以子类必须重写
Datawhale 大话设计模式
weixin_50899664的博客
12-13 135
设计模式
C#入门经典(第7版)、大话设计模式
忘忧
04-14 788
C#入门经典(第7版) C# 6.0 & Visual Studio 2015 PDF 链接：https://pan.baidu.com/s/14ftp4mgDyw_AtpPqNp1wlw 提取码：8d01 大话设计模式(带目录完整版) 链接：https://pan.baidu.com/s/1qsXk7Mum2CalTuBTwJCz1w 提取码：3zjr
Android之大话设计模式——：抽象工厂模式借鉴.pdf
12-25
Android之大话设计模式——：抽象工厂模式借鉴.pdf
Android之大话设计模式——：抽象工厂模式参考.pdf
12-01
Android之大话设计模式——：抽象工厂模式参考.pdf
【资源免费下载】Java代码积累丨大话设计模式（Java实现版本）、线程协作
10-31
设计模式参考《大话设计模式》 工厂简单模式 创造型模式 工厂方法模式 抽象工厂模式 原型模式 建造者模式 单例模式 结构型模式 队列模式 桥接模式 组合模式 装饰模式 外观模式 享元模式 代理模式 行为模式（类行为...
设计模式之《大话设计模式》.pptx
10-31
设计模式之《大话设计模式》.pptx
设计模式C++版(pdf版)
10-21
设计模式精解－GoF 23种设计模式解析附C++实现源码
《大话设计模式》Java版的实现案例源码.zip
最新发布
02-20
《大话设计模式》Java版的实现案例源码.zip
Android之大话设计模式：抽象工厂模式终稿.pdf
03-15
**抽象工厂模式**是软件设计模式中的一种创建型模式，主要用在需要创建一系列相关或相互依赖的对象，而无需指定它们具体的类时。这个模式的关键在于提供了一个接口，允许客户端在不关心产品具体实现的情况下创建多个...
python3设计模式之简单工厂模式
12-25
在Python3环境下，调试实现了《大话设计模式》中简单工厂模式，通过定义单独的工厂类，完成对具体的产品的实例化,参考链接 具体实现见代码： #!/usr/bin/env python # -*- coding: utf-8 -*- # Date : 2017-10-15 ...
Python设计模式之工厂方法模式实例详解
12-25
本文实例讲述了Python设计模式之工厂方法模式。分享给大家供大家参考，具体如下： 工厂方法模式(Factory Method Pattern):定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延时到其...
大话设计模式C++实现-第23章-命令模式
西青年·部落格
12-23 1412
一、UML图 二、概念 命令模式（Command）：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求进行排队或记录请求日志，以及支持可撤销的操作。 三、说明 角色： （1）Command类：用来声明执行操作的接口。 （2）ConcreteCommand类：将一个接收者对象绑定与一个动作，调用接收者相应的操作，以实现Excute。 （3）
设计模式系列（大话设计模式c++版）——观察者模式
月照大江流的博客
07-16 378
设计模式系列（大话设计模式c++版）——观察者模式模式定义模式特点模式实现 模式定义 让我们来看看《大话设计模式》这本书中对于观察者模式的定义：其又叫发布—订阅模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当这个主题对象在状态发生变化时，会通知所有的观察者对象，是他们可以随之自动更新自己的状态。 其组成大概分为至少4个部分：观察者接口、发布者接口、一般是1个发布者、不止一个的观察者 模式特点 将一个系统分割成一系列相互协作的类，同时又需要维护类间的一致性，观察者模式可以避免各类
大话设计模式学习 C++
南柯一梦的博客
11-11 552
大话设计模式学习的c++练手记录
《大话设计模式》C++实现：02 策略模式（一）商场促销实例-初始版本（switch_case）
qq_29567701的博客
11-18 365
文章目录1. 什么是策略模式？2. 策略模式的适用场景？2.1 优缺点2.1.1 好处2.1.2 当心2.2 何时使用？3. 怎样使用策略模式？3.1 方法3.2 UML类图演进3.2.1 version1 （本篇博文的demo）4. 实例4.1 结果（结论先行）4.2 具体实现5. 策略模式-相关链接 1. 什么是策略模式？ 策略模式（strategy）：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。 2. 策略模式的适用场景？ 2.1 优缺点 2.
大话设计模式 c++
09-13
其中创建型模式包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、原型模式和建造者模式；结构型模式包括适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式和享元模式；行为型模式包括策略...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值