Auxilio com abstração de classe

[Nerdmonkey 3]

Peço a opinião de vocês quanto ao nível de abstração da classe abaixo.

 

Criei o objeto e me retornou sucesso.

 

Quero entender em que nível estou pra saber a hora de partir para novos paradigmas como por exemplo o design pattern que algo que sempre ouço falar mas nunca parei pra estudar o conceito e uso.

 
$config = new Configuration('hostname', 'hostUsername', 'hostPassword', 'database', 'email', 'password');
 

<?php
class Configuration extends ReceiveDataConfiguration
{
public function __construct($hostname, $hostUsername, $hostPassword, $database, $email, $password)
{
parent::__construct($hostname, $hostUsername, $hostPassword, $database, $email, $password);
}
}

ReceiveDataConfiguration.php

<?php
abstract class ReceiveDataConfiguration
{
/** @var mixed $connect */
private $connect;

/** @var string $hostname */
private $hostname;

/** @var string $hostUsername */
private $hostUsername;

/** @var string $hostPassword */
private $hostPassword;

/** @var string $database */
private $database;

/** @var string $email */
private $email;

/** @var string $password */
private $password;

public function __construct($hostname, $hostUsername, $hostPassword, $database, $email, $password)
{
$this->setHostname($hostname);
$this->setHostUserName($hostUsername);
$this->setHostPassword($hostPassword);
$this->setDatabase($database);
$this->setEmail($email);
$this->setPassword($password);
$this->tryConnect();
}

/**
* @param $hostname
* @return mixed
*/
private function setHostname($hostname)
{
$this->hostname = $hostname;
return $this->hostname;
}

/**
* @param $hostUsername
* @return string
*/
private function setHostUserName($hostUsername)
{
$this->hostUsername = $hostUsername;
return $this->hostUsername;
}

/**
* @param $hostPassword
* @return mixed
*/
private function setHostPassword($hostPassword)
{
$this->hostPassword = $hostPassword;
return $this->hostPassword;
}

/**
* @param $database
* @return mixed
*/
private function setDatabase($database)
{
$this->database = $database;
return $this->database;
}

/**
* @param $email
* @return mixed
*/
private function setEmail($email)
{
$this->email = $email;
return $this->email();
}

/**
* @param $password
* @return mixed
*/
private function setPassword($password)
{
$this->password = $password;
return $this->password;
}

/**
* Try to connect with database using the data informed
* @return string
*/
private function tryConnect()
{
try{
$this->connect = new \PDO("mysql:host{$this->hostname};dbname={$this->database}", $this->hostUsername, $this->hostPassword);
$this->connect->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

if($this->connect == true):
echo 'foi';
endif;
}catch(\Exception $e){
return $e->getCode() . ' ' . $e->getMessage();
}
}
}

[Matheus Tavares 167]

Amigo, gostei muito do seu questionamento.

 

Sobre "o nível de abstração", eu não enxerguei abstração nenhuma, ou quase nenhuma.

 

Entenda: Você está criando uma classe de configuração, informando todos os parâmetros manualmente para que eles sejam lidos por outra classe, que irá definir novamente os valores manualmente.

 

O erro vem do conceito: herança não determina faz, e sim é-um.

 

Conexão do banco é uma coisa, configuração é outra. Concorda comigo? Então por que ReceiveDataConfiguration (que pelo nome deveria "receber" dados, mas até a conexão ela faz) é estendida por Configuration?

 

Analise esta abordagem:

MySql.php

<?php
class MySql {


    /* @var PDO */
    private $Connection;


    /* @var ConfiguracoesBanco */
    private $Configs;


    public function __construct( ConfiguracoesBanco $Configs ) {
        $this->Configs = $Configs;
    }


    public function connect() {
        try{
            $this->Connection = new PDO(
                sprintf(
                    'mysql:host{%s};dbname={%s}',
                    $this->Configs->hostname,
                    $this->Configs->database
                ),
                $this->Configs->username,
                $this->Configs->password
            );
            $this->Connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);


            if( $this->Connection )
                echo 'foi';//apenas para fins didáticos. echos não devem existir aqui


        } catch( Exception $e) {
            return $e->getCode() . ' ' . $e->getMessage();
        }
    }
}

ConfiguracoesBanco.php

<?php
class ConfiguracoesBanco {


    public $hostname;
    public $database;
    public $username;
    public $password;
    public $port;


    public function __construct( $hostname, $database, $username, $password, $port = 3306 ) {
        $this->hostname = $hostname;
        $this->database = $database;
        $this->username = $username;
        $this->password = $password;
        $this->port = $port;
    }


}

teste.php

<?php
require_once( 'Banco.php' );
require_once( 'ConfiguracoesBanco.php' );

$Configs = new ConfiguracoesBanco( 'localhost', 'xxx', 'xxx', 'xxx' );
$Banco = new MySql( $Configs );//Aqui vem a mágica

$Banco->connect();// 'foi'

Obs: Este é apenas um exemplo didático. O código ainda pode ser muito melhorado e remodelado. Os getters e setters foram removidos para diminuir linhas.

 

Abraços e bons estudos!

[Nerdmonkey 3]

E ai Matheus, vlw pela atenção. Entendi sim sua explicação e até funcionou bem com algumas poucas modificações.

 

Agora uma dúvida, porque não consigo validar o método connect() como um booleano?

 

Ps.: Mesmo eu informando os dados inválidos ele nunca cai na exceção, sempre fica no try. Se eu tentar um prepare() ok, ele muda o fluxo, mas preciso validar tudo antes de qualquer ação no banco. É só uma das alternativas, já tentei com as condições também:

try {
$connect->connect();
echo json_encode(var_dump($connect->connect()));
}catch(Exception $e) {
echo json_encode($e->getMessage());
}

Independente da resposta ele diz, feliz e contente, que está tudo ok até que algum ação no banco seja requisitada e seu uso seja necessário. Ai ele volta chorando dizendo que não consegue se comunicar haha