Originariamente inviato da Ironmax
Scusa Grino.
Volevo capire perchè, dato che non mi è mai capitato, ci sono tre gradi di connessione:
const kConnessioneFallita=0;
const kConnessioneStabilita=1;
const kConnessioneEsistente=2;
O almeno in programmazione strutturata si apriva la connessione ed alla fine della query o delle query si chiudeva la connessione.
Poi perchè le seguenti proprietà sono private? Non era meglio statiche?
private $nomehost = "localhost";
private $nomeuser = "root";
private $password = "";
Grazie.
Quando stabilisci una connessione ad un DB MySQL ti viene fornito il famoso $conn che è un id di risorsa (un numero intero per capirci) se richiami la mysql_connect per la seconda volta MySQL si accorge che sei sempre tu e restituisce lo stesso ID.
Se dall'oggetto invochi per due volte lo stesso metodo di connessione, essendo già settato l'attributo della connessione, possiamo dire che la connessione è esistente "già". In teoria potresti ritenere errato che venga invocato più di una volta e quindi voler sapere se il tuo codice contiene più chiamate al metodo di connessione (ma è giusto teoria). Se $connessione è false, allora cerchiamo di ottenere il nostro resource ID. Se va male la mysql_connect ritorna false (ecco perchè ho sbagliato nel secondo esempio ad usare is_null) quindi possiamo comunicare, o con un valore di ritorno o sollevando una eccezione, che il tentativo di stabilire una connessione con mysql non è andato a buon fine.
Se attraversiamo indenni i primi due casi, allora abbiamo ottenuto una nuova risorsa id, quindi comunichiamo che è andato tutto ok.
L'unico attributo veramente statico in questa classe "giocattolo" dovrebbe essere $connessione, perchè l'id che utilizziamo e che comunque mysql ritorna alle nostre richieste di connessione è sempre lo stesso a prescindere dall'oggetto/procedura che lo richiede.
In linea di principio tutti i dati interni, contenuti in attributi della classe, non vanno esposti ma piuttosto va consentito loro un accesso tramite metodi set/get. In tal caso potremo parlare di proprietà. Con PHP hai i metodi magici __set e __get che vengono invocati quando il client tenta di acceder tramite un oggetto ad una proprietà non definita. Questo ti permette una migliore gestione e maggior controllo su ciò che il client cerca di fare piuttosto che rendere pubblici degli attributi.
I modificatori di accesso sono Private, Public, Protected. Il modifcatore static indica invece che un dato attributo o metodo non appartiene ad una singola istanza della classe, ma alla classe stessa. Gli attributi statici risultano condivisi fra le classi, mentre i metodi possono essere invocati senza istanziare alcun oggetto ma anteponendo direttamente il nome della classe: nomeclasse::nomemetodostati();
Infine, come gestire gli attributi o degli aglgomerati di dati correlati fra di loro, sono scelte di progetto. Potresti per esempio decidere di far viaggiare i dati host, user e password, attraverso un oggetto di trasporto utilizzato dalla classe del db e che lo richiede come argomento al momento della costruzione o settabile tramite metodo... per esempio
Codice PHP:
<?php
/*
* Esempio di classi per un DB
*/
class cExceptionClasseTrasporto extends Exception{
const kErroreInatteso=0;
const kProprietaDuplicata=1;
const kProprietaInesistente=2;
private $messaggi=array(
"Errore Inatteso;",
"Tentativo di duplicazione della proprietà: ",
"Si tenta di gestire un proprietà inesistente: "
);
public function __construct($codice,$nomeProprieta) {
parent::__construct($this->messaggi[$codice].$nomeProprieta, $codice);
}
}
abstract class cClasseTrasporto{
private $data=array();
protected function ProprietaEsistente($nome){
return array_key_exists($nome, $this->data);
}
protected function AggiungiProprietà($nome,$valoreDefault){
if(!isset($data['$nome']))
$this->data[$nome]=$valoreDefault;
else
throw new cExceptionClasseTrasporto(cExceptionClasseTrasporto::kProprietaDuplicata,$nome);
}
protected function RimuoviProprietà($nome){
if($this->ProprietaEsistente($nome))
unset($this->data['$nome']);
else
throw new cExceptionClasseTrasporto (cExceptionClasseTrasporto::kProprietaInesistente, $nome);
}
public function __set($nome, $valore) {
if($this->ProprietaEsistente($nome))
$this->data[$nome]=$valore;
else
throw new cExceptionClasseTrasporto (cExceptionClasseTrasporto::kProprietaInesistente, $nome);
}
public function __get($nome) {
if($this->ProprietaEsistente($nome))
return $this->data[$nome];
else
throw new cExceptionClasseTrasporto (cExceptionClasseTrasporto::kProprietaInesistente, $nome);
}
}
class cCTParametriConnessione extends cClasseTrasporto{
public function __construct() {
$this->AggiungiProprietà("user", "root");
$this->AggiungiProprietà("password", "");
$this->AggiungiProprietà("host", "localhost");
}
//posso definire altri metodi per il settaggio dei singoli parametri,
//oppure definire un metodo per il pssaggio dei parametri nella
//forma user@host:passwor, sarà poi il metodo a distribuire i
//valori. Ancora il client può impostare i valori accedendo
//direttamente alle proprietà con $obj->user="pippo"
//posso ridefinire __set e __get per effettuare ulteriori controlli
//prima di invocare il metodo parent::__set o parent::__get
//perchè memorizzi i dati per me
}
abstract class GenericDB{
private $parametriConnessione=null;
public function __construct($oCTParametriConnessione){
//controllo che l'oggetto sia di classe attesa e lo assegno all'attributo
}
public function Connetti(){
//questa funzione resta vuota e poi la specifica implementazione andrà a
//colamre i vuoit, dopotutto è una classe astratta
}
//e via così....
}
//e ancora e ancora...
?>
Rispondi quotando
