Publicado em 30 de set.

Auxilio com abstração de classe

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();
}
}
}

Discussão (2)

Entre ou cadastre-se para participar da discussão

Entrar Criar conta

Matheus Tavares· 30 de set.

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· 13 de out.

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