PHP의 보다 포괄적인 캐시 클래스

/*

 * 이름:    wrapperCache

 * 참고:   fileCache, memcache/memcached, APC, Xcache 및 eaccelerator용 래퍼 캐시

$cacheObj =wrapperCache::getInstance('memcache',30,array(array('host'=>'localhost')));

echo $cacheObj->cache(' key','value');

*/

class WrapperCache {

    const DEFAULT_MEMCACHE_PORT     = 11211;

    const CACHE_TYPE_AUTO           = '자동';

    const CACHE_TYPE_EACCELERATOR   = 'eaccelerator';

    const CACHE_TYPE_APC            = 'apc';

    const CACHE_ TYPE_MEMCACHE       = 'memcache';

>

    비공개 $cache_params;   //경로 또는 연결 옵션과 같은 외부 캐시에 대한 추가 매개변수 memcached

    public  $cache_expire;   //캐시가 만료되는 초

    private $cache_type;     //사용할 캐시 유형

    private $cache_external; //캐시 외부 인스턴스, fileCache 또는 memcache일 수 있음

    private static $instance;//이 클래스의 인스턴스

    // 항상 하나만 반환 인스턴스

    공개 정적 함수 getInstance($type=self::CACHE_TYPE_AUTO, $exp_time=3600, $params='cache/'){

        if (!isset(self::$instance )) { //인스턴스가 존재하지 않습니다

            self::$instance = new self($type, $exp_time, $params); //생성자로 이동

        }

        return self::$instance;

    }

    // 캐시 생성자, 선택적 만료 시간 및 캐시 경로

    비공개 함수 __construct($type, $exp_time, $params) {

        $this->cache_expire = $exp_time;

        $this->cache_params = $params;

        $this->setCacheType($type);

    }

public function __destruct() {

        unset($this->cache_external);

    }

    // 사용자 복제 방지 인스턴스

    공개 함수 __clone(){

        $this->cacheError('복제가 허용되지 않습니다.');

    }

    //폴더에서 캐시 삭제

    공용 함수clearCache(){

        switch($this->cache_type){

            케이스 자체 ::CACHE_TYPE_EACCELERATOR :

                eaccelerator_clean();

                eaccelerator_clear();

                break;

            케이스 자체: :CACHE_TYPE_APC :

                apc_clear_cache('user');

                break;

            케이스 자체:: CACHE_TYPE_XCACHE :

                xcache_clear_cache(XC_TYPE_VAR, 0);

                break;

            케이스 self::CACHE_TYPE_MEMCACHE :

                $this->cache_external- >flush();

                break;

            case self::CACHE_TYPE_MEMCACHED :

                $this-& gt;cache_external-> 플러시();

                break;

            케이스 self::CACHE_TYPE_FILE:

                $this->cache_external ->삭제캐시( );

                break;

        }

    }

    //캐시 쓰기 또는 읽기

    공개 함수 캐시($key, $value = '', $ttl = '') {

        if ($value != '') { //쓰기를 원함

            if ($ttl == '') $ttl = $this->cache_expire;

            $ this->put($key, $value, $ttl);

        } else return $this->get($key);

        //값 읽기

    }

    //주어진 데이터, $key== 캐시 이름, 저장할 데이터 정보/값으로 새 캐시 파일을 생성합니다

    비공개 함수 put($key, $data, $ttl = '') {

        if ($ttl == '') $ttl = $this->cache_expire;

        스위치($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

                eaccelerator_put($key, serialize($data), tl) ;

                break;

            케이스 self::CACHE_TYPE_APC :

                apc_store($key, $data, ttl);

                break;

            케이스 self::CACHE_TYPE_XCACHE :

                xcache_set($key, serialize($data), tl);

                break;

            case self::CACHE_TYPE_MEMCACHE :

                $data=serialize($data);

                $this ->cache_external->set($key, $data, false, $ttl);

                break;

            케이스 self::CACHE_TYPE_MEMCACHED :

                $data=serialize($data);

                $this->cache_external->set($key, $data, $ttl);

                break;

            케이스 self::CACHE_TYPE_FILE :

                $this->cache_external->cache($key,$data);

                break;

        }

    }

    //주어진 키에 대한 캐시를 반환

    비공개 함수 get( $key){

        스위치($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

              $data =  unserialize(eaccelerator_get($key)) ;

                break;

            case self::CACHE_TYPE_APC :

                $data =  apc_fetch($key);

break;

            case self::CACHE_TYPE_XCACHE :

                $data =  unserialize(xcache_get($key));

               휴식;

            case self::CACHE_TYPE_MEMCACHE :

                $data = unserialize($this->cache_external->get($key));

                break;

            case self::CACHE_TYPE_MEMCACHED :

                $data = unserialize($this->cache_ex 내부->get($key ));

                break;

            케이스 self::CACHE_TYPE_FILE :

                $data = $this->cache _외부-> 캐시($key);

                break;

        }

        return $data;

    }

    //캐시에서 키 삭제

    공개 함수 delete($key){

        switch($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

                eaccelerator_rm($key);

                break;

            case self::CACHE_TYPE_APC :

                apc_delete($key);

                휴식;

            case self::CACHE_TYPE_XCACHE :

                xcache_unset($key);

                break;

            케이스 self::CACHE_TYPE_MEMCACHE :

                $this->cache_external->delete($key);

                break;

            케이스 self::CACHE_TYPE_MEMCACHED :

                $this->cache_external->delete($key);

                break;

            케이스 self::CACHE_TYPE_FILE :

                $this->cache_external->delete($key);

                break;

       }

    }

    // 애플리케이션 변수에 대한 오버로드 및 자동 캐시

    public function __set($name, $value) {

        $ this->put($name, $value, $this->cache_expire);

    }

    공개 함수 __get($name) {

        return $this->get($name);

    }

    공개 함수 __isset($key) {// echo "'$name'이 설정되었나요?n"

        if ($this->get($key) !== false)  return true;

        else return false;

    }

    공개 함수 __unset($name) {//echo "'$name'n 설정 해제";

        $this-> delete($name);

    }

    //오버로드 종료

    공용 함수 getCacheType(){

return $this->cache_type;

    }

    //캐시가 설치되어 있으면 설정합니다. 그렇지 않으면 오류가 발생합니다.

    공개 함수 setCacheType($type){

        $this->cache_type=strtolower($type);

        스위치($this->cache_type){

            케이스 self::CACHE_TYPE_EACCELERATOR :

                if (!function_exists('eaccelerator_get')) $this->cacheError('eaccelerator notfound');

               휴식;

            case self::CACHE_TYPE_APC :

                if (!function_exists('apc_fetch')) $this->cacheError('APC를 찾을 수 없음') ;

                break;

            케이스 self::CACHE_TYPE_XCACHE :

                if (function_exists('xcache _get')) $this-> 캐시 오류('Xcache를 찾을 수 없음');

                break;

            case self::CACHE_TYPE_MEMCACHE :

                if (class_exists('멤캐시 ')) $this->init_mem();

                else $this->cacheError('memcache를 찾을 수 없음');

                break;

            케이스 self::CACHE_TYPE_MEMCACHED :

                if (class_exists('Memcached')) $this->init_mem(true);

                else $this->cacheError ('memcached를 찾을 수 없음');

                break;

            case self::CACHE_TYPE_FILE :

                if (class_ 존재합니다('파일캐시' ))$this->init_filecache();

                else $this->cacheError('fileCache를 찾을 수 없음');

                break;

            case self::CACHE_TYPE_AUTO ://캐시 시스템 자동 선택 시도

                if (function_exists('eaccelerator _get')) 정의  elseif (함수_존재(' xcache_get'))      $this->cache_type = self::CACHE_TYPE_XCACHE;

                elseif (class_exists('Memcache'))           $this->init_mem();

               elseif (클래스_존재( 'Memcached'))          $this->init_mem(true);

                elseif (class_exists('fileCache'))          $this->init_filecache();

               else $this-> ;cacheError('호환되는 캐시를 찾을 수 없습니다');

                break;

            default://캐시를 선택하지 않았거나 잘못된 캐시를 선택했습니다

                $msg='어떤 캐시 유형도 선택하지 않았습니다';

                if (isset($type)) $msg='인식할 수 없는 캐시 유형을 선택했습니다 '.$type.'';

                $this->cacheError($msg);

                break;

        }

    }

    private function init_mem($useMemecached = false) { //memcache/memcached 클래스의 인스턴스 가져오기

        if (is_array($this->cache_params)) {

            if ($useMemecached) {

                $this->cache_type = self::CACHE_TYPE_MEMCACHED;

                $this->cache_external = new Memcached( );

>            }

            foreach ($this->cache_params as $server) {

                $server['port'] = isset($server['port']) ? (int)$server['port'] : self::DEFAULT_MEMCACHE_PORT;

                if ($useMemecached) {

                    $this->cache_external->addServer($server['host '], $server['port']);

                } else {

                    $server['percious'] = isset($server['percious']) ? (bool)$server['영구'] : true;

                    $this->cache_external->addServer($server['host'], $server['port'], $server[' persist']);

                }

            }

        } else $this->cacheError($this->cache_type . '에는 배열이 필요합니다. 예:wrapperCache: :getInstance("' . $this->cache_type . '",30,array(array("host"=>"localhost")));');

    }

    비공개 함수 init_filecache(){//파일 캐시 클래스 인스턴스 가져오기

        $this->cache_type = self::CACHE_TYPE_FILE ;

        $this ->cache_external = fileCache::getInstance($this->cache_expire, $this->cache_params);

    }

    공용 함수 getAvailableCache ($return_format='html'){//사용 가능한 캐시를 반환

        $avCaches   = array();

        $avCaches[] = array(self::CACHE_TYPE_EACCELERATOR,function_exists('eaccelerator_get '));

        $avCaches[] = array(self::CACHE_TYPE_APC,         function_exists('apc_fetch')) ;

        $avCaches[] = array(self::CACHE_TYPE_XCACHE,      function_exists('xcache_get'));

        $avCaches[] = array(self::CACHE_TYPE_MEMCACHE,    class_exists('Memcache'));

        $avCaches[] = array(self::CACHE_TYPE_MEMCACHED,   class_exists('Memcached')) ;

        $avCaches[] = array(self::CACHE_TYPE_FILE,        class_exists('fileCache'));

        if ($return_format == 'html ') {

            $ret = '

';

            foreach ($avCaches as $c) {

                $ret .= '

• ' . $c[0] . ' - ';

                  if ($c[1]) $ret .= '찾음/호환 가능';

                  else $ret .= '찾을 수 없음/호환 불가능';

                  $ret .= '';

              }

              $ret 를 반환합니다. '

';

        } else return $avCaches;

    }

    비공개 함수 캐시 오류($msg){ //오류 발생

        Trigger_error('
wrapperCache error: '.$msg.

            '
호환되는 캐시를 자동으로 선택하려면 '자동'을 사용해 보세요.

                   
또는 목록에서 지원되는 캐시를 선택하세요:'.$this->getAvailableCache(), E_USER_ERROR);

    }

}