How To Use Open Closed Principle in PHP/Laravel

Mohasin Hossain — Fri, 11 Aug 2023 05:20:58 +0000

In this tutorial, I’ll show you in a very simple way with an example, how you can use OCP(Open Closed Principle) in PHP/Laravel. let’s start walking…

At first, let me explain what is Open closed Principle

Open Closed principle is the 2nd principle of the SOLID principle. In SOLID O is stand for Open Closed principle. Open Closed principle means A class/method should be open for extension but closed for modification, which means you can change behavior without modifying source code. You shouldn’t touch the root/main code. The main idea of this principle is to keep existing code from breaking when you implement new features, which means extending functionality by adding new code instead of changing existing code. In the programmatical word “Separate extensible behavior behind an interface, and flip the dependencies”, that means separate the behaviors, so the system can easily be extended, but never broken.

Goal: Get to a point where you can never break the core of your system.

Let me give you some real-life example

At first, you need to imagine or think about where you actually break or violate the OCP(Open Closed principle) in real-life project. Imagine you have an eCommerce project where you have multiple payment method options and you may integrate more payment method in future in time to time and in this point there are chances to break OCP(Open Closed principle). Now drive into the deep. Look at the picture billow.

You can see in pay method there are two payment method credit card and PayPal.

And in payment class you also see two method for two different payment methods. And still now you are in safe zone. you are not breaking OCP(Open Closed Principle) but if you want to add another payment method like the picture below and now you are breaking OCP(Open Closed Principle) as you are modify the existing pay method, not extending.

You also breaking OCP(Open Closed Principle) in payment class as you are modify the payment class instead of extending like the picture below.

Now the question, how you can write code without breaking the OCP(Open Closed Principle). How you can extend code instead of modifying the existing code. How you can add functionality without modifying or touching the exiting code. now I’ll show you How. we solve the problem with “Factory Design Pattern”. Let’s solve the OCP violation! See the picture carefully given below.

In the picture above you can see PayableInterface with pay method and three different payment method classes like CreditCardPayment, PaypalPayment, WirePayment. Every class implements the PayableInterface & uses the pay method of PayableInterface.

N.B. If any class implements an interface then the class must use all the methods of that interface.

Now we need to create a Payment factory class where we can initialize our payment methods in the initializePayment method like the picture below. if we need to add more payment methods we can add easily without modifying the existing code like before. we just need to initialize the payment method from our Payment factory class & create a new payment method class by implementing our PayableInterface. that’s it.

Now you can just call the pay method by passing only the payment method type in the payment factory class via initializePayment method like the picture below.

In conclusion, the Open Closed principle is very simple to follow, it helps to add new features or functionality by extending existing code instead of modifying existing code. To follow the OCP you just need to be concerned about is, will I modify my code for adding new features or functionality in the future.

For more details of SOLID principle, you may have a look at the link given below. Please feel free to leave a comment if you have any feedback, questions or want me to write about another PHP/Laravel related topic.

https://github.com/mohasinhossain/SOLID-Principles-in-PHP

How To Use Liskov Substitution Principle in PHP/Laravel

Mohasin Hossain — Thu, 03 Aug 2023 07:01:08 +0000

In this tutorial, I’ll show you in a very simple way with an example, how you can use LSP(Liskov Substitution Principle) in PHP/Laravel. let’s start walking…

At first, let me explain what is Liskov Substitution Principle

Liskov Substitution Principle is the 3rd principle of the SOLID principle. In SOLID L is stand for the Liskov Substitution principle. Liskov Substitution principle means any implementation of an abstraction or an interface should be substitutable anywhere that the abstraction is accepted. When extending a class, remember that you should be able to pass objects of the subclass in place of objects of the parent class without breaking the client code. This means that the subclass should remain compatible with the behavior of the superclass. When overriding a method, extend the base behavior rather than replacing it with something else entirely. Every class that implements an interface, must be able to substitute any reference throughout the code that implements that same interface. Every part of the code should get the expected result no matter what instance of a class you send to it, given it implements the same interface.

keynotes of LSP(Liskov Substitution Principle)

Signature must match
Precondition can’t be greater
Postconditions at least equal to
Exception types must match

Let’s drive into deep

You see the picture above is the most familiar & common real-life example for LSP(Liskov Substitution Principle). There is two duck one is real & the other is a rubber duck. Both are looking the same but their activity is not the same. Look at the picture below.

In the picture above you see RubberDuck class extends Duck and has three methods. quack(), fly() and swim().In this class, we are violating LSP as we are overriding the method & throw Exceptions which is not matched with the parent Duck class. Real duck can fly but rubber duck can’t fly and the return type of fly method is not the same so at this point, we are breaking the LSP.

Let’s fix the LSP(Liskov Substitution Principle) violation.

We can extend our code to different interfaces like the picture below.

In the picture above we have three different interfaces are QuackableInterface, FlyableInterface, SwimmableInterface. now we can implement the interface we need for our RubberDuck class like QuackableInterface and SwimmableInterface, as the rubber duck can quack or swim by helping 3rd person but it never can fly so couldn’t implement FlyableInterface. that’s how we can solve the LSP violation.

In conclusion, the Liskov Substitution Principle is very simple to follow, it gives the ability for every child class to substitute its parent class. To follow the LSP you just need to be concerned about is, the return type & exception type of any method of a child class must match with its parent class or the interface that is implemented.

For more details of SOLID principle, you may have a look at the link given below. Please feel free to leave a comment if you have any feedback, questions or want me to write about another PHP/Laravel related topic.

DEV Community: Mohasin Hossain

How To Use Open Closed Principle in PHP/Laravel

How To Use Liskov Substitution Principle in PHP/Laravel