4.3. Frontendy Zend_Cache
Poprzedni | Rozdział 4. Zend_Cache | Następny

## 4.3. Frontendy Zend_Cache

### 4.3.1. Zend_Cache_Core

#### 4.3.1.1. Wprowadzenie

`Zend_Cache_Core` jest specjalnym frontendem ponieważ jest on jądrem modułu. Jest on podstawowym frontendem bufora i jest rozszerzany przez inne klasy.

| Notatka
Wszystkie frontendy dziedziczą z klasy `Zend_Cache_Core` więc jej metody i opcje (opisane niżej) są także dostępne w innych frontendach, dlatego nie będą tu opisane.

#### 4.3.1.2. Dostępne opcje

Te opcje są przekazywane do metody fabryki jako pokazano w poprzednich przykładach.

Tabela 4.1. Dostępne opcje

Opcja | Typ danych | Domyślna wartość | Opis
--- | --- | --- | ---
`caching` | `boolean` | `true` | włącza / wyłącza buforowanie (może być użyteczne do sprawdzania buforowanych skryptów)
`lifeTime` | `int` | `3600` | okres ważności bufora (w sekundach), jeśli ustawiony na `null`, bufor będzie ważny na zawsze
`logging` | `boolean` | `false` | jeśli ma wartość true, aktywowane jest logowanie za pomocą `Zend_Log` is activated (ale system jest wolniejszy)
`writeControl` | `boolean` | `true` | Włącza / wyłącza kontrolę zapisu (bufor jest odczytywany zaraz po zapisaniu aby wykryć uszkodzone wpisy), włączając kontrolę zapisu lekko zwolniesz zapisywanie bufora, ale nie będzie to miało wpływu na jego odczytywanie (może to wykryć niektóre uszkodzone pliki bufora, ale nie jest to perfekcyjna kontrola)
`automaticSerialization` | `boolean` | `false` | Włącza / wyłącza serializację, może być użyte do bezpośredniego zapisywania danych, które nie są łańcuchami znaków (ale jest to wolniejsze)
`automaticCleaningFactor` | `int` | `10` | Włącza / ustawia proces automatycznego czyszczenia (garbage collector): 0 oznacza brak automatycznego czyszczenia, 1 oznacza systematyczne czyszczenie bufora, a x > 1 oznacza automatyczne losowe czyszczenie 1 raz na x operacji zapisu.

#### 4.3.1.3. Przykłady

Przykład jest podany w dokumentacji na samym początku.

Jeśli w buforze przechowujesz tylko łańcuchy znakow (ponieważ z opcją "automaticSerialization" option możliwe jest przechowywanie wartości logicznych), możesz użyć bardziej kompaktowej konstrukcji:

    <?php

    // zakładamy, że mamy już obiekt $cache

    $id = 'myBigLoop'; // id bufora czyli "tego co chcemy buforować"

    if (!($data = $cache->load($id))) {
        // brak bufora

        $data = '';
        for ($i = 0; $i < 10000; $i++) {
            $data = $data . $i;
        }

        $cache->save($data);

    }

    // [...] przetwarzaj dane $data (wyświetl je, przekaż itp.)

    ?>

Jeśli chcesz buforować wiele bloków lub instancji danych, idea jest ta sama:

    <?php

    // upewnij się, że używasz unikalnych identyfiikatorów:
    $id1 = 'foo';
    $id2 = 'bar';

    // blok 1
    if (!($data = $cache->load($id1))) {
        // brak bufora

        $data = '';
        for ($i=0;$i<10000;$i++) {
            $data = $data . $i;
        }

        $cache->save($data);

    }
    echo($data);

    // to nigdy nie jest buforowane
    echo('NEVER CACHED! ');

    // blok 2
    if (!($data = $cache->load($id2))) {
        // brak bufora

        $data = '';
        for ($i=0;$i<10000;$i++) {
            $data = $data . '!';
        }

        $cache->save($data);

    }
    echo($data);

    ?>

### 4.3.2. Zend_Cache_Frontend_Output

#### 4.3.2.1. Wprowadzenie

`Zend_Cache_Frontend_Output` jest frontendem przechwytującym dane wyjściowe. Przejmuje on wyświetlanie danych wyjściowych w PHP przechwytując wszystko co jest pomiędzy metodami `start()` oraz `end()`.

#### 4.3.2.2. Dostępne opcje

Ten frontend nie ma żadnych specyficznych opcji innych niż te z `Zend_Cache_Core`.

#### 4.3.2.3. Przykłady

Przykład jest podany w dokumentacji na samym początku. To są główne różnice:

    <?php

    // jeśli bufor nie istnieje, przechwytywane są dane wyjściowe
    if(!$cache->start('mypage')):

    // wyświetlaj jak zawsze
    echo 'Witaj! ';
    echo 'To jest buforowane ('.time().') ';

    $cache->end(); // kończy się wyświetlanie danych
    endif;

    echo 'To nie jest nigdy buforowane ('.time().').';

    ?>

Używając tej formy bardzo łatwe jest ustawienie buforowania danych wyjściowych w twoim aktualnie działającym projekcie przy małej ilości przeróbek w kodzie lub przy ich braku.

### 4.3.3. Zend_Cache_Frontend_Function

#### 4.3.3.1. Wprowadzenie

Frontend `Zend_Cache_Frontend_Function` buforuje rezultaty wywołań funkcji. Posiada on jedną metodą nazwaną `call()`, ktora przyjmuje nazwę funkcji oraz parametry do wywołania w tablicy.

#### 4.3.3.2. Dostępne opcje

Tabela 4.2. Dostępne opcje

Opcja | Typ danych | Domyślna wartość | Opis
--- | --- | --- | ---
`cacheByDefault` | `boolean` | `true` | jeśli ma wartość true, wywołania funkcji będą domyślnie buforowane
`cachedFunctions` | `array` |  | nazwy funkcji które mają być zawsze buforowane
`nonCachedFunctions` | `array` |  | nazwy funkcji które nigdy nie mają być buforowane

#### 4.3.3.3. Przykłady

Użycie funkcji `call()` jest takie samo jak użycie funkcji `call_user_func_array()` w PHP:

    <?php

    $cache->call('veryExpensiveFunc', $params);

    # $params jest tablicą
    # przykładowo aby wywołać (z buforowaniem) funkcję veryExpensiveFunc(1, 'foo', 'bar'), użyj
    # $cache->call('veryExpensiveFunc', array(1, 'foo', 'bar'))

    ?>

Frontend `Zend_Cache_Frontend_Function` jest na tyle sprytny, że buforuje zarówno wartość zwracaną przez funkcję, jak i wszystkie dane wyjściowe, które ona wypisuje.

| Notatka
Możesz przekazać dowolną wbudowaną funkcję lub zdefiniowną przez użytkownika z wyjątkiem `array()`, `echo()`, `empty()`, `eval()`, `exit()`, `isset()`, `list()`, `print()` oraz `unset()`.

### 4.3.4. Zend_Cache_Frontend_Class

#### 4.3.4.1. Wprowadzenie

Frontend `Zend_Cache_Frontend_Class` różnie się od frontendu `Zend_Cache_Frontend_Function` tym, że umożliwia buforowanie wywołań metod obiektów (także statycznych)

#### 4.3.4.2. Dostępne opcje

Tabela 4.3. Dostępne opcje

Opcja | Typ danych | Domyślna wartość | Opis
--- | --- | --- | ---
`cachedEntity` (wymagane) | `mixed` |  | jeśli ustawiona jest nazwa klasy, będziemy buforować klasę abstrakcyjną i używać tylko statycznych wywołań; jeśli ustawiony jest obiekt będziemy buforować metody tego obiektu
`cacheByDefault` | `boolean` | `true` | jeśli ma wartość true, wywołania będą domyślnie buforowane
`cachedMethods` | `array` |  | nazwy metod które mają być zawsze buforowane
`nonCachedMethods` | `array` |  | nazwy metod które nie mają być nigdy buforowane

#### 4.3.4.3. Przykłady

Na przykład, aby buforować statyczne wywołania:

    <?php

    class test {

        # metoda statyczna
        public static function foobar($param1, $param2) {
            echo "foobar_output($param1, $param2)";
            return "foobar_return($param1, $param2)";
        }

    }

    // [...]
    $frontendOptions = array(
        'cachedEntity' => 'test' // Nazwa klasy
    );
    // [...]

    # buforowane wywołanie
    $res = $cache->foobar('1', '2');

    ?>

Aby buforować klasyczne wywołania metod:

    <?php

    class test {

        private $_string = 'hello !';

        public function foobar2($param1, $param2) {
            echo($this->_string);
            echo "foobar2_output($param1, $param2)";
            return "foobar2_return($param1, $param2)";
        }

    }

    // [...]
    $frontendOptions = array(
        'cachedEntity' => new test() // instancja klasy
    );
    // [...]

    # buforowane wywołanie
    $res = $cache->foobar2('1', '2');

    ?>

### 4.3.5. Zend_Cache_Frontend_File

#### 4.3.5.1. Wprowadzenie

`Zend_Cache_Frontend_File` jeest frontendem działającym w oparciu o datę modyfikacji "głównego pliku". Jest to bardzo interesujące, na przykład przy zagadnieniach związanych z konfiguracją czy szablonami.

Na przykład, jeśli masz plik konfiguracyjny XML, który jest analizowany przez funkcję zwracającą obiekt konfiguracji (na przykład `Zend_Config`). Za pomocą frontendu `Zend_Cache_Frontend_File`, możesz przechować obiekt konfiguracji w buforze (aby zapobiec analizowaniu pliku konfiguracyjnego XML za każdym razem), ale przy zależności od "głównego pliku". Więc jeśli plik konfiguracyjny XML zostanie zmodyfikowany, bufor natychmiast straci ważność.

#### 4.3.5.2. Dostępne opcje

Tabela 4.4. Dostępne opcje

Opcja | Typ danych | Domyślna wartość | Opis
--- | --- | --- | ---
`masterFile (mandatory)` | `string` | `` | kompletna ścieżka i nazwa głównego pliku

#### 4.3.5.3. Przykłady

Użycie tego frontendu jest takie same jak `Zend_Cache_Core`. Nie ma potrzeby zamieszczania specyficznego przykładu - jedyną rzeczą do zrobienia jest zdefiniowanie pliku `masterFile` gdy używamy metody fabryki.

### 4.3.6. Zend_Cache_Frontend_Page

#### 4.3.6.1. Wprowadzenie

Frontend `Zend_Cache_Frontend_Page` działa jak `Zend_Cache_Frontend_Output` ale jest zaprojektowany dla kompletnej strony. Nie jest możliwe użycie `Zend_Cache_Frontend_Page` do buforowania pojedynczego bloku.

Z drugiej strony, identyfikator bufora jest obliczany na podstawie `$_SERVER['REQUEST_URI']` oraz (zależnie od opcji) `$_GET`, `$_POST`, `$_SESSION`, `$_COOKIE`, `$_FILES`. Jeszcze lepiej, masz tylko jedną metodę do wywołania (`start()`) ponieważ metoda `end()` jest wywoływana w pełni automatycznie na końcu strony.

Obecnie nie jest to zaimplementowane, ale planujemy dodać warunkowy system HTTP w celu oszczędzania transferu (system wyśle nagłówek HTTP 304 Not Modified jeśli bufor istnieje i gdy przeglądarka ma aktualną wersję bufora).

| Notatka
Zend_Cache_Frontend_Page jest jeszcze w wersji "alpha" i z biegiem czasu ma być ulepszany.

#### 4.3.6.2. Dostępne opcje (for this frontend in Zend_Cache factory)

Tabela 4.5. Dostępne opcje

Opcja | Typ danych | Domyślna wartość | Opis
--- | --- | --- | ---
`httpConditional` | `boolean` | `false` | użyj systemu httpConditional (obecnie jeszcze nie zaimplementowane)
`debugHeader` | `boolean` | `false` | jeśli ma wartość true, testowy tekst jest dodawany przed każdą buforowaną stroną
`defaultOptions` | `array` | `array(...zobacz niżej...)` | asocjacyjna tablica domyślnych opcji: `(boolean, domyślnie wartość true) cache` : bufor jest włączony jeśli ma wartość true `(boolean, domyślnie wartość false) cacheWithGetVariables` : jeśli ma wartość true, buforowanie jest włączone nawet wtedy gdy są jakieś zmienne w tablicy `$_GET` `(boolean, domyślnie wartość false) cacheWithPostVariables` : jeśli ma wartość true, buforowanie jest włączone nawet wtedy gdy są jakieś zmienne w tablicy `$_POST` `(boolean, domyślnie wartość false) cacheWithSessionVariables` : jeśli ma wartość true, buforowanie jest włączone nawet wtedy gdy są jakieś zmienne w tablicy `$_SESSION` `(boolean, domyślnie wartość false) cacheWithFilesVariables` : jeśli ma wartość true, buforowanie jest włączone nawet wtedy gdy są jakieś zmienne w tablicy `$_FILES` `(boolean, domyślnie wartość false) cacheWithCookieVariables` : jeśli ma wartość true, buforowanie jest włączone nawet wtedy gdy są jakieś zmienne w tablicy `$_COOKIE` `(boolean, domyślnie wartość true) makeIdWithGetVariables` : jeśli ma wartość true, identyfikator bufora będzie zależał od zawartości tablicy `$_GET` `(boolean, domyślnie wartość true) makeIdWithPostVariables` : jeśli ma wartość true, identyfikator bufora będzie zależał od zawartości tablicy `$_POST` `(boolean, domyślnie wartość true) makeIdWithSessionVariables` : jeśli ma wartość true, identyfikator bufora będzie zależał od zawartości tablicy `$_SESSION` `(boolean, domyślnie wartość true) makeIdWithFilesVariables` : jeśli ma wartość true, identyfikator bufora będzie zależał od zawartości tablicy `$_FILES` `(boolean, domyślnie wartość true) makeIdWithCookieVariables` : jeśli ma wartość true, identyfikator bufora będzie zależał od zawartości tablicy `$_COOKIE`
`regexps` | `array` | `array()` | tablica asocjacyjna do ustawienia opcji tylko dla pewnych adresów REQUEST_URI, klucze są wyrażeniami regularnymi (PCRE), wartości są asocjacyjnymi tablicami ze specyficznymi opcjami do ustawienia gdy wyrażenie regularne zostanie dopasowane do $_SERVER['REQUEST_URI'] (zobacz defaultOptions aby zobaczyć listę wszystkich dostępnych opcji) ; jeśli kilka wyrażen regularnych będzie pasowało do $_SERVER['REQUEST_URI'], zostanie użyte tylko te ostatnie

#### 4.3.6.3. Przykłady

Użycie Zend_Cache_Frontend_Page jest naprawdę łatwe:

    <?php

    // [...] // wymagane, konfiguracja i fabryka

    $cache->start();
    // jeśli bufor jest trafiony, wynik jest wysyłany do przeglądaki a skrypt tutaj kończy działanie

    // reszta strony

    ?>

bardziej kompleksowy przykład, który pokazuje sposób centralnego zarządzania buforowaniem w pliku ładującym (przykładowo do użycia z klasą Zend_Controller)

    <?php

    // [...] powinieneś unikać tworzenia dużej ilości kodu przed sekcją buforowania
    // [...] na przykład, w celu optymalizacji, instrukcje "require_once" lub "Zend::loadClass"
    // [...] powinny znajdować się za sekcją buforowania

    require_once 'Zend/Cache.php';

    $frontendOptions = array(
       'lifeTime' => 7200,
       'debugHeader' => true, // dla testów
       'regexps' => array(
           '^/$' => array('cache' => true),         // buforuj cały kontroler IndexController
           '^/index/' => array('cache' => true),    // buforuj cały kontroler IndexController
           '^/article/' => array('cache' => false), // nie buforuj kontrolera ArticleController...
           '^/article/view/' => array(              // ...ale buforuj akcję "view"
               'cache' => true,                     // kontrolera ArticleController
               'cacheWithPostVariables' => true,    // i buforuj gdy są dostępne zmienne $_POST
               'makeIdWithPostVariables' => true,   // (ale bufor będzie zależał od tablicy $_POST)
           )
       )
    );
    $backendOptions = array(
        'cacheDir' => '/tmp/'
    );

    // pobieranie obiektu Zend_Cache_Frontend_Page
    $cache = Zend_Cache::factory('Page', 'File', $frontendOptions, $backendOptions);

    $cache->start();
    // jeśli bufor jest trafiony, wynik jest wysyłany do przeglądaki a skrypt tutaj kończy działanie

    // [...] koniec pliku uruchamiającego (te linie nie będą wykonane jeśli bufor jest trafiony)

    ?>

Poprzedni | Początek rozdziału | Następny
4.2. Teoria buforowania | Spis treści | 4.4. Backendy Zend_Cache