Interfacce di classe con più classi e iniezione delle dipendenze

NOTA SUL TITOLO DELLA DOMANDA: Non sapevo davvero come esprimere il titolo, quindi se qualcuno può modificarlo e renderlo più articolato, lo apprezzerei molto.

DOMANDA:

In sostanza, quello che sto cercando di fare è creare una classe principale "App" che abbia accesso privato al database e config oggetti e fornisca un'interfaccia per accedere alle proprietà di configurazione e utilizzare i metodi del database.

Sono nuovo dell'intera cosa dell'interfaccia e non l'ho mai usato in precedenza. Potrei sbagliare tutto questo e apprezzare ogni aiuto che chiunque può dare nel indicarmi la giusta direzione. L'interfaccia potrebbe non essere la strada da percorrere, non lo so, ma sembrava il modo giusto per farlo.

Inoltre, sto cercando di integrare questo con un vecchio codice che usa un contenitore delle dipendenze come una specie di interfaccia, suppongo. Lo includerò qui sotto ma non è così cruciale per me perché sto cercando di eliminarlo con questa nuova interfaccia. Ma volevo includerlo per completezza nel caso in cui fosse importante in qualche modo.

Attualmente ricevo errori relativi alla mancata possibilità di accedere alla proprietà privata di app- > _cfg ma sono sicuro che posso farcela, sono più interessato a sapere se sono sulla strada giusta qui. Se quello che sto facendo è una buona pratica o sono lontano.

Quindi cercheremo di sintetizzare questo codice nel modo più chiaro possibile senza incollare un muro di codice qui ...

//overloaded if that matters
class config {
//config stuff, db logins, etc
}

$cfg = new config();

class mysqli {
//db stuff, connect to db, select, insert etc..
}

//Dependency Container mentioned above, not cruicial
//hoping to remove this
class depcon {

    public static $_database;
    public static $_config;

    public static function createDatabaseObject() {

        $db = new mysqli();
        $db->setConfig(self::$_config);
        $db->connect();

        return $db;
    }
}

//hand off config object to container
depcon::$_config = $cfg;

//use container to create object, injecting config
$db = depCon::createDatabaseObject();

//set container db object to obj it just created
depCon::$_database = $db;

class app {

    private $_db;
    private $_cfg;

    public function __contstruct($db, $cfg) {
        $this->setDatabase($db);
        $this->setConfig($cfg);
    }

    private function setConfig($cfg) {
        $this->_cfg = $cfg;
    }

    private function setDatabase($db) {
        $this->_db = $db;
    }
}

$app = new app($db, $cfg);

interface iuser {
    public function getUsers();
    public function addUser(array $data);
}

class user implements iuser {

    private $_app;
    private $users;

    public function __construct($app) {
        $this->setApp($app);
    }

    private function setApp($app) {

        $this->_app = $app;
    }

    public function getUsers() {
        return $this->_app->_db->select('allUsers');
    }

    public function addUser(array $data) {
        return $this->_app->_db->insert($data);
    }
}

Grazie per l'aiuto. Per favore fatemi sapere se ci sono domande.