[PHP] pobierz, plaintext 
<?php
# autor: fifi209 (Fast)
    # class: CacheSystem
    # version: 1.02
 
    class CacheSystem {
    
        const COMPRESSION_NONE=0;
        const COMPRESSION_BZIP2=1;
        protected $dir;
        private $compression;
        
        public function __construct($dir, $compression) {
            if (@opendir($dir)) {
                $this->dir = $dir;
                switch ($compression) {
                    case self::COMPRESSION_NONE:
                        $this->compression = false;
                        break;
                    case self::COMPRESSION_BZIP2:
                        $this->compression = true;
                        break;
                }
            }else{
                echo 'Podany katalog nie istnieje lub nie masz praw do jego otworzenia.';
            }
        }
        
        public function __get($cacheFile) {
            if (file_exists($this->dir.'/'.$cacheFile.'.cache')) {
                if ($this->compression == false) {
                    return file_get_contents($this->dir.'/'.$cacheFile.'.cache');
                }else{
                    $handle = bzopen($this->dir.'/'.$cacheFile.'.cache', 'r');
                    $text = bzread($handle, filesize($this->dir.'/'.$cacheFile.'.cache'));
                    bzclose($handle);
                    return $text;
                }
            }else{
                return false;
            }
        }
        
        public function __set($cacheFile, $value) {
            if ($this->compression == false) {
                file_put_contents($this->dir.'/'.$cacheFile.'.cache', $value);
                return true;
            }else{
                $handle = bzopen($this->dir.'/'.$cacheFile.'.cache', 'w');
                bzwrite($handle, $value);
                bzclose($handle);
                return true;
            }
        }
        
        public function destroy($cacheFile) {
            if ($this->$cacheFile != false) {
                unlink($this->dir.'/'.$cacheFile.'.cache');
                return true;
            }else{
                return false;
            }
        }
        
    }
?>
[PHP] pobierz, plaintext 

Napisałem ją dla siebie, ale może się komuś przyda. A teraz prosiłbym o jakieś uwagi dot. kodu, tj. co by można zmienić, zrobić inaczej.
Wydaje mi się, że jak na tą prostotę funkcjonalność jest wystarczająca. (przynajmniej dla mnie)

Użycie przykładowe:

Najpierw konstruktor:

[PHP] pobierz, plaintext 
<?php
$cache = new CacheSystem('cache', CacheSystem::COMPRESSION_NONE);
?>
[PHP] pobierz, plaintext 

Parametr pierwszy - ścieżka do folderu cache
Parametr drugi - używana kompresja (w tym wypadku brak, lecz "NONE" można zastąpić "BZIP2")

a) Dodawanie cache/Zmienianie jego wartości (konstruktor pomijam)

[PHP] pobierz, plaintext 
<?php
$cache->podstrona = 'Jakas wartosc';
?>
[PHP] pobierz, plaintext 

Odczyt cache

[PHP] pobierz, plaintext 
<?php
echo $cache->podstrona;
?>
[PHP] pobierz, plaintext 

c) Usuwanie cache

[PHP] pobierz, plaintext 
<?php
$cache->destroy('podstrona');
?>
[PHP] pobierz, plaintext 

podstrona -> nazwa pliku cache

Zły dział. Jest dział do ocen.

A co jak będę chciał dodać klasę albo tablicę do cachu ?

Do gotowców nie mogłem zaliczyć, chodzi nie tyle o ocenę co sugestie (co zmienić, dodać)

Co do pytania:

[PHP] pobierz, plaintext 
<?php
$cache->podstrona = serialize(array('a', 'b'));
print_r(unserialize($cache->podstrona));
?>
[PHP] pobierz, plaintext 

Działa bez zarzutu.

Z klasą też nie widzę problemów:

[PHP] pobierz, plaintext 
<?php
class testowa {
        
        public function __toString() {
            return 'testowa';
        }
    
    }
 
$cache->podstrona = serialize(new testowa);
echo unserialize($cache->podstrona);
?>
[PHP] pobierz, plaintext 

osobiście wolalbym pobierać/ustawiać zawartość keszu przez settera/gettera - wtedy w podpowiadaniu składni wyskakują odpowiednie metody.

Przydałoby się też keszowanie nagłówków strony.

I nie pogardziłbym możliwością ustawiania czasu życia.

edit:

hmm... i nigdzie nie widzę phpdoc'a

Co za problem zrobić cache nagłówków i zapisać np. jako headers ?
Czas życia? Przecież jak np. aktualizujesz coś w bazie to tylko zmieniasz zawartość cache, a jeżeli usuwasz coś z bazy to i wykonujesz destroy() dla danego pliku cache.

Czas życia - możesz dorobić przez cron'a (sprawdź kiedy plik został utworzony i po x czasie możesz go usuwać) [bez sensu]

Taa... żaden. Cache_Lite lepsze. Tylko mi w nim brakuje keszowania nagłówków.



Heh, tak powiedzmy że zmieniam coś 20 razy na sekundę w bazie danych i za każdym razę robię destroy?
Z tym cronem to nie przesadzaj, z natury człowiek leniwy jestem - mam sobie jeszcze zaprzątać głowę cronem, jakbym mógł jedną opcję ustawić?

Bez obrazy, ale czy nie popadłeś w samozachwyt nad własnym kodem? Chciałeś propozycje, to masz.

Aha, ja bym zwracał null'a zamiast false. Ale to tylko takie już moje bajdurzenie

Dobrze wiesz, że nie zmieniasz nic 20 razy na sekundę bo by Ci ta baza padła chyba a limity na rok byś wyczerpał w kilka dni. (chyba, że miałbyś swój serwer) Poza tym gdy edytujesz dane, to nie musisz robić destroy.

Nad czasem życia pomyśle.

Nie nie popadłem w samozachwyt.

Zwracać null a nie false, powiedz mi jaką widzisz różnicę? Mi wydawało się wygodniej dostać bool(true or false)

Ja cache pierwszy raz użyłem, gdy na stronie musiałem wykonać kilkanaście zapytać do mysql, czas wykonywania tego skryptu to było od 0.8sek do 2sek zależnie od wolnego czasu procesora. Dane były aktualizowane raz na dzień, po dodaniu cache czas wczytywania strony spadł na: 0,00093sek.

P.S. Nikt mądry raczej nie użyje cache, przy takim wypadku jak Ty podałeś - już lepiej zoptymalizować bazę i zapytania i pobierać na bieżąco.

Na życzenie dorobiony czas życia cache:

Tabela sql:

[SQL] pobierz, plaintext 
CREATE TABLE `cache` (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `name` varchar(25) NOT NULL,
  `time` int(10) UNSIGNED NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=MEMORY DEFAULT CHARSET=latin2 AUTO_INCREMENT=1 ;
[SQL] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
# autor: fifi209 (Fast)
    # class: CacheSystemDB
    # version: 1.0
 
    class CacheSystemDB extends CacheSystem {
        
        private $pdo;
 
        public function setDatabase(PDO $handle) {
            $this->pdo = $handle;
        }
        
        public function setTimeLife($cacheFile, $time) {
            if ($this->$cacheFile != false) {
                $result = $this->pdo->prepare('SELECT `id` FROM `cache` WHERE `name` = :name LIMIT 1');
                $result->bindValue(':name', $cacheFile, PDO::PARAM_STR);
                $result->execute();
                
                if ($result->rowCount() > 0) {
                    $result->closeCursor();
                    $result = $this->pdo->prepare('UPDATE `cache` SET `time` = :time WHERE `name` = :name LIMIT 1');
                    
                }else{
                    $result->closeCursor();
                    $result = $this->pdo->prepare('INSERT INTO `cache` (`id`, `name`, `time`) VALUES(null, :name, :time)');
                }
                
                $result->bindValue(':name', $cacheFile, PDO::PARAM_STR);
                $result->bindValue(':time', $time+time(), PDO::PARAM_INT);
                $result->execute();
                $result->closeCursor();
                return true;
            }else{
                return false;
            }
        }
        
        public function destroyDie() {
            $result = $this->pdo->query('SELECT * FROM `cache` WHERE `time` < '.time());
            if ($result->rowCount() > 0) {
                foreach ($result as $row) {
                    $this->destroy($row['name']);
                }
                $del = $this->pdo->query('DELETE FROM `cache` WHERE `time` < '.time());
                $del->closeCursor();
            }
            $result->closeCursor();
        }    
        
    }
?>
[PHP] pobierz, plaintext 

Jeżeli trzeba to dodam później opis jak tego używać.

Mało logiczne - mógłbyś rozwinąć tą myśl?

Po prostu wolę używać kodu, który ma (z klasą rozszerzającą) 110 linii niż np. cache_lite, gdzie jest grubo ponad 1000 linii i próbują mi wmówić, że to jest wydajniejsze.

Kesz który wymaga połączenia z bazą danych? Oczywiście są takie przypadki kiedy coś takiego się przyda, ale to dobre jako opcja.

Jeśli liczysz wydajność w liniach kodu to gratulacje...

I mógłbyś zacząć używać jakiś argumentów w dyskusji?

Jeśli wystawiasz coś do oceny, to spodziewaj się że wszyscy wytkną braki, co akurat jest lepsze od "och ach, ale słitaśna klasa".

A czemu nie? Dane są trzymane w pamięci, więc z tym problemów nie będzie. Zawsze można napisać inne rozszerzenie trzymające np. w xml
(pisałem to z myślą, że mi tego ramu nie braknie)


Na pewno, kod bez zbędnych pierdół będzie się szybciej parsował.


Ja czekam na kolejne uwagi, co dodać/usunąć/zmienić.



A czy ja oczekuję braw i oklasków? Napisałem na samym początku, że chciałbym wiedzieć czy coś trzeba zmienić etc.

P.S. Z miłą chęcią przeczytam propozycję dot. trzymania danych (czas życia cache)
[w mysql mogę robić wszystko hurtem]

W keszu chodzi żeby ograniczać zużycie zasobów.
Hmm... xml - nie da to za dużego narzutu na parsowanie?



Co nie znaczy że ogólnie będzie szybciej działał. A w cache lite nie ma pierdół

A czas życia możesz wyznaczać na podstawie daty utworzenia pliku.

Tak chciałem zrobić, lecz co gdy będę chciał wydłużyć...? Usunąć plik i na nowo tworzyć?


I zamiast np. 10 połączeń z mysql i różnych operacji mam 0 połączeń lub ew. jedno (bo nie każdemu cache trzeba czas życia ustawiać)



Zależy jak dużo danych przewidujesz, ja przewiduję (u siebie) max 30 podstron, także parsowanie takiego xml nie byłoby problemem.
Poza tym, ja żyję w świecie na którym cały ram i czas procesora mam dla siebie.

http://php.net/touch



Ale mógłbyś mieć 0. Czyli lepiej.



Chcesz cały kesz trzymać w jednym pliku xml?!



Super. Tylko, że my nie o tym.

Dzięki, potem napiszę kolejne rozszerzenie.


Napiszę kolejne to będę mógł mieć zero.


Nie cache, a informacje o czasie życia cache.


Stwierdziłem tylko fakt i miałem przez to na myśli, że przy takich zasobach, dużych różnic nie będzie. (chodziło o parsowanie xml)

Trochę sprzeczne jest ze sobą to co mówisz. Z jednej strony cache_lite złe bo ma 1000+ linii kodu, a zaraz mówisz, że parsowanie XML'a jest spoczko. Gdzie sens?

Nigdy jakoś nie miałem problemów z obciążeniem przy parsowaniu xml.




Jak już wspominałem kod piszę, praktycznie tylko dla siebie.


Macie jakieś uwagi do kodu?

@edit
Obiecałem rozszerzenie oparte na pliku xml
(w te klocki nie jestem dobry ale mi jako tako wyszło)

[PHP] pobierz, plaintext 
<?php
   # autor: fifi209 (Fast)
    # class: CacheSystemXML
    # version: 1.1
 
    class CacheSystemXML extends CacheSystem {
    
        private $path;
        
        public function __construct($dir, $compression, $path) {
            $this->setXMLPath($path);
            $this->destroyDie();
            parent::__construct($dir, $compression);
        }
        
        private function setXMLPath($path) {
            if (@opendir($path)) {
                $this->path = $path.'/cache.xml';
                return true;
            }else{
                return false;
            }
        }
        
        public function setTimeLife($cacheFile, $time) {
            if ($this->$cacheFile != false) {
                if (!empty($this->path)) {
                    $xml = simplexml_load_file($this->path);
                    $edit=false;
                    foreach ($xml->item as $item) { if ($item->name == $cacheFile) { $item->time = $time; $edit=true; } }
                        if ($edit == false) {
                            $item = $xml->addChild('item');
                            $item->addChild('name', $cacheFile);
                            $item->addChild('time', $time);
                        }
                        file_put_contents($this->path, $xml->asXML());
                        return true;
                }else{
                    return false;
                }    
            }else{
                return false;
            }
        }
        
        public function destroy($cacheFile) {
            $result = parent::destroy($cacheFile);
            if ($result == true) {
                return $this->destroyDie();
            }else{
                return false;
            }
        }
            
        
        public function destroyDie() {
            if (!empty($this->path)) {
                $xml = simplexml_load_file($this->path);
                foreach ($xml->item as $item) {
                    if ($item->time > time()) {
                        $items[] = $item;
                    }else{
                        $this->destroy($item->name);
                    }
                }
    
                $new = new simplexmlelement('<?xml version="1.0" encoding="UTF-8"?><items></items>');
                foreach ($items as $value) {
                    $item = $new->addChild('item');
                    $item->addChild('name', $value->name);
                    $item->addChild('time', $value->time);
                }
                file_put_contents($this->path, $new->asXML());
                
                return true;
            }else{
                return false;
            }
        }
    }
?>
[PHP] pobierz, plaintext 

Szablon pliku cache.xml:

setXMLPath, to IMO powinno być w konstruktorze, z wymaganą zmienną path.

Jak zdziedziczę to mam metody $o->destroy() i $o->destroyDie(). Bezsensowne nazewnictwo. Poza tym, z tego co widzę to przed odczytem, muszę dać destroyDie(), które przejdzie przez cały system keszowania? Bzdura. Czyli jak mam 10000 plików keszu, to serwer klęka.

To powinno wyglądać tak, że przy odczycie danego elementu keszu, jest sprawdzany tylko jego TTL i usuwany w tym momencie.

Nie wiem co w nazewnictwie jest nie tak. :< Wysłucham Twoich propozycji.

Przecież destroyDie odczyta, które są już nieużyteczne i je wywali - fakt mogłem to inaczej rozwiązać, poprawię to w kolejnej wersji.

Co do konstruktora, niestety odpada bo musiałbym nadpisać konstruktor z klasy głównej - co za tym idzie niepotrzebny kod + zmiany w dostępie do zmiennych w klasie głównej.

destroyDie, jest nieintuicyjne. brzmi trochę jak jakieś combo w mortal combat.
cleanAll, checkAllLifetime, można pewnie jeszcze coś lepszego wymyślić.



Fakt, ale przechodzenie po wszystkich elementach mija się ogólnie z celem. Jako ogólna metoda ok, może się przydać, ale przy odczycie pojedynczego elementu mam sprawdzać wszystkie?



a parent::__construct to już się nie da wywołać?

Tobie chodzi o usuwanie? ;d To też zmienię.




Tak, wpadłem na to zaraz po edycji postu ;d

Już część edytowałem, jak masz jakieś jeszcze pomysły to dawaj - może skorzystam.

Jutro przebuduję plik xml, tak żeby nie było potrzebne czytanie element po elemencie.

Cache'owanie + kompresja = zuo

Poza tym, nie ma modułu do wykorzystania akceleratora, APC, shm, etc... A kompresja nie jest rewelacją, powiem więcej - kopiesz dołek pod sobą.