php same method in different classes - php

Question

I have various classes with a method having the same code. Maintenance point of view is a very bad practice.
This is an example of this classes:
Class accountController:
<?php
namespace controller\admin;
class accountController extends \controller\baseController
{
private $table = 'account';
public function itemslist()
{
list($res, $totalcount) = $this->getResultAndCount();
return $this->twig->render('/admin/accounts.html.twig');
}
.
... other methods
.
private function getResultAndCount()
{
$sql = 'SELECT * FROM ' . $this->table;
$count = $this->pdo->rowCount();
$rows = $this->pdo->resultset();
return array($rows, $count);
}
}
Class userController:
<?php
namespace controller\admin;
class userController extends \controller\baseController
{
private $table = 'user';
public function itemslist()
{
list($res, $totalcount) = $this->getResultAndCount();
return $this->twig->render('/admin/users.html.twig');
}
.
... other methods
.
private function getResultAndCount()
{
$sql = 'SELECT * FROM ' . $this->table;
$count = $this->pdo->rowCount();
$rows = $this->pdo->resultset();
return array($rows, $count);
}
}
As shown the method getResultAndCount, having the same code, is duplicated. Not being an expert in OOP I have been searching the way to have just one code somewhere and reference ti it in the itemslistAction() method.
I have seen ways to do this, like having another class with this method and calling it, interfaces, method in the parent class, ... but I'm confused and I wonder wich will be the best way to implemented it and how.

Answer 1

Both of your classes extends \controller\baseController class. You could put the duplicate function in the \controller\baseController class but if you have other classes that extends \controller\baseController and if you are going to use this function only in the classes you declared, you could create a new class that extends \controller\baseController and implement the duplicate function in this class.
<?php
namespace controller\admin;
class bridgeClass extends \controller\baseController
{
//...
protected function getResultAndCount()
{
$sql = 'SELECT * FROM ' . $this->table;
$count = $this->pdo->rowCount();
$rows = $this->pdo->resultset();
return array($rows, $count);
}
}
?>
We implemented the function in the bridgeClass as declared above. Also notice that we changed the visibility of function from private to protected so the child classes can access the function without a problem. Then you can make both of your classes extends bridgeClass. So in that case now both of your classes have bridgeClass and \controller\baseController as their parents.

Answer 2

<?php
namespace controller\admin;
abstract class baseController
{
private $table;
public function itemslist()
{
list($res, $totalcount) = $this->getResultAndCount();
return $this->twig->render('/admin/accounts.html.twig');
}
private function getResultAndCount()
{
$sql = 'SELECT * FROM ' . $this->table;
$count = $this->pdo->rowCount();
$rows = $this->pdo->resultset();
return array($rows, $count);
}
}
Class accountController:
<?php
namespace controller\admin;
class accountController extends \controller\baseController
{
private $table = 'account';
// more method ....
}
Class userController:
<?php
namespace controller\admin;
class userController extends \controller\baseController
{
private $table = 'user';
// more method ....
}

Answer 3

Just scratch:
interface IValue{
public function value();
}
class DBQuery implements IValue{
private $pdo;
private $sql;
public function __construct(...){
....
}
public function value(){
// execute $this->sql
}
}
class LazyTemplate{
private $twig;
private $template;
private $data;
public function __construct(..., IValue $data){
....
}
public function render(){
return $this->twig->render(
$this->template,
$this->data->value()
);
}
}
namespace controller\admin;
class accountController extends \controller\baseController
{
private $items;
public function __construct(...){
$this->items = new LazyTemplate(
$this->twig,
'/admin/accounts.html.twig',
new DBQuery($this->pdo, 'SELECT * FROM account')
);
}
public function itemslist()
{
return $this->items->render();
}
}
class userController extends \controller\baseController
{
private $items;
public function __construct(...){
$this->items = new LazyTemplate(
$this->twig,
'/admin/users.html.twig',
new DBQuery($this->pdo, 'SELECT * FROM user')
);
}
public function itemslist()
{
return $this->items->render();
}
}
P. s. I don't know Twig API, so there may be better way.
Many suggested using inheritance to remove duplication of code. Indeed, inheritance allows you to do this quickly and simply, but consider the shortcomings of this approach:
Our classes are getting bigger, although the domain model does not require it.
We might easily need a few lists, but we have provided only one inheritance. Blow up the base class even more?
Lists may be required elsewhere. Copy the code there and get duplication again?
We just complicate the testing. It was necessary to add a very small aspect that is easy to test, but now we have this part of the whole hierarchy.
It follows from our intentions. What did we really want to say with duplicate code? - I would put it this way: "it is necessary somehow to get the data and * somehow* transfer them to the template". "somehow" is, I would say, the boundaries of abstraction, those places that should be highlighted in separate entities.
"somehow transfer them (data) to a template" - is some kind of entity that, on demand, takes data, gives it to the template and returns the result of the render. I called this entity LazyTemplate, because it performs" lazy calculations "(even without caching, as it usually happens).
LazyTemplate could receive data immediately or through a closure, but I chose the interfaceIValue. Interfaces are "strict types" and we can easily provide parameter checking by PHP itself (5.0+). Also, we do not require these data until the moment of emergency. If our list is hidden, then there is no sense in executing the query to the DB. IValue is simply a contract betweenLazyTemplate and its environment.
"somehow get the data" - this is another entity. Ideally, this entity should not specify the source of this data, but, for simplicity, I decided to immediately describe the class DBQuery. In addition, we already have IValue, which performs the same function.
Of course, we had to introduce several additional abstractions (very small ones, worth noting), but now we can re-use them, extend them (for example, by creating the class CachedValue,DynamicTemplate, etc.) and test only a specific functional.
The controllers still have similar lines of code, but do not blindly try to eradicate duplication. The list of users and the list of accounts are two different lists and they can, in the future, become absolutely incompatible.
P. s. I apologize for any mistakes.