php文件下载（可限制下载速度）实现代码

在php中文件下载会利用到header fopen fread三个主要函数，同时还有一些辅助函数如判断文件存在file_exists is_file等函数，下面我们来看一款文件下载可以限制下载速度实例

*/
$file = "test.mp3"; // file to be send to the client
$speed = 8.5; // 8,5 kb/s download rate limit
if(file_exists($file) && is_file($file)) {
   header("cache-control: private");
   header("content-type: application/octet-stream");
   header("content-length: ".filesize($file));
   header("content-disposition: filename=$file" . "%20");
   flush();
   $fd = fopen($file, "r");
    while(!feof($fd)) {
          echo fread($fd, round($speed*1024));
       flush();
       sleep(1);
    }
   fclose ($fd);
}

/*
flush
flush函数 刷新php程序的缓冲 实现echo动态输出
本函数实现的结果是页面不断地显示echo输出　的数据
for ($i=10; $i>0; $i--)
{
echo $i.'<br />';
ob_flush();
flush();
sleep(1);
}
ob_end_flush();

sleep
sleep() 函数延迟代码执行若干秒。
header
header() 函数向客户端发送原始的 http 报头。

认识到一点很重要，即必须在任何实际的输出被发送之前调用 header() 函数（在 php 4 以及更高的版本中，您可以使用输出缓存来解决此问题）：

filesize 获取文件大小
fread 读取由fopen打开的文件内容

下面是一个php缓存文件实现类，根据我的经验，缓存文件是根据用户设置的时间与文件生成的日间以及当前时间进行比较，然后再判断是否需要重新生成缓存文件。*/

class pagecache {

 /**
  * @var string $file 缓存文件地址
  * @access public
  */
 public $file;
 
 /**
  * @var int $cachetime 缓存时间
  * @access public
  */
 public $cachetime = 3600;
 
 /**
  * 构造函数
  * @param string $file 缓存文件地址
  * @param int $cachetime 缓存时间
     */
 function __construct($file, $cachetime = 3600) {
  $this->file = $file;
  $this->cachetime = $cachetime;
 }
 
 /**
  * 取缓存内容
  * @param bool 是否直接输出，true直接转到缓存页,false返回缓存内容
  * @return mixed
     */
 public function get($output = true) {
  if (is_file($this->file) && (time()-filemtime($this->file))<=$this->cachetime && !$_get['nocache']) {
   if ($output) {
    header('location:' . $this->file);
    exit;
   } else {
    return file_get_contents($this->file);
   }
  } else {
   return false;
  }
 }
 
 /**
  * 设置缓存内容
  * @param $content 内容html字符串
     */
 public function set($content) {
  $fp = fopen($this->file, 'w');
  fwrite($fp, $content);
  fclose($fp);
 }
}

serialize — 产生一个可存储的值的表示
unserialize — 从已存储的表示中创建 php教程 的值

想要将已序列化的字符串变回 php 的值，可使用 unserialize()。serialize() 可处理除了 resource 之外的任何类型。甚至可以 serialize() 那些包含了指向其自身引用的数组。你正 serialize() 的数组／对象中的引用也将被存储。

*/
serialize

//store data:
$array = explode('rn', $string);
$serialized = serialize($array);

//restore data:
$array = unserialize($serialized);
$text = implode('rn', $array);

unserialize
function restorepost() {
    if (isset($_post[savepost])) {
        $_post = unserialize(strips教程lashes(htmlspecialchars_decode($_post[savepost])));
    }
}

下面的代码就是我通过我的数据库教程读取出文件路径并最终实现批量修改rar文件注释的方法.因为数据库是access,我新建了一个odbc源.同时rar.exe及cmd.exe都在1.php教程同目录下

 

<?
$id=$_get[id];
if($id=="")
{
echo "参数错误";
exit;
}
if($id>=400)
{
echo "全部结束";
exit;
}
$db=odbc_connect("dw","","");
$sql="select * from 'download' where 'id'=$id";
$query=odbc_exec($db,$sql);
$filename=odbc_result($query,2);
if($filename=="")
{

}
$filename=str_replace("#1′,"",$filename);
$filename=str_replace("#2′,"",$filename);
$filename="soft/".$filename;
echo $filename."<br>";
if(!file_exists($filename))
{
echo "文件不存在,转到下一个id";
$id++;
echo "<meta http-equiv='refresh'

content='0;url=../test/1.php?id=$id'>";
exit;
}//读出文件名,并检查文件是否存在
else
{
'winrar a $filename 使用说明.txt';
echo "插入说明文件成功";
$id++;
echo "<meta http-equiv='refresh' content='0;url=../test/1.php?id=$id'>";
}
odbc_close($db);
?>

缓存技术是每次访问页面的时候，都会先检测相应的缓存是否存在，如果不存在，就连接数据库，得到数据，完成模板变量的赋值，显示页面，同时生成缓存文件，这样下次访问的时候缓存文件就发挥作用了

而不会再执行if块的数据查询语句了。当然，在实际使用中会有很多东西要考虑，比如，有效期的设置，缓存组的设置等等

<?php 
class cacheexception extends exception {} 
/**
 * 缓存抽象类
 */ 
abstract class cache_abstract { 
    /**
     * 读缓存变量
     *
     * @param string $key 缓存下标
     * @return mixed
     */ 
    abstract public function fetch($key); 
     
    /**
     * 缓存变量
     *
     * @param string $key 缓存变量下标
     * @param string $value 缓存变量的值
     * @return bool
     */ 
    abstract public function store($key, $value); 
     
    /**
     * 删除缓存变量
     *
     * @param string $key 缓存下标
     * @return cache_abstract
     */ 
    abstract public function delete($key); 
     
    /**
     * 清(删)除所有缓存
     *
     * @return cache_abstract
     */ 
    abstract public function clear(); 
     
    /**
     * 锁定缓存变量
     *
     * @param string $key 缓存下标
     * @return cache_abstract
     */ 
    abstract public function lock($key); 
 
    /**
     * 缓存变量解锁
     *
     * @param string $key 缓存下标
     * @return cache_abstract
     */ 
    abstract public function unlock($key); 
 
    /**
     * 取得缓存变量是否被锁定
     *
     * @param string $key 缓存下标
     * @return bool
     */ 
    abstract public function islocked($key); 
 
    /**
     * 确保不是锁定状态
     * 最多做$tries次睡眠等待解锁，超时则跳过并解锁
     *
     * @param string $key 缓存下标
     */ 
    public function checklock($key) { 
        if (!$this->islocked($key)) { 
            return $this; 
        } 
         
        $tries = 10; 
        $count = 0; 
        do { 
            usleep(200); 
            $count ++; 
        } while ($count <= $tries && $this->islocked($key));  // 最多做十次睡眠等待解锁，超时则跳过并解锁 
 
        $this->islocked($key) && $this->unlock($key); 
         
        return $this; 
    } 
} 
 
 
/**
 * apc扩展缓存实现
 * 
 * 
 * @category   mjie
 * @package    cache
 * @author     流水孟春
 * @copyright  copyright (c) 2008- <cmpan(at)qq.com>
 * @license    new bsd license
 * @version    $id: cache/apc.php 版本号 2010-04-18 23:02 cmpan $
 */ 
class cache_apc extends cache_abstract { 
     
    protected $_prefix = 'cache.mjie.net'; 
     
    public function __construct() { 
        if (!function_exists('apc_cache_info')) { 
            throw new cacheexception('apc extension didn't installed'); 
        } 
    } 
     
    /**
     * 保存缓存变量
     *
     * @param string $key
     * @param mixed $value
     * @return bool
     */ 
    public function store($key, $value) { 
        return apc_store($this->_storagekey($key), $value); 
    } 
     
    /**
     * 读取缓存
     *
     * @param string $key
     * @return mixed
     */ 
    public function fetch($key) { 
        return apc_fetch($this->_storagekey($key)); 
    } 
     
    /**
     * 清除缓存
     *
     * @return cache_apc
     */ 
    public function clear() { 
        apc_clear_cache(); 
        return $this; 
    } 
     
    /**
     * 删除缓存单元
     *
     * @return cache_apc
     */ 
    public function delete($key) { 
        apc_delete($this->_storagekey($key)); 
        return $this; 
    } 
     
    /**
     * 缓存单元是否被锁定
     *
     * @param string $key
     * @return bool
     */ 
    public function islocked($key) { 
        if ((apc_fetch($this->_storagekey($key) . '.lock')) === false) { 
            return false; 
        } 
         
        return true; 
    } 
     
    /**
     * 锁定缓存单元
     *
     * @param string $key
     * @return cache_apc
     */ 
    public function lock($key) { 
        apc_store($this->_storagekey($key) . '.lock', '', 5); 
        return $this; 
    } 
     
    /**
     * 缓存单元解锁
     *
     * @param string $key
     * @return cache_apc
     */ 
    public function unlock($key) { 
        apc_delete($this->_storagekey($key) . '.lock'); 
        return $this; 
    } 
     
    /**
     * 完整缓存名
     *
     * @param string $key
     * @return string
     */ 
    private function _storagekey($key) { 
        return $this->_prefix . '_' . $key; 
    } 
} 
 
/**
 * 文件缓存实现
 * 
 * 
 * @category   mjie
 * @package    cache
 * @author     流水孟春
 * @copyright  copyright (c) 2008- <cmpan(at)qq.com>
 * @license    new bsd license
 * @version    $id: cache/file.php 版本号 2010-04-18 16:46 cmpan $
 */ 
class cache_file extends cache_abstract { 
    public $usesubdir     = false; 
     
    protected $_cachesdir = 'cache'; 
     
    public function __construct() { 
        if (defined('data_dir')) { 
            $this->_setcachedir(data_dir . '/cache'); 
        } 
    } 
     
    /**
     * 获取缓存文件
     *
     * @param string $key
     * @return string
     */ 
    protected function _getcachefile($key) { 
        $subdir = $this->usesubdir ? substr($key, 0, 2) . '/' : ''; 
        return $this->_cachesdir . '/' . $subdir . $key . '.php'; 
    } 
 
    /**
     * 读取缓存变量
     * 为防止信息泄露，缓存文件格式为php文件，并以"<?php exit;?>"开头
     * 
     * @param string $key 缓存下标
     * @return mixed
     */ 
    public function fetch($key) { 
        $cachefile = self::_getcachefile($key); 
        if (file_exists($cachefile) && is_readable($cachefile)) { 
            // include 方式 
            //return include $cachefile; 
            // 系列化方式 
 
            return unserialize(@file_get_contents($cachefile, false, null, 13)); 
        } 
 
        return false; 
    } 
 
    /**
     * 缓存变量
     * 为防止信息泄露，缓存文件格式为php文件，并以"<?php exit;?>"开头
     *
     * @param string $key 缓存变量下标
     * @param string $value 缓存变量的值
     * @return bool
     */ 
    public function store($key, $value) { 
        $cachefile = self::_getcachefile($key); 
        $cachedir  = dirname($cachefile); 
 
        if(!is_dir($cachedir)) { 
            if(!@mkdir($cachedir, 0755, true)) { 
                throw new cacheexception("could not make cache directory"); 
            } 
        } 
    // 用include方式 
        //return @file_put_contents($cachefile, '<?php return ' . var_export($value, true). ';'); 
 
        return @file_put_contents($cachefile, '<?php exit;?>' . serialize($value)); 
    } 
 
    /**
     * 删除缓存变量
     *
     * @param string $key 缓存下标
     * @return cache_file
     */ 
    public function delete($key) { 
        if(emptyempty($key)) { 
            throw new cacheexception("missing argument 1 for cache_file::delete()"); 
        } 
         
        $cachefile = self::_getcachefile($key); 
        if(!@unlink($cachefile)) { 
            throw new cacheexception("cache file could not be deleted"); 
        } 
 
        return $this; 
    } 
 
    /**
     * 缓存单元是否已经锁定
     *
     * @param string $key
     * @return bool
     */ 
    public function islocked($key) { 
        $cachefile = self::_getcachefile($key); 
        clearstatcache(); 
        return file_exists($cachefile . '.lock'); 
    } 
 
    /**
     * 锁定
     *
     * @param string $key
     * @return cache_file
     */ 
    public function lock($key) { 
        $cachefile = self::_getcachefile($key); 
        $cachedir  = dirname($cachefile); 
        if(!is_dir($cachedir)) { 
            if(!@mkdir($cachedir, 0755, true)) { 
                if(!is_dir($cachedir)) { 
                    throw new cacheexception("could not make cache directory"); 
                } 
            } 
        } 
 
        // 设定缓存锁文件的访问和修改时间 
        @touch($cachefile . '.lock'); 
        return $this; 
    } 
   
    /**
     * 解锁
     *
     * @param string $key
     * @return cache_file
     */ 
    public function unlock($key) { 
        $cachefile = self::_getcachefile($key); 
        @unlink($cachefile . '.lock'); 
        return 

下面来看一款关于smarty缓存的文件实例代码

再来看看smarty提供的页面缓存功能：

　

　1<?php

　　2require('smarty.class.php');

　　3$smarty = new smarty;

　　4$smarty->caching = true;

　　5if(!$smarty->is_cached('index.tpl')) {

　　6 // no cache available, do variable assignments here.

　　7 $contents = get_database_contents();

　　8 $smarty->assign($contents);

　　9}

　　10$smarty->display('index.tpl');

　　11?>

php缓存技术工作时,当程序查询数据的时候，会把相应的结果序列化后保存到文件中，以后同样的查询语句就可以不用直接查询数据库，而是从缓存文件中获得。这一改进使得程序运行速度得以太幅度提升.