The Clean Architecture in php

interface
CustomerRepositoryInterface {
public function
getAll
();
public function
getBy
(
$conditions
);
public function
getById
(
$id
);
public function
save
(Customer
$customer
);
}
As you can see, again, we have a simple PHP interface, uncoupled from anything but the Domain
Model (through the usage of
Customer
). This interface doesn’t do anything. It simply defines a
contract to be followed by an actual implementation. We’ll talk about that implementation in
Database Infrastructure / Persistence in a little bit.
The Domain Services layer should contain a definition of all the repositories an application
will need to properly function, as well as each repository containing all the methods that the
application will need to interact with the data.
Factories
Factories are responsible for creating objects. At first, that seems a little silly as creating an object
is as simple as:

---

Database Independence
87
$customer
=
new
Customer();
It’s not always this easy, however. Sometimes, complex logic goes into creating a customer. If you
notice above when we defined the
Customer
class, we gave it a credit limit and status attribute.
It might be that all customers get set to a certain state when they’re created such that these two
attributes are always set to a predefined value. If we were to continue with simple instantiation:
$customer
=
new
Customer();
$customer
->
setCreditLimit
(
0
);
$customer
->
setStatus
(
'pending'
);
Now let’s assume we might have several different places in the code where we create customers.
We now have to repeat this code all over the place. If these default rules ever change, we then
have several places we need to go change the code. If we miss some, now we have bugs in the
code.
Using a factory lets us consolidate that code and make it reusable: