The factory method pattern allows the system to introduce new products without modifying the factory role.

1. Factory Mode

2. Simple Factory Pattern

3. Abstract Factory Pattern

In what situations is it used in actual development? Why do I feel that I rarely use these design patterns in current development? . .

Reply content:

The factory method pattern allows the system to introduce new products without modifying the factory role.

1. Factory Mode

2. Simple Factory Pattern

3. Abstract Factory Pattern

In what situations is it used in actual development? Why do I feel that I rarely use these design patterns in current development? . .

Let me first talk about the examples that I have seen using the factory pattern:

In the general MVC framework, there is a basic DB database basic operation class
I call it DB class, and there is a baseModel class to inherit the db class
baseModel is the base class of all framework models and needs to be inherited. baseModel
baseModel already has methods for adding, deleting, checking and modifying the db class. baseModel is actually a database factory. Different models inherit baseModel and have object instances for operating different data tables. In this way, a basic class is used to complete the instance. It converts objects from different data tables, just like a factory. Passing different table names will return you different objects.
This is my understanding. If there is any mistake, please forgive me and correct me.

Factory pattern is a pattern used to instantiate objects. It is a way to replace the new operation with factory methods. Factory mode is everywhere in Java projects, because factory mode is equivalent to creating new instance objects. For example, in our system, we often need to keep logs. If the initialization work done when creating a logger instance may be a long piece of code, It may require initialization, assignment, data query, etc., which will cause the code to be bloated and ugly.

<code>    private static Logger    logger = LoggerFactory.getLogger(MyBusinessRPC.class);
    
 public static Logger getLogger(String name) {
    ILoggerFactory iLoggerFactory = getILoggerFactory();
    return iLoggerFactory.getLogger(name);
  }

public static ILoggerFactory getILoggerFactory() {
    if (INITIALIZATION_STATE == UNINITIALIZED) {
      INITIALIZATION_STATE = ONGOING_INITIALIZATION;
      performInitialization();
    }
    switch (INITIALIZATION_STATE) {
      case SUCCESSFUL_INITIALIZATION:
        return StaticLoggerBinder.getSingleton().getLoggerFactory();
      case NOP_FALLBACK_INITIALIZATION:
        return NOP_FALLBACK_FACTORY;
      case FAILED_INITIALIZATION:
        throw new IllegalStateException(UNSUCCESSFUL_INIT_MSG);
      case ONGOING_INITIALIZATION:
        // support re-entrant behavior.
        // See also http://bugzilla.slf4j.org/show_bug.cgi?id=106
        return TEMP_FACTORY;
    }
    throw new IllegalStateException("Unreachable code");
  }</code>

If you want to understand the factory pattern, you must know the simple factory pattern.

<code> switch ($type) { 
      case '存款職員': $man = new Depositer; 
      break;
      case '銷售': $man = new Marketer; 
      break; 
      case '接待': $man = new Receiver; 
      break; 
      default: echo '傳輸參數(shù)有誤，不屬于任何一個職位'; 
      break; 
  }
</code>

No, this is the simple factory model. Is it very common? The simple factory model has a shortcoming. Although it follows the single responsibility principle, it violates another very important principle: Open and closed principle. If a new clerk position is added, then we have to modify the corresponding code and add a case. This is very scary, because if we modify the written code again, it may cause unknown effects.

The factory mode is an upgrade to the simple factory. Here is the DB class in MVC. When making an external call, you only need to select the table name you need, and the factory will call the real database processing method and then return the results you want.

Whether it is the factory pattern or other creation patterns, they all have one purpose - to initialize an object. In other words, in order to build a data structure model (classes and objects themselves are a custom data structure).

So, the question is, why can we create an object in this way and use design pattern? Essentially, the reason is that we don’t want upper-level users to directly use new to initialize objects. new

There are many reasons for this, most of which are that

isolates the object creation process from upper-level users; or the object creation process is complicated and difficult for users to master ; Or object creation must meet certain conditions . These conditions may be business needs or system constraints. There is no need for upper-level users to master them and increase the difficulty of development by others.

So, by now we should be clear, whether it is the factory mode or the opening and closing principle mentioned by the comrades above, it is to isolate some complex processes so that these complex processes are not exposed to the outside world. If they are exposed These processes will add trouble to users, which is called teamwork.

Object-oriented encapsulation itself is to make external

as simple as possible. API

例如，你定義了一個 Status字段，但這個字段因為某些業(yè)務(wù)原因，需要使用整數(shù)來表示狀態(tài)。那么，如果數(shù)字少了還好辦，如果數(shù)字多了，上層使用者就不一定能記清楚每個數(shù)字代表的狀態(tài)（比如你要做語音通信系統(tǒng)，那么，語音設(shè)備是有很多狀態(tài)數(shù)字的）。這時，如果使用 new來創(chuàng)建對象，然后再對 Status 進行賦值，不可避免的，可能要查閱開發(fā)文檔，或者會不小心給出一個錯誤的值。這時，你就不妨使用工廠模式，或者其它合適的設(shè)計模式，來進行代碼的建設(shè)。

比如，這樣：

<code>public static class Factory
{
    public static Ixxxxxx CreateWithOpen()
    {
        var obj = new Obj();
        obj.Status = 1;
        return obj;
    }
    public static Ixxxxxx CreateWithClose()
    {
        var obj = new Obj();
        obj.Status = 2;
        return obj;
    }
}
</code>

當(dāng)然，使用枚舉也行，這個說白了，就是看設(shè)計者的意愿了。

所以，設(shè)計模式?jīng)]有說必需在哪個場景中使用，更確切的說，應(yīng)該是，當(dāng)你使用了設(shè)計模式，能不能為你的團隊成員帶來方便，或者提升代碼質(zhì)量，避免一些錯誤。如果是，就用，如果僅僅帶來了復(fù)雜，并沒有益處，那還是算了。

一句話，沒有該不該用，也沒有哪些需要不需要用，用就要帶來效益，無論是對團隊還是產(chǎn)品質(zhì)量或產(chǎn)品的可維護性。用不用，要以團隊配合和產(chǎn)品為導(dǎo)向，這才是對一個軟件設(shè)計師的基本要求。

工廠的職能就是你給它一個模型或者具體的樣品需求，它給你一個成品。工廠模式也是這樣的道理，比如，你入?yún)⑹莂，它就給你一個A對象，你入?yún)，它就給你生產(chǎn)一個B對象，這里a,b就是你讓工廠生產(chǎn)的商品具體需求，如長寬高等。

工廠模式還是很常見的，你沒用到可能是因為項目規(guī)模小，或者是類不夠抽象。

工廠你可以理解為隱藏了內(nèi)部細節(jié)，你調(diào)用工廠的生產(chǎn)API ，直接獲得所描述的物體，具體怎么生產(chǎn)的，你不用去關(guān)注細節(jié)，因為有的東西簡單，直接new出來就可以了，但有的很復(fù)雜，比如spring的注入鏈。要理解工廠模式，建議看看spring實現(xiàn)的factory。