Taking Java code as an example to explain the simple factory pattern in design patterns

Simply put, the factory pattern is to return a type of object according to the requirements. The meaning of using the factory pattern is that if the instantiation of the object and the code dependency are too large, it will be inconvenient to expand and maintain. The purpose of using the factory is Decouple the instantiation of the object from the main program code. Let’s take a closer look:

1. Introduction to the Simple Factory Pattern
Simple Factory Pattern (Simple Factory), also known as the "static factory method pattern ". It belongs to the "creation pattern" (the pattern of creating objects) and is a special implementation of the "factory method" pattern.
Usually, we use the simple factory pattern to create classes. For example, obtaining a thread pool object is achieved through the simple factory pattern. Its structure diagram is as follows:

Factory: The factory is the core of the simple factory pattern and provides an external interface. If the client or other program wants to obtain the Product object, it must obtain it through the Factory interface.
Abstract products: Abstract products are abstractions of (many) different products. Product can be an interface or abstract class.
Concrete product: The product object returned in the factory is actually created through ConcreteProduct.

2. Simple factory pattern code model

public class Factory {
 public static Product newInstance() {
  return new ConcreteProduct();
 }
}
public abstract Product {
}
public class ConcreteProduct extends Product {
 public ConcreteProduct() {}
}

3. Practical application of simple factory pattern

We are writing a Servlet to process customers When making requests from the client, one Servlet often handles multiple business logics, such as:

protected void doPost(HttpServletRequest request, HttpServletResponse response) {
 String flag = request.getParameter("flag");
 if(flag.equals("service1")) {
  service1();
 }else if(flag.equals("service2")) {
  service2();
 }
 ...
}

The above is the conventional method for our Servlet to handle multiple business logics, writing an if else statement. A better way is to separate the distribution of requests from the Servlet and let the Servlet only handle business logic. We regard various requested Servlets as product classes, javax.servlet.HttpServlet is the product parent class, and javax.servlet.Servlet is the product interface. In this way, we define a ServletFactory, parse the url request in the filter and hand it over to the ServletFactory for processing. That's it. This is a typical simple factory application.

@WebFilter("/TransRequest")
public class TransRequest implements Filter{
 private String servletName;
 @Override
 public void doFilter(ServletRequest request, ServletResponse response,
   FilterChain chain) throws IOException, ServletException {
  HttpServletRequest myRequest = (HttpServletRequest)request;
  //拿到请求的servlet名字， 这里我们约定请求都是/servletName形式
  String names[] = myRequest.getRequestURI().trim().split("/");
  servletName = names[2];
  if( servletName != null) {
  //以下是最典型的两句简单工厂的例子
   Servlet servlet = ServletFactory.createServlet(servletName);
   servlet.service(request, response);
  }else
   chain.doFilter(request, response);
 }

Every time a request comes, we use the factory to produce a servlet. This can be more convenient without configuring a large amount of servlet path information in xml. And this will also make the logic clearer. The servlet only handles business at the business layer.
The factory class is as follows:

public class ServletFactory {
 public static Servlet createServlet(String servletName) throws ServletException {
  if(servletName.equals("servletName1")) {
   return new Service1();
  }else if(servletName.equals("servletName2")){
   return new Service2();
  }else{
   throw new ServletException("No such servlet");
  }
 }
}

Although the above factory class does not abandon the cumbersome if else, it still solves some problems by using the idea of ​​​​a simple factory. Simple factory is a very simple design pattern that is not considered a design pattern, and the problems it solves are also very limited. The above request distribution has been implemented in all major javaEE frameworks, such as Struts2. Of course, the framework is not a simple factory.

4. Summary

The simple factory pattern, in summary, is a factory class, a product interface (in fact, it can also be an abstract class, or even an ordinary parent class) and a group of products that implement The specific product of the interface, and this factory class, creates a specific implementation class based on the parameters passed in, and transforms it up to the interface as a result and returns it.

The above is using Java code as an example to explain the content of the simple factory pattern in the design pattern. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!