标签: factory-pattern

我正在尝试编写工厂模式以在我的程序中创建MainMode或TestMode.我以前用来创建这些对象的代码是:

play = (isMode) ? new MainMode(numberRanges, numberOfGuesses) : 
                  new TestMode(numberRanges, numberOfGuesses, randNo());

我的游戏(游戏)将根据布尔值(isMode)创建MainMode对象或TestMode对象.正如您所看到的,我在TestMode对象中添加了一个额外的值(randNo()).此值在TestMode中用于允许用户输入自己的"随机数",而在MainMode构造函数中,这是随机生成的.在这个程序中,MainMode和TestMode都是抽象类Game的子类.

现在我想用工厂模式替换这一行,虽然我不确定我的TestMode构造函数需要一个额外的对象,我不确定我需要传递这个值的位置.如果我要创建一个工厂,它需要在一个新的类中,可能名为GameFactory或ModeFactory或类似的东西.

我该怎么做？

编辑:这里的问题是上面的代码在我的GUI中,其中numberRanges,numberOfGuesses和randNo()方法的值是.我想创建一个Factory类,但我无法传递这些值,因为randNo()会激活它自己.这是我的randNo()方法.

private int randNo() {
    boolean isValidNumber = true;
    int testRandomNum = 0;
    while(isValidNumber) {
        try {
            testRandomNum = Integer.parseInt(JOptionPane.showInputDialog("Enter Random Number"));
            isValidNumber = false;
        } catch (NumberFormatException e) {
            JOptionPane.showMessageDialog(null, "Sorry, but the number you entered was invalid");
        }
    }

    return testRandomNum;
}

问题是每当我传递randNo()时它都会显示JOptionPane.正如我已经说过的,GUI和Logic是分开的.GUI位于GUI包中,而其余代码位于逻辑包中.

我正在构建一个索引几个不同数据源的搜索应用程序.当针对搜索引擎索引执行查询时,每个搜索结果指定它来自哪个数据源.我已经构建了一个工厂模式,我用它为每种类型的搜索结果显示不同的模板,但我意识到这种模式将变得更难以管理,因为越来越多的数据源被搜索引擎索引(即新的必须为每个新数据源创建代码模板.

我根据Granville Barnett在DotNetSlackers.com上发表的一篇文章为我的工厂创建了以下结构

工厂模式http://img11.imageshack.us/img11/8382/factoryi.jpg

为了使这个搜索应用程序更易于维护,我的想法是创建一组数据库表,可用于定义我的工厂模式可以引用的各个模板类型,以确定要构造的模板.我想我需要有一个查找表,用于根据搜索结果数据源指定要构建的模板类型.然后,我需要有一个表来指定要为该模板类型显示的字段.我还需要一个表(或模板表中的其他列),用于定义如何呈现该字段(即超链接,标签,CssClass等).

有没有人有这样的模式的例子？请告诉我.谢谢,-Robert

我正在使用一个站点,该站点将从许多不同的源中提取源,然后将这些流保存到一个通用模型中,在这种情况下是一个特征.FeedEntry类中的代码示例可能是:

feed = Feedzirra::Feed.fetch_and_parse(feed_url)
add_entries(feed.entries) 
...

def self.add_entries(entries)

   entries.each do |entry|  
      # Should know how to parse itself into a trait          
      @trait = parse(entry)
      if @trait.save
      ...
   end  
 end

不可否认,我来自java背景,在java中,我会建立一个继承heirarchy,然后在FeedEntry的每个子类上扩展parse方法,以便每个FeedEntry都知道如何解析自己.所以我的问题:
1)这是一个可行的铁路计划吗？
2)如果是这样,是否只包含一个基本上是"类型"的列,表示FeedEntry的子类是什么？
3)如果没有,有关DRYest方法的任何建议吗？

谢谢!

我想知道何时需要使用抽象工厂模式.

这是一个例子,我想知道是否有必要.

UML

以上是抽象工厂模式,我的同学推荐.以下是我的实施.我不认为有必要使用这种模式.

以下是一些核心代码:

    package net;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;



public class Test {
    public static void main(String[] args) throws IOException, InstantiationException, IllegalAccessException, ClassNotFoundException {
        DaoRepository dr=new DaoRepository();
        AbstractDao dao=dr.findDao("sql");
        dao.insert();
    }
}

class DaoRepository {
    Map<String, AbstractDao> daoMap=new HashMap<String, AbstractDao>();
    public DaoRepository () throws IOException, InstantiationException, IllegalAccessException, ClassNotFoundException  {
        Properties p=new Properties();
        p.load(DaoRepository.class.getResourceAsStream("Test.properties"));
        initDaos(p);
    }
    public void initDaos(Properties p) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        String[] daoarray=p.getProperty("dao").split(",");
        for(String dao:daoarray) {
            AbstractDao ad=(AbstractDao)Class.forName(dao).newInstance();
            daoMap.put(ad.getID(),ad);
        }
    } …

在C#中,您必须在类中声明所有内容,因此示例工厂模式可能如下所示:

namespace MySpace {

public class CFactory
{
  public static CFactory Current()
  {
    static CFactory singleton;
    return singleton;
  }
  public CBase Create() { return null; }
}

}

在C++中,你没有这个限制.所以将"工厂"方法作为全局函数而不是让它们成为一个类被认为是"不好的做法"？

例1:

namespace MySpace {

// factory method
std::shared_ptr<CBase> CreateBase() { return NULL; }

}

例2:

namespace MySpace {

// factory class
class CFactory
{
public:
  std::shared_ptr<CBase> CreateBase() { return NULL; }
};

// factory method exposing class
CFactory& GetFactory()
{
  static CFactory singleton;
  return singleton;
}

}

例3:

namespace MySpace { …

让我们假设我们得到以下内容:

A)工厂界面如

public interface IEmployeeFactory
{        
    IEmployee CreateEmployee(Person person, Constants.EmployeeType type, DateTime hiredate);
}

B)混凝土工厂如

public sealed class EmployeeFactory : Interfaces.IEmployeeFactory
{        
    public Interfaces.IEmployee CreateEmployee(Person person, Constants.EmployeeType type, DateTime hiredate)
    {
        switch(type)
        {
        case BusinessObjects.Common.Constants.EmployeeType.MANAGER:
            {
                return new Concrete.Manager(person, hiredate);
            }
        case BusinessObjects.Common.Constants.EmployeeType.SALES:
            {
                return new Concrete.Sales(person, hiredate);
            }
        default:
            {
                throw new ArgumentException("Invalid employee type");
            }
        }
    }
}

C)员工家庭:Manager与Sales从一个抽象的员工继承.

更多关于我的简单建筑

一些客户端代码

public sealed class EmployeeFactoryClient
{
    private Interfaces.IEmployeeFactory factory;
    private IDictionary<String, Interfaces.IEmployee> employees;

    public …

根据DDD(蓝皮书,埃文斯),工厂有责任在有效状态下创建聚合根.这是否意味着它应该能够创建技术ID(mongoDB世界中的objectId)以及域ID？

一方面,这似乎是一个技术细节,让Mongo处理ID的创建似乎没问题.

另一方面,通过id(通过getById在DDD存储库中)进行查询会将技术ID公开给域,这反过来又会使工厂负责创建它.

也许我无法理解技术ID与DomainId的不同用例/重叠等,或者我可能过于热心,但无论如何我都很感激你的意见.

简而言之:在DDD中:工厂是否应该能够创建技术ID以及域ID？

可能的实现:Hi/Lo(如何设置MongoDB Norm中的hilo序列起始值？)

编辑:虽然hi/lo方式将Factory暴露给持久层,这只是存储库应该知道的东西.嗯

谢谢

Parasitic Constructor Pattern可以看作是工厂和构造函数模式的组合.在工厂模式中,我们调用一个函数,然后显式创建一个对象,并向对象添加所需的属性和方法,最后返回该对象.

function createPerson(name, age, job){
    var o = new Object();   //explicit object creation
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function(){
            alert(this.name);
        };
    return o;
}

var person1 = createPerson(“Nicholas”, 29, “Software Engineer”);
var person2 = createPerson(“Greg”, 27, “Doctor”);

注意事项:

• 创建并返回显式对象
• 方法和属性将添加到显式创建的对象中
• 没有new运算符的方法被调用

缺点:它不允许识别对象的类型.

通过使用new运算符调用任何函数都可以将其视为构造函数.当没有new操作符调用时,在函数内部,this对象指向全局对象(window在浏览器中).当使用new运算符调用函数时,它首先创建新实例,object然后将this对象设置为新创建的对象.

构造函数模式向this对象添加方法和属性,最后返回this对象,从而允许稍后使用instanceOf运算符标识对象的类型.

function Person(name, age, job){
    this.name = …

我有两个版本的工厂类基于该文章设计

http://www.oodesign.com/factory-pattern.html

public abstract class Employee
{
    public string Name { get; set; }
    protected string Role { get; set; }
    public abstract string GetRole();
}

public class Manager : Employee
{
    public Manager()
    {
        Role = "MGR";
    }
    public override string GetRole()
    {
        return this.Role;
    }
}

版本1:简单,违反开放式关闭原则

当我添加一个新的具体类时,每次都需要更改SimpleEmployeeFactory

public class SimpleEmployeeFactory
{
    public static Employee GetEmployee(int typeId)
    {
        switch (typeId)
        {
            case 1:
                return new Manager();
            case 2:
                return new TechnicalLead();
            default:
                return null; //if the id …

我得到了我认为可能是一个不寻常的问题(我已经搜索了很多答案,但我不认为我找到了一个).

我有从队列中读取的消息,并且根据消息类型包含需要反序列化为具体c#类的有效负载.这需要最终具体(我不能使用泛型)因为我使用表达式树对从队列到达的类执行评估.

基类如下所示:

public abstract class BaseRuleMessage<T>  
{
    public abstract Func<T, bool> CompileRule(Rule r, T msg);

    public T Deserialize(ClientEventQueueMessage message)
    {
        return JsonConvert.DeserializeObject<T>(message.Payload);
    }        

    public BaseRuleMessage()
    {
        RulesCompleted = new List<int>();
    }

    public IEnumerable<Rule> FilterRules(RuleGroup ruleGroup)
    {
        return ruleGroup.Rules.Where(item =>
            !RulesCompleted.Any(r => r.Equals(item.Id)));
    }

我像这样实现基类:

 public class UiTransactionUpdate : BaseRuleMessage<UiTransactionUpdate>
{

    public override Func<UiTransactionUpdate, bool> CompileRule(Rule r, UiTransactionUpdate msg)
    {
        var expression = Expression.Parameter(typeof(UiTransactionUpdate));
        Expression expr = BuildExpr(r, expression, msg);
        return Expression.Lambda<Func<UiTransactionUpdate, bool>>(expr, expression).Compile();
    }
    public Guid TransactionId { get; …