Technócil

Magento E-Commerce

Postado por João Vagner em 21.02.2010 10:49 Desenvolvimento web, Internet, OOP, ecommerce, frameworks, php

Quem nunca ouviu falar hoje em dia de uma das ferramentas mais completas para e-commerce disponíveis gratuitamente, se você nunca ouviu falar, esta na hora de de atualizar hein?

O Magento se tornou hoje a principal ferramenta para comercio eletrônico, alem de completo, tem a robustez do Zend Framework, e diversos conceitos de ecommerce e SEO otimizados. Tudo, quer dizer, quase tudo hoje se faz no magento sem muitas dificuldades. Alem do Zend Framework por  traz em seu código, ele implementa todas as possibilidades do Pear, traz consigo uma estrutura de canais para módulos aonde a comunidade desenvolve, e você pode usufruir muito bem através de alguns comandos práticos e simples.

O Magento também esta disponível por SVN, o que facilita muito o desenvolvimento, e um padrão / qualidade de código excelente. As instalações do magento são simples, e pode ser feita muito simplesmente por qualquer um com acesso ao SSH da conta. Praticidade total. O Próximo artigo dessa serie sera a instalação e configuração básica da loja, cache, e módulos Claro, depois de nossa introdução a alguns conceitos aplicados pelo magento, tanto em código, quanto em uso de sistema.

1 – Estrutura básica de trabalho.

Existe um bom senso para se trabalhar com o magento, uma estrutura compartilhada segura muito bem, claro, desde que configurado para se tornar leve, trabalhar com cache.  Veja aqui os requisitos que o magento necessita para um BOM desempenho em produção. Mas iremos ver isso mais para a frente. Agora e hora da nossa introdução a pastas do Magento. Pastas nos quais iremos ter acesso para upload e modificação de arquivos.

• app  - Pasta da sua aplicação
  • code - Pasta do seus modulos
    • comunity
    • core
    • local
  • design - Pasta aonde toda a estrutura de layout, blocos,  xml e xhtml (.phtml), sao armazenados
    • adminhtml
    • frontend
    • install
  • etc – Pasta de XML de configurações de sua loja
  • locale – Pasta com as linguas instaladas em sua Loja, tipo pt_BR, En, fr_FR, etc
• media – Pasta aonde as imagens do seu catalogo sao armazenadas, recortadas e trabalhadas.
• var – Pasta de exportação de dados, backups do banco e etc
• skin – Pasta aonde encontrados o css, javascript e imagem relativa a nosso tema.
  • adminhtml
  • frontend
  • install

Se você for curioso deve estar se perguntando  porque as pastas frontend estão com enfase, simples, porque são elas as responsáveis por nosso front-end, html, css, javascript, blocos, etc. Ali e onde a magica ocorre e o template ou tema toma vida.

Pronto, agora já visto a estrutura de pasta do magento, você já sabe aonde e porque deve mexer, cada coisas em seus lugares formando uma plataforma versátil de comercio eletrônico.

2 – O Conceito de “EAV” e  Base de Dados.

O magento trabalha com modelo de EAV em suas tabelas. Agora você desenvolvedor deve estar pensando que a coisa esta se complicando.  Na verdade esta simplificando. Entramos agora no conceito de Entity-Attribute-Value.

O Modelo proposto de EAV e totalmente oposto da modelagem comum, O modelo simples de modelagem seguindo o ER, no futuro traz alguns obstáculos quando  possui uma evolução constante, e muita vezes o modelo de dados tem que se adaptar as novas regras do jogo, e do em questão de compatibilidade, isso se torna bem ruim.

O Conceito básico do EAV e simples, tenha como ideia guardar o Objeto, o atributo e seus valores de atributos. Você esta bem blindado de mudança nas regras do jogo, pois seu modelo baseado em EAV se adapta com muita facilidade a sua necessidade.

Alguns consideram esse modelo de EAV um erro, eu vejo como um obra prima de engenharia de software. Alem de bem projetado, e muito organizado e sistemático, e possui uma ótima flexibilidade.

2 – Instalação, controle de versão e Magento Connect

O Magento traz soluções maravilhosas para melhorar as tarefas mais chatas dos sistemas hoje disponíveis. A instalação, Upgrades e Updates.

Subversion (SVN)

Atualmente você pode fazer um checkout do projeto usando subversion (SVN), que permite flexilidade um bom controle do desenvolvimento e avanços do projeto. Para quem usa Linux e não tem ainda o subversion, basta executar os comandos abaixo:

Vale a dica que para que instalações locais funcionem direitinho, e necessário o uso do Virtual Hosts, porem isso no apache 2 + Linux se torna pratico.

$: sudo apt-get install subversion

Confirme a instalação dos pacotes necessários, depois basta ir na sua pasta padrão do apache, no meu caso sempre fica na home, chamada sites:

$: cd ~/joaovagner/sites/;
$: mkdir magento ;
$: cd magento ;

Pronto, já possui sua pasta para o magento, basta agora fazer o checkout do projeto:

$: svn checkout http://svn.magentocommerce.com/source/branches/1.4

Pronto, já possui um branche do projeto, ou seja, ele esta pronto para rodar, agora caso queira manter uma workcopy basta fazer checkout do trunk, sempre em desenvolvimento, para isso recomendo uma criação de uma pasta para se manter organizado:

$: cd ~/joaovagner/sites/;
$: mkdir magento-trunk ;
$: cd magento-trunk;

Agora basta executar o checkout do trunk:

$: svn checkout http://svn.magentocommerce.com/source/branches/1.4-trunk

Instalação via SSH

A instalação por SSH se baseia simplesmente em comandos de download, disponivel aqui.

Abaixo os comandos necessários usando wget:

//Acesso minha pasta padrão do apache
$: cd ~/joaomedeiros/sites

//Crio uma pasta para o magento
$: mkdir magento

//Acesso a pasta que criei
$: cd magento

//Uso wget para fazer o download dos pacotes, tanto o magento em sí como o arquivo de dados de exemplos
$: wget http://www.magentocommerce.com/downloads/assets/1.4.0.0/magento-1.4.0.0.tar.gz
$: wget http://www.magentocommerce.com/downloads/assets/1.2.0/magento-sample-data-1.2.0.tar.gz

//Descompactação dos pacotes baixados
$: tar -zxvf magento-1.4.0.0.tar.gz
$: tar -zxvf magento-sample-data-1.2.0.tar.gz

// Movemos as imagens de exemplo para a pasta correnta de media
$: mv magento-sample-data-1.2.0/media/* magento/media/

//movendo os registros no banco de exemplo para a a pasta magento

$: mv magento-sample-data-1.2.0/magento_sample_data_for_1.2.0.sql magento/data.sql

//Movendo o .htaccess para interpretação de regras personalizáveis do magento
$: mv magento/* magento/.htaccess .

//Setando permissão de escritas na pasta correta, pois a instalação vai precisar
$: chmod o+w var var/.htaccess app/etc

//Permissão recursiva na pasta de media de imagens de produtos do magento.
$: chmod -R o+w media

//Aqui eu uso o .SQL para inserir dados de exemplo de produtos + CMS + homepage.
$: mysql -h localhost -u seuuserdobanco -psuasenha magento_database < data.sql

//Atualização de pacotes e instalação do canal de upgrade e update do magento connect no pear.
$: ./pear mage-setup .
$: ./pear install magento-core/Mage_All_Latest-stable

//Limpando todos os arquivos desnecessários
$: rm -rf downloader/pearlib/cache/* downloader/pearlib/download/*
$: rm -rf magento/ magento-sample-data-1.2.0/
$: rm -rf magento-1.4.0.0.tar.gz magento-sample-data-1.2.0.tar.gz data.sql

Caso esteja em um MAC OS e não possua o Wget, basta usar o CURL, uma alternativa que funciona basicamente como alternativa ao wget, basta substituir o wget por curl -O

//mesmo efeito que o wget
$: curl -O http://www.magentocommerce.com/downloads/assets/1.4.0.0/magento-1.4.0.0.tar.gz
$: curl -O http://www.magentocommerce.com/downloads/assets/1.2.0/magento-sample-data-1.2.0.tar.gz

Pronto, agora basta acessar a URL localhost e executar a instalação, claro, novamente recomendo o uso do Virtual Hosts para que isso possa fluir melhor.

Agora basta acessar, ai: http://magento.localhost/ (Interpretando que esse e seu virtual host!)

Caso você utilize Windows, pode usar o pacote Magento and Zend Server – Unified Installer e executar sua instalação no Windows com Zend Server e já um pacote do Magento. Eu nunca executei tal teste, não tenho certeza de como funciona e os passos!

Dicas e macetes em problemas de Instalações + Permissões

Como ja venho a tempos executando instalações, entendendo os processos e funcionalidades do magento, venho já armazenando e guardando alguns macetes de problemas recorrentes que enfrento, tanto em servidores conhecidos da IW2 como em terceiros, e as vezes ate localmente.

Instalação e erro 505

Comigo sempre ocorre de um upgrade ou nova instalação, ocorrer erro500, o famoso “Internal Server Error”, isso pode ser corrigido com Shell Script:

$: cd magento ;
$: find . -type d -print | xargs chmod 755
$: find . -type f -print0 | xargs -0 -n1 chmod 644
$: chmod 775 app/etc var var/.htaccess && chmod -R 775 media

Problema Resolvido

Menu Administrativo parou de funcionar! O Que eu faço?!

Esse problema ocorre devido a compilação do javascript, e simples resolver, e já e um problema frequente:

Passo 1 – Abrir o Arquivo com problema

O Arquivo que esta causando esse problema se localiza na seguinte path: app/code/core/Mage/Page/Block/Html/Head.php

Basta renomear o Head.php para head.php. No Terminal basta executar o comando mv:

$: cd magento;
$: mv pp/code/core/Mage/Page/Block/Html/Head.php   app/code/core/Mage/Page/Block/Html/head.php

Passo 2 - Permissões corretas

Esses arquivos precisam de permissões corretas para que o Browser tenha o retorno necessário:

$: cd magento;
$: chmod 755 js/ ;
$: chmod 644 js/lib/ ;
$: chmod 644 js/index.php ;

Pronto, seu menu está perfeito! Seu Magento esta pronto para trabalhar!

Tags: ecommerce, frameworks, magento, varien, zend framework

OOP no PHP: Overloading, utilizando os métodos mágicos do PHP

Postado por Tobias em 16.04.2009 04:56 Desenvolvimento web, Geral, Internet, OOP, php

E aeeeeew blz? Bom gente voltando do período de preguiça bagarai, vício em jogos online e outras vagabundagens ociosidade vamos dar continuidade a série de artigos sobre OOP no PHP. O assunto de hoje é bem interessante, no post de hoje vamos ver como usar um dos métodos mágicos do php.

Neste artigo vou falar do método mágico __call(),  que funciona da seguinte maneira:

Quando uma classe tem o método __call() o php roda esse método sempre que qualquer método da classe for chamado, mesmo se o método que foi chamado não existir um método inexistente ou inacessível for chamado (obrigado Edgar pelo puxão de orelha), isso abre espaço para algumas coisas interessantes.

Vamos a um exemplo do funcionamento de __call():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?php
class ExemploCall {  
  function __call($m, $a)
  {
    print "Método chamado: $m\n";
    print "Parametros: \n";
    var_dump($a);
    return $this->x;
  }
}
$call = new ExemploCall();
$call->test(1,2,'teste');
 
//Mostra na tela
/*
Método chamado: test 
Parametros: 
array(3) { 
  [0]=>  int(1) 
  [1]=>  int(2) 
  [2]=>  string(5) "teste" 
} 
*/
?>

O exemplo acima simplesmente exibe na tela o método chamado e os parametros enviados, mas vendo isso a pergunta que surge na cabeça é, pra que ou onde eu vou usar o método __call()?

A resposta pra essa pergunta vai da sua criatividade mas eu vou postar aqui uma forma de uso que o cakephp usava há algum tempo atrás.

Funcionava da seguinte forma, havia um método padrão chamado find que era chamado e fazia consultas ao banco de acordo com os parametros passados, porém, (aqui que vem a mágica) ele também podia ser chamado como findByNomeDoCampo o que em alguns momentos facilitava bastante a vida do programador, vamos fazer algo parecido com isso.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

<?php
 
/**
  Só vou postar o código relevante aos métodos mágicos, mas supõe-se que
  deste ponto em diante você já tem incluido no arquivo toda a rotina de 
  conexão com o banco de dados, etc, etc, etc...  
**/
 
class Model {
 
  public function __construct() 
  { //O conteúdo deste método vai variar de acordo com sua classe
  }
 
  public function __call($method, $params)
  {
    // Verifica se o método chamado existe nessa classe
    if ( method_exists($this,$method) )
    {
      //Caso exista chama o método
      return call_user_method($method, $this, $params);
    } 
    else 
    {
      //Caso não exista, chama um método especial que fará a nossa mágica
      $this->parseMethods($method,$params);
    }
  }
 
  private function parseMethods($method,$params)
  {
    //Verifica se o método segue o padrão adotado
    if ( eregi('findBy',$method) === false ) 
    {      
      //Caso não siga dispara um erro dizendo que o método é inválido/não encontrado
      trigger_error('Método inválido ou inexistente',E_USER_ERROR); 
      die;
    }
    else
    {
      //Caso seja um método padronizado (findByAlgo) recupera o nome do campo e converte tudo para minúsculo
      $fieldName = strtolower(str_ireplace('findBy','',$method));      
 
      //Formata os parametros para serem passados ao método find padrão
      $options = $params['1'];
      $options['conditions'] = array($fieldName=>$params['0']);
 
      //Chama o método find original
      $this->find($options);            
    }
  }
 
 
  public function find($options) 
  {    
    var_dump($options);
    //Aqui você faria a consulta usando as informações recebidas
  }
 
}
 
//Instancia a classe
$model = new Model();
 
//Define parametros a serem passados
$options = array (
   'fields' => array ('*')
  ,'order'  => array ('nome ASC')
);
 
//Chama o método mágico
// Onde o primeiro parametro é o valor que o campo passado no nome do método deve ter.
$model->findByBlog('Technócio',$options);
 
/**
O que chega no método options é:
array(3) { 
    ["fields"] =>  array(1) { 
        [0]=>  string(1) "*" 
    } 
    ["order"] =>  array(1) { 
        [0]=>  string(8) "nome ASC" 
    } 
    ["conditions"] =>  array(1) { 
        ["blog"]=>  string(9) "Technócio" 
    } 
} 
**/
?>

O código ta bem comentado e bem simples também, embora não tenha me aprofundado muito no assunto acho que deu pra ter uma noção dessa possibilidade e do que pode ser feito com isso.

Como sempre, para dúvidas, sugestões e puxões de orelha, utilizem os comentários. Até a próxima (que dessa vez não vai ser tão demorada assim).

Tags: call, Desenvolvimento web, metodos magicos, OOP, php, php5, __call

Bloqueio de rota administrativa do CakePHP

Postado por João Vagner em 12.03.2009 08:34 Destaques, Geral, Internet, OOP, frameworks, php

Olá Pessoal,

Quem utiliza o Fremwork CakePHP sabe que é uma mão na roda o route admin. Nos poupa um bocado de trabalho criar as funções da administração do site. Isso graças ao “Bake” Porém a rota não pode ficar totalmente acessivel a qualquer um, certo?

O Jonathan Snook escreveu um artigo em relação a isso, porém em alguns testes por aqui nenhum realmente funcionou utilizando .htaccess para proteção dessa rota com password.

Password Protecting Admin Functions in CakePHP.

O Conceito da proteção no artigo do Jonathan Snook é simples, E pode ser gerado com qualquer um que possua acesso ao SSH do site. Não é necessário acesso root para esses tipos de ações no servidor.
Seu servidor não te da acesso ao SSH? Está na hora de mudar para a IW²

O primeiro passo dessa proteção se dá ao inserir seguinte conteúdo no seu .htaccess :

1
2
3
4

AuthUserFile /diretorio/passwd/protecao
AuthName "Administracao CAKE"
AuthType Basic
Require valid-user

Com acesso ao ssh utilize o seguinte comando dentro da pasta “www”.

htpasswd -c /diretorio/passwd/protecao username

.
Isso gera um arquivo com a senha criptografada! Caso queira barar o arquivo gerado para verificar fiquem à vontade!

Bons testes, aqui nunca funcionou!

Meu jeitinho

A maneira no qual eu utilizo é a verificação simples de variavel, ou seja, apenas um usuário dentro do código no qual após o POST, verifica os dados, e grava uma sessão, se os mesmos forem iguais.

Primeiro passo é abrir o seu /app/config/routes.php, e crie uma rota chamada admin, usando o controller de páginas estáticas. Veja:

1

Router::connect('/admin/', array('controller' => 'pages', 'action' => 'display', 'admin'));

Agora crie um arquivo chamado admin.ctp dentro da pasta /app/views/pages/ com um formulário básico para login e senha:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?php  
//Define o layout padrão para a página
$this->layout = 'admin'; 
?>
<h1><?php __('Administração');?></h1>
<?php   
// Caso ocorra algum erro, é exibido em sua div correta!
if(isset($error)) {   
    echo "<div class='error'>" . $error . "</div>";   
}   
?>   
<?php 
/*
criamos um formulário com o vetor User, indicando a rota /admin/login, onde teremos nossa verificação de usuário e senha para registro da sessão da administração, e acesso ao restante dos actions _admin_
*/
echo $form->create('User', array('url'=>'/admin/login/'));
?>   
<fieldset>
    <legend>Digite os dados</legend>   
        <?php  echo $form->input('username', array('label'=>'Login')); ?>
        <?php echo $form->input('password', array('label'=>'Senha', 'id'=>'Senha')); ?>   
  <?php echo $form->end('Logar!'); ?>   
   </fieldset>
</form>

O próximo passo é criar uma nova rota no /app/config/routes.php, rota no qual foi definida na URL do nosso formulário, onde será submetida os dados para verificação.

1

Router::connect('/admin/login/', array('controller' => 'users', 'action' => 'admLogin'));

Claro, obviamente eu já possuo um controller chamado users, caso não tenha, pode cria-lo, utilizando o código abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

<?php
class UsersController extends AppController {
 
	var $name = 'Users';
	var $helpers = array('Html', 'Form');
 
/*
Claro, que aqui irão outras actions suas ;)
*/
 
	function admLogin() {   
	    //verifica se o post possui alguma informação para registrar o nosso array com informações
	    if($this->data) {   
                $dbuser	=       array('username'=='Administrador', 'password'=>'Sua_senha_aqui');
	           if(($this->data['User']['username'] == $dbuser['username']) && 
                         ($this->data['User']['password'] == $dbuser['password']))  {   
                                 $this->Session->Write('admin', $dbuser);   
                                 // registra a sessão "admin" para futuras verificações
                                 $this->Session->setFlash('Logado com sucesso');   
                                 //Notifica o sucesso ao logar!
                                 $this->redirect('/admin/users/index');   
                                 // redireciona para a action index do controller users.
	        } else {   
	              $this->Session->setFlash('Erro! Dados inválidos');
                          // notifica o erro    
	        }   
	    }   
	}
 
 
}
?>

Note que por enquanto o nosso controller users possui apenas um action. Fica a seu critério a criação do resto do conteúdo ;)

Agora iremos criar a função para verificação da sessão:

1
2
3
4
5
6
7
8
9

<?php
	function checkAdminSession() {   
               if (!$this->Session->check('admin')) {   
               $this->Session->setFlash('Você não tem acesso a essa área');   
               $this->redirect('/admin/login/');   
    }   
}   
 
?>

A minha recomendação é que coloque essa função dentro do arquivo /app/app_controller.php no qual o cake carrega automáticamente. Esse arquivo serve para colocar as funções que vai utilizar em todos os controllers, sem a necessidade de ficar repetindo os mesmos.

Agora vem a parte mais interessante, vamos inserir o beforeFilter(); também dentro do /app/app_controller.php, para verificação do parametro /admin/ na url, e execução da verificação da sessão. Veja:

1
2
3
4
5
6
7
8

<?php
 
function beforeFilter() {   
        if(isset($this->params['admin'])) {   
           $this->checkAdminSession();   
    }   
 }
?>

O que a função faz é: Se existe algum parametro na url “admin”, executa a função checkAdminSession e veja se existe a sessão “admin”. Se não existir a sessão, a checkAdminSession redireciona para login.

Pronto, e assim você tem uma certa segurança em relação a rota /admin/ não estar sendo visualizada por tudo e por todos!

Tags: cakephp, Desenvolvimento web, frameworks

OOP no PHP: Reaproveitamento, Sobrescrevendo métodos

Postado por Tobias em 17.12.2008 07:09 Desenvolvimento web, Destaques, OOP, php

E ae blz?

Chegamos numa das partes interessantes da nossa série de posts, é onde começo a falar das gambiarras técnicas usadas por nós programadores para salvar horas de trabalho no desenvolvimento.

Para ilustrar o post de hoje vou usar um caso que aconteceu comigo a algum tempo. Na empresa onde trabalho, fizemos um sistema publicador de sites, um CMS próprio desenvolvido aqui, e que um belo dia recebi um pedido para incluir nele uma espécie de lixeira.

Bom para implementar essa feature a solução sugerida foi criar uma coluna em cada tabela com o nome de trash e que teria valor default 0 e quando um item fosse deletado esse valor seria alterado para 1.

Tendo isso em mente comecei a implementação, alterar o banco foi moleza, agora eu precisava implementar essa condição no sistema. Foi quando me deparei com a seguinte situação, teria que alterar cada uma das chamadas do método findAll() em todo o sistema, pensei,… pensei,… e quando já não via mais solução pra isso um amigo sugeriu “pow, sobrescreve findAll() que tu evita esse trabalhão“, e assim foi feito :).

Agora que vocês já sabem o problema vou mostrar a solução que eu usei nessa situação.

Eu tinha em em mãos as classes Model, AppModel e uma classe pra cada um dos models específicos (sim, usamos CakePHP).

A classe Model é a base de toda interação com o banco, é uma classe do core do framework extendida pela classe AppModel.

A AppModel é uma classe feita exatamente para esse fim, ela inicialmente é vazio e só extende a classe Model do framework e é extendida pelos models da aplicação, ou seja, é usada por todos os models do sistema e ainda herda o método que eu preciso sobrescrever, tudo que eu precisava.

O método findAll original dentro da classe Model é tem essa estrutura de parâmetros:

A método sobrescrito na AppModel ficou assim:

findInTrash)
			$new_conditions += array($this->name.'.trash' => '0');

		return parent::findAll($new_conditions, $fields, $order, $limit, $page, $recursive);
	}
	...
}
?>

Antes de mais nada vou avisar o óbvio, só coloquei aqui os códigos necessários para explicar o post as classes são bem maiores que isso ;).

Notem também que eu não mudei os parametros usados no método mas poderia faze-lo se fosse necessário, esse método recebe todos os paramêtros possíveis no findAll original, altera as condições necessárias e chama o método findAll da classe pai usando o parent::.

Nesse caso em particular eu só precisava sobrescrever o método para adicionar uma condição específica, mas dependendo do caso talvez você precise que um mesmo método seja chamado de formas diferentes ou com uma quantidade de parâmetros diferentes, o que também poderia ser feito, mas isso já é assunto para um próximo post.

Dúvidas? sugestões? puxões de orelha? comentários tão ai pra isso.

Um abraço e até o próximo post.

OOP no PHP: Heranças e Interfaces, extendendo e implementando classes

Postado por Tobias em 15.12.2008 12:00 Desenvolvimento web, Destaques, OOP, php

E ae blz?

Bom gente depois de um alguns dias atrasado devido a problemas pessoais aqui vai o segundo post da série OOP no PHP, nossos assuntos agora são Heranças e Interfaces, e aproveitando o assunto eu preparei uma classe de acesso ao banco de dados que ilustra perfeitamente o nosso assunto de hoje e também usa as definições do post anterior.

Vamos começar com a teoria:

extends – Essa palavra chave indica que uma classe extende outra classe, ou seja, herda todos os métodos e atributos da classe pai.

Exemplos simples:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<?php
 
class Pai {
	public function pai() {
		echo “Função da classe pai”;
	}
}
 
class Filha extends Pai {
	private function $filha;
 
	public function chamaPai(){
		$this->pai();
	}
 
	public function responde() {
		echo 'Sou uma classe filha';
	}
}
 
?>

No exemplo acima estão disponívels na classe filha todos os métodos/atributos públicos e protegidos (quando existerem) da classe pai.

implements – Essa aqui é um pouco diferente, ela define que uma determinada classe implemente uma interface, que nada mais é uma que uma definição de nomes e parametros de cada método da classe, porém, a real utilidade das interfaces é mais conceitual no mundo OOP e na maioria das vezes é deixada de lado.

vamos a um exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<?php
 
interface iFilha {
	public function chamaPai();
	public function responde();
}
 
class Pai {
	public function pai() {
		echo “Função da classe pai”;
	}
}
 
class Filha extends Pai implements iFilha {
	private function $filha;
 
	public function chamaPai(){
		$this->pai();
	}
 
	public function responde() {
		echo 'Sou uma classe filha';
	}
}
 
?>

Algumas considerações interessantes sobre interfaces:

• Somente métodos públicos aparecem nas interfaces;
• Uma classe pode implementar mais de uma interface;
• Uma classe não pode implementar duas interfaces com métodos de nomes iguais;
• Interfaces podem ser herdadas assim como classes, basta usar extends.

Bom acho que deu pra entender como funcionam essas coisas, então vamos pra um exemplo de uso nessa classe de acesso ao banco que eu fiz pra ajudar o nosso entendimento.

config.php

1
2
3
4
5
6
7
8
9
10
11

<?php
 
class Config {
	const DB_HOST 	= 'localhost';
	const DB_USER 	= 'root';
	const DB_PASS 	= 'root';
	const DB_SCHEMA = 'technocil';
	const DB_ENCODING = 'UTF8';
}
 
?>

dbo_mysql.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

<?php
 
require 'config.php';
 
interface iDBOMysql {
 
	public function __construct();
 
	public function connect();
 
	public function insert($table,$fields);
 
	public function update($table,$fields);
 
	public function delete($table,$conditions);
 
	public function select($table,$fields='*',$conditions=null,$order=null,$limit=null);
 
}
 
class DBOMysql extends Config implements iDBOMysql {
 
	private $connection;
	private $result;
 
	/**
	 * Construtor chama os métodos necessários quando a classe é instanciada
	 */
	public function __construct() {
		$this->connect();
	}
 
	/**
	 * Conecta com o banco de dados utilizando os dados das constantes de configuração
	 */
	public function connect() {
		$this->connection = mysql_connect(parent::DB_HOST,parent::DB_USER,parent::DB_PASS) or die (mysql_error());
		if (mysql_select_db(parent::DB_SCHEMA, $this->connection)) {
			$this->setEnconding();
		}
	}
 
	private function setEnconding() {
		$this->query('SET NAMES '' . parent::DB_ENCODING.''');		
	}
 
	private function query($sql) {
		return mysql_query($sql,$this->connection);
	}
 
	/**
	 * Executa uma query de inserção no banco de dados
	 *
	 * @param string $table nome da tabela
	 * @param array $fields array com os campos e valores a serem inseridos
	 */
	public function insert($table,$fields) {
 
		$columns = $values = array();		
		foreach ($fields as $column => $value) {
			$columns[] = mysql_real_escape_string($column);
			$values[] = mysql_real_escape_string($value);
		}
 
		$sql  = 'INSERT INTO '.mysql_real_escape_string($table).' ';
		$sql .= '('.join(',',$columns).') ';
		$sql .= 'VALUES (''.join("','",$values).'')';
 
		return $this->query($sql);
 
	}
 
	/**
	 * Executa uma query de atualização no banco de dados
	 *
	 * @param string $table nome da tabela
	 * @param array $fields array com os campos e valores a serem inseridos
	 */
	public function update($table,$fields,$conditions=null) {
 
		$columns = $values = array();		
		foreach ($fields as $column => $value) {
			$itens[] = mysql_real_escape_string($column).'=''.mysql_real_escape_string($value).''';
		}
 
		$sql  = 'UPDATE '.mysql_real_escape_string($table).' ';
		$sql .= 'SET '.join(',',$itens).' ';
 
		if ($conditions != null)
			$sql .= 'WHERE '.mysql_real_escape_string($conditions);
 
		return $this->query($sql);	
 
	}
 
	/**
	 * Executa uma query para excluir registros do banco
	 *
	 * @param string $table nome da table
	 * @param string $conditions condições de exclusão (opcional)
	 */
	public function delete($table,$conditions) {
 
		$sql  = 'DELETE FROM '.mysql_real_escape_string($table).' ';
		if ($conditions != null)
			$sql .= 'WHERE '.mysql_real_escape_string($conditions);
 
		return $this->query($sql);
 
	}
 
	/**
	 * Executa uma query para selecionar registros no banco de dados
	 *
	 * @param string $table 
	 * @param array $fields 
	 * @param string $conditions 
	 * @param string $order
	 * @param string $limit
	 */
	public function select($table,$fields='*',$conditions=null,$order=null,$limit=null) {
 
		$sql  = 'SELECT ';
		$sql .= (is_array($fields)) ? join(',',$fields) : $fields;
		$sql .= ' FROM '.mysql_real_escape_string($table).' ';
 
		if ($conditions != null)
			$sql .= 'WHERE '.mysql_real_escape_string($conditions);
 
		if ($order != null)
			$sql .= 'ORDER BY '.mysql_real_escape_string($order);
 
		if ($limit != null)
			$sql .= mysql_real_escape_string($limit);
 
		$results = $this->query($sql);
 
		$fetch = array();
		while ( $loop = mysql_fetch_assoc($results) ) {
			$fetch[] = $loop;
		}
 
		return $fetch;
 
	}
}
 
?>

Só uma rápida explicação:
A classe Config é uma classe que contem as constantes de configuração de acesso ao banco, a classe DBOMysql é a classe que implementa a interface iDBOMysql e extend a classe Config, vocês podem notar também o uso de public em private nos atributos, essa classe mostra o uso extends e implements, só gostaria de lembrar que como a classe os métodos private da classe não aparecem na interface, e que nesse caso a interface não é algo essencial.

Bom gente por enquanto é isso, quero me desculpar pelo atraso do post, a última semana foi meio corrida e o fim de semana foi de comemoração por que terminei a faculdade.

Abraços e até a próxima, onde nossos assuntos vão ficar cada vez mais interessantes.

Tags: extends, herança, implements, interfaces, OOP, php

OOP no PHP: Visibilidade, definições de public, protected, private e static

Postado por Tobias em 11.12.2008 12:52 Desenvolvimento web, OOP, php

E ae blz?

Bom inaugurando a minha participação aqui no blog resolvi começar com uma série de artigos sobre OOP e PHP, no primeiro post eu vou explicar o que significam as palavrinhas public, protected, private e static, o que significam e a função de cada uma delas em nossas classes.

Só pra constar essa série inicial terá 5 posts com os seguintes assuntos.

• Visibilidade, definições de public, protected, private e static
• Heranças e Interfaces, extendendo e implementando classes
• Reaproveitamento, Sobrescrevendo métodos
• Overloading, utilizando os métodos mágicos do PHP
• Improviso, simulando a sobrecarga de métodos no PHP

Bom já que estamos com tudo resolvido vamos começar a brincadeira.

As definições de escopo são bem simples e não há necessidade de se extender falando delas.

public é a liberal das definições de escopo, todo método ou atributo de uma classe definido como
public pode ser acessado de qualquer lugar.

protected é um pouco mais contida só pode ser acessada de dentro da classe e de suas classes filhas.

private como o nome já diz é totalmente restrita e só pode ser acessada de dentro da classe.

Exemplo abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<?php
 
class Exemplo {
 
  public $publicInfo = 'Sou uma informação pública';
  protected $protectedInfo = 'Sou uma informação protegida';
  private $privateInfo = 'Sou uma informação restrita';
 
  public function getPublicInfo() {
    echo $this->publicInfo;
  }
 
  protected function getProtectedInfo() {
    echo $this->protectedInfo;
  }
 
  private function getPrivateInfo() {
    echo $this->privateInfo;
  }
 
}
 
$exemplo = new Exemplo;
 
//Imprime Sou uma informação pública
$exemplo->getPublicInfo();
 
//Retorna Fatal error: Call to protected method Exemplo::getProtectedInfo() from context
$exemplo->getProtectedInfo();
 
//Retorna Fatal error: Call to private method Exemplo::getPrivateInfo() from context
$exemplo->getPrivateInfo();
 
?>

Tudo bem aparentemente, então vamos pra função de static.

static permite que algum método ou atributo de uma classe seja chamado sem a necessidade de instanciar a classe. O método/atributo é chamado da seguinte forma:

NomeDaClasse::NomeDoMetodo() ou
NomeDaClasse::$NomeDoAtributo

Exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?php
 
class ExemploStatic {
	public static $atributo = 'Eu tenho alguma informação';
 
	public static function fazAlgumaCoisa() {
		echo 'Eu faço alguma coisa';
	}
}
 
//Imprime Eu tenho alguma informação
echo ExemploStatic::$atributo;
 
//Imprime Eu faço alguma coisa
ExemploStatic::fazAlgumaCoisa();
 
?>

É por hora acho que já ta de bom tamanho, você pode encontrar mais informações sobre public, private e protected e também sobre a static na documentação oficial do php.

Ainda ficou com alguma dúvida? sim? bom os comentários tão aqui pra isso, mas se você não ficou com dúvidas e quer dar um puxão de orelha no menino aqui, os comentários também server pra isso.

Um abraço e até o próximo post.

Tags: escopo, OOP, php, private, protected, public, static