Blog do DragaO~

PHP OO : Acessando Objetos em qualquer página

Olá pessoas que visitam este pequeno blog :D
Hoje venho com uma dúvida que muitas pessoas possuem, e vejo que o material sobre o assunto me pareceu escasso (e na sua grande maioria em inglês): acessar objetos em diferentes partes de um sistema/site.

Um certo dia eu comecei a tentar “brincar” com programação orientada a objetos em PHP, e notei que eu precisava acessar o mesmo objeto em uma página, e logo após em outra, o que eu fiz? simplesmente criei uma sessão (eu costumo utilizar sessões) e “joguei” meu objeto lá dentro.
Trocando isso tudo em códigos, o que eu fiz foi mais ou menos isso :

meuobjeto.php

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

<?
class MeuObjeto
{
    private $algo;
 
    public function __construct()
    {
        $this->algo = mt_rand();
    }
 
    public function getAlgo()
    {
        return $this->algo;
    }
}
?>

Como podem ver, este é um objeto bastante simples, que não faz nada, porém vai me ser útil neste exemplo :D
(o intuito deste post não é ensinar programação orientada a objetos, portanto, não me aterei à esta parte)

Agora vamos fazer um exemplo bem básico para criar um objeto da classe “MeuObjeto”, acessar ele e ver as suas propriedades :

teste.php:

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

<?
//dando um nome a sessao
session_name('minha_sessao');
//inicindo a sessao
session_start();
 
//incluindo o arquivo que contem o objeto
include('meuobjeto.php');
 
//instanciando um novo objeto e atribuindo-o a uma variavel
$objeto = new MeuObjeto();
//mostrando seu valor
echo "valor da variavel/objeto : " . $objeto->getAlgo();
//mostrando o var_dump para que possamos ver como a variavel "realmente eh"
var_dump($objeto);
 
//atribuindo o objeto a uma variavel qualquer de nossa sessao
$_SESSION['algo'] = $objeto;
//verificando o valor do objeto que esta na sessao
echo "valor da variavel/objeto que esta na sessao : " . $_SESSION['algo']->getAlgo();
//mostrando o var_dump para que possamos ver se continua tudo correto
var_dump($_SESSION['algo']);
?>

como disse anteriormente, gosto de utilizar sessões, porém, este exemplo pode ser perfeitamente praticável com cookies, arquivos, banco de dados, ou até mesmo pela URL (confesso que não testei em nada a não ser sessões, porém, na teoria, deve funcionar com todos, por isso peço que me avisem caso não funcione em algum destes ;)), isso depende tudo da sua “criatividade” :D

Como comentei o código creio não precisar explicar nada, apenas aconselhar que, quem não sabe o que são includes, que leia isto (não é pré-requisito para este post, mas para programação em si)

O exemplo acima deve mostrar algo como :

valor da variavel/objeto : 741366652

object(MeuObjeto)#2 (1) {
  ["algo:private"]=>
  int(741366652)
}

valor da variavel/objeto que esta na sessao : 741366652

object(MeuObjeto)#2 (1) {
  ["algo:private"]=>
  int(741366652)
}

Note que, ambas variáveis são objetos da classe “MeuObjeto” e que possuem um atributo chamado “algo” de visibilidade “privada”, com o valor inteiro “741366652″ atribuído à este atributo
Vendo isso parece que não existe problema algum não é mesmo? Pois bem, vamos ao próximo e “revelador” script:

teste2.php

1
2
3
4
5
6
7
8
9
10
11

<?
//iniciando novamente a nossa sessao
session_name('minha_sessao');
session_start();
 
//vendo os valores da variavel de sessao
var_dump($_SESSION['algo']);
 
//mostrando o numero
echo $_SESSION['algo']->getAlgo();
?>

ao ler o scrip parece tudo certo né? mas quando eu tentei acessar apareceu isso :

object(__PHP_Incomplete_Class)#1 (2) {
  ["__PHP_Incomplete_Class_Name"]=>
  string(9) "MeuObjeto"
  ["algo:private"]=>
  int(235422008)
}

já de cara dá pra ver que a coisa não aconteceu como a gente esperava, pois nossa variável de sessão passou a ser pertencente à classe “__PHP_Incomplete_Class_Name” e não mais “MeuObjeto”, porém, podemos ver que o PHP salvou o nome da classe dentro deste objeto.
Pois é, mas isso não serve pra nada :)

Se a gente parar para ler o erro fatal (que, aliás, é bem grande), vemos que ele fala algo sobre uma função chamada “unserialize()” e também fala sobre o método mágico “__autoload()”
O que nos interessa é a função “unserialize()”, portanto, vamos à ela ;)

Basicamente falando, a função “unserialize()” desfaz o que a função “serialize()” fez; seria mais ou menos como uma criptografia (reversa, obviamente), portanto, vamos pegar o nosso arquivo “teste.php” e fazer algumas modiicações:

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

<?
//dando um nome a sessao
session_name('minha_sessao');
//inicindo a sessao
session_start();
 
//incluindo o arquivo que contem o objeto
include('meuobjeto.php');
 
//instanciando um novo objeto e atribuindo-o a uma variavel
$objeto = new MeuObjeto();
//mostrando seu valor
echo "valor da variavel/objeto : " . $objeto->getAlgo();
//mostrando o var_dump para que possamos ver como a variavel "realmente eh"
var_dump($objeto);
 
//atribuindo a serializaçao de um objeto a uma variavel qualquer de nossa sessao
$_SESSION['algo'] = serialize($objeto);
//vendo como fica o objeto serializado na sessao
var_dump($_SESSION['algo']);
 
//deserializando a nossa sessao e atribuindo a uma variave
$variavel = unserialize($_SESSION['algo']);
// verificando o valor do objeto que esta na sessao
echo "valor da variavel/objeto que esta na sessao : " . $variavel->getAlgo();
//vendo os valores que existem na sessao
var_dump($_SESSION['algo']);
//vendo os valores que existem na variavel
var_dump($variavel);
?>

vou me ater somente às modificações, beleza? ;)

20

$_SESSION['algo'] = serialize($objeto);

aqui estamos serializando nosso objeto e colocando-o em uma variável qualquer de nossa sessão, e esse é o primeiro passo que faz com que nosso objeto funcione normalmente ;)

22

var_dump($_SESSION['algo']);

aqui estamos mostrando novo valor da nossa sessão, que no meu caso, foi isso :

string(56) "O:9:"MeuObjeto":1:{s:15:"�MeuObjeto�algo";i:1119598129;}"

vejam como realmente é diferente de quando não havíamos serializado:

object(MeuObjeto)#2 (1) {
  ["algo:private"]=>
  int(741366652)
}

caso não lembre, o valor do atributo “algo” é diferente pois é gerado randomicamente, o que quero comparar é o modo como apareceu as informações na tela :)
Pois bem, aquela “coisa louca” é a representação do teu objeto, legal né ? :D

seguindo em frente…

27

$variavel = unserialize($_SESSION['algo']);

aqui estamos desfazendo o que fizemos acima, a fim de utilizar novamente o nosso objeto
afinal aquela string que vimos antes não é um objeto :)
básicamente a função “unserialize()” nos devolve o nosso objeto, nada mais, então, a partir desse ponto, temos o mesmo objeto que tínhamos antes na variável “$objeto”, mas ela passou pela sessão e agora “foi parar” na variável “$variavel” (novamente minha criatividade atacando :D)

29

echo "valor da variavel/objeto que esta na sessao : " . $variavel->getAlgo();

aqui estamos vendo se o valor realmente continuou o mesmo que estava antes (”1119598129″), vejam a minha saída:

valor da variavel/objeto que esta na sessao : 1119598129

como pode-se ver, realmente permaneceu o mesmo valor, mas será que após deserializar o nosso objeto a variável de sessão foi afetada? vejamos a seguir a minha saída:

valores da sessao :
string(56) "O:9:"MeuObjeto":1:{s:15:"�MeuObjeto�algo";i:1119598129;}"

como esperado, a sessão continuou intacta (até mesmo porque não mexemos nela né :))
e qual será o valor que existe na variável “$variavel”? será que é o valor da sessão ou será que está igual ao “$objeto”? na curiosidade, aí vai :

object(MeuObjeto)#2 (1) {
  ["algo:private"]=>
  int(1119598129)
}

mágico não? :)
agora conseguimos transferir um objeto para a sessão, serializá-lo e mesmo assim conseguimos obter os dados “reais” dele :)
e claro, não poderia me esquecer de mostrar a minha saída “na íntegra”:

valor da variavel/objeto : 1119598129

object(MeuObjeto)#1 (1) {
  ["algo:private"]=>
  int(1119598129)
}

string(56) "O:9:"MeuObjeto":1:{s:15:"�MeuObjeto�algo";i:1119598129;}"

valor da variavel/objeto que esta na sessao : 1119598129

valores da sessao :
string(56) "O:9:"MeuObjeto":1:{s:15:"�MeuObjeto�algo";i:1119598129;}"

object(MeuObjeto)#2 (1) {
  ["algo:private"]=>
  int(1119598129)
}

e, para provar que eu não simplesmente mostrei à vocês uma função que faz criptografia reversível, vamos ao novo arquivo “teste2.php”:

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

<?
//iniciando novamente a nossa sessao
session_name('minha_sessao');
session_start();
//incluindo nosso objeto 
include('meuobjeto.php');
 
//vendo os valores da variavel de sessao
var_dump($_SESSION['algo']);
//deserializando o objeto da sessao e atribuindo a uma variavel comum
$outra_var = unserialize($_SESSION['algo']);
 
//vendo o que eh a variavel
var_dump($outra_var);
//mostrando o numero
echo $outra_var->getAlgo();
?>

novamente, apenas as modificações ;)

6

include('meuobjeto.php');

muito importante essa linha, pois caso o nosso objeto não exista no documento em questão, o PHP não vai conseguir identificar a classe, e logo vai “dizer” que esse objeto é da classe ‘__PHP_Incomplete_Class”, portanto lembre-se de incluir a classe :)

9

var_dump($_SESSION['algo']);

aqui estamos vendo o conteúdo da variável de sessão para ver se o nosso “objeto” continua lá, e eis o que aparece:

string(56) "O:9:"MeuObjeto":1:{s:15:"�MeuObjeto�algo";i:1119598129;}"

realmente, a nossa string permanece ali, mas será que ela funciona? veremos agora :)

11

$outra_var = unserialize($_SESSION['algo']);

primeiro, deserializamos a nossa variável de sessão em uma variável qualquer…

14

var_dump($outra_var);

…e vemos que o seu valor continua o mesmo de antes :

object(MeuObjeto)#2 (1) {
  ["algo:private"]=>
  int(1119598129)
}

mas será que o nosso método ainda funciona? eis a resposta, vejam a saída da liha 16 :

1119598129

pois é, agora conseguimos realmente passar objetos entre páginas utilizando sessões :)
o melhor de tudo, é que, como já é sabido, sessões são nada menos do que arquivos armazenados no servidor, então quer dizer que podemos armazenar nossos objetos em arquivos puros, cookies e até mesmo banco de dados :D
e como o objeto serializado não passa de uma string, poderíamos também passa-lo pela URL usando o método GET, portanto, o limite é a sua imaginação :D

ah, antes que eu me esqueça, esse modo de “utilização” preserva tudo do objeto, não somente métodos e atributos, mas também heranças e tudo mais :)

sinceramente, eu acho isso que o PHP faz uma baita gambiarra, mas, paciência né, afinal o PHP ainda está “migrando” para ser uma linguagem orientada a objetos (atualmente ela apenas “tem suporte”), portanto, pode ser que no futuro isso melhore ;)

Confesso que testei apenas com sessões, portanto, não posso afirmar com 100% de certeza que funciona de outros métodos, por isso, peço que caso algum deles não funcione, me avisem :D

e antes de terminar este post, como será que a gente faria para alterar o valor de um objeto que está na sessão? simples, deserializamos ela em uma variavel, fazemos as alterações nessa variável, e depois serializamos ela novamente, assim :

1
2
3
4
5
6
7
8
9

session_name('minha_sessao');
session_start();
 
//deserializando um objeto jah serializado
$variavel = unserialize($_SESSION['algo']);
//mudando o valor de algum atributo
$variavel->setaAlgumValor('algo');
//re-serializando para a sessao
$_SESSION['algo'] = serialize($variavel);

simples assim :)

bom, espero que tenham gostado deste post, e lembre-se:

• em caso de dúvidas, pergunte
• achou um erro? diga

agora, deixo informações que podem ser relevantes para esse exemplo ter funcionado, que é onde eu testei :

referência das funções :
“serialize()“, “unserialize()”

até o próximo post, e não se esqueça de dar uma nota :)

Postagens parecidas/interessantes:

Criando variaveis dinamicamente atraves de um formulario

O Método GET e as URL’s

Mostrando o Conteúdo de Pastas/Diretórios com PHP

Cadastro Simples com PHP e MySQL

Linux : Instalando o PHP-GTK2 com suporte à MySQL