我们的核心产品的一部分是一个网站CMS,它使用各种页面小部件.这些小部件负责显示内容,列出产品,处理事件注册等.每个小部件由从基本小部件类派生的类表示.在呈现页面时,服务器从数据库中获取页面的小部件,然后创建正确类的实例.工厂方法对吗？

Private Function WidgetFactory(typeId)
    Dim oWidget
    Select Case typeId
        Case widgetType.ContentBlock
            Set oWidget = New ContentWidget
        Case widgetType.Registration
            Set oWidget = New RegistrationWidget
        Case widgetType.DocumentList
            Set oWidget = New DocumentListWidget
        Case widgetType.DocumentDisplay
    End Select
    Set WidgetFactory = oWidget
End Function

无论如何,这一切都很好,但随着时间的推移,小部件类型的数量增加到大约50,这意味着工厂方法相当长.每次我创建一个新类型的小部件时,我会在方法中添加另外几行,并且在我脑海中发出一点警报,这可能不是最好的做事方式.我倾向于忽略那个警报,但它越来越响亮.

那么,我做错了吗？有没有更好的方法来处理这种情况？

假设我有一个ObjectInfo类,其中包含Object name和Object type作为String.(我只是为了提出问题而做点什么.)

class ObjectInfo {
    String objectName;

    String objectType;

    private ObjectInfo(String objectName, String objectType) {
          this.objectName = objectName;
          this.objectType = objectType;
    }
}

如果我想提供一个静态工厂方法来创建这个类的实例,以下两种方法中的哪一种更好？为什么？

public static ObjectInfo newInstance(String objectName, String objectType) {
    return new ObjectInfo(objectName, objectType)    
}

public static ObjectInfo valueOf(String objectName, String objectType) {
    return new ObjectInfo(objectName, objectType)    
}

基本上,我想问的是什么时候我们应该使用valueOf()&newInstance()？程序员社区中是否有任何约定？

-Ankit

为什么LocalDate,LocalTime,Stream,等对象使用一个工厂方法of()而不是构造的？

我找到了为什么应该使用工厂方法而不是new 这里的解释.这个答案有很多原因,但与Java Date/Time API相关的唯一原因如下:

与构造函数不同,它们不需要在每次调用时创建新对象

作为LocalDate并且LocalTime是不可变的,使用工厂并重用现有对象而不是每次都创建新对象可能是有意义的.

这就是为什么对象喜欢LocalDate和LocalTime用工厂方法创建的原因(即LocalDate.of())？还有其他原因吗？

此外,Stream对象是可变的.为什么使用工厂方法(Stream.of())来创建Stream？

简单工厂：

工厂方法：

嘿大家。我正在寻找简单工厂和工厂方法之间的区别。我知道结构差异（上图），但我无法理解用例的差异。例如，这是对工厂方法的解释：

在工厂方法模式中，我们将引入一个名为“IMobileFactory”的新接口和两个具体实现“NokiaFactory”和“IphoneFactory”。这些具体的类控制对象的创建。

在我的例子中，客户想要一个诺基亚对象。所以下面给出了步骤。

1.客户端将加载对“NokiaFactory”的引用。但是 Client 不会像 Simple Factory 模式那样直接引用“NokiaFactory”类。客户端通过接口“IMobileFactory”引用具体实现。

2.然后客户端调用'CreateMobile()'方法，该方法将返回一个'IMobile'类型的对象。

3.这里我们要通过一些配置或者参数告知客户端要使用的具体实现。

我无法理解第一步：

但是 Client 不会像 Simple Factory 模式那样直接引用“NokiaFactory”类。客户端通过接口“IMobileFactory”引用具体实现。

所以客户写了这样的东西：

IMobileFactory factory = LoadFactory("NokiaFactory");

那么为什么它有用而且更好呢？有什么好处？为什么我不应该这样写：

NokiaFactory factory = new NokiaFactory();

或者那怎么办：

IMobileFactory factory = new NokiaFactory();

我有一个具有 4 个非常相似方法的控制器，在远程服务器上调用 API 以对不同类型的用户执行不同的操作。这些 API 调用之间发生的变化只是端点和一些参数。

因此，这 4 个方法都使用非常相似的代码调用服务：它们从服务器获取令牌、设置参数、返回 API 的响应。由于稍后将添加更多操作，我决定使用工厂方法模式创建一个 ServiceFactory 并在服务上使用模板模式以避免代码重复。

我的问题是，为了让工厂自动装配服务，它需要与它们耦合，我必须对@Autowire每个实现进行耦合。有更好的解决方案吗？

这是我到目前为止的代码：

休息控制器

@RestController
public class ActionController {
  @Autowired
  private SsoService ssoService;

  // this is the factory
  @Autowired
  private ServiceFactory factory;

  @PostMapping("/action")
  public MyResponse performAction(@RequestBody MyRequest request, HttpServletRequest req) {
    // template code (error treatment not included)
    request.setOperator(ssoService.getOperator(req));
    request.setDate(LocalDateTime.now());
    return serviceFactory.getService(request).do();
  }
}

服务工厂

@Component
public class ServiceFactory {

  @Autowired private ActivateUserService activateUserService;
  @Autowired private Action2UserType2Service anotherService;
  //etc

  public MyService getService(request) { …

Smalltalk中是否使用了工厂方法,如果是这样,那么应该如何编写一个,而不是像Java中那样？谢谢.

我有一个Spring声明如下的bean:

<osgi:reference id="basicAuthSecurityHandler" interface="com.groupgti.handler.authentication.basic.Handler"/>
<bean id="securityHandler" factory-bean="basicAuthSecurityHandler" factory-method="getSecurityHandler"/>

我的getSecurityHandler方法看起来像这样:

public ConstraintSecurityHandler getSecurityHandler(String realm) {
    ConstraintSecurityHandler handler =(ConstraintSecurityHandler) factory.getBean("securityHandler");
    handler.setRealmName(realm);
    return handler;
}

这个securityHandlerbean在范围内prototype.我需要在getSecurityHandler使用spring构造时将参数传递给方法.这甚至可能吗？我找不到任何关于它的文档.

我有一个基类Base需要创建另一种类型的实例TRequired,但是,只有派生类Base知道如何构造它们.

使用抽象属性作为工厂方法是不好的风格？例如

protected abstract TRequired NewTRequired { get; }

我应该出于某种原因使用某种方法吗？有没有指导为什么我应该/不应该在这里使用房产？

Java 10的发布带来了新的静态工厂方法,特别是:

• static <E> List<E> copyOf?(Collection<? extends E> coll)
• static <E> Set<E> copyOf?(Collection<? extends E> coll)
• static <K,V> Map<K,V> copyOf?(Map<? extends K,? extends V> map)

看到这些方法允许我们将Collections 复制到不同的Collection实现中,它们如何与现有方法进行比较和对比？

我刚刚学习 Rust，所以也许我没有正确理解一些概念。

我有一些实现的特点：

trait Abstract {
    fn name(&self) -> &str;
}

struct Foo {}
struct Bar {}
struct Baz {}

impl Abstract for Foo {
    fn name(&self) -> &str { "foo" }
}
impl Abstract for Bar {
    fn name(&self) -> &str { "bar" }
}
impl Abstract for Baz {
    fn name(&self) -> &str { "baz" }
}

我想向此特征添加一个静态方法，以按名称创建一些标准实现：

trait Abstract {
    fn new(name: &str) -> Self {
        match name {
            "foo" => Foo{},
            "bar" => Bar{},
            "baz" => …