[Resolvido] Classe de conexao

[Jefferson Fernandes_81308 0]

Ola pessoal,andei lendo alguns tutoriais de classes de conexao para aprender melhor sobre classes em php pois nao domino.

 

 

Achei um script pronto na net que gostaria de testar...

mas nao sei como aplicar uma conexao com o DB nele...

poderiam me ajudar?

 

 

class Usuario {
/**
 * Nome do banco de dados onde está a tabela de usuários
 * 
 * @var string
 * @since v1.0
 */
var $bancoDeDados = '127.0.0.1';

/**
 * Nome da tabela de usuários
 * 
 * @var string
 * @since v1.0
 */
var $tabelaUsuarios = 'usuarios';

/**
 * Nomes dos campos onde ficam o usuário, a senha e o e-mail de cada usuário
 * 
 * Formato: tipo => nome do campo na tabela
 * 
 * O campo (email) só é necessário para o "Esqueci minha senha"
 * 
 * @var array
 * @since v1.0
 */
var $campos = array(
	'usuario' => 'usuario',
	'senha' => 'senha'
);

/**
 * Nomes dos campos que serão pegos da tabela de usuarios e salvos na sessão,
 * caso o valor seja false nenhum dado será consultado
 * 
 * @var mixed
 * @since v1.0
 */
var $dados = array('id', 'nome');

/**
 * Inicia a sessão se necessário?
 * 
 * @var boolean
 * @since v1.0
 */
var $iniciaSessao = true;

/**
 * Prefixo das chaves usadas na sessão
 * 
 * @var string
 * @since v1.0
 */
var $prefixoChaves = 'usuario_';

/**
 * Usa um cookie para melhorar a segurança?
 * 
 * @var boolean
 * @since v1.0
 */
var $cookie = true;

/**
 * O usuário e senha são case-sensitive?
 * 
 * Em valores case-sensitive "casa" é diferente de "CaSa" e de "CASA"
 * 
 * @var boolean
 * @since v1.1
 */
var $caseSensitive = true;

/**
 * Filtra os dados antes de consultá-los usando mysql_real_escape_string()?
 * 
 * @var boolean
 * @since v1.1
 */
var $filtraDados = true;

/**
 * Quantidade (em dias) que o sistema lembrará os dados do usuário ("Lembrar minha senha")
 * 
 * Usado apenas quando o terceiro parâmetro do método Usuario::logaUsuario() for true
 * Os dados salvos serão encriptados usando base64
 * 
 * @var integer
 * @since v1.1
 */
var $lembrarTempo = 1;

/**
 * Diretório a qual o cookie vai pertencer
 * Atenção: Não edite se você não souber o que está fazendo!
 * 
 * @var string
 * @since v1.1
 */
var $cookiePath = '/';

/**
 * Armazena as mensagens de erro
 * 
 * @var string
 * @since v1.0
 */
var $erro = '';

/**
 * Codifica a senha do usuário
 * 
 * Modifique esse método caso você use alguma senha encriptada
 * 
 * @access public
 * @since v1.0
 *
 * @param string $senha A senha que será codificada
 * @return string A senha já codificada
 */
function codificaSenha($senha) {
	// Altere aqui caso você use, por exemplo, o MD5:
	// return md5($senha);
	return $senha;
}

/**
 * Verifica se um usuário existe no sistema
 * 
 * @access public
 * @since v1.0
 * @uses Usuario::codificaSenha()
 * 
 * @param string $usuario O usuário que será validado
 * @param string $senha A senha que será validada
 * @return boolean Se o usuário existe
 */
function validaUsuario($usuario, $senha) {
	$senha = $this->codificaSenha($senha);

	// Filtra os dados?
	if ($this->filtraDados) {
		$usuario = mysql_escape_string($usuario);
		$senha = mysql_escape_string($senha);
	}

	// Os dados são case-sensitive?
	$binary = ($this->caseSensitive) ? 'BINARY' : '';

	// Procura por usuários com o mesmo usuário e senha
	$sql = "SELECT COUNT(*) AS total
			FROM `{$this->bancoDeDados}`.`{$this->tabelaUsuarios}`
			WHERE
				{$binary} `{$this->campos['usuario']}` = '{$usuario}'
				AND
				{$binary} `{$this->campos['senha']}` = '{$senha}'";
	$query = mysql_query($sql);
	if ($query) {
		// Total de usuários encontrados
		$total = mysql_result($query, 0, 'total');

		// Limpa a consulta da memória
		mysql_free_result($query);
	} else {
		// A consulta foi mal sucedida, retorna false
		return false;
	}

	// Se houver apenas um usuário, retorna true
	return ($total == 1) ? true : false;
}

/**
 * Tenta logar um usuário no sistema salvando seus dados na sessão e cookies
 * 
 * @access public
 * @since v1.0
 * @uses Usuario::validaUsuario()
 * @uses Usuario::lembrarDados()
 *
 * @param string $usuario O usuário que será logado
 * @param string $senha A senha do usuário
 * @param boolean $lembrar Salvar os dados em cookies? (Lembrar minha senha)
 * @return boolean Se o usuário foi logado
 */
function logaUsuario($usuario, $senha, $lembrar = false) {			
	// Verifica se é um usuário válido
	if ($this->validaUsuario($usuario, $senha)) {

		// Inicia a sessão?
		if ($this->iniciaSessao AND !isset($_SESSION)) {
			session_start();
		}

		// Filtra os dados?
		if ($this->filtraDados) {
			$usuario = mysql_real_escape_string($usuario);
			$senha = mysql_real_escape_string($senha);
		}

		// Traz dados da tabela?
		if ($this->dados != false) {
			// Adiciona o campo do usuário na lista de dados
			if (!in_array($this->campos['usuario'], $this->dados)) {
				$this->dados[] = 'usuario';
			}

			// Monta o formato SQL da lista de campos
			$dados = '`' . join('`, `', array_unique($this->dados)) . '`';

			// Os dados são case-sensitive?
			$binary = ($this->caseSensitive) ? 'BINARY' : '';

			// Consulta os dados
			$sql = "SELECT {$dados}
					FROM `{$this->bancoDeDados}`.`{$this->tabelaUsuarios}`
					WHERE {$binary} `{$this->campos['usuario']}` = '{$usuario}'";
			$query = mysql_query($sql);

			// Se a consulta falhou
			if (!$query) {
				// A consulta foi mal sucedida, retorna false
				$this->erro = 'A consulta dos dados é inválida';
				return false;
			} else {
				// Traz os dados encontrados para um array
				$dados = mysql_fetch_assoc($query);
				// Limpa a consulta da memória
				mysql_free_result($query);

				// Passa os dados para a sessão
				foreach ($dados AS $chave=>$valor) {
					$_SESSION[$this->prefixoChaves . $chave] = $valor;
				}
			}
		}

		// Usuário logado com sucesso
		$_SESSION[$this->prefixoChaves . 'logado'] = true;

		// Define um cookie para maior segurança?
		if ($this->cookie) {
			// Monta uma cookie com informações gerais sobre o usuário: usuario, ip e navegador
			$valor = join('#', array($usuario, $_SERVER['REMOTE_ADDR'], $_SERVER['HTTP_USER_AGENT']));

			// Encripta o valor do cookie
			$valor = sha1($valor);

			// Cria o cookie
			setcookie($this->prefixoChaves . 'token', $valor, 0, $this->cookiePath);
		}

		// Salva os dados do usuário em cookies? ("Lembrar minha senha")
		if ($lembrar) $this->lembrarDados($usuario, $senha);

		// Fim da verificação, retorna true
		return true;


	} else {
		$this->erro = 'Usuário inválido';
		return false;
	}
}

/**
 * Verifica se há um usuário logado no sistema
 * 
 * @access public
 * @since v1.0
 * @uses Usuario::verificaDadosLembrados()
 *
 * @param boolean $cookies Verifica também os cookies?
 * @return boolean Se há um usuário logado
 */
function usuarioLogado($cookies = true) {
	// Inicia a sessão?
	if ($this->iniciaSessao AND !isset($_SESSION)) {
		session_start();
	}

	// Verifica se não existe o valor na sessão
	if (!isset($_SESSION[$this->prefixoChaves . 'logado']) OR !$_SESSION[$this->prefixoChaves . 'logado']) {
		// Não existem dados na sessão

		// Verifica os dados salvos nos cookies?
		if ($cookies) {
			// Se os dados forem válidos o usuário é logado automaticamente
			return $this->verificaDadosLembrados();
		} else {
			// Não há usuário logado
			$this->erro = 'Não há usuário logado';
			return false;
		}
	}

	// Faz a verificação do cookie?
	if ($this->cookie) {
		// Verifica se o cookie não existe
		if (!isset($_COOKIE[$this->prefixoChaves . 'token'])) {
			$this->erro = 'Não há usuário logado';
			return false;
		} else {
			// Monta o valor do cookie
			$valor = join('#', array($_SESSION[$this->prefixoChaves . 'usuario'], $_SERVER['REMOTE_ADDR'], $_SERVER['HTTP_USER_AGENT']));

			// Encripta o valor do cookie
			$valor = sha1($valor);

			// Verifica o valor do cookie
			if ($_COOKIE[$this->prefixoChaves . 'token'] !== $valor) {
				$this->erro = 'Não há usuário logado';
				return false;
			}
		}
	}

	// A sessão e o cookie foram verificados, há um usuário logado
	return true;
}

/**
 * Faz logout do usuário logado
 * 
 * @access public
 * @since v1.0
 * @uses Usuario::limpaDadosLembrados()
 * @uses Usuario::usuarioLogado()
 * 
 * @param boolean $cookies Limpa também os cookies de "Lembrar minha senha"?
 * @return boolean
 */
function logout($cookies = true) {
	// Inicia a sessão?
	if ($this->iniciaSessao AND !isset($_SESSION)) {
		session_start();
	}

	// Tamanho do prefixo
	$tamanho = strlen($this->prefixoChaves);

	// Destroi todos os valores da sessão relativos ao sistema de login
	foreach ($_SESSION AS $chave=>$valor) {
		// Remove apenas valores cujas chaves comecem com o prefixo correto
		if (substr($chave, 0, $tamanho) == $this->prefixoChaves) {
			unset($_SESSION[$chave]);
		}
	}

	// Destrói asessão se ela estiver vazia
	if (count($_SESSION) == 0) {
		session_destroy();

		// Remove o cookie da sessão se ele existir
		if (isset($_COOKIE['PHPSESSID'])) {
			setcookie('PHPSESSID', false, (time() - 3600));
			unset($_COOKIE['PHPSESSID']);
		}
	}

	// Remove o cookie com as informações do visitante
	if ($this->cookie AND isset($_COOKIE[$this->prefixoChaves . 'token'])) {
		setcookie($this->prefixoChaves . 'token', false, (time() - 3600), $this->cookiePath);
		unset($_COOKIE[$this->prefixoChaves . 'token']);
	}

	// Limpa também os cookies de "Lembrar minha senha"?
	if ($cookies) $this->limpaDadosLembrados();

	// Retorna SE não há um usuário logado (sem verificar os cookies)
	return !$this->usuarioLogado(false);
}

/**
 * Salva os dados do usuário em cookies ("Lembrar minha senha")
 * 
 * @access public
 * @since v1.1
 * 
 * @param string $usuario O usuário que será lembrado
 * @param string $senha A senha do usuário
 * @return void
 */
function lembrarDados($usuario, $senha) {	
	// Calcula o timestamp final para os cookies expirarem
	$tempo = strtotime("+{$this->lembrarTempo} day", time());

	// Encripta os dados do usuário usando base64
	// O rand(1, 9) cria um digito no início da string que impede a descriptografia
	$usuario = rand(1, 9) . base64_encode($usuario);
	$senha = rand(1, 9) . base64_encode($senha);

	// Cria um cookie com o usuário
	setcookie($this->prefixoChaves . 'lu', $usuario, $tempo, $this->cookiePath);
	// Cria um cookie com a senha
	setcookie($this->prefixoChaves . 'ls', $senha, $tempo, $this->cookiePath);
}

/**
 * Verifica os dados do cookie (caso eles existam)
 * 
 * @access public
 * @since v1.1
 * @uses Usuario::logaUsuario()
 * 
 * @return boolean Os dados são validos?
 */
function verificaDadosLembrados() {
	// Os cookies de "Lembrar minha senha" existem?
	if (isset($_COOKIE[$this->prefixoChaves . 'lu']) AND isset($_COOKIE[$this->prefixoChaves . 'ls'])) {
		// Pega os valores salvos nos cookies removendo o digito e desencriptando
		$usuario = base64_decode(substr($_COOKIE[$this->prefixoChaves . 'lu'], 1));
		$senha = base64_decode(substr($_COOKIE[$this->prefixoChaves . 'ls'], 1));

		// Tenta logar o usuário com os dados encontrados nos cookies
		return $this->logaUsuario($usuario, $senha, true);		
	}

	// Não há nenhum cookie, dados inválidos
	return false;
}

/**
 * Limpa os dados lembrados dos cookies ("Lembrar minha senha")
 * 
 * @access public
 * @since v1.1
 * 
 * @return void
 */
function limpaDadosLembrados() {
	// Deleta o cookie com o usuário
	if (isset($_COOKIE[$this->prefixoChaves . 'lu'])) {
		setcookie($this->prefixoChaves . 'lu', false, (time() - 3600), $this->cookiePath);
		unset($_COOKIE[$this->prefixoChaves . 'lu']);			
	}
	// Deleta o cookie com a senha
	if (isset($_COOKIE[$this->prefixoChaves . 'ls'])) {
		setcookie($this->prefixoChaves . 'ls', false, (time() - 3600), $this->cookiePath);
		unset($_COOKIE[$this->prefixoChaves . 'ls']);			
	}
}
}

?>

[Henrique Barcelos 290]

Onde você encontrou isso??? :upset:

 

Primeiro que em nenhum lugar a conexão com o banco de dados é feita, deveria haver um mysql_connect aí em algum lugar.

Outra coisa, o nome do banco de dados não é 127.0.0.1, esse é host onde se encontra o SGBD.

 

No próprio título do tópico você fala que quer uma 'classe de conexão', entretanto, faz um monte de coisa MENOS conexão com o banco de dados. A ideia da orientação a objetos é MODULARIZAR seu código, ou seja, cada componente (classe) tem uma função bem definida...

 

Sugiro buscar outros exemplos, aqui no fórum deve haver alguns...

[Jefferson Fernandes_81308 0]

Entao Na verdade eu estava querendo testar este Script para ver se funciona...

 

So que como nao Ah em nenhum lugar uma conexao eu nao consegui...

 

O que eu quero saber e se vou precisar fazer uma classe de conexao ou se posso chamar a conexao por

 mysql_connect 

[Kakashi_Hatake 267]

Onde você encontrou isso??? :upset:

 

 

Acho que foi aqui :seta: http://blog.thiagobelem.net/arquivos/2010/01/usuarios.class.parte4.phps

 

Essa classe parece ser apenas uma parte da "coisa" :unsure:

[WeJr 5]

Com o código abaixo você faz a conexão com o BD (é só incluir ele em toda página que for fazer uma operação no BD.

<?php
$hostname_db = ""; //O endereço (host) do SGBD (mySQL)
$database_db = ""; //Nome do Banco de Dados
$username_db = ""; //Usuário para acesso ao banco de dados
$password_db = ""; //Senha de acesso

//Variável ($db) que será utilizada no mysql_query(). Exemplo: mysql_query($query,$db);
$db = mysql_pconnect($hostname_db, $username_db, $password_db) or trigger_error(mysql_error(),E_USER_ERROR); 
mysql_select_db($database_db,$db);
?>

Salve esse código em um arquivo, preencha as informações necessárias e inclua ele com o "require();" em todas as páginas em que será feita uma operação com o Banco de Dados.

[shini 318]

pq um conexão permanente?

[Henrique Barcelos 290]

Bom, vamos lá, fiz um exemplo aqui bem simples:

 

A classe aqui abaixo é tudo o que você precisa para realizar qualquer operação básica sobre o banco de dados. Para tal, vamos utilizar a API MySQLi, que é orientada a objetos, ao invés das funções mysql_* que serão descontinuadas em breve. Mais detalhes sobre o MySQLi aqui.

<?php
class Db_Driver {
private $connector;
private static $defaultConnector;

public function __construct(MySQLi $conn = null) {
	$this->connect($conn);
}

public static setDefaultConnector(MySQLi $conn) {
	self::$defaultConnector = $conn;
}

public static getDefaultConnector() {
	return self::$defaultConnector;
}

public function connect(MySQLi $conn = null) {
	if(!$this->isConnected()) {
		if($conn === null) { 
			if(self::$defaultConnector === null) {
				throw new Exception('Não existe nenhum conector 
					com o banco de dados!');
			} else {
				$conn = self::$defaultConnector;
			}
		}
		$this->connector = $conn;
	}
}

public function disconnect() {
	if($this->isConnected()) {
		$this->connector->close();
		$this->connector = null;
	}
}

public function isConnected() {
	return $this->connector instanceof MySQLi;
}

public function getConnector() {
	$this->connect();
	return $this->connector;
}

public function query($sql) {
	$this->connect();
	$result = $this->connector->query($sql);
	if(!$result) {
		throw new Exception("Erro SQL #{$this->connector->errno}: 
			{$this->connector->error}");
	}
	return $result;
}

public function fetch($sql) {
	$result = $this->query($sql);
	return $result->fetch_assoc();
}

public function fetchAll($sql) {
	$data = array();
	$result = $this->query($sql);
	while($cursor = $result->fetch_assoc()) {
		$data[] = $cursor;
	}
	return $data;
}

public function lastId() {
	return $this->connector->insert_id;
}
}

 

Uso:

$conn = new MySQli('HOST', 'SEU_USUARIO', 'SUA_SENHA', 'NOME_DO_BANCO_DE_DADOS');
$driver = new Db_Driver($conn);

 

Mas poxa vida, toda vez que eu quiser fazer uma operação no banco de dados preciso instanciar um objeto MySQLi e passar como parâmetro no construtor de Db_Driver? Isso dá muito trabalho... E se eu quiser alterar os dados para a conexão? Vou ter que fazer um por um em cada lugar que eu utilizar???

Nãaao, claro que não :thumbsup:...

 

Exatamente por conta disso temos a propriedade estática $defaultConnector. Você faz assim:

$conn = new MySQli('HOST', 'SEU_USUARIO', 'SUA_SENHA', 'NOME_DO_BANCO_DE_DADOS');
Db_Driver::setDefaultConnector($conn);

 

Dessa forma, para utilizar Db_Driver, basta instanciar um objeto sem parâmetros no construtor:

$driver = new Db_Driver();

//Mostrar todas as linhas da tabela...
$data = $driver->fetchAll('SELECT * FROM nome_tabela');
var_dump($data);

//Inserir dados...
$result = $driver->query('INSERT INTO nome_tabela(campo1, campo2) VALUES ("foo", "bar")');
if($result) {
echo 'Dados inseridos!';
}

Quando não há um conector como parâmetro, a classe buscará o conector padrão. Se o mesmo não estiver setado, aí sim uma exceção será lançada.

 

Qual a vantagem dessa abordagem???

E se um dia você precisar de dados de dois bancos de dados distintos, às vezes até em outro servidor?

Dá pra fazer assim:

$conn1 = new MySQLi('HOST', 'USUARIO', 'SENHA', 'DB');
$conn2 = new MySQLi('HOST_EXTERNO', 'USUARIO_EXTERNO', 'SENHA_EXTERNA', 'DB_EXTERNO');

$driver = new Db_Driver($conn1);
// Recupere os dados necessários no banco 1...
$driver->connect($conn2);
// Faça o que tiver que fazer no banco 2...
$driver->connect($conn1);
// Caso ainda precise voltar ao banco 1...

[Jefferson Fernandes_81308 0]

Obrigado Henrique Barcelos usei sua class e funcionou muito bem =)

 

 

Pode considerar fechado o POst!!!!!

 

Acho que foi aqui :seta: http://blog.thiagobelem.net/arquivos/2010/01/usuarios.class.parte4.phps

 

Essa classe parece ser apenas uma parte da "coisa" :unsure:

 

 

Foi ai mesmo!!!

[Henrique Barcelos 290]

Haha... Eu nem testei ela, achei que pudesse aparecer um probleminha ou outro...

Fechando o tópico...