When is it a good idea to use factory methods within an object instead of a Factory class?
可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试):
问题:
回答1:
I like thinking about design pattens in terms of my classes being \'people,\' and the patterns are the ways that the people talk to each other.
So, to me the factory pattern is like a hiring agency. You\'ve got someone that will need a variable number of workers. This person may know some info they need in the people they hire, but that\'s it.
So, when they need a new employee, they call the hiring agency and tell them what they need. Now, to actually hire someone, you need to know a lot of stuff - benefits, eligibility verification, etc. But the person hiring doesn\'t need to know any of this - the hiring agency handles all of that.
In the same way, using a Factory allows the consumer to create new objects without having to know the details of how they\'re created, or what their dependencies are - they only have to give the information they actually want.
public interface IThingFactory
{
Thing GetThing(string theString);
}
public class ThingFactory : IThingFactory
{
public Thing GetThing(string theString)
{
return new Thing(theString, firstDependency, secondDependency);
}
}
So, now the consumer of the ThingFactory can get a Thing, without having to know about the dependencies of the Thing, except for the string data that comes from the consumer.
回答2:
Factory methods should be considered as an alternative to constructors - mostly when constructors aren\'t expressive enough, ie.
class Foo{
public Foo(bool withBar);
}
is not as expressive as:
class Foo{
public static Foo withBar();
public static Foo withoutBar();
}
Factory classes are useful when you need a complicated process for constructing the object, when the construction need a dependency that you do not want for the actual class, when you need to construct different objects etc.
回答3:
One situation where I personally find separate Factory classes to make sense is when the final object you are trying to create relies on several other objects. E.g, in PHP: Suppose you have a House object, which in turn has a Kitchen and a LivingRoom object, and the LivingRoom object has a TV object inside as well.
The simplest method to achieve this is having each object create their children on their construct method, but if the properties are relatively nested, when your House fails creating you will probably spend some time trying to isolate exactly what is failing.
The alternative is to do the following (dependency injection, if you like the fancy term):
$TVObj = new TV($param1, $param2, $param3);
$LivingroomObj = new LivingRoom($TVObj, $param1, $param2);
$KitchenroomObj = new Kitchen($param1, $param2);
$HouseObj = new House($LivingroomObj, $KitchenroomObj);
Here if the process of creating a House fails there is only one place to look, but having to use this chunk every time one wants a new House is far from convenient. Enter the Factories:
class HouseFactory {
public function create() {
$TVObj = new TV($param1, $param2, $param3);
$LivingroomObj = new LivingRoom($TVObj, $param1, $param2);
$KitchenroomObj = new Kitchen($param1, $param2);
$HouseObj = new House($LivingroomObj, $KitchenroomObj);
return $HouseObj;
}
}
$houseFactory = new HouseFactory();
$HouseObj = $houseFactory->create();
Thanks to the factory here the process of creating a House is abstracted (in that you don\'t need to create and set up every single dependency when you just want to create a House) and at the same time centralized which makes it easier to maintain. There are other reasons why using separate Factories can be beneficial (e.g. testability) but I find this specific use case to illustrate best how Factory classes can be useful.
回答4:
It is important to clearly differentiate the idea behind using factory or factory method. Both are meant to address mutually exclusive different kind of object creation problems.
Let\'s be specific about \"factory method\":
First thing is that, when you are developing library or APIs which in turn will be used for further application development, then factory method is one of the best selections for creation pattern. Reason behind; We know that when to create an object of required functionality(s) but type of object will remain undecided or it will be decided ob dynamic parameters being passed.
Now the point is, approximately same can be achieved by using factory pattern itself but one huge drawback will introduce into the system if factory pattern will be used for above highlighted problem, it is that your logic of crating different objects(sub classes objects) will be specific to some business condition so in future when you need to extend your library\'s functionality for other platforms(In more technically, you need to add more sub classes of basic interface or abstract class so factory will return those objects also in addition to existing one based on some dynamic parameters) then every time you need to change(extend) the logic of factory class which will be costly operation and not good from design perspective. On the other side, if \"factory method\" pattern will be used to perform the same thing then you just need to create additional functionality(sub classes) and get it registered dynamically by injection which doesn\'t require changes in your base code.
interface Deliverable
{
/*********/
}
abstract class DefaultProducer
{
public void taskToBeDone()
{
Deliverable deliverable = factoryMethodPattern();
}
protected abstract Deliverable factoryMethodPattern();
}
class SpecificDeliverable implements Deliverable
{
/***SPECIFIC TASK CAN BE WRITTEN HERE***/
}
class SpecificProducer extends DefaultProducer
{
protected Deliverable factoryMethodPattern()
{
return new SpecificDeliverable();
}
}
public class MasterApplicationProgram
{
public static void main(String arg[])
{
DefaultProducer defaultProducer = new SpecificProducer();
defaultProducer.taskToBeDone();
}
}
回答5:
It is good idea to use factory methods inside object when:
- Object\'s class doesn\'t know what exact sub-classes it have to create
- Object\'s class is designed so that objects it creates were specified by sub-classes
- Object\'s class delegates its duties to auxiliary sub-classes and doesn\'t know what exact class will take these duties
It is good idea to use abstract factory class when:
- Your object shouldn\'t depend on how its inner objects are created and designed
- Group of linked objects should be used together and you need to serve this constraint
- Object should be configured by one of several possible families of linked objects that will be a part of your parent object
- It is required to share child objects showing interfaces only but not an implementation
回答6:
They\'re also useful when you need several \"constructors\" with the same parameter type but with different behavior.
回答7:
UML from
![\"enter](\"https://i.stack.imgur.com/LUIor.gif\")
Product: It defines an interface of the objects the Factory method creates.
ConcreteProduct: Implements Product interface
Creator: Declares the Factory method
ConcreateCreator: Implements the Factory method to return an instance of a ConcreteProduct
Problem statement: Create a Factory of Games by using Factory Methods, which defines the game interface.
Code snippet:
import java.util.HashMap;
/* Product interface as per UML diagram */
interface Game{
/* createGame is a complex method, which executes a sequence of game steps */
public void createGame();
}
/* ConcreteProduct implementation as per UML diagram */
class Chess implements Game{
public Chess(){
}
public void createGame(){
System.out.println(\"---------------------------------------\");
System.out.println(\"Create Chess game\");
System.out.println(\"Opponents:2\");
System.out.println(\"Define 64 blocks\");
System.out.println(\"Place 16 pieces for White opponent\");
System.out.println(\"Place 16 pieces for Black opponent\");
System.out.println(\"Start Chess game\");
System.out.println(\"---------------------------------------\");
}
}
class Checkers implements Game{
public Checkers(){
}
public void createGame(){
System.out.println(\"---------------------------------------\");
System.out.println(\"Create Checkers game\");
System.out.println(\"Opponents:2 or 3 or 4 or 6\");
System.out.println(\"For each opponent, place 10 coins\");
System.out.println(\"Start Checkers game\");
System.out.println(\"---------------------------------------\");
}
}
class Ludo implements Game{
public Ludo(){
}
public void createGame(){
System.out.println(\"---------------------------------------\");
System.out.println(\"Create Ludo game\");
System.out.println(\"Opponents:2 or 3 or 4\");
System.out.println(\"For each opponent, place 4 coins\");
System.out.println(\"Create two dices with numbers from 1-6\");
System.out.println(\"Start Ludo game\");
System.out.println(\"---------------------------------------\");
}
}
/* Creator interface as per UML diagram */
interface IGameFactory {
public Game getGame(String gameName);
}
/* ConcreteCreator implementation as per UML diagram */
class GameFactory implements IGameFactory {
HashMap<String,Game> games = new HashMap<String,Game>();
/*
Since Game Creation is complex process, we don\'t want to create game using new operator every time.
Instead we create Game only once and store it in Factory. When client request a specific game,
Game object is returned from Factory instead of creating new Game on the fly, which is time consuming
*/
public GameFactory(){
games.put(Chess.class.getName(),new Chess());
games.put(Checkers.class.getName(),new Checkers());
games.put(Ludo.class.getName(),new Ludo());
}
public Game getGame(String gameName){
return games.get(gameName);
}
}
public class NonStaticFactoryDemo{
public static void main(String args[]){
if ( args.length < 1){
System.out.println(\"Usage: java FactoryDemo gameName\");
return;
}
GameFactory factory = new GameFactory();
Game game = factory.getGame(args[0]);
if ( game != null ){
game.createGame();
System.out.println(\"Game=\"+game.getClass().getName());
}else{
System.out.println(args[0]+ \" Game does not exists in factory\");
}
}
}
output:
java NonStaticFactoryDemo Chess
---------------------------------------
Create Chess game
Opponents:2
Define 64 blocks
Place 16 pieces for White opponent
Place 16 pieces for Black opponent
Start Chess game
---------------------------------------
Game=Chess
This example shows a Factory class by implementing a FactoryMethod.
Gameis the interface for all type of games. It defines complex method:createGame()Chess, Ludo, Checkersare different variants of games, which provide implementation tocreateGame()public Game getGame(String gameName)isFactoryMethodinIGameFactoryclassGameFactorypre-creates different type of games in constructor. It implementsIGameFactoryfactory method.game Name is passed as command line argument to
NotStaticFactoryDemogetGameinGameFactoryaccepts a game name and returns correspondingGameobject.
Factory:
Creates objects without exposing the instantiation logic to the client.
FactoryMethod
Define an interface for creating an object, but let the subclasses decide which class to instantiate. The Factory method lets a class defer instantiation to subclasses
Use case:
When to use: Client doesn\'t know what concrete classes it will be required to create at runtime, but just wants to get a class that will do the job.
回答8:
It\'s really a matter of taste. Factory classes can be abstracted/interfaced away as necessary, whereas factory methods are lighter weight (and also tend to be testable, since they don\'t have a defined type, but they will require a well-known registration point, akin to a service locator but for locating factory methods).
回答9:
Factory classes are useful for when the object type that they return has a private constructor, when different factory classes set different properties on the returning object, or when a specific factory type is coupled with its returning concrete type.
WCF uses ServiceHostFactory classes to retrieve ServiceHost objects in different situations. The standard ServiceHostFactory is used by IIS to retrieve ServiceHost instances for .svc files, but a WebScriptServiceHostFactory is used for services that return serializations to JavaScript clients. ADO.NET Data Services has its own special DataServiceHostFactory and ASP.NET has its ApplicationServicesHostFactory since its services have private constructors.
If you only have one class that\'s consuming the factory, then you can just use a factory method within that class.
回答10:
Consider a scenario when you have to design an Order and Customer class. For simplicity and initial requirements you do not feel need of factory for Order class and fill your application with many \'new Order()\' statements. Things are working well.
Now a new requirement comes into picture that Order object cannot be instantiated without Customer association (new dependency). Now You have following considerations.
1- You create constructor overload which will work only for new implementations. (Not acceptable). 2- You change Order() signatures and change each and every invokation. (Not a good practice and real pain).
Instead If you have created a factory for Order Class you only have to change one line of code and you are good to go. I suggest Factory class for almost every aggregate association. Hope that helps.
回答11:
According to sourcemaking website, it\'s intentions are:
Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
Defining a \"virtual\" constructor.
The new operator considered harmful.
An example of how it can be used:
abstract class AbstractFactoryMethod {
abstract function makePHPBook($param);
}
class OReillyFactoryMethod extends AbstractFactoryMethod
{
function makePHPBook($param)
{
$book = NULL;
switch ($param) {
case \"us\":
$book = new OReillyPHPBook();
break;
// Other classes...
case \"other\":
$book = new SamsPHPBook();
break;
default:
$book = new OReillyPHPBook();
break;
}
return $book;
}
And then the testing:
function testFactoryMethod($factoryMethodInstance)
{
$phpUs = $factoryMethodInstance->makePHPBook(\"us\");
echo \'us php Author: \'.$phpUs->getAuthor();
echo \'us php Title: \'.$phpUs->getTitle();
}
echo \'Testing OReillyFactoryMethod\';
$factoryMethodInstance = new OReillyFactoryMethod();
testFactoryMethod($factoryMethodInstance);
回答12:
Any class deferring the object creation to its sub class for the object it needs to work with can be seen as an example of Factory pattern.
I have mentioned in detail in an another answer at https://stackoverflow.com/a/49110001/504133
回答13:
Factory classes are more heavyweight, but give you certain advantages. In cases when you need to build your objects from multiple, raw data sources they allow you to encapsulate only the building logic (and maybe the aggregation of the data) in one place. There it can be tested in abstract without being concerned with the object interface.
I have found this a useful pattern, particularly where I am unable to replace and inadequate ORM and want to efficiently instantiate many objects from DB table joins or stored procedures.
回答14:
I liken factories to the concept of libraries. For example you can have a library for working with numbers and another for working with shapes. You can store the functions of these libraries in logically named directories as Numbers or Shapes. These are generic types that could include integers, floats, dobules, longs or rectangles, circles, triangles, pentagons in the case of shapes.
The factory petter uses polymorphism, dependency injection and Inversion of control.
The stated purpose of the Factory Patterns is: Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
So let\'s say that you are building an Operating System or Framework and you are building all the discrete components.
Here is a simple example of the concept of the Factory Pattern in PHP. I may not be 100% on all of it but it\'s intended to serve as a simple example. I am not an expert.
class NumbersFactory {
public static function makeNumber( $type, $number ) {
$numObject = null;
$number = null;
switch( $type ) {
case \'float\':
$numObject = new Float( $number );
break;
case \'integer\':
$numObject = new Integer( $number );
break;
case \'short\':
$numObject = new Short( $number );
break;
case \'double\':
$numObject = new Double( $number );
break;
case \'long\':
$numObject = new Long( $number );
break;
default:
$numObject = new Integer( $number );
break;
}
return $numObject;
}
}
/* Numbers interface */
abstract class Number {
protected $number;
public function __construct( $number ) {
$this->number = $number;
}
abstract public function add();
abstract public function subtract();
abstract public function multiply();
abstract public function divide();
}
/* Float Implementation */
class Float extends Number {
public function add() {
// implementation goes here
}
public function subtract() {
// implementation goes here
}
public function multiply() {
// implementation goes here
}
public function divide() {
// implementation goes here
}
}
/* Integer Implementation */
class Integer extends Number {
public function add() {
// implementation goes here
}
public function subtract() {
// implementation goes here
}
public function multiply() {
// implementation goes here
}
public function divide() {
// implementation goes here
}
}
/* Short Implementation */
class Short extends Number {
public function add() {
// implementation goes here
}
public function subtract() {
// implementation goes here
}
public function multiply() {
// implementation goes here
}
public function divide() {
// implementation goes here
}
}
/* Double Implementation */
class Double extends Number {
public function add() {
// implementation goes here
}
public function subtract() {
// implementation goes here
}
public function multiply() {
// implementation goes here
}
public function divide() {
// implementation goes here
}
}
/* Long Implementation */
class Long extends Number {
public function add() {
// implementation goes here
}
public function subtract() {
// implementation goes here
}
public function multiply() {
// implementation goes here
}
public function divide() {
// implementation goes here
}
}
$number = NumbersFactory::makeNumber( \'float\', 12.5 );
回答15:
AbstractFactory example.
TypeImpl<String> type = new TypeImpl<>();
type.addType(\"Condition\");
type.addType(\"Hazardous\");
AbstractTypeFactory<String, Tag> tags = new AbstractTypeFactory<String, Tag>(type) {
@Override
public Tag create(String string) {
String tp = type.find(string);
switch (tp) {
case \"Hazardous\":
return new HazardousTag();
case \"Condition\":
return new ConditionTag();
default:
return null;
}
}
};
Tag tagHazardous = tags.create(\"Hazardous\");
Tag tagCondition = tags.create(\"Condition\");
}
回答16:
if you want to create a different object in terms of using. It is useful.
public class factoryMethodPattern {
static String planName = \"COMMERCIALPLAN\";
static int units = 3;
public static void main(String args[]) {
GetPlanFactory planFactory = new GetPlanFactory();
Plan p = planFactory.getPlan(planName);
System.out.print(\"Bill amount for \" + planName + \" of \" + units
+ \" units is: \");
p.getRate();
p.calculateBill(units);
}
}
abstract class Plan {
protected double rate;
abstract void getRate();
public void calculateBill(int units) {
System.out.println(units * rate);
}
}
class DomesticPlan extends Plan {
// @override
public void getRate() {
rate = 3.50;
}
}
class CommercialPlan extends Plan {
// @override
public void getRate() {
rate = 7.50;
}
}
class InstitutionalPlan extends Plan {
// @override
public void getRate() {
rate = 5.50;
}
}
class GetPlanFactory {
// use getPlan method to get object of type Plan
public Plan getPlan(String planType) {
if (planType == null) {
return null;
}
if (planType.equalsIgnoreCase(\"DOMESTICPLAN\")) {
return new DomesticPlan();
} else if (planType.equalsIgnoreCase(\"COMMERCIALPLAN\")) {
return new CommercialPlan();
} else if (planType.equalsIgnoreCase(\"INSTITUTIONALPLAN\")) {
return new InstitutionalPlan();
}
return null;
}
}
{var%20f='http://v.t.sina.com.cn/share/share.php?appkey=1515056452',u=z||d.location,p=['&url=',e(u),'&title=',e(t||d.title),'&source=',e(r),'&sourceUrl=',e(l),'&content=',c||'gb2312','&pic=',e(p||'')].join('');function%20a(){if(!window.open([f,p].join(''),'mb',['toolbar=0,status=0,resizable=1,width=440,height=430,left=',(s.width-440)/2,',top=',(s.height-430)/2].join('')))u.href=[f,p].join('');};if(/Firefox/.test(navigator.userAgent))setTimeout(a,0);else%20a();})(screen,document,encodeURIComponent,'','','https://i.stack.imgur.com/LUIor.gif', '推荐 人气声优 的文章《Factory Pattern. When to use factory methods?》','https://www.manongdao.com/article-7657.html','页面编码gb2312|utf-8默认gb2312'));){kind=link}