Witam, tworzę zalążek aplikacji, która będzie obsługiwać inne aplikacje.

Stanąłem nad jednym zagadnieniem, możliwe że moje ubytki wiedzy wiążą się z małym niedoinformowaniem.

Otóż. Tworzę sobie loader całej aplikacji.

Plik index.php wygląda miej więcej tak że wywołuje klasę EngineInit, a w niej funkcję EngineStart.

W klasie EngineInit, w func EngineStart ładuję odpowiednie klasy, które własnie tworzę.
Dopowiednio jest to obsługa sesji, obsługa debugowania aplikacji, obsługa aplikacji, obsługa baz danch i inne

Problem polega na tym że chcę kożystać z tych obiektów tak:

[PHP] pobierz, plaintext 
class EngineInit 
{
        public function EngineStart()
        {
                 // [...]
                 // Ładowanie obiektów najbardziej potrzebnych
                 $conf = new ConfigurationInit;
                 $db    = new DataBaseLoader;
                 $session = new SessionsLoader;
                 // [...]
        }// end EngineStart
 
}
 
[PHP] pobierz, plaintext 

Problem polega na tym że chcę użyć np. obiektu $conf w $db lub w $session i np. $db w $session..
Global nie działa
Ma ktoś pomysł jak to rozwiązać?

Proszę o naprowadzenie

Najprościej zastosować singletona http://phpedia.pl/wiki/Singleton tworzysz obiekt używając metody statycznej

Czyli musiał bym to zrobić w taki sposób?

[PHP] pobierz, plaintext 
class Singleton  {    
private static $instance;    
private function __construct() {}
 private function __clone(){}
public static function getInstance ()    
 {         if (self::$instance === null) {             self::$instance = new Singleton();         }         return self::$instance;     }  }    
    $obiekt = Singleton::getInstance(); // ? 
[PHP] pobierz, plaintext 

Tak, w tym momencie gdy obiekt już był gdzieś stworzony Singleton::getInstance(); zwraca ci ten stworzony obiekt. Teraz tylko jedna instancja klasy będzie

Niestety nie działa;

[PHP] pobierz, plaintext 
$db = 	Singleton::getInstance(); 
$db->query("UPDATE users, sessions SET users.user_last_visit = sessions.session_time WHERE users.id=sessions.session_user AND sessions.session_time < ".(time() - SESSION_TIMES));
[PHP] pobierz, plaintext 

I wywala: Call to undefined method Singleton::query();

Jakiś inny pomysł ?

A masz w ogóle tą metody query w Singleton?

Nie może nie działać...

najprostszy singleton wygląda mniej więcej tak:

[PHP] pobierz, plaintext 
class Singleton {
    private static $instance = null;
 
    private static __construct() {}
    private static __clone() {}
 
    public static function getInstance() {
        return self::$instance === null ? self::$instance = new self: self::$instance;
    }
 
    // metody dalsze...
 
}
[PHP] pobierz, plaintext 

Singleton do takich celów został stworzony - postaraj się go zastosować poprawnie - opłaci się

Koledze nie o to chodzi, czy i gdzie wykorzystać singleton. Jeśli nawet wykorzysta ten wzorzec, to nadal jego problem nie będzie rozwiązany.

@zielu001: Z Twojego opisu wynika, że klasa EngineInit jest niejako klasą główną, a metoda EngineStart ma zainicjować konfigurację, bazę danych i sesje, z których później będziesz korzystał. Jednak w kodzie, który nam pokazałeś tworzysz tylko zmienne lokalne, działające w obrębie metody EngineStart. Nie będziesz miał zatem możliwości posługiwania się nimi później. Dlatego klasa mogłaby/powinna wyglądać nieco inaczej:

[PHP] pobierz, plaintext 
class EngineInit {
  private $_configuration = null;
  private $_database = null;
  private $_session = null;
  public function EngineStart() {
    $this->_configuration = new ConfigurationInit;
    $this->_database = new DataBaseLoader;
    $this->_session = new SessionsLoader;
  }
}
[PHP] pobierz, plaintext 

Teraz przejdźmy do meritum. Jeśli obiekt klasy DatabaseLoader (i tutaj nieważne, czy jest to singleton, czy nie), czy też klasy SessionLoader musi skorzystać z danych zawartych w obiekcie klasy ConfigurationInit, to trzeba te informacje przekazać. Jak to zrobić? Otóż można posłużyć się "mechanizmem" DI (dependency injection, wstrzykiwanie zależności). Metoda EngineStart wyglądałaby zatem trochę inaczej:

[PHP] pobierz, plaintext 
class EngineInit {
  // ...
  public function EngineStart() {
    $this->_configuration = new ConfigurationInit;
    $this->_database = new DataBaseLoader($this->_configuration);
    $this->_database = DataBaseLoader::getInstance($this->_configuration);  // jeśli klasa DataBaseLoader będzie singletonem
    $this->_session = new SessionLoader($this->_configuration);
  }
}
[PHP] pobierz, plaintext 

Teraz konstruktory klas DataBaseLoader i SessionLoader mogą skorzystać z informacji, jakie "posiada" obiekt klasy ConfigurationInit. Gwoli dopełnienia formalności uzupełnijmy dla przykładu klasę DataBaseLoader:

[PHP] pobierz, plaintext 
// tutaj zwykła (nie będąca Singletonem) klasa DataBaseLoader
class DataBaseLoader {
  // ...
  public function __construct($configuration) {
    $this->_connection = $this->connect($configuration->getDbHost(), $configuration->getDbUser(), $configuration->getDbPassword());  // przykład
  }
}
[PHP] pobierz, plaintext 

Innym "mechanizmem" jest Dependency Non-Injection (uzależnianie bez wstrzykiwania). Mechanizm ten polega na zainicjowaniu "na sztywno" obiektu klasy, z której potrzebujemy skorzystać. Tak mogłaby wyglądać klasa DataBaseLoader wykorzystująca Dependency Non-Injection

[PHP] pobierz, plaintext 
class DataBaseLoader {
  // ...
  private $_configuration = null
  public function __construct() {
    $this->_configuration = new ConfigurationInit;
    $this->_connection = $this->connect($this->_configuration->getDbHost(), $this->_configuration->getDbUser(), $this->_configuration->getDbPassword()); // przykład
  }
}
[PHP] pobierz, plaintext 

O tym, który z przedstawionych mechanizmów wybrać musisz zdecydować sam. Dependency Injection daje nam sporą elastyczność, ponieważ przekazywane obiekty nie muszą być obiektami dokładnie jednej klasy, choć muszą spełniać założenia pewnych wzorców, które nazywamy interfejsami. Dependency Non-Injection samo w sobie nie zapewnia nam żadnej elastyczności i wymusza na nas korzystnie z dokładnie takiej, a nie innej klasy (czasami jednak właśnie tego potrzebujemy).

Wszystkie napisane wyżej klasy, to tylko przykłady. W rzeczywistości konstruktor klasy obsługującej połączenie z bazą danych nie potrzebuje wszystkich danych konfiguracyjnych, a tylko niektórych (tzn. nazwa/adres serwera, nazwa i hasło użytkownika bazy danych, czy kodowanie połączenia). Wystarczyłoby zatem przekazać konstruktorowi klasy DataBaseLoader tablicę zawierającą wymagane dane, a nie cały obiekt klasy ConfigurtionInit.

EDIT1: Poprawiłem parę literówek, ale chyba jeszcze jakieś są.
EDIT2: Problem i jego rozwiązanie z dziedziczeniem nie mają nic wspólnego.

Można powiedzieć że o to mi chodziło, ale nie jestem do końca przekonany.

Jak widać chcę załadować wszystko w klasie głownej jak to nazwałeś i to jest racja. A potem w tych "pod klasach" ( czyli np. SessionLoader )
kożystać z tych innych "pod klas" załadowanych w głowej klasie "EngineInit";

Czyli coś takiego:

[PHP] pobierz, plaintext 
    class EngineInit {
    private $_configuration = null;
    private $_database = null;
    private $_session = null;
    public function EngineStart() {
    $this->_configuration = new ConfigurationInit;
    $this->_database = new DataBaseLoader;
    $this->_session = new SessionsLoader;
    }
    }
 
class SessionLoader
{
function NpSessionClearCzyCos__() {
 
// ? - chcę się tutaj odwołać do klasy głównej i skorzystać z zasobów _database ,
// lecz nie wiem jak to zrobić, znaczy wiem, ale nie chcę tworzyć kolejnego obiektu 
//tylko skorzystać z tych co uruchomiłem wcześniej w EngineLoader
$this?->_database->query("|Zapytanie SQL|"); // 
 
# To z tym $this? wiem że to nie ma być this ale dałem abyście zrozumieli o co mi chodzi bo nie umiem tłumaczyć
 
}
}
[PHP] pobierz, plaintext 

No przecież opisałem Ci dwa mechanizmy, przy czym jeśli chcesz korzystać z obiektów utworzonych w klasie "głównej" to nie masz wyboru i pozostaje Ci jedynie Dependency Injection:

[PHP] pobierz, plaintext 
class EngineInit {
  private $_configuration = null;
  private $_database = null;
  private $_session = null;
  public function EngineStart() {
    $this->_configuration = new ConfigurationInit;
    $this->_database = new DataBaseLoader;
    $this->_session = new SessionsLoader($this->_database);
  }
}
class SessionLoader {
  private $_database = null;
  public function __construct($database) {
    $this->_database = $database;
  }
  function NpSessionClearCzyCos__() {
    $this->_database->query("|Zapytanie SQL|"); 
  }
}
[PHP] pobierz, plaintext 

Wiem, wiem, ale ja bym chciał bez podawania obiektu, ponieważ np. w jednej klasie będę potrzebował obsługi użytkownika, templatek, bazy danych, a w innej tylko bazy danych.. A tu musze podawać jako parametr, który tworzę. Będzie to też uciążliwe jeśli zrobię obsługę aplikacji, gdzie klasa aplikacji będzie ładowana automatycznie i nie będzie możliwości podania parametrów do konstruktora ponieważ będzie używana tylko funkcja startująca tą aplikację czyli jedna dla wszystkich.


// EDIT:
Chyba się źle za to zabrałem..
Wymyślę coś innego. Ma ktoś jakiś pomysł? Jak napisać coś co będzie funkconalne ?

Pytałeś, jak przekazywać obiekty jednej klasy obiektom innej klasy i jak korzystać z obiektów jednej klasy wewnątrz innej klasy, gdy obiekty obu klas są tworzone w metodzie jeszcze innej klasy. Tutaj nie masz wyjścia i musisz skorzystać z DI.
Alternatywą jest Dependency Non-Injection, ale tam nie przekazujesz obiektów wcześniej utworzonych, a tworzysz zupełnie odrębne instancje tych obiektów. Dla przykładu klasa SessionLoader i EngineInit:

[PHP] pobierz, plaintext 
class SessionLoader {
  private $_database = null;
  public function __construct() {
    $this->_database = new DataBaseLoader;  // tworzysz nową instancję obiektu, nie korzystasz z instancji utworzonej w metodzie EngineStart klasy EngineInit
  }
  function NpSessionClearCzyCos__() {
    $this->_database->query("|Zapytanie SQL|");
  }
}
class EngineInit {
  private $_configuration = null;
  private $_database = null;
  private $_session = null;
  public function EngineStart() {
    $this->_configuration = new ConfigurationInit;
    $this->_database = new DataBaseLoader;  // obiekt $this->_database nie ma nic wspólnego z obiektem $this->_database w klasie SessionLoader
    $this->_session = new SessionsLoader;
  }
}
[PHP] pobierz, plaintext 

Opisane przeze mnie "mechanizmy" zastępują niejako słówko global, którego chciałeś na początku użyć.

No tak, a dało by się zrobić coś w rodzaju globalnego ( wszystkiego ) obiektu który przechowywał by wszystkie moje obiekty?
Albo stworzyć klasę która poprzez funkcję wskazywała by na inną klasę czyli użycie np.

[PHP] pobierz, plaintext 
$this->rejestr->pobierzKlasę("nazwa klasy")->funkcja_z_pobranej_klasy(params)
[PHP] pobierz, plaintext 

Wtedy DI był by w sumie idealny.

Ale jak zrobić w tym "pobierzKlasę("nazwa klasy")" aby nie tworzyło nowego obiektu tylko korzystało z już utworzonego ?

Dependency Injection dzisiaj jest wykorzystywane praktycznie wszędzie. Natomiast Twój pomysł nie jest zły i jest podobny np. do Zend-owskich Bootstraperów, które na podstawie danych konfiguracyjnych (zazwyczaj z pliku .ini) "przygotowują" odpowiednie klasy do współdziałania z całą aplikacją.


To zależy od założeń Twojego projektu. Poczytaj o wzorcu FrontController, który poniekąd temu właśnie służy.

Chcę stworzyć szybki, dobrze zabezpieczony framework.

Mógł byś mnie naprowadzić jak najlepiej było by to napisać?
Oczywiście robię to aby się czegoś ciekawego nauczyć.