Objota O mundo orientado a objetos

Drive MySql de conexão para Eclipse

Posted on setembro 13, 2010

Posted by Rodrigo Ireno

Olá, neste artigo iremos focar em como utilizar o drive de conexão do Mysql na IDE eclipse. Veremos passo-a-passo como instalar, o que é uma coisa muito simples, e alguns comandos SQL com Java.

Quem já me conhece sabe que costumo escrever sobre php. Então já deve ter visto o artigo sobre PDO. E advinha em que o PDO foi baseado? Em? O Java!

Vamos aos passos:

1º - Faça download do Eclipse se não estiver instalado, neste link:
http://www.eclipse.org/downloads/packages/eclipse-ide-java-developers/heliosr

- para este artigo sugiro utilizar a versão clássica para java SE.

2º - Faça download do drive de conexão com o banco de dados mysql. No próprio site deles, neste link:
http://www.mysql.com/downloads/connector/j/

Escolha o tipo de arquivo que deseja baixar e clique em download, você será redirecionado para uma página que irá sugerir um cadastro, porém isso não é necessário, clique no link
» No thanks, just take me to the downloads!” e siga em frente para fazer download.

Depois disso você será direcionado a página com o link de download. Clique no link, como na imagem abaixo, pode ser qualquer um com as bandeiras do Brasil:

3º - Agora precisamos do Banco de dados, claro! Você pode adquirir o banco de dados gratuitamente no próprio site Mysql.com, porém sua configuração iria estender um pouco mais a coisa, e até tornar um pouco mais complicado. Para tanto, utilize um gerenciador que já instala pra você o Mysql – entre outras coisas -, e uma interface de administrador. O mais fácil e que eu sugiro é o xampp.

O xampp é gratuito e de fácil instalação. Depois de instalado, para acionar o banco de dados mysql é só clicar no botão "start", e para usar o phpMyAdmin (interface para administração do banco) é preciso iniciar também o Apache com "start".

Veja um artigo utilizando o xampp.

Você pode fazer download do xampp neste link:
http://www.baixaki.com.br/download/xampp.htm

Bom, se tudo ocorreu bem até agora, você já deve ter os ingredientes:
Eclipse, drive de conexão, xampp  (cujo "m" da sigla é de Mysql)

Vamos por a mão na massa então! Instale o xampp e o eclipse.

Com o xampp iniciado clique em start para o mysql e o Apache;

Depois clique no botão admin para o mysql;

Ele irá abrir em seu browser padrão o phpMyAdmin. Crie um banco de dados com o nome tutorial.

não iremos entrar em maiores detalhes no phpMyAdmin, pois este não é o foco deste artigo, conteudo sobre phpMyAdmin

Interface phpmyadmin

Depois de criado, ele irá aparecer na lateral esquerda do browser. Clique no nome do Banco de dados que você acabou de criar com o nome tutorial e depois na aba SQL, à direita. E excute esta query, ou crie uma tabela equivalente.


CREATE TABLE IF NOT EXISTS `cliente` (

`id` int(11) NOT NULL AUTO_INCREMENT,

 `nome` varchar(80) NOT NULL,

 `fone` varchar(80) NOT NULL,

PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Após isso crie um novo projeto no eclipse com o nome de sua preferência. Dentro deste projeto crie as seguintes classes abaixo.

Antes de tudo, vamos esclarecer que este artigo não visa utilizar nenhum padrão de desenvolvimento específico. É somente um “Oi banco de dados”

package tutorial;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Conexao {

	// Carrega driver JDBC
	static {
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}
	}

	//Obtem conexao com banco de dados
	public Connection obtemConexao() throws SQLException{
		return DriverManager.getConnection(
				"jdbc:mysql://localhost/tutorial","root","");
	}
}

package tutorial;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.ResultSet;

public class Cliente {

	private int idCliente;
	private String nome;
	private String fone;

	public Cliente(){

	}

	public Cliente(int idCliente) {
		this.idCliente = idCliente;
	}

	public Cliente(String nome, String fone) {
		this.nome = nome;
		this.fone = fone;
	}

	public int getIdCliente() {
		return idCliente;
	}

	public void setIdCliente (int idCliente) {
		this.idCliente = idCliente;
	}

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	public String getFone() {
		return fone;
	}

	public void setFone(String fone) {
		this.fone = fone;
	}

	//  Inclusao de clientes
	public void incluir(Connection conn) {

		//Armazena a string contento o comando sql numa variavel.
		//Repare nos pontos de interrogação, pois eles serão preenchidos!

		String sqlInsert = "INSERT INTO cliente(nome, fone) VALUES ( ?, ?)";

		//inicio um objeto que prepara a instrução a ser executada.
		 //Veja o 'null'.Ele ainda está vazio

		PreparedStatement stm = null;
		try {

			 	//Agora sim. Atraves do objeto Connection eu
			 	//recupero o objeto 'preparador de instrução'.
			 	//veja que já inseri a variavel que tem o comando sql!

			stm = conn.prepareStatement(sqlInsert);

			 //Lembra dos pontos de interrogação, no seu comando sql?
			 //o método setString seta estes pontos de interrogação.
			 //substituindo-os pelo valor que vem no segundo parâmetro.
			 //Portanto...

			//Aqui, substitui a primeira interrogação pelo nome do cliente
			stm.setString(1, getNome());

			//Aqui, substitui a segunda interrogação pelo fone (telefone) do cliente
			stm.setString(2, getFone());

			//E finalmente depois de tudo devidamente preparado ele chama
			// o comando execute()
			stm.execute();

		} catch (Exception e) {
			//Caso tenha uma exceção printa na tela
			e.printStackTrace();
				try {
					//Aqui ele 'tenta' retroceder, na ação que deu errado.
					// quese um Ctrl+Z da vida.
					conn.rollback();
				} catch (SQLException e1) {
					System.out.print(e1.getStackTrace());
				}
		} finally {
			// Comando finally sempre é executado
			if (stm != null) {
				try {
					// Encerra as operações.
					stm.close();
				} catch (SQLException e1) {
					System.out.print(e1.getStackTrace());
				}
			}
		}
	}

	public void buscar(Connection conn) {

		String sqlSelect = "SELECT nome, fone FROM cliente WHERE cliente.id = ?";

		PreparedStatement stm = null;

		  // Aqui temos uma nova estrela no pauco.
		  // O objeto ResultSet é responsavel por manipular
		  // os resultados de uma query de busca.

		ResultSet rs = null;

		try {
			//vide explicaçao anterior
			stm = conn.prepareStatement(sqlSelect);

			//ponto de interrogação por valor getIdCliente()
			stm.setInt(1, getIdCliente());

			//O comando abaixo retorna um objeto ResultSet
			//com os valores dos dados buscados.

			rs = stm.executeQuery();

			//use next() para verificar se ele veio preenchido
			//de dados. Ele também pode ser usado em um while,
			//para querys que resultem em mais de um registro.

			if (rs.next()){

				//Acima no nosso select foi declarado:
				//SELECT nome, fone FROM..
				//portanto o 1 = nome e o
				//2 = fone

				//getString(1) refere-se ao atributo 'nome' da nossa query
				this.setNome(rs.getString(1));

				//Já o getString(2) refere-se ao atributo 'fone'
				this.setFone(rs.getString(2));
			}

		} catch (Exception e) {
			e.printStackTrace();
				try {
					conn.rollback();
				} catch (SQLException e1) {
					System.out.print(e1.getStackTrace());
				}
		} finally {
			if (stm != null) {
				try {
					stm.close();
				} catch (SQLException e1) {
					System.out.print(e1.getStackTrace());
				}
			}
		}
	}
}

package tutorial;

import java.sql.SQLException;
import java.sql.Connection;

 public class Teste {

    public static void main(String[] args) {

      Connection conn = null;

      Cliente cl;

      try {

      // obtem conexao com o banco
    	 Conexao bd = new Conexao();
         conn = bd.obtemConexao();

         conn.setAutoCommit(false);

      //  Inclusao do Primeiro Cliente
         cl = new Cliente("Mariana Soares", "1127991999");
         cl.incluir(conn);

      // Inclusao do Segundo Cliente
         cl = new Cliente();
         cl.setNome("João Neves");
         cl.setFone("1160606161");
         cl.incluir(conn);

      // Inclusao do Terceiro Cliente
         cl = new Cliente("Maria Oliveira", "1121212121");
         cl.incluir(conn);

      // efetiva inclusoes
         conn.commit();
         System.out.println("Inclusão concluída");
         System.out.println("Buscando...");

      // Busca Cliente com id 2
         cl = new Cliente(2);
         cl.buscar(conn);

         String saida = "Nome: "+cl.getNome()+
         				 "\nTelefone: "+cl.getFone()+
         				 "\nid: "+cl.getIdCliente();

         System.out.println(saida);
      }
          catch (Exception e) {
            e.printStackTrace();
            if (conn != null) {
               try {
                  conn.rollback();
               }
                   catch (SQLException e1) {
                     System.out.print(e1.getStackTrace());
                  }
            }
         }
      finally {
         if (conn != null) {
            try {
               conn.close();
            }
                catch (SQLException e1) {
                  System.out.print(e1.getStackTrace());
               }
         }
      }
      System.exit(0);
    }
}

Veja minha estrutura para este projeto:

Depois que as classes já estiverem ok iremos adicionar aquele drive ao nosso projeto. Para isso clique com o botão direito sobre o seu projeto.
Siga o caminho: Build Path > Configure Build Path >
escolha a aba Libraries.
Agora clique no botão “Add External JARs...”
Encontre o drive que você baixou, com extensão “.JAR”. Clique nele, depois em Abrir.
(ele precisa estar descompactado, ele era um .zip lembra?)
Pronto seu driver já foi instalado.

Para testar a coisa toda:

O xampp deve estar ligado, com mysql e apache iniciados. phpMyAdmin aberto, para você checar as alterações na sua tabela.

O script foi feito para inserir  três clientes toda vez que for rodado, e buscar um pelo id. Rode a classe Teste, agora veja o resultado no phpMyAdmin. Para atualizar a visualização, basta clicar na aba visualizar.

Esse artigo fica por aqui, qualquer dúvida postem. Obrigado e até a próxima!

Classe de conexão com php utilizando PDO

Posted on agosto 22, 2010

Posted by Rodrigo Ireno

Olá neste artigo vamos aprender a fazer conexão com um banco de dados utilizando um recurso muito bacana que o php nos oferece, o PDO (PHP Data Object). Ele é um objeto que possibilita tornar sua "fábrica de conexões" - já vou exeplicar também - portável.

Imagine que você está usando o banco de dados MySql e que a vida é bela e seu sistema sempre usará este banco! lindo esse sonho não? 🙂

Tá! agora acorda! e veja como o mundo é cruel e as coisas não tão simples assim. Pois se você se baseia totalmente em usar funções como mysqli_connect() , mysqli_.. qualquer coisa., trate de terminar de ler este artigo!

E se esta galera! Estes métodos estão misturados em diversas partes do seu código! Vai te dar uma dor de cabeça sem tamanho, só de pensar em mudar de banco de dados. Pensando nessa, foi que desenvolveram um recurso no php, o PDO. Uma classe que se encarrega de fazer o gerenciamento dos drivers pra você. Isso mesmo! parece que existe uma luz no fim do túnel!

E lembra do que falei? - "fábrica de conexões"

Este é outro conceito muito usado, para garantir tanto uma certa organização quanto a integridade do banco de dados. É o pattern conhecido como Singleton.

Qual é a idéia? Manter uma instância única para que toda a aplicação possa utilizá-la. Veja como isso faz sentido ser utilizado principalmente para conectar-se com um banco. Toda vez que se conecta o banco abre uma porta, e se você criar conexões sem nenhum controle, dependendo do número de acessos que o seu site tiver ele vai derrubar o banco.

O conceito deste pattern está bem explícito na própria wikipedia, mas vamos fazer um código aqui também. Então vamos ao que intereça:

O PDO


/*
 Chega de funções, e funções. Tudo no método construtor do PDO
*/
$pdo = new PDO("tipoDeBanco:host=EnderecoDoHost;dbname=nomeDoBanco", "usuário", "senha" );

Veja só, o objeto já faz tudo numa tacada só. Depois disso é só ir trabalhando com ele e seus métodos de interface.

Executando uma query

Se estiver executando local, o host é localhost, senha não tem e usuário é root. Há e o tipo de banco de dados também!

<?php
try {
	// PDO em ação!
	$pdo = new PDO ( "mysql:host=localhost;dbname=tutorial", "root", "" );

	// Com o objeto PDO instanciado
	// preparo uma query a ser executada
	$stmt = $pdo->prepare("SELECT * FROM cliente");

	// Executa query
	$stmt->execute();

	// lembra do mysql_fetch_array?
	//PDO:: FETCH_OBJ: retorna um objeto anônimo com nomes de propriedades que
	//correspondem aos nomes das colunas retornadas no seu conjunto de resultados
	//Ou seja o objeto "anônimo" possui os atributos resultantes de sua query
	while ( $obj = $stmt->fetch ( PDO::FETCH_OBJ ) ) {

		// Resultados podem ser recuperados atraves de seus atributos
		echo "<b>Nome:</b> " . $obj->nome . " - <b>Telefone:</b> " . $obj->fone."</br>";
	}
	// fecho o banco
	$pdo = null;
	// tratamento da exeção
} catch ( PDOException $e ) {
	echo $e->getMessage ();
}
?>

obs: com a função fetch() é possível trazer os resultados de várias maneiras, este foi só um exemplo. O que determina o tipo de retorno é a constante "PDO::FETCH_OBJ", para mais informações vide manual. Sobre a função fetch().

Compare! um exemplo com o modo tradicional de conexão com MySql

Veja que está tudo dentro de um bloco try, catch. Para quem não sabe, o programa quando encontra um erro dentro de um bloco try, salta para o catch e consegue recuperar a exceção ou erro, por um objeto de exceção que vem por parâmetro. Para mais informações sobre o uso de pdo visite seu manual no site oficial do php.

A fabrica de conexões

Se você seguiu o link que existe ali em cima, já deve ter visto a página da wikipedia com exemplos em diversas linguagens do pattern Singleton, mas vamos terminar a coisa aqui pra não ficar dúvida! 🙂


<?php
class Conexao extends PDO {

	private static $instancia;

	public function Conexao($dsn, $username = "", $password = "") {
		// O construtro abaixo é o do PDO
		parent::__construct($dsn, $username, $password);
	}

	public static function getInstance() {
		// Se o a instancia não existe eu faço uma
		if(!isset( self::$instancia )){
			try {
				self::$instancia = new Conexao("mysql:host=localhost;dbname=conteudo", "root", "");
			} catch ( Exception $e ) {
				echo 'Erro ao conectar';
				exit ();
			}
		}
		// Se já existe instancia na memória eu retorno ela
		return self::$instancia;
	}
}
?>

Então fazendo uso desta classe toda vez que eu quiser fazer conexão com o banco eu uso o método implementado getInstance(), pois ele é quem vai me retornar uma conexão existente ou criá-la para mim.

Veja que eu coloquei direto alí os valores, senhas e talls.. pra conectar certo. Então, porém tanto pra php quanto pra java - falando de web - o ideal é centralizar todas as configurações em um único arquivo, para o site. Em java se faz uso do arquivo de configuração web.xml, já no php este arquivo de configuração geral é mais conhecido como config.

É nada mais nada menos que um arquivo com extensão .php que contem todas as configurações necessárias para o site. Acho que esse assunto ainda rende um post, vou colocar algo a respeito futuramente!
é isso obrigado por ler este post, e até a próxima! vlew 🙂

:: Este post possui uma complementação neste outro artigo! Usando Classe de Conexão com PDO (exemplos práticos)

Acesso a banco de dados com php

Posted on julho 28, 2010

Posted by Rodrigo Ireno

Olá, neste artigo vamos abordar conexão com banco de dados usando php. Sei que até agora vimos muitas coisas relacionadas a orientação a objetos, porém para fim de simplificar o entendimento vou abordar de forma procedural. Programar de forma procedural. Ou seja, não orientado a objetos. Calma! Veremos exemplos orientados a objetos também, aqui é só pra centralizar a idéia no processo de conectar. O que no final das contas é uma coisa muito simples.

Se você vem acompanhando meus artigos já deve ter visto algo sobre o xampp, mas se você estava sapeando pelo Google e parou por aqui, eis um link de um artigo que fala um pouco sobre o xampp:  Hello world em php. Ele é um aplicativo que instala um kit básico pra desenvolvimento em php. Entre os softwares instalados está o banco de dados MySql. Que é o que nos interessa neste artigo, porque vamos nos conectar com ele.

Crendo eu, que você já tem o xampp vamos prosseguir. Acesse o http://localhost e depois o phpMyAdmin. Este aplicativo é feito em php e usaremos ele para administrar nosso banco de dados.

Para manipular um banco de dados utiliza-se uma linguagem própria. Esta linguagem é o SQL. É muito fácil encontrar conteúdo sobre SQL, eis que pelo menos o banco de dados MySQL tem documentação online. Outros bancos de dados também usam SQL, porém existe uma variação da sintaxe. Para nosso exemplo utilize o código abaixo para criar o banco de dados e a tabela que iremos utilizar.


/* Cria o banco de dados */

CREATE DATABASE objota;

/*
	O código abaixo cria a tabela clientes.

	veja que os comandos são bem explícitos. (cria a tabela se ela não existe)
*/

CREATE TABLE IF NOT EXISTS objota.clientes (
  id int(11) NOT NULL AUTO_INCREMENT,
  nome varchar(50) NOT NULL,
  telefone varchar(20) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=5 ;

/* Insere alguns registros na tabela */

INSERT INTO objota.clientes (id, nome, telefone) VALUES
(1, 'Carlos', '3333-4444'),
(2, 'Mario', '5555-6666'),
(3, 'Marcela', '7894-6543'),
(4, 'Gustavo', '1535-5847');

Com o phpMyAdmin aberto em seu navegador copie este código SQL, selecione a aba SQL no menu da página inicial cole este código no campo de input e após isso clique em executar. Este código criará um banco de dados com o nome objota e uma tabela com o nome clientes com os seguintes atributos: id, nome, telefone.

Como se trata de um exemplo a tabela já virá ”populada”, ou seja, com algum conteúdo. Feito isso nosso banco de dados já existe. Iremos então usar um comando para recuperar estes dados. Mas antes, a tal conexão.

Conectando ao banco de dados

Para se conectar a um banco de dados é necessário possuir:

  • Nome do banco de dados
  • Nome do usuário de banco de dados
  • Endereço do banco de dados
  • Senha
  • Porta

Como se trata de uma conexão local o Endereço do banco no caso é sua própria máquina. Você pode referenciar ele pelo nome localhost. O nome do banco de dados é objota, neste exemplo. Por padrão no phpMyAdmin o nome padrão de usuário é root. Senha até então não existe, então simplesmente não forneça nada. Porta padrão é 3306. Vejamos o código abaixo:

<?php

$con = mysqli_connect("localhost","root","","objota","3306");

if(!$con){
	echo "Ops! <br/>";
}
else{
	// Se conectou posso fazer uma busca por dados.
	echo "Conectou!!! <br/>";

	//Vejamos um comando SQL para selecionar os dados de nossa tabela.
	$sql = "SELECT id, nome, telefone
			FROM clientes";

	//Forneço o ponteiro de conexão $con e o comando SQL vai no segundo parâmetro
	$rs =  mysqli_query($con, $sql);

	//Extraímos os dados da resource resultante em um array
	$dados = mysqli_fetch_array($rs);

	//Pronto!! eis os dados obtidos
	var_export($dados);
}

?>

Detalhando os acontecimentos. Primeiro me conectei ao banco usando a função mysqli_connect(). Faço uma breve verificação, caso esteja tudo bem prosseguimos com o acesso. Armazeno na variável $sql um comando SELECT que traz todo o conteúdo da tabela.
Logo em seguida utilizo a função mysqli_query($con, $sql) ,  repare que passo como primeiro parâmetro o ponteiro de conexão, em seguida vem a query (comando SQL). Essa função me retorna uma resource , que tecnicamente ainda não são os dados que eu pedi. Afinal quero nome e telefone da tabela. Para extrair desta resource os dados que eu quero, é preciso usar a função mysqli_fetch_array($resource) , veja que forneço a resource como parâmetro e ele finalmente me retorna um array com os dados que eu requisitei.

Obs: Neste exemplo fiz uso da função var_export($var) para mostrar todo o conteúdo do array na tela, muitos programadores usam isto para verificar o conteúdo de uma variável a fim de debugar o um código.

Porém abaixo segue mais um código que faz o mesmo que o código acima. Porém ele acessa os dados do array com um loop e mostra na tela de forma mais “apresentável”.

<?php

$con = mysqli_connect("localhost","root","","objota","3306");

if(!$con){
	echo "Ops! <br/>";
}
else{
	// Se conectou posso fazer uma busca por dados.
	echo "Conectou!!! <br/>";

	//Vejamos um comando SQL para selecionar os dados de nossa tabela.
	$sql = "SELECT id, nome, telefone
			FROM clientes";

	//Forneço o ponteiro de conexão $con e o comando SQL vai no segundo parâmetro
	$rs =  mysqli_query($con, $sql);

	//Extraímos os dados da resource resultante em um array
	while($dados = mysqli_fetch_array($rs)){

		// Com o uso do caracter ponto "."
		// é possível concatenar (unir) trechos de string
		echo "<b>Nome:</b> ".$dados['nome']." <b>Telefone:</b> ".$dados['telefone']."<br/>";
	}
}

?>

extra: veja este vídeo que mostra o phpMyAdmin em uso video

Bom pessoal, este artigo acaba aqui, porém ainda tem muita coisa pra falar e exemplificar. Foi apenas um breve exercício, mas espero ter ajudado em algo. No próximo artigo adentraremos um pouco mais em orientação a objetos, e veremos futuramente acesso a banco de dados usando um objeto. Dúvidas?