위젯 캐싱

위젯 캐싱¶

위젯의 성능을 향상시키기 위한 다양한 캐싱 전략을 학습합니다.

캐싱 기본 개념¶

캐싱이 필요한 이유¶

// 캐싱 없이 매번 데이터베이스 조회
function proc($args) {
    // 매 요청마다 실행되는 무거운 쿼리
    $output = executeQuery('complex.getHeavyData', $args);
    return $this->compileTemplate($args);
}

// 캐싱 적용 후
function proc($args) {
    $cache_key = $this->getCacheKey($args);
    $cached_data = $this->getCache($cache_key);

    if ($cached_data) {
        Context::set('data', $cached_data);
        return $this->compileTemplate($args);
    }

    // 캐시가 없을 때만 데이터베이스 조회
    $output = executeQuery('complex.getHeavyData', $args);
    $this->setCache($cache_key, $output->data, 300); // 5분 캐싱

    Context::set('data', $output->data);
    return $this->compileTemplate($args);
}

파일 기반 캐싱¶

기본 파일 캐시 구현¶

class FileCache
{
    private $cache_dir;
    private $default_ttl = 3600; // 1시간

    public function __construct($cache_dir = null)
    {
        $this->cache_dir = $cache_dir ?: _XE_PATH_ . 'files/cache/widgets/';
        $this->ensureCacheDir();
    }

    /**
     * 캐시 디렉토리 생성
     */
    private function ensureCacheDir()
    {
        if (!is_dir($this->cache_dir)) {
            FileHandler::makeDir($this->cache_dir);
        }
    }

    /**
     * 캐시 키 생성
     */
    public function generateKey($prefix, $data)
    {
        return $prefix . '_' . md5(serialize($data));
    }

    /**
     * 캐시 데이터 조회
     */
    public function get($key)
    {
        $cache_file = $this->cache_dir . $key . '.cache';

        if (!file_exists($cache_file)) {
            return null;
        }

        $cache_data = unserialize(file_get_contents($cache_file));

        // TTL 확인
        if (isset($cache_data['expires']) && time() > $cache_data['expires']) {
            $this->delete($key);
            return null;
        }

        return $cache_data['data'];
    }

    /**
     * 캐시 데이터 저장
     */
    public function set($key, $data, $ttl = null)
    {
        $ttl = $ttl ?: $this->default_ttl;
        $cache_file = $this->cache_dir . $key . '.cache';

        $cache_data = array(
            'data' => $data,
            'created' => time(),
            'expires' => time() + $ttl
        );

        file_put_contents($cache_file, serialize($cache_data));
    }

    /**
     * 캐시 데이터 삭제
     */
    public function delete($key)
    {
        $cache_file = $this->cache_dir . $key . '.cache';
        if (file_exists($cache_file)) {
            unlink($cache_file);
        }
    }

    /**
     * 만료된 캐시 정리
     */
    public function cleanup()
    {
        $files = glob($this->cache_dir . '*.cache');
        $cleaned = 0;

        foreach ($files as $file) {
            $cache_data = unserialize(file_get_contents($file));

            if (isset($cache_data['expires']) && time() > $cache_data['expires']) {
                unlink($file);
                $cleaned++;
            }
        }

        return $cleaned;
    }

    /**
     * 모든 캐시 삭제
     */
    public function flush()
    {
        $files = glob($this->cache_dir . '*.cache');
        foreach ($files as $file) {
            unlink($file);
        }
    }
}

위젯에서 파일 캐시 사용¶

class latest_posts_widget extends WidgetHandler
{
    private $cache;

    public function __construct()
    {
        $this->cache = new FileCache();
    }

    function proc($args)
    {
        // 캐시 키 생성
        $cache_key = $this->cache->generateKey('latest_posts', array(
            'mid_list' => $args->mid_list,
            'list_count' => $args->list_count,
            'template' => $args->template,
            'cache_version' => $this->getCacheVersion()
        ));

        // 캐시 확인
        $cached_data = $this->cache->get($cache_key);
        if ($cached_data) {
            Context::set('document_list', $cached_data);
            Context::set('from_cache', true);
            return $this->compileTemplate($args);
        }

        // 데이터 조회
        $document_list = $this->getDocumentList($args);

        // 후처리
        $document_list = $this->processDocuments($document_list, $args);

        // 캐시 저장
        $cache_time = max(60, (int)$args->cache_time); // 최소 1분
        $this->cache->set($cache_key, $document_list, $cache_time);

        Context::set('document_list', $document_list);
        Context::set('from_cache', false);

        return $this->compileTemplate($args);
    }

    /**
     * 캐시 버전 관리
     */
    private function getCacheVersion()
    {
        // 데이터 구조가 변경될 때마다 버전 업데이트
        return '1.2.0';
    }
}

메모리 캐싱 (APCu)¶

APCu 캐시 구현¶

class MemoryCache
{
    private $prefix;
    private $default_ttl = 3600;

    public function __construct($prefix = 'widget_')
    {
        $this->prefix = $prefix;
    }

    /**
     * APCu 사용 가능 여부 확인
     */
    public function isAvailable()
    {
        return extension_loaded('apcu') && apcu_enabled();
    }

    /**
     * 캐시 키 생성
     */
    private function getKey($key)
    {
        return $this->prefix . $key;
    }

    /**
     * 캐시 데이터 조회
     */
    public function get($key)
    {
        if (!$this->isAvailable()) {
            return null;
        }

        $cache_key = $this->getKey($key);
        $success = false;
        $data = apcu_fetch($cache_key, $success);

        return $success ? $data : null;
    }

    /**
     * 캐시 데이터 저장
     */
    public function set($key, $data, $ttl = null)
    {
        if (!$this->isAvailable()) {
            return false;
        }

        $cache_key = $this->getKey($key);
        $ttl = $ttl ?: $this->default_ttl;

        return apcu_store($cache_key, $data, $ttl);
    }

    /**
     * 캐시 데이터 삭제
     */
    public function delete($key)
    {
        if (!$this->isAvailable()) {
            return false;
        }

        return apcu_delete($this->getKey($key));
    }

    /**
     * 패턴으로 캐시 삭제
     */
    public function deleteByPattern($pattern)
    {
        if (!$this->isAvailable()) {
            return false;
        }

        $iterator = new APCUIterator('/^' . preg_quote($this->prefix . $pattern, '/') . '/');
        return apcu_delete($iterator);
    }

    /**
     * 모든 캐시 삭제
     */
    public function flush()
    {
        if (!$this->isAvailable()) {
            return false;
        }

        return $this->deleteByPattern('');
    }
}

Redis 캐싱¶

Redis 캐시 구현¶

class RedisCache
{
    private $redis;
    private $prefix;
    private $default_ttl = 3600;
    private $connected = false;

    public function __construct($config = array())
    {
        $this->prefix = $config['prefix'] ?: 'widget:';

        if (class_exists('Redis')) {
            $this->redis = new Redis();
            $this->connect($config);
        }
    }

    /**
     * Redis 연결
     */
    private function connect($config)
    {
        try {
            $host = $config['host'] ?: '127.0.0.1';
            $port = $config['port'] ?: 6379;
            $timeout = $config['timeout'] ?: 2.5;

            $this->connected = $this->redis->connect($host, $port, $timeout);

            if ($this->connected && !empty($config['password'])) {
                $this->redis->auth($config['password']);
            }

            if ($this->connected && !empty($config['database'])) {
                $this->redis->select($config['database']);
            }

        } catch (Exception $e) {
            $this->connected = false;
        }
    }

    /**
     * Redis 사용 가능 여부 확인
     */
    public function isAvailable()
    {
        return $this->connected;
    }

    /**
     * 캐시 키 생성
     */
    private function getKey($key)
    {
        return $this->prefix . $key;
    }

    /**
     * 캐시 데이터 조회
     */
    public function get($key)
    {
        if (!$this->isAvailable()) {
            return null;
        }

        try {
            $data = $this->redis->get($this->getKey($key));
            return $data ? unserialize($data) : null;
        } catch (Exception $e) {
            return null;
        }
    }

    /**
     * 캐시 데이터 저장
     */
    public function set($key, $data, $ttl = null)
    {
        if (!$this->isAvailable()) {
            return false;
        }

        try {
            $cache_key = $this->getKey($key);
            $serialized_data = serialize($data);
            $ttl = $ttl ?: $this->default_ttl;

            return $this->redis->setex($cache_key, $ttl, $serialized_data);
        } catch (Exception $e) {
            return false;
        }
    }

    /**
     * 캐시 데이터 삭제
     */
    public function delete($key)
    {
        if (!$this->isAvailable()) {
            return false;
        }

        try {
            return $this->redis->del($this->getKey($key));
        } catch (Exception $e) {
            return false;
        }
    }

    /**
     * 패턴으로 캐시 삭제
     */
    public function deleteByPattern($pattern)
    {
        if (!$this->isAvailable()) {
            return false;
        }

        try {
            $keys = $this->redis->keys($this->prefix . $pattern);
            if ($keys) {
                return $this->redis->del($keys);
            }
            return 0;
        } catch (Exception $e) {
            return false;
        }
    }

    /**
     * 캐시 통계
     */
    public function getStats()
    {
        if (!$this->isAvailable()) {
            return array();
        }

        try {
            return $this->redis->info();
        } catch (Exception $e) {
            return array();
        }
    }
}

다층 캐싱 전략¶

캐시 계층 관리자¶

class MultiLevelCache
{
    private $caches = array();
    private $levels = array('memory', 'file', 'redis');

    public function __construct()
    {
        // 캐시 레벨별 인스턴스 생성
        $this->caches['memory'] = new MemoryCache();
        $this->caches['file'] = new FileCache();
        $this->caches['redis'] = new RedisCache();
    }

    /**
     * 캐시 데이터 조회 (상위 레벨부터)
     */
    public function get($key)
    {
        foreach ($this->levels as $level) {
            $cache = $this->caches[$level];

            if (!$cache->isAvailable()) {
                continue;
            }

            $data = $cache->get($key);
            if ($data !== null) {
                // 상위 레벨 캐시에 데이터 복사
                $this->backfillCache($key, $data, $level);
                return $data;
            }
        }

        return null;
    }

    /**
     * 캐시 데이터 저장 (모든 레벨에)
     */
    public function set($key, $data, $ttl = null)
    {
        $success = false;

        foreach ($this->levels as $level) {
            $cache = $this->caches[$level];

            if ($cache->isAvailable()) {
                // 레벨별 TTL 조정
                $level_ttl = $this->adjustTTL($ttl, $level);
                if ($cache->set($key, $data, $level_ttl)) {
                    $success = true;
                }
            }
        }

        return $success;
    }

    /**
     * 상위 레벨 캐시 백필
     */
    private function backfillCache($key, $data, $current_level)
    {
        $current_index = array_search($current_level, $this->levels);

        // 현재 레벨보다 상위 레벨에 데이터 저장
        for ($i = 0; $i < $current_index; $i++) {
            $level = $this->levels[$i];
            $cache = $this->caches[$level];

            if ($cache->isAvailable()) {
                $cache->set($key, $data, $this->adjustTTL(null, $level));
            }
        }
    }

    /**
     * 레벨별 TTL 조정
     */
    private function adjustTTL($ttl, $level)
    {
        $default_ttl = $ttl ?: 3600;

        switch ($level) {
            case 'memory':
                return min($default_ttl, 300); // 메모리는 5분 최대
            case 'file':
                return $default_ttl;
            case 'redis':
                return $default_ttl * 2; // Redis는 더 오래 보관
        }

        return $default_ttl;
    }

    /**
     * 캐시 데이터 삭제 (모든 레벨에서)
     */
    public function delete($key)
    {
        foreach ($this->levels as $level) {
            $cache = $this->caches[$level];

            if ($cache->isAvailable()) {
                $cache->delete($key);
            }
        }
    }

    /**
     * 캐시 통계
     */
    public function getStats()
    {
        $stats = array();

        foreach ($this->levels as $level) {
            $cache = $this->caches[$level];
            $stats[$level] = array(
                'available' => $cache->isAvailable(),
                'stats' => method_exists($cache, 'getStats') ? $cache->getStats() : array()
            );
        }

        return $stats;
    }
}

위젯에서 다층 캐싱 사용¶

class optimized_widget extends WidgetHandler
{
    private $cache;

    public function __construct()
    {
        $this->cache = new MultiLevelCache();
    }

    function proc($args)
    {
        // 캐시 키 생성
        $cache_key = $this->generateCacheKey($args);

        // 캐시 확인
        $cached_data = $this->cache->get($cache_key);
        if ($cached_data) {
            Context::set('data', $cached_data['data']);
            Context::set('cache_info', $cached_data['cache_info']);
            return $this->compileTemplate($args);
        }

        // 데이터 조회 및 처리
        $data = $this->processData($args);

        // 캐시 정보 추가
        $cache_data = array(
            'data' => $data,
            'cache_info' => array(
                'generated_at' => time(),
                'version' => $this->getCacheVersion()
            )
        );

        // 캐시 저장
        $this->cache->set($cache_key, $cache_data, $args->cache_time);

        Context::set('data', $data);
        Context::set('cache_info', $cache_data['cache_info']);

        return $this->compileTemplate($args);
    }

    private function generateCacheKey($args)
    {
        $key_data = array(
            'widget' => get_class($this),
            'args' => $this->normalizeArgs($args),
            'version' => $this->getCacheVersion()
        );

        return 'widget_' . md5(serialize($key_data));
    }

    private function normalizeArgs($args)
    {
        // 캐시 키에 영향을 주는 인수만 추출
        return array(
            'mid_list' => $args->mid_list,
            'list_count' => $args->list_count,
            'template' => $args->template,
            'show_thumbnail' => $args->show_thumbnail
        );
    }
}

캐시 무효화 전략¶

이벤트 기반 캐시 무효화¶

class CacheInvalidator
{
    private $cache;
    private $patterns = array();

    public function __construct($cache)
    {
        $this->cache = $cache;
        $this->registerEventHandlers();
    }

    /**
     * 이벤트 핸들러 등록
     */
    private function registerEventHandlers()
    {
        // 게시물 등록/수정/삭제 시 캐시 무효화
        EventHandler::addHandler('board.insertDocument', array($this, 'invalidateDocumentCache'));
        EventHandler::addHandler('board.updateDocument', array($this, 'invalidateDocumentCache'));
        EventHandler::addHandler('board.deleteDocument', array($this, 'invalidateDocumentCache'));

        // 댓글 등록/삭제 시 캐시 무효화
        EventHandler::addHandler('board.insertComment', array($this, 'invalidateCommentCache'));
        EventHandler::addHandler('board.deleteComment', array($this, 'invalidateCommentCache'));
    }

    /**
     * 게시물 관련 캐시 무효화
     */
    public function invalidateDocumentCache($obj)
    {
        $module_srl = $obj->module_srl;

        // 해당 게시판의 모든 위젯 캐시 삭제
        $patterns = array(
            'widget_*_mid_*_' . $module_srl . '_*',
            'widget_*_module_' . $module_srl . '_*',
            'latest_posts_*_' . $module_srl
        );

        foreach ($patterns as $pattern) {
            $this->cache->deleteByPattern($pattern);
        }
    }

    /**
     * 댓글 관련 캐시 무효화
     */
    public function invalidateCommentCache($obj)
    {
        // 댓글 수가 변경되므로 관련 캐시 무효화
        $this->invalidateDocumentCache($obj);
    }

    /**
     * 특정 패턴으로 캐시 무효화
     */
    public function invalidateByPattern($pattern)
    {
        return $this->cache->deleteByPattern($pattern);
    }

    /**
     * 시간 기반 캐시 정리
     */
    public function scheduleCleanup()
    {
        // 매일 새벽 3시에 만료된 캐시 정리
        if (date('H') == 3 && date('i') < 10) {
            $this->cache->cleanup();
        }
    }
}

캐시 성능 모니터링¶

캐시 성능 추적¶

class CacheMonitor
{
    private static $stats = array(
        'hits' => 0,
        'misses' => 0,
        'sets' => 0,
        'deletes' => 0,
        'total_time' => 0
    );

    /**
     * 캐시 히트 기록
     */
    public static function recordHit($cache_key, $execution_time = 0)
    {
        self::$stats['hits']++;
        self::$stats['total_time'] += $execution_time;

        self::logAccess('HIT', $cache_key, $execution_time);
    }

    /**
     * 캐시 미스 기록
     */
    public static function recordMiss($cache_key, $execution_time = 0)
    {
        self::$stats['misses']++;
        self::$stats['total_time'] += $execution_time;

        self::logAccess('MISS', $cache_key, $execution_time);
    }

    /**
     * 캐시 저장 기록
     */
    public static function recordSet($cache_key)
    {
        self::$stats['sets']++;
        self::logAccess('SET', $cache_key);
    }

    /**
     * 캐시 삭제 기록
     */
    public static function recordDelete($cache_key)
    {
        self::$stats['deletes']++;
        self::logAccess('DELETE', $cache_key);
    }

    /**
     * 액세스 로그 기록
     */
    private static function logAccess($action, $cache_key, $execution_time = 0)
    {
        if (!__DEBUG__) {
            return;
        }

        $log_entry = array(
            'timestamp' => microtime(true),
            'action' => $action,
            'key' => $cache_key,
            'execution_time' => $execution_time,
            'memory_usage' => memory_get_usage(true)
        );

        $log_file = _XE_PATH_ . 'files/cache/cache_access.log';
        file_put_contents($log_file, json_encode($log_entry) . "\n", FILE_APPEND);
    }

    /**
     * 캐시 통계 반환
     */
    public static function getStats()
    {
        $total_requests = self::$stats['hits'] + self::$stats['misses'];
        $hit_ratio = $total_requests > 0 ? (self::$stats['hits'] / $total_requests) * 100 : 0;

        return array(
            'hits' => self::$stats['hits'],
            'misses' => self::$stats['misses'],
            'hit_ratio' => round($hit_ratio, 2),
            'total_requests' => $total_requests,
            'sets' => self::$stats['sets'],
            'deletes' => self::$stats['deletes'],
            'average_time' => $total_requests > 0 ? self::$stats['total_time'] / $total_requests : 0
        );
    }

    /**
     * 통계 리셋
     */
    public static function resetStats()
    {
        self::$stats = array(
            'hits' => 0,
            'misses' => 0,
            'sets' => 0,
            'deletes' => 0,
            'total_time' => 0
        );
    }
}

캐시 설정 관리¶

위젯별 캐시 설정¶

class WidgetCacheConfig
{
    private static $configs = array();

    /**
     * 위젯별 캐시 설정 로드
     */
    public static function loadConfig($widget_name)
    {
        if (isset(self::$configs[$widget_name])) {
            return self::$configs[$widget_name];
        }

        $config_file = _XE_PATH_ . 'files/config/widget_cache/' . $widget_name . '.json';

        if (file_exists($config_file)) {
            $config = json_decode(file_get_contents($config_file), true);
        } else {
            $config = self::getDefaultConfig();
        }

        self::$configs[$widget_name] = $config;
        return $config;
    }

    /**
     * 기본 캐시 설정
     */
    private static function getDefaultConfig()
    {
        return array(
            'enabled' => true,
            'default_ttl' => 300,
            'max_ttl' => 3600,
            'cache_levels' => array('memory', 'file'),
            'invalidation_events' => array(
                'board.insertDocument',
                'board.updateDocument',
                'board.deleteDocument'
            ),
            'cache_key_prefix' => 'widget',
            'compression' => false
        );
    }

    /**
     * 캐시 설정 저장
     */
    public static function saveConfig($widget_name, $config)
    {
        $config_dir = _XE_PATH_ . 'files/config/widget_cache/';
        if (!is_dir($config_dir)) {
            FileHandler::makeDir($config_dir);
        }

        $config_file = $config_dir . $widget_name . '.json';
        file_put_contents($config_file, json_encode($config, JSON_PRETTY_PRINT));

        self::$configs[$widget_name] = $config;
    }
}

모범 사례¶

1. 적절한 TTL: 데이터 특성에 맞는 캐시 유효 시간 설정
2. 계층적 캐싱: 빠른 메모리 캐시와 영구 저장소 조합
3. 무효화 전략: 데이터 변경 시 관련 캐시 적절히 삭제
4. 모니터링: 캐시 히트율과 성능 지표 추적
5. 설정 관리: 위젯별 캐시 정책 유연하게 관리

다음 단계¶

위젯 캐싱을 마스터했다면, 파일 관리에서 콘텐츠 관리를 학습하세요.