Detailed explanation of PHP's simple factory pattern

This article mainly shares with you a detailed explanation of PHP's simple factory mode. It has a good reference value and I hope it will be helpful to everyone. Let’s follow the editor to have a look.

1. Definition of simple factory

Provides a function to create object instances without having to worry about its specific implementation , the type of the instance being created can be an interface, an abstract class, or a concrete class.

2. The structure and description of a simple factory

The structure of a simple factory is as follows:

##Api: Define the functional interface required by the customer
Impl: Specifically implement the implementation class of Api, there may be multiple
Factory: Factory, select the appropriate implementation class to create the Api interface object
Client: Client, obtain the Api interface object through Factory, and then program for the Api interface

Api interface:

/**
 * 接口的定义，该接口可以通过简单工厂来创建
 * 
 * @author Administrator
 *
 */
public interface Api {

	/**
	 * 具体功能方法的定义
	 * 
	 * @param s
	 *            需要的参数
	 */
	public void operation(String s);
}

ImplA:

/**
 * 接口的具体实现对象A
 * 
 * @author Administrator
 *
 */
public class ImplA implements Api {

	@Override
	public void operation(String s) {
		// 实现的功能
		System.out.println("ImplA s==" + s);

	}

}

ImplB:

/**
 * 接口的具体实现对象B
 * 
 * @author Administrator
 *
 */
public class ImplB implements Api {

	@Override
	public void operation(String s) {
		// 实现的功能
		System.out.println("ImplB s==" + s);

	}

}

Factory:

/**
 * 工厂类，用来创建Api对象
 * 
 * @author Administrator
 *
 */
public class Factory {
	/**
	 * 具体创建Api对象的方法
	 * 
	 * @param condition
	 *            从外部传入的选择条件
	 * @return
	 */
	public static Api createApi(int condition) {
		// 应该根据某些条件去选择究竟创建哪一个具体的实现对象
		// 这些条件可以从外部传入，也可以从其他途径获取
		// 如果只有一个实现，可以省略条件
		Api api = null;
		if (condition == 1) {
			api = new ImplA();
		} else if (condition == 2) {
			api = new ImplB();
		}
		return api;
	}

}

Test class Client:

public class Client {
	public static void main(String[] args) {
		// 通过简单工厂来获取接口对象
		Api api = Factory.createApi(1);
		api.operation("正在使用简单工厂模式");
	}

}

Simple factory calling sequence diagram:

Naming suggestions for simple factories:

Class naming suggestions are "Module name + Factory", for example, the factory of the user module is called UserFactory
The method name is usually "get+interface name" or "create+interface name". For example, if the user interface name is UserEbi, then the method name is usually getUserEbi or createUserEbi.
The main internal function of a simple factory method is "

Select the appropriate implementation class". The selection condition or the source of the parameter is usually Focus on the following:

comes from the client, and the parameters are passed in by the Client.
comes from the configuration file, and is obtained from the configuration file. The judged value
comes from a certain value during the program's running time, such as obtaining a certain running-time value from the cache

Advantages of simple factory:

Help encapsulation
Although simple factory is simple, it is very friendly It helps us realize the encapsulation of components, and then allows the outside of the components to truly interface-oriented programming.

2. Decoupling

Through a simple factory, the client and the specific implementation class are decoupled.

Disadvantages of simple factories: 1. May increase the complexity of the client

2. Inconvenient to expand sub-factories

The essence of a simple factory: choosing an implementation

When to choose a simple factory:

If you want to completely encapsulate and isolate the specific implementation, so that the outside can only operate the package through the interface, then you can choose a simple factory to let the client obtain the corresponding interface through the factory without caring. specific implementation.
If you want to centrally manage and control the responsibilities of creating external objects, you can choose a simple factory.

• 
  

Recommended study: "

PHP Video Tutorial

"

The above is the detailed content of Detailed explanation of PHP's simple factory pattern. For more information, please follow other related articles on the PHP Chinese website!