What is the difference between Builder Design pattern and Factory Design pattern? - Stack Overflow

A factory is simply a wrapper function around a constructor (possibly one in a different class). The key difference is that a factory method pattern requires the entire object to be built in a single method call, with all the parameters passed in on a single line. The final object will be returned.

A builder pattern, on the other hand, is in essence a wrapper object around all the possible parameters you might want to pass into a constructor invocation. This allows you to use setter methods to slowly build up your parameter list. One additional method on a builder class is a build() method, which simply passes the builder object into the desired constructor, and returns the result.

In static languages like Java, this becomes more important when you have more than a handful of (potentially optional) parameters, as it avoids the requirement to have telescopic constructors for all the possible combinations of parameters. Also a builder allows you to use setter methods to define read-only or private fields that cannot be directly modified after the constructor has been called.

上述为Stackoverflow的回答。

简单来说就是：

factory模式就是在你定义了一个class A之后，再定义一个AFactory类，来单独存放A class的各种构造函数。AFactory的每一个函数都会返回A的一个对象。

factory模式在java中较为常见，在python,go,C++中几乎不会见到，因为java在new一个对象时只能使用class的同名构造函数，只能用过参数个数来区分不同的同名构造函数。而其他语言大多支持自定义名称的构造函数因此无需额外的Factory类。

以python为例，我们看下两者的区别：

# coding=utf-8
# @Time: 2022/1/10 17:59
from typing import List


class A(object):
    def __init__(self, name: str):
        self.__name = name

    @classmethod
    def NewAFromList(cls, strs: List[str]):
        AList = []
        for s in strs:
            cls_kwargs = {"name": s}
            AList.append(cls(**cls_kwargs))
        return AList

    def __repr__(self):
        return self.__name


class AFactory(object):
    @staticmethod
    def NewAFromList(strs: List[str]) -> List[A]:
        AList = []
        for s in strs:
            AList.append(A(name=s))
        return AList


if __name__ == '__main__':
    # As = A.NewAFromList(["a", "b"])
    # for e in As:
    #     print(e)

    Af = AFactory()
    As = Af.NewAFromList(strs=["a", "b"])
    for e in As:
        print(e)

上述python的demo中，直接使用A的构造函数NewAFromList就很方便了，虽然额外加一个AFactory也能实现需求，但明显是多此一举。就算A有几十种构造函数也没什么必要单独拉一个Factory类出来。factory模式中每一个Factory的函数都相当于原始类的一个构造函数，它会直接返回要构造的原始对象，但builder模式不同，它构建最终返回对象的步骤是一步一步来的，每一步都会返回builder类本身，相当于每一步返回一个半成品(即构造原始对象的一个组件)，直到最后的build()函数才会返回最终对象，返回的最终对象具体包含什么组件，取决于你调用了构造类的哪些函数。builder模式的作用与factory的区别这里就体现出来了，builder模式在java以外的其他语言中也有其使用价值，可以用于构造复杂的可变对象。直接上一个demo最好：

# coding=utf-8
# @Time: 2022/1/10 17:59


class A(object):
    def __init__(self, name: str, gender: str = None, age: int = None):
        self.__name = name
        self.__gender = gender
        self.__age = age

    def setName(self, name: str):
        self.__name = name

    def setGender(self, gender: str):
        self.__gender = gender

    def setAge(self, age: int):
        self.__age = age

    def info(self):
        print("Name: %s, Gender: %s, Age: %s" % (self.__name,
                                                 self.__gender if self.__gender else "Unknown",
                                                 self.__age if self.__age else "Unknown"))


class ABuilder(object):
    def __init__(self):
        self.__A = A(name=None)

    def addName(self, name: str):
        self.__A.setName(name)
        return self

    def addGender(self, gender: str):
        self.__A.setGender(gender)
        return self

    def addAge(self, age: str):
        self.__A.setAge(age)
        return self

    def build(self) -> A:
        return self.__A


if __name__ == '__main__':
    chen = ABuilder().addName("chen").addAge(10).build()
    iuna = ABuilder().addName("iuna").build()
    chen.info()
    iuna.info()