How to effectively handle the caching problem of tokens in PHP to reduce the number of API requests?

Optimize the PHP Token cache mechanism and reduce the frequency of API calls

In PHP projects, especially when third-party interfaces such as WeChat APIs are involved, efficient management of tokens is crucial. This article provides optimization solutions for the token caching problem, effectively reducing the number of API requests.

Problems with existing code: storing the token in the Session, and the logic is flawed. Session storage is not suitable for high concurrency scenarios, and the if-else structure in the code causes the first request to always get the token, and the business logic cannot be directly executed. In addition, the 120-second expiration time is too short, and frequent refresh of tokens has increased API requests.

Improvement solution: adopt file caching mechanism and optimize code logic

Using file caching can avoid concurrency issues and performance bottlenecks in Session. The file content format is cache_time access_token and is updated regularly. In order to avoid concurrent read and write conflicts, a file lock mechanism is adopted.

Improved code:

 <?php header("Content-type:text/html;charset=utf-8");
$cacheFile = __DIR__ . &#39;/access_token.cache&#39;; // cache file path function getAccessToken($appId, $appSecret) {
    $tokenUrl = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={$appId}&secret={$appSecret}";
    $ch = curl_init();
    curl_setopt_array($ch, [
        CURLOPT_URL => $tokenUrl,
        CURLOPT_SSL_VERIFYPEER => false,
        CURLOPT_SSL_VERIFYHOST => false,
        CURLOPT_RETURNTRANSFER => true,
    ]);
    $response = curl_exec($ch);
    curl_close($ch);
    $data = json_decode($response, true);
    if (isset($data['access_token'])) {
        return $data;
    } else {
        return false; // Failed to obtain the token}
}

function cacheAccessToken($accessToken, $expireTime) {
    global $cacheFile;
    $data = "{$expireTime} {$accessToken}";
    if (!file_exists($cacheFile)) {
        touch($cacheFile);
    }
    if (flock($cacheFile, LOCK_EX)) { // Get exclusive lock file_put_contents($cacheFile, $data);
        flock($cacheFile, LOCK_UN); // Release the lock}
}

function getCachedAccessToken() {
    global $cacheFile;
    if (file_exists($cacheFile)) {
        if (flock($cacheFile, LOCK_SH)) { // Get the shared lock $data = file_get_contents($cacheFile);
            flock($cacheFile, LOCK_UN); // Release the lock list($cacheTime, $accessToken) = exploit(' ', $data, 2);
            if (time() <p> <strong>Further optimization: Use Redis or Memcached</strong></p><p> For high concurrency scenarios, it is recommended to use distributed caches such as Redis or Memcached, which provide higher performance and reliability. This requires modifying the code to use the corresponding cache client library.</p><p> <strong>Timing tasks:</strong></p><p> It is recommended to add a timed task (for example, using crontab), execute the script every 7000 seconds (or less, depending on the actual situation), and refresh the token cache. This ensures that the token is always valid and avoids API request failures due to cache expiration.</p><p> Through the above improvements, the Token cache can be effectively managed, unnecessary API requests can be reduced, and system performance and stability can be improved. Which caching scheme to choose depends on the size and requirements of the project. For small projects, file cache plus timing tasks are a good choice; for large projects, Redis or Memcached is a more ideal solution.</p>

The above is the detailed content of How to effectively handle the caching problem of tokens in PHP to reduce the number of API requests?. For more information, please follow other related articles on the PHP Chinese website!