Estudando sobre PHP POO - ajuda

[George Feitosa Jr 3]

Eai pessoal, seguinte estou estudando sobre como programar orientado a objetos no php e estava com algumas duvidas semana passada. Hoje estou tentando fazer um sistema simples de login(ainda estou terminando ele xD), mas orientado a objetos para ver se estou indo bem. Procurei a todo tempo fazer com que as classes sejam totalmente reutilizáveis. Poderiam analisar meu código e me informar se estou cometendo erros?

 

Classe que faz a conexão com o banco de dados

	class Conexao {
		private $dsn, $user, $pass;
		protected $pdo;
		public function __construct($dsn, $user, $pass){
			$this->dsn = $dsn;
			$this->user = $user;
			$this->pass = $pass;
			$this->connect();
		}
		public function connect(){
			try{
				return $this->pdo = new PDO($this->dsn, $this->user, $this->pass);
			} catch(PDOException $e){
				die('Falha na conexão com o banco de dados').$e->getMessage();
			}
		}
		
	}

Classe que resgata, edita, deleta e atualiza a tabela no banco de dados

	class CRUD extends Conexao{
		
		private $sql;
		private $table;
		private $values;
		private $condition;

		public function __construct($table){
			parent::__construct("mysql:host=localhost;dbname=sistema_compras;","root","");
			$this->table = $table;
		}
		public function readDocumment($condition = null){
			$this->condition = $condition;	
			
			if($this->condition != null){
				$this->sql = "SELECT * FROM {$this->table} WHERE {$this->condition}";
			}else{
				$this->sql = "SELECT * FROM {$this->table}";
			}
			return $this->query($this->sql)->fetchAll(PDO::FETCH_ASSOC);
		}
		public function query($sql){
			return $this->pdo->query($sql);
		}
		public function insertDocumment($values){
			$this->values = $values;
			
			$this->sql = "INSERT INTO $this->table SET $this->values";
			$this->query($this->sql);
		}
		public function updateDocumment($values, $condition){
			$this->condition = $condition;
			$this->values = $values;
			
			$this->sql = "UPDATE $this->table SET $this->values WHERE $this->condition";
			$this->query($this->sql);
		}
		public function deleteDocumment($condition){
			$this->condition = $condition;
			$this->sql = "DELETE FROM $this->table WHERE $this->condition";
			$this->query($this->sql);
		}
	}

Classe que fica responsável pelo login do usuário

	class Login extends CRUD{

		private $email, $pass;
		private $checkUser, $user;

		/*AQUI É INFORMADA A TABELA QUE VAI SER PROCURADO O USUARIO*/
		public function __construct($table){
			parent::__construct($table);
		}
		/*MÉTODO PARA PROCURAR O USUARIO NO BANCO DE DADOS*/
		public function getUser($cond){
			/*EXECUTA A QUERY DENTRO DA CLASSE CRUD PARA PROCURAR O USUARIO*/
			$this->checkUser = parent::readDocumment($cond);
			
			/*SE NAO ACHAR NADA, INFORMA QUE OS DADOS ESTAO INCORRETOS*/
			if(!$this->checkUser){
				echo ('Dados incorretos');
			}else{
				/*SE ACHAR ELE RETORNA OS ARRAYS DO USUARIO*/
				foreach($this->checkUser as $this->user){
					return $this->user;
				}
			}
		}
	}

	$login = new Login("usuario_tb");
	
	$usuario = 'usuario@email.com';
	$senha = 'senha12345';
	
	$dados = $login->getUser("email_usuario = '$usuario' AND senha_usuario = '$senha'");
	
	if($dados){
		extract($dados);
		echo 'Bem vindo - '.$nome_usuario;
	}

enfim pessoal é isso, o que vocês acham? Estou ainda tendo uma ideia muito errada sobre poo ou estou indo pelo caminho certo?  t+

[Williams Duarte 431]

Sua Classe de Conexão pode implementar o Pattern Registry ou Singleton. Dessa forma você evita abrir mais de uma conexão a cada instancia da classe.

 

Login não é CRUD, então não faz sentido herdar funcionalidades! Basta injetar através do construtor!

 

Você está injetando dados de acesso através da Classe CRUD.

 

CRUD.php

public function __construct($table){
     parent::__construct("mysql:host=localhost;dbname=sistema_compras;","root","");
     $this->table = $table;
}

O correto é ter um arquivo de configuração "config.php", desta forma você injetaria diretamente na conexão.

 

 

Onde mais você usa esses objetos?

 

private $sql; private $table; private $values; private $condition;

Há não ser no próprio escopo da função, declarando nelas uma variável local, que pode ser simplesmente usada diretamente!

[Don Benatti 28]

Existe um problema aqui:

 

Citar

public function connect(){
    try{
        return $this->pdo = new PDO($this->dsn, $this->user, $this->pass);
    } catch(PDOException $e){
        die('Falha na conexão com o banco de dados').$e->getMessage();
    }
}

 

E dois problemas aqui:

Citar

die('Falha na conexão com o banco de dados') . $e->getMessage();

 

não coloque "$e->getMessage()" concatenado com die, não é este o objetivo de die

Indico algo como:

die("Falha na conexão com o banco de dados: {$e->getMessage()}");

 

Dito isso, o problema em "connect" é que você está parando todo o sistema de dentro de uma classe sem permitir que a exceção seja tratada de fora, nesse caso, você pode criar sua própria classe que implemente "Throwable" ou extenda "Exception", pois não pode deixar que uma exceção tipo PDO seja esperada, pois esse tipo gerenciador não deve ser conhecido.

Veja um exemplo somente para o método "connect"

 

DataBaseConnectionException.php

class DataBaseConnectionException extends Exception
{}

Exemplo:

/**
* @throws DataBaseConnectionException
*/
public function connect() 
{
    try {
        return $this->pdo = new PDO($this->dsn, $this->user, $this->pass);
    } 
    catch(PDOException $e) {
        throw new DataBaseConnectionException($e->getMessage());
    }
}

 

Dessa maneira a exceção será tratada de fora

try {
    $conexao->connect(/*[...]*/
} 
catch(DataBaseConnectionException $e) {
    // Faça algo com $e
}

 

[George Feitosa Jr 3]

@Don Benatti Obrigado pela ajuda! vou corrigir isso.

[Williams Duarte 431]

Tirando o erro de concatenação, a solução sugerida em criar uma Exception personalizada, é a mesma coisa de dar a volta e parar no mesmo lugar.

 

Pois ambas as Exceptions, tanto PDOException e  DataBaseConnectionException, vai estender métodos da classe nativa Exception. Se quer capturar o erro da exceção em Runtime, use Monolog, muito mais simples.