Freelancers BR

Vou demonstrar como utilizar a Classe de Conexão criada no tutorial anterior, com um simples SELECT.

<?php
//caminho para a classe
require_once 'classes/Db/Conexao.class.php';

//tratamento de excessoes
try {
    //'instancia' singleton
    $Conexao = Conexao::getInstance();

    //submete a consulta ao banco
    $sql = 'SELECT * FROM tabela';
    $result = $Conexao->query($sql);

    echo "O total de registros retornados foi de: {$result->num_rows} <br /><br />";

    //percorre o objeto mysqli_result retornado (array associativo)
    while($row = $result->fetch_array(MYSQLI_ASSOC)) {

        echo $row['campo'].'<br />'; //mostra na tela o campo
    }

    //fecha a conexao
    $Conexao->close();
}
catch (Exception $e) {
    //se der erro mostra na tela
    echo $e->getMessage();
}

?>

Pensei em criar alguns tutoriais sobre orientação a objetos no PHP, no fim acabei achando melhor criar algo mais útil que exemplos simples para quem está começando com poo, afinal existe uma infinidade de tutoriais de poo pela web.
Optei então pela criação de uma classe de conexão com o banco de dados MySQL utilizando a extensão MySQLi (extensão mysql ‘melhorada’).
Muitos desenvolvedores preferem utilizar a extensão PDO (PHP Data Objects), confesso que venho utilizando a MySQLi há algum tempo e tive apenas pequenos probleminhas com relação ao fechamento da conexão inesperadamente (sem ser por time out), porém isso não vem ao caso e era em outro contexto. Uma pequena desvantagem da MySQLi é o fato de não existir o método fetch_all da PDO, apesar de ser um pouco mais performática. O engraçado é que quando utilizo Zend Framework prefiro utilizar PDO, pois é, cada programador com suas manias. É fato que as duas são boas, tem suas vantagens e desvantagens. Percebo uma tendência maior dos desenvolvedores preferirem a PDO, talvez pelo fato de ser “mais orientada a objeto”.
Aproveitando o assunto, foi lançada a pouco tempo um novo driver chamado MySQLND.
Nesse exemplo vamos utilizar o design pattern Singleton.
Segue a classe de conexão com as funcionalidades comentadas em cada linha.

<?php
/**
 * Conexao com MySQL
 * Essa classe herda a superclasse mysqli
 * e necessario que a extensao mysqli esteja habilitada
 *
 * @author Lucas Renan
 */
class Conexao extends mysqli {

    /**
     * Connected
     * propriedade privada para 'indicar'
     * o estado da conexao
     *
     * @var boolean
     * @static
     */
    private static $_connected = false;

    /**
     * Instancia Conexao
     * propriedade para a implementacao do design pattern singleton
     *
     * @var Conexao
     * @static
     */
    private static $_instance = null;

    /**
     * Destrutor
     * Quando o objeto for destruido a conexao e fechada
     *
     * @param void
     * @return void
     */
    public function  __destruct() {

        $this->close();
    }

    /**
     * Retorna Conexao
     * Esse metodo verifica se ja existe na memoria uma instancia
     * da classe de Conexao
     * Se existir apenas retorna
     * se nao instancia
     *
     * @param void
     * @return Conexao
     */
    public static function getInstance() {

        if (null === self::$_instance) {

            self::$_instance = new self ();
        }

        return self::$_instance;
    }

    /**
     * Conecta no banco
     * Utiliza o construtor da superclasse
     *
     * @param void
     * @return void
     */
    public function connect() {
        //se nao estiver conectado
        if(!self::$_connected) {
            parent::__construct(
                    'localhost',
                    'user',
                    'senha',
                    'banco'
            );

            //se der erro na conexao gera uma excessao
            if(mysqli_connect_errno()) {
                throw new Exception('A Conexao falhou: '.mysqli_connect_error());
            }

            self::$_connected = true;
        }
    }

    /**
     * Fecha a conexao
     * Sobrescreve o metodo close da superclasse
     *
     * @param void
     * @return void
     */
    public function close() {

        if(self::$_connected) {
            parent::close();
            self::$_connected = false;
        }
    }

    /**
     * Consulta
     * Sobreescreve o metodo da superclasse
     *
     * @param string $sql
     * @return mysqli_result Object
     */
    public function query($sql) {
        //'tenta' conectar
        $this->connect();
        $result = parent::query($sql);

        if($result) {

            return $result;
        }
        else {
            //se der erro gera uma excessao
            throw new Exception('Query Exception: '.mysqli_error($this).' numero:'.mysqli_errno($this));
        }
    }

    /**
     * Ping servidor banco
     * Sobreescreve o metodo da superclasse
     *
     * @return boolean
     */
    public function ping() {
        // se estiver conectado retorna verdadeiro
        if(@mysqli_ping($this)) {
            return true;
        }
        else {
            return false;
        }
    }
}
?>

Veja como utilizá-la:

http://www.freelancersbrasil.com/select-com-a-classe-de-conexao/

Nos tutoriais passados apresentei algumas formas de submeter instruções SQL ao banco de dados MySQL utilizando JSP. Hoje vamos utilizar Prepared Statment.
Estamos utilizando a Classe de Conexao.

<%@ page language="java" import="java.sql.*" %>
<%@ page language="java" import="database.Conexao" %>

<%
try {
    //instancia classe de conexao
    Conexao conexao = new Conexao("localhost", "banco", "user", "senha");
    //conecta no banco
    Connection connection = conexao.connect();

    //consulta - prepared statment
    String sql = "SELECT * FROM tabela WHERE campoPK=?";
    PreparedStatement ps = connection.prepareStatement(sql);
    String codigo = "1";

    //seta o valor do ?
    ps.setString(1, codigo);
    ResultSet rs = ps.executeQuery();

    //se encontrou o registro
    if (rs.next() == true) {
        out.println(rs.getString("Nome") + "<br />"); //mostra o campo 1
    } else {
        out.println("Registro nao encontrado");
    }

    //fecha a conexao com o banco
    connection.close();
}
catch(Exception e) {
    out.println(e.toString());
}

%>

Mais um post simples, update com JSP (Java Server Pages) e MySQL. Estamos utilizando a Classe de Conexao.

<%@ page language="java" import="java.sql.*" %>
<%@ page language="java" import="database.Conexao" %>

<%
try {
    //instancia classe de conexao
    Conexao conexao = new Conexao("localhost", "banco", "user", "senha");
    //conecta no banco
    Connection connection = conexao.connect();

    //cria o statment e realiza o update
    Statement st = connection.createStatement();
    String sql = "UPDATE tabela SET campo1='valor1', campoN='valorN' WHERE codigo=1"; //chutamos o valor 1
    int res = st.executeUpdate(sql);

    if (res == 1) {
        out.println("Alterado com sucesso!");
    } else {
        out.println("Falha na alteracao!");
    }

    //fecha a conexao com o banco
    connection.close();
}
catch(Exception e) {
    out.println(e.toString());
}

%>

Veja Mais:
http://www.freelancersbrasil.com/select-com-jsp-e-mysql/
http://www.freelancersbrasil.com/insert-com-jsp-e-mysql/

Continuando com os tutorias de JSP e MySQL, nesse post é mostrado como realizar uma instrução INSERT.
Lembrando que estamos utilizando a nossa Classe de Conexao.

<%@ page language="java" import="java.sql.*" %>
<%@ page language="java" import="database.Conexao" %>

<%
try {
    //instancia classe de conexao
    Conexao conexao = new Conexao("localhost", "banco", "user", "senha");
    //conecta no banco
    Connection connection = conexao.connect();

    //cria o statment e realiza o insert
    Statement st = connection.createStatement();
    String sql = "INSERT INTO tabela (campo1, campoN) VALUES ('valor1', 'valorN')";
    int res = st.executeUpdate(sql);

    if (res == 1) {
        out.println("Cadastrado com sucesso!");
    } else {
        out.println("Falha no cadastro!");
    }

    //fecha a conexao com o banco
    connection.close();
}
catch(Exception e) {
    out.println(e.toString());
}

%>

Veja outros tutoriais:
SELECT JSP + MySQL

Continuando com os exemplos de JSP + MySQL, hoje apresento a utilização da classe de conexão criada no tutorial anterior http://www.freelancersbrasil.com/classe-conexao-jsp-mysql/ com uma consulta em determinada tabela no MySQL.

<%@ page language="java" import="java.sql.*" %>
<%@ page language="java" import="database.Conexao" %>

<%
try {
    //instancia classe de conexao
    Conexao conexao = new Conexao("localhost", "banco", "user", "senha");
    //conecta no banco
    Connection connection = conexao.connect();

    //cria o statment e realiza a consulta
    Statement st = connection.createStatement();
    String sql = "SELECT * FROM tabela";
    ResultSet rs = st.executeQuery(sql);

    while(rs.next()) {
        out.println(rs.getString(1) + "<br />"); //mostra o campo 1
    }

    //fecha a conexao com o banco
    connection.close();
}
catch(Exception e) {
    out.println(e.toString());
}

%>

Veja outros tutoriais:
INSERT com JSP e MySQL

Resolvi criar uns tutorias de JSP (Java Server Pages), para auxiliar quem está começando a estudar JSP, até porque quando eu tive que programar um projetinho para uma matéria da faculdade (em JSP + Postgre), achei um pouco trabalhoso (e como JAVA é trabalhoso uhahuha) e optei pelo MySQL porque eu realmente gosto do MySQL. Depois quero construir uns exemplos similares em PHP, assim poderemos comparar um pouco as linguagens e quem sabe até comprovar o aumento significativo de produtividade quando se utiliza um framework.

Bom, vamos começar pela criação de uma classe de Conexão com o MySQL. Nesse momento eu estou utilizando o NetBeans como IDE e o GlassFish embutido como servidor.

A primeira coisa a fazer é baixar o driver do MySQL para Java em:
http://dev.mysql.com/downloads/connector/j/5.1.html

Depois eu copiei o driver para a pasta lib dentro da pasta do glassfish.
No NetBeans criei um projeto Web e inclui um novo package chamado database, dentro dele criei uma classe chamada de Conexao.

package database;

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

public class Conexao {

    private String connectionString;
    private String driverName = "com.mysql.jdbc.Driver"; //driver do MySQL
    private String database;
    private String user;
    private String password;
    private String host;
    private Connection connection = null;

    //construtor
    public Conexao(String host, String database, String user, String password) {

        this.host = host; //geralmente localhost
        this.database = database; //nome do banco
        this.user = user; //usuario do banco
        this.password = password; //senha do usuario
        //mysql usa a porta 3306
        connectionString = "jdbc:mysql://" + host + ":3306/" + database; //string de conexao
    }

    //conectar no banco
    public Connection connect() throws SQLException {
        try {
            Class.forName(this.driverName);
            //faz a conexao e retorna
            this.connection = DriverManager.getConnection(connectionString, this.user, this.password);
            return this.connection;
        }
        catch (ClassNotFoundException ex){
            throw new SQLException(ex.getMessage());
        }
        catch (SQLException ex) {
            throw new SQLException(ex.getMessage());
        }
    }

    //fecha conexao
    public void close() throws SQLException{
        try {
            connection.close();
        } catch (SQLException ex) {
            throw new SQLException(ex.getMessage());
        }
    }

}//fim conexao

Você pode encontrar um exemplo de como utilizá-la em:
http://www.freelancersbrasil.com/select-com-jsp-e-mysql/
http://www.freelancersbrasil.com/insert-com-jsp-e-mysql/

Esse post é quase um twitt, huahuahahu.
Para você que está estudando o Zend Framework, recomendo o site ZendCasts que possui excelentes screencasts sobre Zend Framework:
http://www.zendcasts.com/

A comparação de strings é tarefa rotineira na vida de qualquer programador. Acredito que a maioria dos programadores PHP desconheçam ou simplesmente ignorem as funções de comparação de strings e acabam realizando a comparação como se estivessem comparando números, como no exemplo abaixo:

$var1 = 'A';

if($var1 == 'A') {
    echo $var1.' igual A';
}

O que acontece nesse caso é que o PHP transforma os caracteres em números inteiros e realiza a comparação desses números.
Uma maneira melhor é utilizar as funções específicas de comparação como strcasecmp e strcmp. Essas funções são uma forma de fazer comparação de strings segura para binário, o PHP converte as strings em sua forma binária e compara os binários.
Ambas retornam um número inteiro, menor que 0 se string1 é menor do que string2, maior que 0 se string1 é maior do que string2 e 0 se as duas forem iguais.

A função strcasecmp compara duas strings sem diferenciar maiúsculas e minúsculas.

$var1 = 'A';
$var2 = 'a';

//comparacao case insensitive
if(strcasecmp($var1, $var2) == 0) {

    echo $var1.' (igual) '.$var2; //Imprime 'A igual a'
}

A função strcmp compara duas strings diferenciando maiúsculas e minúsculas.

//comparacao case sensitive
if(strcmp($var1, $var2) != 0) {

    echo $var1.' (diferente) '.$var2; //Imprime 'A diferente de a'
}

$var1 = 'A';
$var2 = 'B';

//comparacao case sensitive
if(strcmp($var1, $var2) != 0) {

    echo $var1.' (diferente) '.$var2; //Imprime 'A diferente de B
}

uhahuahuuhaahuhuahuhuahuhua

Eu aqui fazendo trabalho da facul, como todo bom nerd que se preze, programando em pleno domingão, quando uma amiga me manda um link, falando que viu algo engraçado no domingão do faustão… eu abro o vídeo, vejo um pouco e choro de dar risada hahahaahha
…
Enquanto o bonitão tá na balada te chifrando
O nerd com certeza está em casa estudando
O curso superior do gostosão tá no início
E o nerd ganha em dólar no Vale do Silício…