The Clean Architecture in php

class
UsersController
{
public function
indexAction
() {
$repo
=
new
UserRepository();
$users
=
$repo
->
getAll
();
return
$users
;
}
}
In this example, we have a class, called
UsersController
, that uses another class, called
UserRepository
to get all the users. This code looks much better than the first example, but
it still has a high level of coupling.
Can the
UsersController
function without the
UserRepository
? Definitely not, it’s highly
coupled to it.
Why is Coupling the Enemy?
So what’s the big deal about all this coupling anyway? Who cares?
People who care about having loosely coupled code are:
1. Developers who refactor their code. Do you always get it right the first time? Do
requirements never change on you? We often need to move things around or rework them,
but that’s often hard to do when the code you’re reworking is so tightly bound to code in
several other places. One little change here, a couple dozen regression bugs there.
2. Developers who like to test their code. Testing code can be an absolute pain if the code
is tightly coupled. Often, we want to test just one component of an application at a time, in
isolation – unit testing. But that’s impossible when one class requires a dozen other classes
to run, and instantiates them itself.
3. Developers who like to reuse their code. Reusing code is great! Writing the same code
twice sucks. Reusing one piece of code is absolutely impossible when it is tightly coupled
to the rest of your application. You can’t just copy the class out and drop it in another
project without either hacking away it’s coupling, or bringing everything else with it. For
shame.
Simply put, coupling is the enemy of developers everywhere as it makes their future lives
incredibly difficult. Don’t screw over your future self.