interazione tra libreria e componente

[Cybassh]

Buongiorno a tutti,
  sto affrontando ultimamente una questione un po' delicata. Ho implementato una libreria per rispondere a richieste comuni fra più componenti. Rispondere ovviamente con metodi. Per ora l'ho fatta funzionare richiamandola e istanziandola in ogni parte che mi serviva.
Quindi:
  nel file principale del componente (che è il punto d'ingresso e si trova nella cartella del componente)
  e nei model coinvolti dalle viste.

Ora, istanziarlo in questa maniera risulta dispendioso a livello di risorse. Non sono riuscito a capire come instanziarlo soltanto una volta, per esempio sul file d'ingresso, e richiamarlo quando serve. Qualcuno mi potrebbe spiegare il meccanismo che regola le librerie?

Grazie

[mau_develop]

ma è una classe statica? .. per forza ..credo

M

[Milcon]

Ciao, sarebbe costruttivo vederla questa libreria
di classi; deve essere un bel lavoro.
Complimenti

[Cybassh]

Buongiorno,
  in primis mi scuso per il ritardo con cui rispondo ma ho staccato la connesione ad internet a casa.

a) Onestamente non conosco la possibilità di rendere satica una libreria. Conosco la possibilità di rendere statici metodi o attributi(mai usato all'interno di Joomla)
b) ora provero' a sintetizzare il costrutto. La libreria è stata pensata come contenitore di "sotto classi", ognuna delle quale svolge dei servizi specifici o di utilità generale. Si cerca di gestire  il personale all'interno dell'Ateneo nell'aspetto dei dati per la trasparenza. Docenti e non. Le classi  incorposrate sono Pagine Personale, Materiale didattico, offerta didattica, gestione della connessione e classe d'utilità generica.
La classe contenitore si chiama Ghetto(per ora .

Codice: [Seleziona]

<?php

require_once('GhettoConn.php');
require_once('GhettoUtil.php');
require_once('GhettoMD.php');
require_once('GhettoOF.php');
require_once('GhettoPP.php');

class Ghetto {
    protected $util;
    protected $GestConn;
    protected $MD;
    protected $OF;
    protected $PP;
    private $dbConn;
    
    public function __construct($scen=1){
        $this->GestConn=new GestConn();
        $this->util=new Util();
        $this->MD=new MD();
        $this->OF=new OF();
        $this->PP=new PP();
        
        if ($scen==1){
            $this->GestConn->connettiAR();
        }
        $this->dbConn= $this->GestConn->daiConnAR();
        //var_dump($this->dbConn);
    }
    
    public function daiConnAR(){
        $db=$this->dbConn;
        return $db;
    }
}
la classe incorporata, per esempio quella della connessione,  è :

Codice: [Seleziona]

<?php
include('config.php');

class GestConn //extends JObject {
{
private $dbConn;
    private $dbWwwold;
    
    public function __construct(){
        
    }

    public function daiConnDB() {
        return     $this->dbConn;
    }
    
    public function connettiAR(){
        $paramConn=new Connessioni;
        $options=$paramConn->daiParametri("AR");
        
        $this->dbConn =& JDatabase::getInstance($options);
    }
    
    public function conettiWWWOLD(){
        $paramConn=new Connessioni;
        $options=$paramConn->daiParametri("WWWOLD");
        
        $this->dbWwwold =& JDatabase::getInstance($options);
    }
    
    public function daiConnAR(){
        $db1=$this->dbConn;
        return     $db1;
    }
    public function daiConnWWWOLD(){
        $db1=$this->dbWwwold;
        return     $db1;
    }
}la quale prende  i valori di connessione da Config.php

[mau_develop]

PAer classe statica intendevo una classe con solo metodi statici, ovviamente
Poi non estendi nessuna libreria ...
Quello che non capisco  è anche perchè se dal controller usi il model hai bisogno di istanziare due volte la classe.

Non dico che non abbia senso ma solo che non capisco

.

[Cybassh]

Ah, dici che è meglo utilizzare metodi statici? e come?

cmq si, l'ho richiamata nell'entry point e nel costruttore della classe... non ha molto senso...pero' una volta chiamata nell'entry point, dopo è rintracciabile nei vari modelli?

[mau_develop]

cosa vuoi fare con quella classe?

ps.. cmq nn sono l'unico che usa il termine classi statiche... http://www.google.com/search?q=php+classi+statiche

M.

[Cybassh]

vorrei fosse possibile richiamarne l'istanza nelle diverse views e models del componenente, instanziandola una sola volta.

grazie per il link

[mau_develop]

si ma per fare cosa?

cioè cosa fa quella classe?

M.

[Milcon]

Codice: [Seleziona]

GestConn=new GestConn()



mi sa che questa istanza di classe che hai creato non è stata importata.

[Cybassh]

per esempio c'è la funzione che traduce la matricola in id_anagrafica (questo perchè il sistema prevede che siano associate + matricole ad un id_anagrafica)

nell'entry point si richiama  questa funzione. prima era nel model del componente docenti ed era :

Codice: [Seleziona]

...
$session=& JFactory::getSession();

if ($test==null){
    $session->clear('test');
}else {
    $session->set('test',$test);
}


if (!($task=="VisuaFoto")){
    $model=$controller->getmodel();
       
    if (isset($matricola)) {
        $id_anagrafica = $model->tradMatricola($matricola);
    }
    if (isset($id_anagrafica)){    //controlla se l'accesso è avvenuto con il passaggio di una nuova matricola
        $id_sess=$session->get("id_anagrafica",null);
        if ($id_sess==null){    //CONTROLLA SE LA SESSIONE ERA PRESENTE
            $session->set('id_anagrafica',$id_anagrafica);
            JRequest::setVar('view','home');
        }else{
            if ($id_anagrafica!=$id_sess){    //CONTROLLA SE E' UN NUOVO DOCENTE
                $session->set('id_anagrafica',$id_anagrafica);
            }
        }
ora vorrei richiamarla direttamente dall'oggetto Ghetto, sostituendo
         $id_anagrafica = $model->tradMatricola($matricola);
con
         $id_anagrafica=$Ghetto->tradMatricola($matricola);

si, scusa Milcon c'è stato un errore di trascrizione
$gestConn=new Ghetto();

[Cybassh]

Cioè, mi consigli di rendere tutti i metodi statici?

[Cybassh]

sto provando un po', e son arrivato ad un fatal error. Prendiamo in esame sola la gestione per la connessione al db mysql.

Ghetto.php(classe contenitore):

Codice: [Seleziona]

require_once('GhettoConn.php');
require_once('GhettoUtil.php');
require_once('GhettoMD.php');
require_once('GhettoOF.php');
require_once('GhettoPP.php');

class Ghetto {
    protected $util;
    protected $GestConn;
    protected $MD;
    protected $OF;
    protected $PP;
    private $dbConn;
    private $framework='J!';
   
    public function __construct($attrib=1){
        $this->GestConn=new GestConn();
        $this->util=new Util();
        $this->MD=new MD();
        $this->OF=new OF();
        $this->PP=new PP();
       
       
        if ($attrib==1){
            //$this->GestConn->connJDB_AR();
            //$this->GestConn->ConnMysqlAR();
            GestConn::ConnMysqlAR();
            $this->dbConn=GestConn::daiConnMysqlAR();
            /*var_dump($this->dbConn);
            exit;*/
            //$this->dbConn= $this->GestConn->daiConnJAR();
            /*var_dump($this->dbConn);
            exit;*/
        }
        //var_dump($this->dbConn);
    }
...
public static function daiConn(){
        return $this->dbConn;
    }
Classe incorporata che si preoccupa della connessione; GhettoConn.php :

Codice: [Seleziona]

include('config.php');

class GestConn //extends JObject {
{
    private static $dbConn;
    private $dbWwwold;
   
    public function __construct(){
    }
   
   
   
 
   
    public function daiConnJAR(){
        $db1=$this->dbConn;
        return     $db1;
    }
    public function daiConnJWWWOLD(){
        $db1=$this->dbWwwold;
        return     $db1;
    }
   
    public static function ConnMysqlAR(){
        $paramConn=new Connessioni;
        $options=$paramConn->daiParametri("AR");
       
        $link = mysql_connect($server = "$options[host]", $username = "$options[user]",
                    $password = "$options[password]");
        //var_dump($link);
        self::$dbConn = $link;
    }
   
    public static function daiConnMysqlAR(){
        $db1=self::$dbConn;
        return     $db1;
    }
Entry point del controller quando richiamo il model relativo (sul costruttore metto :

Codice: [Seleziona]

        include('commonModel.php');
che include appunto

Codice: [Seleziona]

jimport('Ghetto.Ghetto');

$gestConn= new Ghetto();

$db1=Ghetto::daiConn();

[mau_develop]

...ho visto alcune cose che nn mi sono chiare, il problema è che ti sto rispondendo in auto mentre torno da Trieste... e nn ci riesco
se non arrivo tardi dopo guardo e ti dico

M.

[tomtomeight]

Ciao Mau

è che ti sto rispondendo in auto mentre torno da Trieste...

Immagino che non stai guidando tu Vero? 

[mau_develop]

si... nn ho ancora l'autista... avevo l'auricolare però... vale? azz... oggi 900km...

self::
-------------
attenzione alla versione di php, se nn funziona self devi usare il nome completo

poi passo a qualche post prima..
---------------------
nell'entry point si richiama  questa funzione. prima era nel model del componente docenti ed era :
--------------------
io lascerei fare all'entry point il solo mestiere di includere ciò che ti serve e dirigerti al controller corretto, poi nel controller, se lo usi (perchè il CRUD di joomla usa il proxi al model) usi il model e associ i dati alla view...

Detto questo, sarò stanco ma non riesco a capire perchè hai fatto quelle classi... che connessione devi gestire?

Comunque sia se una classe deve modificare la "costruzione" di Joomla estendo una classe di joomla e sovrascrivo il metodo che mi interessa, ma il 99% delle volte i metodi servono solo a compiere delle piccole utilità.. esempio spesso mi serve recuperare un id... o avere il contenuto di una tabella in un array pronto all'uso quindi in quasi tutto ciò che scrivo esiste una classe che uso staticamente (non viene costruita e implementa metodi statici dichiarati statici) che fa tutte le cose che joomla farebbe con uno spreco di codice e macchinosità incredibile.

per cui la mia classe Tools{
contiene sempre funzioni tipo:

public static function getListaFornitori(){
getdb etc etc
return $lista;
}

}

Il vantaggio principale è che evito confusioni con le variabili... ciò che esiste dentro quel metodo lì nasce e lì muore poi che se nell'entry point includo la classe.php
in qualunque punto del mio componente/modulo posso usare $mialista = Tools::getListaFornitori()

E'inutile fare altrimenti perchè comunque nessuno dei presupposti per crearla esiste..incapsulazione, ereditarietà e polimorfismo... tanto vale usare una classe statica equiparabile a un "kit di funzioni" (si faceva spesso quando non esistevano le classi).

...tutto imho ehhh! ...

M.

[Cybassh]

XD
Grande Mau!

ora mi sto sprovando. Già ieri ero arrivato a buon punto
...spero

grazie tante 

[Cybassh]

il fatto è che ho strutturato il tutto con la classe contenitore in vista di un numero considerevole di metodi che dovrò aggiungere. Però certo che con le funzioni statiche il discorso organizzativo cambia.

e funziona pure!