概述

描述

又称为工厂模式，也叫虚拟构造器(Virtual Constructor)模式，或者多态工厂(Polymorphic Factory)模式
工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

套路

创建抽象产品类 ；
创建具体产品类，继承抽象产品类；
创建抽象工厂类
创建工厂类，继承抽象工厂类，定义具体产品类的创建方法；
通过调用具体工厂类的方法，从而创建不同具体产品类的实例

使用场景

当一个类不知道它所需要的对象的类时。使用者无需知道具体产品类的类名，只需要知道所对应的工厂即可；
当一个类希望通过其子类来指定创建对象时。由子类来创建具体产品

优缺点

优点
- 将创建实例的工作与使用实例的工作分开，实现了解耦；
- 用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。
- 加入新产品时，无须修改抽象工厂和抽象产品提供的接口，只要添加一个具体工厂和具体产品就可以了。这样更符合“开闭原则”。
缺点
- 在添加新产品时，需要编写新的具体产品类和工厂类，在一定程度上增加了系统的复杂度，
- 引入抽象层，增加了系统的抽象性和理解难度
- 一个具体工厂只能创建一种具体产品

UE4 中的工厂方法实践

自定义工厂模式实践

创建产品抽象类和产品具体类

// 产品抽象类

UCLASS(Abstract)

class DESIGNPATTERNS_API UProductObject : public UObject

{

	GENERATED_BODY()

public:

	virtual void ShowInfo() { check(0 && "You must override this");  }

};

// 产品具体类A

UCLASS()

class DESIGNPATTERNS_API UProductA : public UProductObject

{

	GENERATED_BODY()

public:

	virtual void ShowInfo() override {

		UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__" This is a ProductA"));

	}

};

// 产品具体类B

UCLASS()

class DESIGNPATTERNS_API UProductB : public UProductObject

{

	GENERATED_BODY()

public:

	virtual void ShowInfo() override {

		UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__" This is a ProductB"));

	}

};

创建工厂抽象类和工厂具体类

// 工厂抽象类

UCLASS(Abstract)

class DESIGNPATTERNS_API UFactoryObject : public UObject

{

	GENERATED_BODY()

public:

	virtual UProductObject* CreateNewProduct() {

		check(0 && "You must override this");

		return nullptr;

	}

};

// 工厂具体类A

UCLASS(Blueprintable,BlueprintType)

class DESIGNPATTERNS_API UFactoryA : public UFactoryObject

{

	GENERATED_BODY()

public:

	virtual UProductObject* CreateNewProduct() override {

		return NewObject<UProductA>();

	}

};

// 工厂具体类B

UCLASS(Blueprintable, BlueprintType)

class DESIGNPATTERNS_API UFactoryB : public UFactoryObject

{

	GENERATED_BODY()

public:

	virtual UProductObject* CreateNewProduct() override {

		return NewObject<UProductB>();

	}

};

调用

// 调用测试用的Actor

UCLASS()

class DESIGNPATTERNS_API AFactoryActor : public AActor

{

	GENERATED_BODY()

public:

	UPROPERTY()

		UFactoryA* FactoryA;

	UPROPERTY()

		UFactoryB* FactoryB;

	void BeginPlay() override {

		// A 工厂生成 A 产品

		FactoryA = NewObject<UFactoryA>();

		UProductObject* ProductA = FactoryA->CreateNewProduct();

		ProductA->ShowInfo();

		// B 工厂生成 B 产品

		FactoryB = NewObject<UFactoryB>();

		UProductObject* ProductB = FactoryB->CreateNewProduct();

		ProductB->ShowInfo();

	}

};

调式输出

LogTemp: Warning: UProductA::ShowInfo This is a ProductA

LogTemp: Warning: UProductB::ShowInfo This is a ProductB

引擎自带工厂方法模式——自定义资源创建

继承 UObject 自定义资产类

UCLASS(Blueprintable, BlueprintType)

class DESIGNPATTERNS_API UCustomAsset : public UObject

{

	GENERATED_BODY()

public:

	UPROPERTY(EditAnywhere)

		FString ProductName;

};

继承 UFactory 的工厂类

SupportedClass 指定资产类
FactoryCreatNew 重载资产类实例化

【UE4 设计模式】工厂方法模式 Factory Method Pattern 及自定义创建资源

UCLASS()

class DESIGNPATTERNS_API UUEDefaultFactory : public UFactory

{

	GENERATED_UCLASS_BODY()

public:

	virtual UObject* FactoryCreateNew(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, FFeedbackContext* Warn) override;

	//virtual uint32 GetMenuCategories() const override; //4.25以前

};

UUEDefaultFactory::UUEDefaultFactory(const class FObjectInitializer& ObjectInitializer)

	: Super(ObjectInitializer)

{

	bCreateNew = true;

	bEditAfterNew = true;

	SupportedClass = UCustomAsset::StaticClass();

}

UObject* UUEDefaultFactory::FactoryCreateNew(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, FFeedbackContext* Warn)

{

	auto newProduct = NewObject<UCustomAsset>(InParent, InClass, InName, Flags);

	return newProduct;

}

//uint32 UUEDefaultFactory::GetMenuCategories() const

//{

	//return EAssetTypeCategories::Misc;

//}

自定义模块，并添加到工程中

项目目录

DesignPatterns

	└─ Source

	       ├─ DesignPatterns

	       │    ├─ DesignPatterns.Build.cs

	       │    ├─ DesignPatterns.cpp

	       │    ├─ DesignPatterns.h

	       │    ├─ DesignPatternsGameModeBase.cpp

	       │    ├─ DesignPatternsGameModeBase.h

	       │    └─ Patterns_Factory

	       │         ├─ FactoryObject.cpp

	       │         ├─ FactoryObject.h

	       │         ├─ ProductObject.cpp

	       │         ├─ ProductObject.h

	       │         ├─ UEDefaultFactory.cpp

	       │         └─ UEDefaultFactory.h

	       ├─ DesignPatternsEditor

	       │    ├─ DesignPatternsEditor.Build.cs

	       │    ├─ DesignPatternsEditor.cpp

	       │    └─ DesignPatternsEditor.h

	       ├─ DesignPatterns.Target.cs

	       └─ DesignPatternsEditor.Target.cs

添加 DesignPatternsEditor 模块

在Source目录下，分别添加 DesignPatternsEditor.Build.cs 、DesignPatternsEditor.cpp 、DesignPatternsEditor.h 三个文件

DesignPatternsEditor.Build.cs

using UnrealBuildTool;

public class DesignPatternsEditor : ModuleRules

{

	public DesignPatternsEditor(ReadOnlyTargetRules Target) : base(Target)

	{

		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;

		PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "UnrealEd", "DesignPatterns"});

		PrivateDependencyModuleNames.AddRange(new string[] {  });

		// Uncomment if you are using Slate UI

		PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });

		// Uncomment if you are using online features

		// PrivateDependencyModuleNames.Add("OnlineSubsystem");

		// To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true

	}

}

DesignPatternsEditor.h

4.25开始需要自定义 AssetTypeActions（继承自 FAssetTypeActions_Base），才可以在编辑器中找到

#pragma once

#include "CoreMinimal.h"

#include "AssetTypeActions_Base.h"

#include "DesignPatterns/Patterns_Factory/FactoryObject.h"

class FDesignPatternsEditorModule : public IModuleInterface

{

public:

	/** IModuleInterface implementation */

	virtual void StartupModule() override;

	virtual void ShutdownModule() override;

};

class FAssetTypeActions_CustomAsset : public FAssetTypeActions_Base

{

public:

	FAssetTypeActions_CustomAsset(){}

	FAssetTypeActions_CustomAsset(EAssetTypeCategories::Type InAssetCategory);

	virtual FColor GetTypeColor() const override { return FColor(97, 85, 212); }

	virtual void OpenAssetEditor(const TArray<UObject*>& InObjects, TSharedPtr<class IToolkitHost> EditWithinLevelEditor = TSharedPtr<IToolkitHost>()) override;

	// IAssetTypeActions Implementation

	virtual FText GetName() const override { return FText::FromName(TEXT("Custom Asset")); }

	virtual UClass* GetSupportedClass() const override { return UCustomAsset::StaticClass(); }

	virtual uint32 GetCategories() override { return MyAssetCategory; }

private:

	EAssetTypeCategories::Type MyAssetCategory;

};

DesignPatternsEditor.cpp

// Copyright Epic Games, Inc. All Rights Reserved.

#include "DesignPatternsEditor.h"

#include "Modules/ModuleManager.h"

#include "IAssetTools.h"

#include "AssetToolsModule.h"

#define LOCTEXT_NAMESPACE "FDesignPatternsEditorModule"

void FDesignPatternsEditorModule::StartupModule()

{

	IAssetTools& AssetTools = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools").Get();

	//定义资产的分类名

	EAssetTypeCategories::Type AssetCategory = AssetTools.RegisterAdvancedAssetCategory(FName(TEXT("CustomKey")), FText::FromName(TEXT("CustomCategory")));

	TSharedPtr<FAssetTypeActions_CustomAsset> actionType = MakeShareable(new FAssetTypeActions_CustomAsset(AssetCategory));

	AssetTools.RegisterAssetTypeActions(actionType.ToSharedRef());

}

void FDesignPatternsEditorModule::ShutdownModule()

{

	if (FModuleManager::Get().IsModuleLoaded("AssetTools"))

	{

		IAssetTools& AssetTools = FModuleManager::Get().GetModuleChecked<FAssetToolsModule>("AssetTools").Get();

		AssetTools.UnregisterAssetTypeActions(MakeShareable(new FAssetTypeActions_CustomAsset));

	}

}

FAssetTypeActions_CustomAsset::FAssetTypeActions_CustomAsset(EAssetTypeCategories::Type InAssetCategory)

{

	MyAssetCategory = InAssetCategory;

}

void FAssetTypeActions_CustomAsset::OpenAssetEditor(const TArray<UObject*>& InObjects, TSharedPtr<class IToolkitHost> EditWithinLevelEditor /*= TSharedPtr<IToolkitHost>()*/)

{

	FSimpleAssetEditor::CreateEditor(EToolkitMode::Standalone, EditWithinLevelEditor, InObjects);

}

#undef LOCTEXT_NAMESPACE

IMPLEMENT_MODULE(FDesignPatternsEditorModule, DesignPatternsEditor);

将模块加入到 项目名.uproject 中

{

	"EngineAssociation": "4.26",

	"Modules": [

		...,

		{

			"Name": "DesignPatternsEditor",

			"Type": "Editor",

			"LoadingPhase": "Default",

			"AdditionalDependencies": [

				"Engine",

				"CoreUObject",

				"Slate",

				"SlateCore",

				"UnrealEd"

			]

		}

	]

}

将模块加入到 项目名.Target.cs 中

using UnrealBuildTool;

using System.Collections.Generic;

public class DesignPatternsEditorTarget : TargetRules

{

	public DesignPatternsEditorTarget( TargetInfo Target) : base(Target)

	{

		Type = TargetType.Editor;

		DefaultBuildSettings = BuildSettingsVersion.V2;

		ExtraModuleNames.AddRange( new string[] { "DesignPatterns", "DesignPatternsEditor" } );

	}

}

测试结果

秒客网

【UE4 设计模式】工厂方法模式 Factory Method Pattern 及自定义创建资源

概述

描述

套路

使用场景

优缺点

UE4 中的工厂方法实践

引擎自带工厂方法模式——自定义资源创建

参考

相关文章