Factory Design Pattern with Laravel Example

Sometimes when you write code, you may run into the issue of reusing a class over and over again. The Factory Pattern will help you create objects that can be used to create objects of other classes. This pattern is typically used when a set of related classes have similar functionality but require different instantiation. With this pattern, you can use a single factory to produce an instance of each class in your project.

What is the Factory Design Pattern?

Factory is a design pattern used to create objects without exposing the creation logic to the client and referring to the newly created objects using a common interface.

There are three types of factory patterns:

1) Simple Factory Pattern
2) Factory Method Pattern
3) Abstract Factory Pattern

Simple Factory Pattern

In this pattern, a simple factory class is responsible for creating objects. The client class calls the static method of the factory class to create an object. The advantage of this pattern is that the factory class can be changed to create objects of different types without changing the client class.

Factory Method Pattern

In this pattern, the factory class is an abstract class and the concrete classes extend this class to create objects. The advantage of this pattern is that the client class can be changed to use a different concrete factory class.

Abstract Factory Pattern

In this pattern, the factory class is an interface and the concrete classes implement this interface to create objects. The advantage of this pattern is that it allows the client class to be independent of the concrete classes used to create objects.

Examples of Factory Pattern Implementations in Laravel

Factory pattern is used in many parts of the Laravel framework. For example:

The Factory Design Pattern is used in Laravel’s Illuminate\Http\Client\Factory class to abstract the process of creating new HTTP client instances. This allows different HTTP clients implementations to be used depending on the needs of the application. For example, one implementation may be used for local development and testing, while another implementation may be used for production.

Also, Laravel uses this design pattern in its Eloquent ORM. When creating a new Eloquent model, Laravel uses it to initiate instances without manually dealing with creation logic.

In general, the Factory Design Pattern can be used anytime you need to create an object in Laravel and the process is too complex to do so in a single line of code.

Simple Factory Pattern Implementation

Using Laravel service container is the proper way to do it, however, here we use pure PHP to illustrate how it works:

<?php

use GuzzleHttp\Client;

class HttpClientFactory
{
	public static function create() : Client
	{
		return new Client(
			[
				'base_uri' => 'https://api.github.com/',
				'timeout'  => 2.0,
			]
		);
	}
}

$client = HttpClientFactory::create();
$client->get('users');

This is a very basic example of a factory design pattern. In this case, the factory is responsible for creating a new GuzzleHttp\Client instance. It can be used to inject different configuration options depending on the environment or context in which it is being used.

Conclusion

After reading about Factory Design in Laravel, it is clear that this is a powerful tool that can help improve the efficiency of your website. By using this tool, you can easily create new objects and reuse existing ones without having to worry about the code behind them. This can help you save so much time and thus money in the long run.