Validation and the Single Responsibility Principle in Object Orientated Programming

When writing software program, you’ll spend a big portion of time creating code that takes an object, validates it after which performs some actions. One of many core tenets of SOLID code is the Single Accountability Precept, and this implies there ought to be a separation of the code that validates the item and the code that executes the motion.

An instance state of affairs is likely to be: Consumer A submits cost of £100 to Consumer B.

On the floor, this appears quite simple and might be carried out utilizing the next logic. The examples on this put up can be PHP however apply to any object-orientated language

We use a PaymentManager to switch the requested funds between two customers from the above code. On this state of affairs, the PaymentRequest object holds the details about the origin/vacation spot and funds despatched.

While this meets the factors of shifting the funds, there are checks that the system must conduct earlier than executing such a request in the true world. Among the checks may embrace:

  • Is the origin account energetic?
  • Is the vacation spot account energetic?
  • Does the origin account have accessible funds to cowl the cost quantity?
  • Is the PaymentRequest quantity legitimate? e.g. it isn’t logical to pay an quantity of zero (or much less)

The factors listed are essential to the appliance, and consequently, it might be tempting to conduct these checks much like the under:

This code works, nevertheless it violates SRP because the perform is now validating the request and calling the cost supervisor. Because the enterprise necessities get extra complicated, this class will proceed to develop and grow to be tough to keep up. 

For instance - performance has been added to the platform, enabling customers to dam each other. Because of this, a consumer shouldn’t be capable of ship funds to a consumer who has blocked them. This is able to require an extra, conditional assertion to be added to the perform.

Validation Lessons

A significantly better means of dealing with this state of affairs is to summary the validation logic away from the execution. This may be achieved by implementing the under:

The validation logic has been extracted to its personal class. This separates the code properly and ensures we won’t be compelled to replace this class each time guidelines are modified or added. It additionally has the advantage of making our unit assessments a lot simpler to jot down. To check the MakePaymentJob we are able to mock the validate() technique as true or false and take a look at whether or not our paymentManager->makePayment() known as.

The validation class itself features as under:

Along with extracting the principles to a validation class, I moved every rule to a personal technique. The descriptive naming of the tactic gives higher context and improves readability while creating a wonderful base for writing unit assessments. I wrote a put up about how we’d take a look at code like this beforehand - you may test it out here.


The validation sample above is vastly improved over the unique code; nonetheless, it may nonetheless do with a couple of changes. For instance, returning false from a failed validation try gives no context for the calling shopper why the request failed. If the paymentRequest failed as a result of the consumer didn’t have sufficient funds, that is one thing we might need to talk to the consumer.

We are able to obtain this by making minor changes to the PaymentValidator class.

The above is a crude demonstration - when working validations throughout a codebase it will be higher to create validation strategies for widespread assertions. Within the instance above it’s a easy better than conditional. There may simply be an agnostic technique in a validation namespace to deal with normal guidelines. Lessons wishing to implement guidelines can then inject the required guidelines.


There are many methods to deal with the precise validation of the objects, however the necessary half is to make sure this logic is separate. It can make extending the principles a lot simpler sooner or later and improve the testability of your code.

Add a Comment

Your email address will not be published. Required fields are marked *