工厂方法模式

工厂方法模式

简单工厂模式

• 缺点：只能创建单一类型的对象，而不是不同类型的类对象
• 需要使用switch case类工厂代码还需要修改，不是扩展而是修改

• 假设我们需要实现一些不同的爬虫类，比如 TextSpider 、 ImageSpider 等等，它们都需要继承自一个 Spider 抽象基类。这里我们可以定义一个简单工厂来实例化具体的爬虫：

enum class SPIDERTYPE {
	TEXT,
	IMAGE,
};

class SpiderFactory {
 public:
    static shared_ptr<Spider> CreateSpider(SPIDERTYPE type) {
        switch(type) {
            case SPIDERTYPE::TEXT: return make_shared<TextSpider>();
            case SPIDERTYPE::IMAGE: return make_shared<ImageSpider>();
        }
    }
};

但这种简单工厂模式也有它的问题，那就是在添加新的爬虫类型的时候，还是需要在 switch 语句中添加新的 case ，这部分代码还需要更改。
这段代码就是使用抽象工厂中介来实现一个具体对象

工厂模式

希望一个类不希望被修改而只是被扩充，则将该类进行抽象，降低强依赖被其他的类使用。

为了解决前面的问题，工厂方法模式抽象了类工厂，用户只需要和具体的类工厂交互即可：

class MySpider {
 public:
    virtual void Crawl() = 0;
};
class SpiderFactory {
 public:
    virtual shared_ptr<MySpider> CreateMySpider() = 0;
};

这样一来，在定义新的爬虫类的时候，只需要：

class MyTextImageSpiderFactory: public SpiderFactory {
	//...
};

class MyTextTextSpider: public MySpider {
	//...
};
class MyTextImageSpider: public MySpider {
	//...
};

总体代码

总体代码

//MySpider.h
#pragmaMySpider.h once
#include <memory>
using namespace std;
class MySpider
{
public:
	virtual void Crawl() = 0;
};

class MySpiderFactory
{
public:
	virtual shared_ptr< MySpider> CreateMySpider() = 0;
};

//MyTextImageSpider.h 
#pragma once
#include "MySpider.h"
#include <iostream>
using namespace std;

class MyTextImageSpider :
    public MySpider
{
public:
	virtual void Crawl()
	{
		cout << "MyTextImageSpider::Crawl" << endl;
	}
};


class MyTextImageSpiderFactory: public MySpiderFactory
{
public:
	virtual shared_ptr< MySpider> CreateMySpider()
	{
		return make_shared< MyTextImageSpider>();
	}
};

/ OOPDPFactorys0.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;

#include "MyTextImageSpider.h"

enum class SPIDERTYPE
{
	TEXT,
	IMAGE,
	VIDEO
};
// 文字信息、图片信息和视频信息
class Spider
{
public:
	virtual void Crawl() = 0;
};

class TextSpider :public Spider
{
public:
	virtual void Crawl()
	{
		cout << "TextSpider::Crawl" << endl;
	}
};


class ImageSpider :public Spider
{
public:
	virtual void Crawl()
	{
		cout << "ImageTextSpider:Crawl" << endl;
	}
};

class VideoSpider :public Spider
{
public:
	virtual void Crawl()
	{
		cout << "VideoSpider::Crawl" << endl;
	}
};

class SpiderFactory
{
public:
	static shared_ptr<Spider> CreateSpyder(SPIDERTYPE type)
	{
		switch (type)
		{
		case SPIDERTYPE::TEXT:
			return make_shared<TextSpider>();
		case SPIDERTYPE::IMAGE:
			return make_shared<ImageSpider>();
		case SPIDERTYPE::VIDEO:
			return make_shared<VideoSpider>();
		default:
			return nullptr;
		}
	}
};

int main()
{
	//TextSpider s;
	//s.Crawl();

	// Simple Factory Model
	SpiderFactory::CreateSpyder(SPIDERTYPE::IMAGE)->Crawl();
	SpiderFactory::CreateSpyder(SPIDERTYPE::VIDEO)->Crawl();

	// Factory Method 
	// TextImageFactory and TextImageSpider
	shared_ptr< MySpiderFactory> textImageFactory = make_shared< MyTextImageSpiderFactory>();
	shared_ptr< MySpider> myTextImageSpider = textImageFactory->CreateMySpider();
	myTextImageSpider->Crawl();
}