Conexão com PDO da para melhorar?

não tá usando prepared statements pra evita sql injection?

http://php.net/manual/pt_BR/pdo.prepare.php

Direto na conexão? Se for não, eu uso nos objetos. ex:

public function inserir_noticia($noticia){
 try {
 $query = "INSERT INTO noticias VALUES('NULL',:titulo,:descricao,:conteudo,:imagem,:img_ico,:data_in,:data_fi,:n_vence,:cod_emb,:criador,:tipo,:stat)";
 $this->Create = $this->Conn->prepare($query);
 $this->Create->bindValue(':titulo' ,$noticia->get_titulo() , PDO::PARAM_STR);
 $this->Create->bindValue(':descricao',$noticia->get_descricao() , PDO::PARAM_STR);
 $this->Create->bindValue(':conteudo' ,$noticia->get_conteudo() , PDO::PARAM_STR);
 $this->Create->bindValue(':imagem' ,$noticia->get_imagem() , PDO::PARAM_STR);
 $this->Create->bindValue(':img_ico' ,$noticia->get_imagem_icon() , PDO::PARAM_STR);
 $this->Create->bindValue(':data_in' ,$noticia->get_data_inicial() , PDO::PARAM_STR);
 $this->Create->bindValue(':data_fi' ,$noticia->get_data_fim() , PDO::PARAM_STR);
 $this->Create->bindValue(':n_vence' ,$noticia->get_n_vencedores() , PDO::PARAM_INT);
 $this->Create->bindValue(':cod_emb' ,$noticia->get_cod_emblema() , PDO::PARAM_INT);
 $this->Create->bindValue(':criador' ,$noticia->get_criador() , PDO::PARAM_INT);
 $this->Create->bindValue(':tipo' ,$noticia->get_tipo() , PDO::PARAM_INT);
 $this->Create->bindValue(':stat' ,$noticia->get_status_noticia(), PDO::PARAM_INT);
 $this->Create->execute();
 if($this->Create->rowCount() == 1){
 return true;
 } else {
 return false;
 }
 } catch (PDOException $ex) {
 exibeMensagens("Erro ao consultar. {$ex->getMessage()}", WS_ERROR);
 }
 }

Roger, joia!

Vamos lá :)

Pq criar as variáveis e um método em inglês e um método em português? Deixe tudo em português ou tudo em inglês. Vamos mudar o método conectar para connect

Não vejo sentido em deixar o método Conectar como private e criar o método público getConn para acessar ele, basicamente o método Conectar esta como público. Então vamos remover o getConn() e deixar apenas o connect, mudando-o para public.

Podemos também adicionar uma variável db para termos a flexibilidade de usar outro banco, que não seja o mysql

Acredito que você não queira exibir esses erros para o usuário, né? Então vamos usar a constante DEBUG, que por padrão é false, para exibir uma mensagem amigável para o usuário, e caso necessário habilitamos o modo DEBUG.

Também não vejo sentido em dois estilos de indentação, ou faz tudo com a sintaxe tradicional ou tudo com a alternativa. Aqui vou deixar tudo com a tradicional.

Aplicar o code style da PSR-2 também é bom

http://www.php-fig.org/psr/psr-2/

Também não vi motivos para a classe ser abstrata

Classes do PHP, é sempre bom colocar o \ antes, para evitar problemas.

Com algumas mudanças, ficaria assim:

class Conn 
{

    private $db = DB;
    private $host = HOST;
    private $port = PORT;
    private $user = USER;
    private $passwd = PASS;
    private $dbName = DBNAME;
    /* @var PDO */
    private $connection = null;    

    public function connect()
    {
        try {
            if($this->connection == null) {
                $dns = $this->db . ':host='.$this->host.';port='.$this->port.';dbname='.$this->dbName;
                $options = [PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES UTF8'];
                $this->connection = new \PDO($dns, $this->user, $this->passwd, $options);
            }
        } catch (PDOException $e) {
            if (DEBUG === false) {
                die('Erro: Por favor tente novamente. Caso o problema persista, entre em contato o administrador adm@empresa.com');    
            }
            echo "Código do erro: {$e->getCode()}<br>"
            . "Mensagem : {$e->getMessage()}<br>"
            . "Arquivo: {$e->getFile()}<br>"
            . "<font style='color:red;'>Motivo: Não foi possivel se conectar ao banco de dados!</font><br>"
            . "Linha : {$e->getLine()}", WS_ERROR;
            
        }
        return $this->connection;
    }
}

Fala edCesar blz?

Poderia me explicar  para que está sendo declarada private $db = DB; e qual o valor de DB, seria o nome do banco? Pois se for já tem uma no meu metodo de conexão => DBSA

// definição de configuração ao servidor MySQL

define('HOST', '127.0.0.1');
define('PORT', 3306);
define('USER', 'root');
define('PASS', '');
define('DBSA', 'banco');

Se no futuro você precisar trabalhar com outro banco, por exemplo, com o Postgre, você tem essa flexibilidade. Da forma atual, você esta acoplado com o mysql

>

1 hora atrás, EdCesar disse:

Se no futuro você precisar trabalhar com outro banco, por exemplo, com o Postgre, você tem essa flexibilidade. Da forma atual, você esta acoplado com o mysql

Ao meu ver, então é melhor usar uma interface do que uma classe concreta.

>

5 horas atrás, RogerTi disse:

Da para melhorar esse tipo de conexão, tem algo errado nele? Obs Funciona normalmente, mas gostaria da opinião de vocês.

PHP "PDO" POO

<?php

abstract class Conn {

 private $Host = HOST;
 private $Port = PORT;
 private $User = USER;
 private $Pass = PASS;
 private $Dbsa = DBSA;
 /* @var PDO */
 private $Connect = null;

 public function getConn(){
 return $this->Conectar();//chamando a conexão com o metodo e retornando Connect
 }

 private function Conectar(){
 try{
 if($this->Connect == null):
 $dns = 'mysql:host='.$this->Host.';port='.$this->Port.';dbname='.$this->Dbsa;
 $options = [PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES UTF8'];
 $this->Connect = new PDO($dns, $this->User, $this->Pass, $options);
 endif;
 } catch (PDOException $e){
 exibeMensagens("Código do erro: {$e->getCode()}<br>"
 . "Mensagem : {$e->getMessage()}<br>"
 . "Arquivo: {$e->getFile()}<br>"
 . "<font style='color:red;'>Motivo: Não foi possivel se conectar ao banco de dados!</font><br>"
 . "Linha : {$e->getLine()}", WS_ERROR);
 die;
 }//finaliza catch
 return $this->Connect;
 }//finaliza método Conectar
}

  

	Toda classe abstrata obrigatoriamente tem que ter um método abstrato, onde as classes que irão implementa-las deverá conter este método, é uma espécie de contrato e pelo que estou vendo nada disso está ocorrendo.

>

22 minutos atrás, Williams Duarte disse:

Ao meu ver, então é melhor usar uma interface do que uma classe concreta.

Outras coisas também poderia melhorar, por exemplo, personalizar as mensagens de erros:

class MyPDOException extends PDOException
{
    /**  
       xpto
    */
}

E na classe Conn lançar

throw new MyPDOException('xpto');

Também não acho Conn um nome adequado, falei mais do grosso mesmo :)