io sto seguendo l'approccio suggeritomi da grino... ma ancora non ho finito... sono work in progressi perchè mi sto studiando tutto man mano che lo incontro...
Vi faccio vedere a che punto sono... nn rimuovo i commento così capite anche il modo in cui sto lavorando:
DAOFactory
Codice PHP:
<?php
/*
Questa classe mi servirà:
1) per selezionare fra i vari disponibili la base dati da cui attingere
2) "vincola" tramite la definizione di metodi astratti le classi che saranno sua estensioni
+----------------------+
| TEORIA -> ABSTRACT |
+----------------------+
Una classe deve essere astratta quando contiene al suo interno metodi astratti.
Essa non può essere istanziata.
I metodi astratti sono un'imposizione sull'implementazione successiva della classe e sono senza corpo.
Cioè le classi "figlie" (extends) dovranno contenere necessariamente i metodi che nella classe "padre"
(in questo caso la sottoscritta) sono stati dichiarati come astratti ripettando il nome e i parametri.
Le classi astratte pertanto svolgono un ruolo di "progettazione", "coordinamento", "uniformazione" soprattutto
nel caso in cui una classe dovrà avere numerosi extends.
Una classe astratta, pertanto, "prevede" necessariamente delle sottoclassi e tali sottoclassi dovranno
necessariamente definire i metodi dichiarati come astratti.
*/
abstract class DAOFactory
{
/*lista dei db disponibili*/
const MYSQL = 1;
//const ORACLE = 2;
//const SYBASE = 3;
/*
definiamo i metodi previsti dalle classi figlie
ovvero tutte le classi che potrò creare in futuro
che necessiteranno di un db come fonte per i loro dati
*/
public abstract function getArticoloDAO();
//public abstract function getCommentiDAO();
//public abstract function getUtentiDAO();
/*
Le classi sopra elencate avranno bisogno di un db... quale?
prego scelga pure...
*/
public static function getDAOFactory($scelta_db)
{
switch ($scelta_db)
{
case self::MYSQL:
return new MysqlDAOFactory();
/*case self::ORACLE:
return new OracleDAOFactory();
case self::SYBASE:
return new SybaseDAOFactory();*/
default:
return null;
}
}
}
?>
MysqlDAOFactory
Codice PHP:
<?php
/*
La classe astratta DAOFactory ha prescelto (... tra i tantissimi disponibli...) MYSQL
e ha "imposto" (in virtù dei metodi astratti) ai suoi extends di implementare un metodo
per ogni classe che richiede il sorgente dati.
Se Mysql viene interpellato per poter avviare qualsivoglia operazione bisognerà connettersi.
Quando nella pagina web faremo:
$MySQLFactory = DAOFactory::getDAOFactory(DAOFactory::MYSQL);
$artDAO = $MySQLFactory->getArticoloDAO();
Nella prima riga:
- scegliamo il db con il metodo statico getDAOFactory della classe DAOFactory
- scegliamo MYSQL tramite proprietà statica ovvero istanzio MysqlDAOFactory
Nel second rigo:
- istanzio la classe ArticoloMysqlDAO attraverso il metodo getArticoloDAO
*/
class MysqlDAOFactory extends DAOFactory
{
private static $host = 'localhost';
private static $user = 'root';
private static $pass = '';
private static $db = 'my_test';
private static $conn = null;
/*metodo per creare una connessione a MySQL*/
public static function createConnection()
{
/*
non eseguiremo la connessione tutte le volte che faremo una query (ovviamente...)
quindi se è NULL, cioè il valore di default, eseguaimo la connessione che sarà
contenuta da self::$conn (è static!! non fare $this->conn che da errore)
*/
if (is_null(self::$conn))
{
if (!(self::$conn = @mysql_connect(self::$host, self::$user, self::$pass)))
{
throw new Exception(mysql_error());
}
if (!@mysql_select_db(self::$db))
{
throw new Exception(mysql_error());
}
}
return self::$conn;
}
/*
Istanziamo la classe che contiene le query a mysql
riguardanti gli articoli
*/
public function getArticoloDAO()
{
return new ArticoloMysqlDAO();
}
}
?>
interfaccia_Articolo_DAO.php
Codice PHP:
<?php
/*
Interaccia della classe ArticoloDAO.
Il nostro applicativo potrà essere sviluppato con diversi db (se se...).
Per ciascun db vi saranno diverse sintassi e funzioni native per ricavare i dati.
Tuttavia definendo nell'interfaccia il nome che dovranno avere i metodi presenti
nelle successive implementazioni si determina che il nome dei metodi per ogni tipo
di db sarà sempre lo stesso.
Quindi swichando in sede di istanza tramite getDAOFactory tutto rimane integro e funzionante.
+-----------------------+
| TEORIA -> INTERFACE |
+-----------------------+
Contiene una serie di metodi con i relativi parametri, ma senza corpo.
L'interfaccia impone l'implementazione di tutti i metodi in essa definiti
tramite una successive classi 'implements'.
A differenza delle classi/metodi astratti nelle interfacce nessun metodo ha un corpo.
Quindi le interfacce possono (in un certo senso) assomigliare a classi astratte ma con
al loro interno tutti metodi astratti.
Infatti, tutti i metodi definiti nelle interfacce implicano che si tratta di metodi astratti
e che, pertanto, occorre necessariamente che nella successive classi 'implements' tali metodi
vengano implementati.
La differenza fra le due è molto sottile: mentre l'interfaccia è un progetto per classi che
saranno tutte su uno stesso livello gerarchico, fra le classi astratte e le extends che ne derivano
vi è un rapporto di tipo gerarchico.
*/
interface ArticoloDAO
{
public function insertArticolo($oArticolo);
public function deleteArticolo($oArticolo);
public function findArticolo($oArticolo);
public function updateArticolo($oArticolo);
public function selectArticoloRS($oArticolo);
public function getNextArticoloTO($RowSet);
public function selectArticoloTO($oArticolo);
}
?>
Articolo.php
Codice PHP:
<?php
class Articoli {
/*le proprietà coincidono coincidono con i campi del db*/
protected $id_art;
protected $titolo_art;
protected $testo_art;
protected $data_inserimento;
/*serie di metori set e get per impostare/ottenere il valore di tali proprietà*/
public function getId_art()
{
return $this->id_art;
}
public function setId_art($id_artIn)
{
$this->id_art = $id_artIn;
}
public function getTitolo_art()
{
return $this->titolo_art;
}
public function setTitolo_art($titolo_artIn)
{
$this->titolo_art = $titolo_artIn;
}
public function getTesto_art()
{
return $this->testo_art;
}
public function setTesto_art($testo_artIn)
{
$this->testo_art = $testo_artIn;
}
public function getData_inserimento()
{
return $this->data_inserimento;
}
public function setData_inserimento($data_inserimentoIn)
{
$this->data_inserimento = $data_inserimentoIn;
}
}
?>
Rispondi quotando
però il codice che vedo non mi fa sperare bene.
