标签: factory

在一般情况下,对此进行了很好的讨论.

但是,我特别想知道为什么Pattern类使用compile静态方法来创建对象,而不是构造函数？

对我来说似乎更直观地使用构造函数.

我有一个工厂类,DocumentLoaderFactory它只返回一个实现接口的实例IDocumentLoader.

所有实现都驻留在以下命名空间下

Skim.Ssms.AddIn.ActiveFileExplorer.Loader

但我想知道的是,哪个命名空间确实DocumentLoaderFactory属于哪个？我现在已将工厂类放在*.Loader命名空间下,但它正在从ActiveFileWindow父命名空间的用户控件()中使用,Skim.Ssms.AddIn.ActiveFileExplorer如下所示.

将工厂方法置于*.Loader其父级命名空间中的优缺点是什么？我想根据利弊做出决定.

这是我项目的布局

什么是这家工厂,使用工厂模式的优势是什么？它是否提供可插拔架构？为什么它被称为"工厂"？

使用DI方法处理条件子工厂的正确方法是什么？场景是注入到条目中的加载器对象取决于该条目的设置.最初我是将IoC容器注入工厂并使用它来根据命名约定来解决.但是,我真的想保持工厂清洁容器.

将工厂注入到将从数据库加载所有设置的类中,然后使用工厂创建一组条目.这些设置确定将在给定条目内使用哪个加载器.

编辑:更改代码以更好地突出显示实际问题.问题是必须同时支持多个数据库管理器,如果不是这样,那么它将很简单.数据库管理器类型由为特定条目存储的条目设置确定.

public class Entry : IEntry
{
     private ISomething loader;

     public Entry(ISomething something)
     {
         this.loader = something;
     }
}

public class EntryFactory : IEntryFactory
{
    IEntry BuildEntry(IEntrySetting setting)
    {
        //Use setting object to determine which database manager will be used
    }
}

public class EntryManager
{
    public EntryManager(IEntryFactory entryFactory)
    {
        var entrySettings = this.settings.Load();
        foreach(var setting in entrySettings)
        {
             this.entries.Add(entryFactory.BuildEntry(setting));
        }
    }
}

我曾考虑让子工厂在主要工厂注册并以这种方式解决,但我不知道是否有更好的方法.

我有一个用于许多单例实现的通用接口.接口定义了可以抛出检查异常的初始化方法.

我需要一个工厂,它将按需返回缓存的单例实现,并想知道以下方法是否是线程安全的？

更新1:请不要建议任何第3部分图书馆,因为这可能需要获得法律许可,因为可能的许可问题:-)

更新2:此代码可能会在EJB环境中使用,因此最好不要生成其他线程或使用类似的东西.

interface Singleton
{
    void init() throws SingletonException;
}

public class SingletonFactory
{
    private static ConcurrentMap<String, AtomicReference<? extends Singleton>> CACHE =
        new ConcurrentHashMap<String, AtomicReference<? extends Singleton>>();

    public static <T extends Singleton> T getSingletonInstance(Class<T> clazz)
        throws SingletonException
    {
        String key = clazz.getName();
        if (CACHE.containsKey(key))
        {
            return readEventually(key);
        }

        AtomicReference<T> ref = new AtomicReference<T>(null);
        if (CACHE.putIfAbsent(key, ref) == null)
        {
            try
            {
                T instance = clazz.newInstance();
                instance.init();
                ref.set(instance); // ----- (1) -----
                return instance;
            }
            catch (Exception …

当我尝试对我的代码的某些部分进行单元测试时,我需要一个用户才能登录.为了减少我使用django_factory_boy用户工厂的灯具数量,但生成的用户无法进行身份验证.

from django_factory_boy.auth import UserF
from django.contrib.auth import authenticate

user = UserF()
user.set_password('password')

然后authenticate(username=user.username, password='password')返回None而不是用户.关于这里缺少什么的想法？

我正在尝试生成一个代表java.nio.file.Path使用静态方法的bean Paths.get(String path).我目前的Spring设置如下:

<bean id="myPath" class="java.nio.file.Paths" factory-method="get">
    <constructor-arg value="c:\\tmp\\" />
</bean>

但它带来了一个令人兴奋的回归No matching factory method found: factory method 'get'.任何想法为什么会这样？

我一直在努力掌握OOP概念,虽然我确实掌握了大多数概念,但我经常发现自己需要一些关于实际实施的建议.其中一种情况是工厂方法.

我正在编写一个PHP应用程序,它将处理从Web和命令行界面传入的请求,因此我提出了以下简单的类继承结构来涵盖这两种类型的请求:

abstract class Request {
}

class HttpRequest extends Request {
}

class CliRequest extends Request {
}

现在我需要一个工厂方法,它将返回一个具体的Request实例,具体取决于返回的值php_sapi_name():

public function create() {
    if(php_sapi_name() === 'cli')
        return new CliRequest();
    else
        return new HttpRequest();
}

我的问题是:我在哪里放？我至少可以想到三种可能性:

1)单独类中的静态方法:

class RequestFactory {
    public static function create() {
        // ...
    }
}

2)单独类中的常规方法(需要首先实例化该类):

class RequestFactory {
    public function create() {
        // ...
    }
}

3)抽象父类中的静态方法:

abstract class Request {
    public static function create() {
        // ...
    }
} …

我已经看到了通过引用类对象并使用一个create方法来实现对象创建工厂的地方:class.newInstance()它使用反射,与直接调用默认构造函数相比可能效率不高.

如果java支持类似的东西return new this();,我可以在父类中实现它,这将作为工厂方法(如果没有这样的构造函数,将抛出异常class.newInstance()).

为什么不支持这样的东西？

PS:我在stackOverflow中的第一个问题:)

我开始研究不同的设计模式,现在我专注于工厂设计模式.我看了一些例子,youtube tuturials和博客,我得到了最多,但我仍然没有得到为什么接口是必要的.

官方定义是:

定义用于创建对象的接口,但让子类决定实例化哪个类.Factory Method允许类将实例化延迟到子类.

因此,界面似乎是工厂设计模式的重要组成部分,但是我发现在主方法中创建集合时实际的唯一原因.如果你不想要它,你可以删除它(看下面的代码,可能的地方),它仍然像计划的那样工作.

using System;
using System.Collections.Generic;
using System.Collections;

namespace FactoryDesignPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            var FordFiestaFactory = new FordFiestaFactory();
            var FordFiesta = FordFiestaFactory.CreateCar("Blue");
            Console.WriteLine("Brand: {0} \nModel: {1} \nColor: {2}", FordFiesta.Make, FordFiesta.Model, FordFiesta.Color);
            Console.WriteLine();


            //Inserted this later. Using a collection requires the Interface to be there.
            List<ICreateCars> Cars = new List<ICreateCars>();
            Cars.Add(new FordFiestaFactory());
            Cars.Add(new BMWX5Factory());

            foreach (var Car in Cars)
            {
                var ProductCar = Car.CreateCar("Red");
                Console.WriteLine("Brand: {0} \nModel: {1} \nColor: {2}", ProductCar.Make, …