标签: factory-pattern

我创建了一个工厂和一组规范来创建和验证聚合根.目前我对工厂进行了一些测试,这些测试称工厂的产品规格,但我想知道这是否足够.从设计的角度来看,将工厂与其产品的规格相结合可能会更好,因为它们密切相关.

如果聚合根产品的规范用于验证而不是用于创建,那么从工厂内部调用它是否有意义？

或者单位测试是否足够好？

这让我困扰了一段时间,如果这是一个神话,我没有任何线索.

似乎工厂模式可以减轻为类添加依赖项的痛苦.

例如,在一本书中,它有类似的东西

假设您有一个名为Order的类.最初它并不依赖于任何东西.因此,您不必费心使用工厂来创建Order对象,而您只是使用plain new来实例化对象.但是,您现在要求必须与客户关联创建订单.您需要更改百万个位置才能添加此额外参数.如果您只为Order类定义了一个工厂,那么您可以在没有同样痛苦的情况下满足新要求.

这与为构造函数添加额外参数有何不同？我的意思是你仍然需要为工厂提供一个额外的论据,而且还有百万个地方使用,对吗？

我有2个案例,一个方法可以被认为是一个工厂设计模式,这个例子是在C#,altought,可以应用于其他编程语言:

enum NinjaTypes {
  Generic,
  Katanna,
  StarThrower,
  Invisible,
  Flyer
}

public class Ninja {
  public string Name { get; set; }
  public void jump() { ... }
  public void kickAss() { ... }
}

public class KatannaNinja: Ninja {
  public void useKatanna() { ... }
}

public class StarNinja: Ninja {
  public void throwStar() { ... }
}

public class InvisibleNinja: Ninja {
  public void becomeInvisible() {...}
  public void becomeVisible() {...}
}

public class FlyNinja: Ninja {
  public void fly() …

我如何能够重写以下实用程序类以获取特定类型的所有类字符串值 - 使用如下所示的Objective-c运行时函数？

ARC文档明确指出应该避免realloc,并且我在这一行上也遇到以下编译器错误:

classList = realloc(classList, sizeof(Class) * numClasses);

"使用ARC不允许将非Objective-C指针类型'void*'隐式转换为'__unsafe_unretained Class*'"

以下代码是对原始文章的引用,可在此处找到.

+ (NSArray *)classStringsForClassesOfType:(Class)filterType {

    int numClasses = 0, newNumClasses = objc_getClassList(NULL, 0);
    Class *classList = NULL;

    while (numClasses < newNumClasses) {
        numClasses = newNumClasses;
        classList = realloc(classList, sizeof(Class) * numClasses);
        newNumClasses = objc_getClassList(classList, numClasses);
    }

    NSMutableArray *classesArray = [NSMutableArray array];

    for (int i = 0; i < numClasses; i++) {
        Class superClass = classList[i];
        do {
            superClass = class_getSuperclass(superClass);
            if (superClass == filterType) {
                [classesArray …

我想创建以下策略模式与Factory结合,但我希望它是类型安全的.到目前为止我做了以下事情:

public interface Parser<T> {

    public Collection<T> parse(ResultSet resultSet);

}


public class AParser implements Parser<String> {

    @Override
    public Collection<String> parse(ResultSet resultSet) {
             //perform parsing, get collection
        Collection<String> cl = performParsing(resultSet); //local private method
        return cl;
    }
}

public class ParserFactory {

    public enum ParserType {
        APARSER
    }


    public static <T> Parser<T> createParser(ParserType parserType) {


        Parser<?> parser = null;
        switch (parserType) {
        case APARSER:
            parser = new AParser();
            break;
        }
            //unchecked cast happens here
        return (Parser<T>) parser;
    }
}


public class …

我知道有很多关于不同工厂模式的差异的问题,但答案是如此不同和令人困惑.我读过的书籍使用不清楚和(简化)简化的例子.即使在阅读维基百科的解释之后,我也有很多问题,以及关于它们的大量在线解释,包括所有这些网站上的解释.我正在阅读的这本书是Head First Design Patterns.

在Simple Factory中,客户端使用单独的类(Creator)和工厂方法(可以是静态的)来返回Products.

在工厂方法模式中,创建者和客户端是相同的东西,他们在同一个类中使用抽象方法来创建新的产品,它们在同一个类中运行.当然,造物主(或客户)是抽象的,因此关于制作混凝土产品的决定被推迟到子类.

1. 我的理解是否正确(例如,FMP中的客户端和创建者是同一件事,我从未在FMP图中看到客户端)？

2. 在Factory Method Pattern中,它表明create方法不能在Creator之外重用,所以它只能在创建一个新的Creator时重用？

3. 在哪种情况下我可以选择一个而不是另一个？

(PS请不要将此标记为重复,我希望在此网站上明确这一点)

我想创建类似通用工厂方法的东西 - 看看这个:

template <class BaseType>
class Factory {
  public:
    template <class ... Args>
    static BaseType* Create(const Args& ... args) {
      return new DerivedType(args ...);
    }
};

其中的DerivedType某些其他类型来自BaseType不同的地方并在其他地方定义.

问题在于存储DerivedType.我想这样做,例如,像这样:

void f() {
  // Derived type may have more than one constructor,
  // that's why I suggest using of the variadic templates.
  BaseType* ptr1 = Factory<BaseType>::Create("abc", 5, 10.);
  BaseType* ptr2 = Factory<BaseType>::Create();
  ...
}

...

Factory<BaseType>::SetType<MyDerivedType>();
f();

Factory<BaseType>::SetType<YourDerivedType>();
f();

我可以设置不同的派生类型,但所有这些类型在编译时都是已知的.我想不出适当的技术来做到这一点.

问题:你能告诉一个吗？

这样做的理由(因此,原始问题,如果有人建议问题是它自己的XY问题) - 是一种单元测试一些棘手的代码部分的能力.例如,如果我有一个代码: …

我正在尝试遵循本文中概述的存储库模式http://code.tutsplus.com/tutorials/the-repository-design-pattern--net-35804#highlighter_174798我正在尝试使用App在Laravel中实例化一个类:: make()(我猜是Laravel的工厂模式？)我试图解析我的课程的参数,但我无法弄清楚如何做到这一点.

码:

namespace My;

class NewClass {
    function __construct($id, $title) 
    {
        $this->id = $id;
        $this->title = $title;
    }
}

$classArgs = [
    'id'    => 1,
    'title' => 'test',
]

$newClass = App::make('My\NewClass', $classArgs);

任何人都可以指出如何使用App :: make()的例子,或者我是否走错了方向,不应该使用App :: make()？

我创建了Exception xml并动态创建并抛出异常.

<exception-mappings>
<exception-mapping key="exceptionkey1">
    <class-name>com.package.CheckedException</class-name>
    <message>Checked Exception Message</message>
</exception-mapping>
<exception-mapping key="exceptionkey2">
    <class-name>com.package.UnCheckedException</class-name>
    <message>UnChecked Exception Message</message>
</exception-mapping>

我根据异常键使用反射动态创建异常对象.

public static void throwException(final String key) throws CheckedException, UncheckedException {
    ExceptionMapping exceptionMapping = exceptionMappings.getExceptionMappings().get(key);
    if (exceptionMapping != null) {
        try {
            Class exceptionClass = Class.forName(exceptionMapping.getClassName());
            try {
                throw ()exceptionClass.newInstance(); // line X
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

我想知道哪一个类在X行进行类型转换,这样我就不需要使用If/else了.原因我不想使用if else,有可能在将来可能会添加新类,并且我不希望每次添加新异常时都更改此代码.

我的基本逻辑是我的服务层将抛出CheckedException或UncheckedException.如果抛出CheckedException,它将由我的Web层处理.此外,我不能抛出超级父类Exception或Throwable,因为我的web层只捕获CheckedException.如果抛出UncheckedException,它将显示异常页面.

请帮助我,因为我无法继续前进.

编辑:任何其他解决方案也被接受.

我正在阅读Hodges的书"Delphi中的更多编码",关于工厂模式的部分.试着学习东西.把我的代码分解成小单元.我使用ReportMemoryLeaksOnShutDown := True;和停止代码会导致内存泄漏.为什么会发生,我该如何解决？

unit Unit2;

interface

uses
  Generics.Collections, System.SysUtils;

type
  TGatewayTpe = (gtSwedbank, gtDNB);

type
  TBaseGateway = class

  end;

type
  TSwedbankGateway = class(TBaseGateway)
  end;

type
  TGatewayFunction = reference to function: TBaseGateway;

type
  TGatewayTypeAndFunction = record
    GatewayType: TGatewayTpe;
    GatewayFunction: TGatewayFunction;
  end;

type
  TGatewayFactory = class
  strict private
    class var FGatewayTypeAndFunctionList: TList<TGatewayTypeAndFunction>;
  public
    class constructor Create;
    class destructor Destroy;
    class procedure AddGateway(const AGatewayType: TGatewayTpe;
      const AGatewayFunction: TGatewayFunction);
  end;

implementation

class procedure TGatewayFactory.AddGateway(const AGatewayType: TGatewayTpe;
  const AGatewayFunction: TGatewayFunction);

var
  _GatewayTypeAndFunction: TGatewayTypeAndFunction; …