• <button id="miwm2"><object id="miwm2"></object></button>
  • <span id="miwm2"><pre id="miwm2"></pre></span>
      當前位置:源碼庫-建站教程-網站開發-PHP教程-PHP命名空間與自動加載機制的基礎介紹

      PHP命名空間與自動加載機制的基礎介紹

      時間:2019-08-25來源/作者:woider 編輯:源碼庫 文章熱度:

      前言

      include 和 require 是PHP中引入文件的兩個基本方法。在小規模開發中直接使用 include 和 require 沒喲什么不妥,但在大型項目中會造成大量的 include 和 require 堆積。這樣的代碼既不優雅,執行效率也很低,而且維護起來也相當困難。

      為了解決這個問題,部分框架會給出一個引入文件的配置清單,在對象初始化的時候把需要的文件引入。但這只是讓代碼變得更簡潔了一些,引入的效果仍然是差強人意。PHP5 之后,隨著 PHP 面向對象支持的完善,__autoload 函數才真正使得自動加載成為可能。

      * include 和 require 功能是一樣的,它們的不同在于 include 出錯時只會產生警告,而 require 會拋出錯誤終止腳本

      * include_once 和 include 唯一的區別在于 include_once 會檢查文件是否已經引入,如果是則不會重復引入。

      =================自動加載==================

      實現自動加載最簡單的方式就是使用 __autoload 魔術方法。當需要使用的類沒有被引入時,這個函數會在PHP報錯前被觸發,未定義的類名會被當作參數傳入。至于函數具體的邏輯,這需要用戶自己去實現。

      首先創建一個 autoload.php 來做一個簡單的測試:

      // 類未定義時,系統自動調用
      function __autoload($class)
      {
       /* 具體處理邏輯 */
       echo $class;// 簡單的輸出未定義的類名
      }
      
      new HelloWorld();
      
      /**
       * 輸出 HelloWorld 與報錯信息
       * Fatal error: Class 'HelloWorld' not found
       */

      通過這個簡單的例子可以發現,在類的實例化過程中,系統所做的工作大致是這樣的:

      /* 模擬系統實例化過程 */
      function instance($class)
      {
       // 如果類存在則返回其實例
       if (class_exists($class, false)) {
        return new $class();
       }
       // 查看 autoload 函數是否被用戶定義
       if (function_exists('__autoload')) {
        __autoload($class); // 最后一次引入的機會
       }
       // 再次檢查類是否存在
       if (class_exists($class, false)) {
        return new $class();
       } else { // 系統:我實在沒轍了
        throw new Exception('Class Not Found');
       }
      }

      明白了 __autoload 函數的工作原理之后,那就讓我們來用它去實現自動加載。

      首先創建一個類文件(建議文件名與類名一致),代碼如下:

      class [ClassName] 
      {
       // 對象實例化時輸出當前類名
       function __construct()
       {
        echo '<h1>' . __CLASS__ . '</h1>';
       }
      }

      (我這里創建了一個 HelloWorld 類用作演示)接下來我們就要定義 __autoload 的具體邏輯,使它能夠實現自動加載:

      function __autoload($class)
      {
       // 根據類名確定文件名
       $file = $class . '.php';
      
       if (file_exists($file)) {
        include $file; // 引入PHP文件
       }
      }
      
      new HelloWorld();
      
      /**
       * 輸出 <h1>HelloWorld</h1>
       */

      =================命名空間==================

      其實命名空間并不是什么新生事物,很多語言(例如C++)早都支持這個特性了。只不過 PHP 起步比較晚,直到 PHP 5.3 之后才支持。

      命名空間簡而言之就是一種標識,它的主要目的是解決命名沖突的問題。

      就像在日常生活中,有很多姓名相同的人,如何區分這些人呢?那就需要加上一些額外的標識。

      把工作單位當成標識似乎不錯,這樣就不用擔心 “撞名” 的尷尬了。

      這里我們來做一個小任務,去介紹百度的CEO李彥宏:

      namespace 百度;
      
      class 李彥宏
      {
       function __construct()
       {
        echo '百度創始人';
       }
      }

      ↑ 這就是李彥宏的基本資料了,namespace 是他的單位標識,class 是他的姓名。

      命名空間通過關鍵字 namespace 來聲明。如果一個文件中包含命名空間,它必須在其它所有代碼之前聲明命名空間。

      new 百度\李彥宏(); // 限定類名
      new \百度\李彥宏(); // 完全限定類名

      ↑ 在一般情況下,無論是向別人介紹 "百度 李彥宏" 還是 "百度公司 李彥宏",他們都能夠明白。

      在當前命名空間沒有聲明的情況下,限定類名和完全限定類名是等價的。因為如果不指定空間,則默認為全局(\)。

      namespace 谷歌;
      
      new 百度\李彥宏(); // 谷歌\百度\李彥宏(實際結果)
      new \百度\李彥宏(); // 百度\李彥宏(實際結果)

      ↑ 如果你在谷歌公司向他們的員工介紹李彥宏,一定要指明是 "百度公司的李彥宏"。否則他會認為百度是谷歌的一個部門,而李彥宏只是其中的一位員工而已。

      這個例子展示了在命名空間下,使用限定類名和完全限定類名的區別。(完全限定類名 = 當前命名空間 + 限定類名)

      /* 導入命名空間 */
      use 百度\李彥宏;
      new 李彥宏(); // 百度\李彥宏(實際結果)
      
      /* 設置別名 */
      use 百度\李彥宏 AS CEO;
      new CEO(); // 百度\李彥宏(實際結果)
      
      /* 任何情況 */
      new \百度\李彥宏();// 百度\李彥宏(實際結果)

      ↑ 第一種情況是別人已經認識李彥宏了,你只需要直接說名字,他就能知道你指的是誰。第二種情況是李彥宏就是他們的CEO,你直接說CEO,他可以立刻反應過來。

      使用命名空間只是讓類名有了前綴,不容易發生沖突,系統仍然不會進行自動導入。

      如果不引入文件,系統會在拋出 "Class Not Found" 錯誤之前觸發 __autoload 函數,并將限定類名傳入作為參數。

      所以上面的例子都是基于你已經將相關文件手動引入的情況下實現的,否則系統會拋出 " Class '百度\李彥宏' not found"。

      =================spl_autoload==================

      接下來讓我們要在含有命名空間的情況下去實現自動加載。這里我們使用 spl_autoload_register() 函數來實現,這需要你的 PHP 版本號大于 5.12。

      spl_autoload_register 函數的功能就是把傳入的函數(參數可以為回調函數或函數名稱形式)注冊到 SPL __autoload 函數隊列中,并移除系統默認的 __autoload() 函數。

      一旦調用 spl_autoload_register() 函數,當調用未定義類時,系統就會按順序調用注冊到 spl_autoload_register() 函數的所有函數,而不是自動調用 __autoload() 函數。

      現在,我們來創建一個 Linux 類,它使用 os 作為它的命名空間(建議文件名與類名保持一致):

      namespace os; // 命名空間
      
      class Linux // 類名
      {
       function __construct()
       {
        echo '<h1>' . __CLASS__ . '</h1>';
       }
      }

      接著,在同一個目錄下新建一個 PHP 文件,使用 spl_autoload_register 以函數回調的方式實現自動加載:

      spl_autoload_register(function ($class) { // class = os\Linux
      
       /* 限定類名路徑映射 */
       $class_map = array(
        // 限定類名 => 文件路徑
        'os\\Linux' => './Linux.php',
       );
      
       /* 根據類名確定文件名 */
       $file = $class_map[$class];
      
       /* 引入相關文件 */
       if (file_exists($file)) {
        include $file;
       }
      });
      
      new \os\Linux();

      這里我們使用了一個數組去保存類名與文件路徑的關系,這樣當類名傳入時,自動加載器就知道該引入哪個文件去加載這個類了。

      但是一旦文件多起來的話,映射數組會變得很長,這樣的話維護起來會相當麻煩。如果命名能遵守統一的約定,就可以讓自動加載器自動解析判斷類文件所在的路徑。接下來要介紹的PSR-4 就是一種被廣泛采用的約定方式。

      =================PSR-4規范==================

      PSR-4 是關于由文件路徑自動載入對應類的相關規范,規范規定了一個完全限定類名需要具有以下結構:

      \<頂級命名空間>(\<子命名空間>)*\<類名>

      如果繼續拿上面的例子打比方的話,頂級命名空間相當于公司,子命名空間相當于職位,類名相當于人名。那么李彥宏標準的稱呼為 "百度公司 CEO 李彥宏"。

      PSR-4 規范中必須要有一個頂級命名空間,它的意義在于表示某一個特殊的目錄(文件基目錄)。子命名空間代表的是類文件相對于文件基目錄的這一段路徑(相對路徑),類名則與文件名保持一致(注意大小寫的區別)。

      舉個例子:在全限定類名 \app\view\news\Index 中,如果 app 代表 C:\Baidu,那么這個類的路徑則是 C:\Baidu\view\news\Index.php

      我們就以解析 \app\view\news\Index 為例,編寫一個簡單的 Demo:

      $class = 'app\view\news\Index';
      
      /* 頂級命名空間路徑映射 */
      $vendor_map = array(
        'app' => 'C:\Baidu',
      );
      
      /* 解析類名為文件路徑 */
      $vendor = substr($class, 0, strpos($class, '\\')); // 取出頂級命名空間[app]
      $vendor_dir = $vendor_map[$vendor]; // 文件基目錄[C:\Baidu]
      $rel_path = dirname(substr($class, strlen($vendor))); // 相對路徑[/view/news]
      $file_name = basename($class) . '.php'; // 文件名[Index.php]
      
      /* 輸出文件所在路徑 */
      echo $vendor_dir . $rel_path . DIRECTORY_SEPARATOR . $file_name;

      通過這個 Demo 可以看出限定類名轉換為路徑的過程。那么現在就讓我們用規范的面向對象方式去實現自動加載器吧。

      首先我們創建一個文件 Index.php,它處于 \app\mvc\view\home 目錄中:

      namespace app\mvc\view\home;
      
      class Index
      {
        function __construct()
        {
          echo '<h1> Welcome To Home </h1>';
        }
      }

      接著我們在創建一個加載類(不需要命名空間),它處于 \ 目錄中:

      class Loader
      {
        /* 路徑映射 */
        public static $vendorMap = array(
          'app' => __DIR__ . DIRECTORY_SEPARATOR . 'app',
        );
      
        /**
         * 自動加載器
         */
        public static function autoload($class)
        {
          $file = self::findFile($class);
          if (file_exists($file)) {
            self::includeFile($file);
          }
        }
      
        /**
         * 解析文件路徑
         */
        private static function findFile($class)
        {
          $vendor = substr($class, 0, strpos($class, '\\')); // 頂級命名空間
          $vendorDir = self::$vendorMap[$vendor]; // 文件基目錄
          $filePath = substr($class, strlen($vendor)) . '.php'; // 文件相對路徑
          return strtr($vendorDir . $filePath, '\\', DIRECTORY_SEPARATOR); // 文件標準路徑
        }
      
        /**
         * 引入文件
         */
        private static function includeFile($file)
        {
          if (is_file($file)) {
            include $file;
          }
        }
      }

      最后,將 Loader 類中的 autoload 注冊到 spl_autoload_register 函數中:

      include 'Loader.php'; // 引入加載器
      spl_autoload_register('Loader::autoload'); // 注冊自動加載
      
      new \app\mvc\view\home\Index(); // 實例化未引用的類
      
      /**
       * 輸出: <h1> Welcome To Home </h1>
       */

      示例中的代碼其實就是 ThinkPHP 自動加載器源碼的精簡版,它是 ThinkPHP 5 能實現惰性加載的關鍵。

      至此,自動加載的原理已經全部講完了,如果有興趣深入了解的話,可以參考下面的 ThinkPHP 源碼。

      class Loader
      {
        protected static $instance = [];
        // 類名映射
        protected static $map = [];
      
        // 命名空間別名
        protected static $namespaceAlias = [];
      
        // PSR-4
        private static $prefixLengthsPsr4 = [];
        private static $prefixDirsPsr4  = [];
        private static $fallbackDirsPsr4 = [];
      
        // PSR-0
        private static $prefixesPsr0   = [];
        private static $fallbackDirsPsr0 = [];
      
        // 自動加載的文件
        private static $autoloadFiles = [];
      
        // 自動加載
        public static function autoload($class)
        {
          // 檢測命名空間別名
          if (!empty(self::$namespaceAlias)) {
            $namespace = dirname($class);
            if (isset(self::$namespaceAlias[$namespace])) {
              $original = self::$namespaceAlias[$namespace] . '\\' . basename($class);
              if (class_exists($original)) {
                return class_alias($original, $class, false);
              }
            }
          }
      
          if ($file = self::findFile($class)) {
      
            // Win環境嚴格區分大小寫
            if (IS_WIN && pathinfo($file, PATHINFO_FILENAME) != pathinfo(realpath($file), PATHINFO_FILENAME)) {
              return false;
            }
      
            __include_file($file);
            return true;
          }
        }
      
        /**
         * 查找文件
         * @param $class
         * @return bool
         */
        private static function findFile($class)
        {
          if (!empty(self::$map[$class])) {
            // 類庫映射
            return self::$map[$class];
          }
      
          // 查找 PSR-4
          $logicalPathPsr4 = strtr($class, '\\', DS) . EXT;
      
          $first = $class[0];
          if (isset(self::$prefixLengthsPsr4[$first])) {
            foreach (self::$prefixLengthsPsr4[$first] as $prefix => $length) {
              if (0 === strpos($class, $prefix)) {
                foreach (self::$prefixDirsPsr4[$prefix] as $dir) {
                  if (is_file($file = $dir . DS . substr($logicalPathPsr4, $length))) {
                    return $file;
                  }
                }
              }
            }
          }
      
          // 查找 PSR-4 fallback dirs
          foreach (self::$fallbackDirsPsr4 as $dir) {
            if (is_file($file = $dir . DS . $logicalPathPsr4)) {
              return $file;
            }
          }
      
          // 查找 PSR-0
          if (false !== $pos = strrpos($class, '\\')) {
            // namespaced class name
            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
            . strtr(substr($logicalPathPsr4, $pos + 1), '_', DS);
          } else {
            // PEAR-like class name
            $logicalPathPsr0 = strtr($class, '_', DS) . EXT;
          }
      
          if (isset(self::$prefixesPsr0[$first])) {
            foreach (self::$prefixesPsr0[$first] as $prefix => $dirs) {
              if (0 === strpos($class, $prefix)) {
                foreach ($dirs as $dir) {
                  if (is_file($file = $dir . DS . $logicalPathPsr0)) {
                    return $file;
                  }
                }
              }
            }
          }
      
          // 查找 PSR-0 fallback dirs
          foreach (self::$fallbackDirsPsr0 as $dir) {
            if (is_file($file = $dir . DS . $logicalPathPsr0)) {
              return $file;
            }
          }
      
          return self::$map[$class] = false;
        }
      
        // 注冊classmap
        public static function addClassMap($class, $map = '')
        {
          if (is_array($class)) {
            self::$map = array_merge(self::$map, $class);
          } else {
            self::$map[$class] = $map;
          }
        }
      
        // 注冊命名空間
        public static function addNamespace($namespace, $path = '')
        {
          if (is_array($namespace)) {
            foreach ($namespace as $prefix => $paths) {
              self::addPsr4($prefix . '\\', rtrim($paths, DS), true);
            }
          } else {
            self::addPsr4($namespace . '\\', rtrim($path, DS), true);
          }
        }
      
        // 添加Ps0空間
        private static function addPsr0($prefix, $paths, $prepend = false)
        {
          if (!$prefix) {
            if ($prepend) {
              self::$fallbackDirsPsr0 = array_merge(
                (array) $paths,
                self::$fallbackDirsPsr0
              );
            } else {
              self::$fallbackDirsPsr0 = array_merge(
                self::$fallbackDirsPsr0,
                (array) $paths
              );
            }
      
            return;
          }
      
          $first = $prefix[0];
          if (!isset(self::$prefixesPsr0[$first][$prefix])) {
            self::$prefixesPsr0[$first][$prefix] = (array) $paths;
      
            return;
          }
          if ($prepend) {
            self::$prefixesPsr0[$first][$prefix] = array_merge(
              (array) $paths,
              self::$prefixesPsr0[$first][$prefix]
            );
          } else {
            self::$prefixesPsr0[$first][$prefix] = array_merge(
              self::$prefixesPsr0[$first][$prefix],
              (array) $paths
            );
          }
        }
      
        // 添加Psr4空間
        private static function addPsr4($prefix, $paths, $prepend = false)
        {
          if (!$prefix) {
            // Register directories for the root namespace.
            if ($prepend) {
              self::$fallbackDirsPsr4 = array_merge(
                (array) $paths,
                self::$fallbackDirsPsr4
              );
            } else {
              self::$fallbackDirsPsr4 = array_merge(
                self::$fallbackDirsPsr4,
                (array) $paths
              );
            }
          } elseif (!isset(self::$prefixDirsPsr4[$prefix])) {
            // Register directories for a new namespace.
            $length = strlen($prefix);
            if ('\\' !== $prefix[$length - 1]) {
              throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
            }
            self::$prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
            self::$prefixDirsPsr4[$prefix]        = (array) $paths;
          } elseif ($prepend) {
            // Prepend directories for an already registered namespace.
            self::$prefixDirsPsr4[$prefix] = array_merge(
              (array) $paths,
              self::$prefixDirsPsr4[$prefix]
            );
          } else {
            // Append directories for an already registered namespace.
            self::$prefixDirsPsr4[$prefix] = array_merge(
              self::$prefixDirsPsr4[$prefix],
              (array) $paths
            );
          }
        }
      
        // 注冊命名空間別名
        public static function addNamespaceAlias($namespace, $original = '')
        {
          if (is_array($namespace)) {
            self::$namespaceAlias = array_merge(self::$namespaceAlias, $namespace);
          } else {
            self::$namespaceAlias[$namespace] = $original;
          }
        }
      
        // 注冊自動加載機制
        public static function register($autoload = '')
        {
          // 注冊系統自動加載
          spl_autoload_register($autoload ?: 'think\\Loader::autoload', true, true);
          // 注冊命名空間定義
          self::addNamespace([
            'think'  => LIB_PATH . 'think' . DS,
            'behavior' => LIB_PATH . 'behavior' . DS,
            'traits'  => LIB_PATH . 'traits' . DS,
          ]);
          // 加載類庫映射文件
          if (is_file(RUNTIME_PATH . 'classmap' . EXT)) {
            self::addClassMap(__include_file(RUNTIME_PATH . 'classmap' . EXT));
          }
      
          // Composer自動加載支持
          if (is_dir(VENDOR_PATH . 'composer')) {
            self::registerComposerLoader();
          }
      
          // 自動加載extend目錄
          self::$fallbackDirsPsr4[] = rtrim(EXTEND_PATH, DS);
        }
      
        // 注冊composer自動加載
        private static function registerComposerLoader()
        {
          if (is_file(VENDOR_PATH . 'composer/autoload_namespaces.php')) {
            $map = require VENDOR_PATH . 'composer/autoload_namespaces.php';
            foreach ($map as $namespace => $path) {
              self::addPsr0($namespace, $path);
            }
          }
      
          if (is_file(VENDOR_PATH . 'composer/autoload_psr4.php')) {
            $map = require VENDOR_PATH . 'composer/autoload_psr4.php';
            foreach ($map as $namespace => $path) {
              self::addPsr4($namespace, $path);
            }
          }
      
          if (is_file(VENDOR_PATH . 'composer/autoload_classmap.php')) {
            $classMap = require VENDOR_PATH . 'composer/autoload_classmap.php';
            if ($classMap) {
              self::addClassMap($classMap);
            }
          }
      
          if (is_file(VENDOR_PATH . 'composer/autoload_files.php')) {
            $includeFiles = require VENDOR_PATH . 'composer/autoload_files.php';
            foreach ($includeFiles as $fileIdentifier => $file) {
              if (empty(self::$autoloadFiles[$fileIdentifier])) {
                __require_file($file);
                self::$autoloadFiles[$fileIdentifier] = true;
              }
            }
          }
        }
      
        /**
         * 導入所需的類庫 同java的Import 本函數有緩存功能
         * @param string $class  類庫命名空間字符串
         * @param string $baseUrl 起始路徑
         * @param string $ext   導入的文件擴展名
         * @return boolean
         */
        public static function import($class, $baseUrl = '', $ext = EXT)
        {
          static $_file = [];
          $key     = $class . $baseUrl;
          $class    = str_replace(['.', '#'], [DS, '.'], $class);
          if (isset($_file[$key])) {
            return true;
          }
      
          if (empty($baseUrl)) {
            list($name, $class) = explode(DS, $class, 2);
      
            if (isset(self::$prefixDirsPsr4[$name . '\\'])) {
              // 注冊的命名空間
              $baseUrl = self::$prefixDirsPsr4[$name . '\\'];
            } elseif ('@' == $name) {
              //加載當前模塊應用類庫
              $baseUrl = App::$modulePath;
            } elseif (is_dir(EXTEND_PATH . $name)) {
              $baseUrl = EXTEND_PATH;
            } else {
              // 加載其它模塊的類庫
              $baseUrl = APP_PATH . $name . DS;
            }
          } elseif (substr($baseUrl, -1) != DS) {
            $baseUrl .= DS;
          }
          // 如果類存在 則導入類庫文件
          if (is_array($baseUrl)) {
            foreach ($baseUrl as $path) {
              $filename = $path . DS . $class . $ext;
              if (is_file($filename)) {
                break;
              }
            }
          } else {
            $filename = $baseUrl . $class . $ext;
          }
      
          if (!empty($filename) && is_file($filename)) {
            // 開啟調試模式Win環境嚴格區分大小寫
            if (IS_WIN && pathinfo($filename, PATHINFO_FILENAME) != pathinfo(realpath($filename), PATHINFO_FILENAME)) {
              return false;
            }
            __include_file($filename);
            $_file[$key] = true;
            return true;
          }
          return false;
        }
      
        /**
         * 實例化(分層)模型
         * @param string $name     Model名稱
         * @param string $layer    業務層名稱
         * @param bool  $appendSuffix 是否添加類名后綴
         * @param string $common    公共模塊名
         * @return Object
         * @throws ClassNotFoundException
         */
        public static function model($name = '', $layer = 'model', $appendSuffix = false, $common = 'common')
        {
          if (isset(self::$instance[$name . $layer])) {
            return self::$instance[$name . $layer];
          }
          if (strpos($name, '/')) {
            list($module, $name) = explode('/', $name, 2);
          } else {
            $module = Request::instance()->module();
          }
          $class = self::parseClass($module, $layer, $name, $appendSuffix);
          if (class_exists($class)) {
            $model = new $class();
          } else {
            $class = str_replace('\\' . $module . '\\', '\\' . $common . '\\', $class);
            if (class_exists($class)) {
              $model = new $class();
            } else {
              throw new ClassNotFoundException('class not exists:' . $class, $class);
            }
          }
          self::$instance[$name . $layer] = $model;
          return $model;
        }
      
        /**
         * 實例化(分層)控制器 格式:[模塊名/]控制器名
         * @param string $name     資源地址
         * @param string $layer    控制層名稱
         * @param bool  $appendSuffix 是否添加類名后綴
         * @param string $empty    空控制器名稱
         * @return Object|false
         * @throws ClassNotFoundException
         */
        public static function controller($name, $layer = 'controller', $appendSuffix = false, $empty = '')
        {
          if (strpos($name, '/')) {
            list($module, $name) = explode('/', $name);
          } else {
            $module = Request::instance()->module();
          }
          $class = self::parseClass($module, $layer, $name, $appendSuffix);
          if (class_exists($class)) {
            return new $class(Request::instance());
          } elseif ($empty && class_exists($emptyClass = self::parseClass($module, $layer, $empty, $appendSuffix))) {
            return new $emptyClass(Request::instance());
          }
        }
      
        /**
         * 實例化驗證類 格式:[模塊名/]驗證器名
         * @param string $name     資源地址
         * @param string $layer    驗證層名稱
         * @param bool  $appendSuffix 是否添加類名后綴
         * @param string $common    公共模塊名
         * @return Object|false
         * @throws ClassNotFoundException
         */
        public static function validate($name = '', $layer = 'validate', $appendSuffix = false, $common = 'common')
        {
          $name = $name ?: Config::get('default_validate');
          if (empty($name)) {
            return new Validate;
          }
      
          if (isset(self::$instance[$name . $layer])) {
            return self::$instance[$name . $layer];
          }
          if (strpos($name, '/')) {
            list($module, $name) = explode('/', $name);
          } else {
            $module = Request::instance()->module();
          }
          $class = self::parseClass($module, $layer, $name, $appendSuffix);
          if (class_exists($class)) {
            $validate = new $class;
          } else {
            $class = str_replace('\\' . $module . '\\', '\\' . $common . '\\', $class);
            if (class_exists($class)) {
              $validate = new $class;
            } else {
              throw new ClassNotFoundException('class not exists:' . $class, $class);
            }
          }
          self::$instance[$name . $layer] = $validate;
          return $validate;
        }
      
        /**
         * 數據庫初始化 并取得數據庫類實例
         * @param mixed     $config 數據庫配置
         * @param bool|string  $name 連接標識 true 強制重新連接
         * @return \think\db\Connection
         */
        public static function db($config = [], $name = false)
        {
          return Db::connect($config, $name);
        }
      
        /**
         * 遠程調用模塊的操作方法 參數格式 [模塊/控制器/]操作
         * @param string    $url     調用地址
         * @param string|array $vars     調用參數 支持字符串和數組
         * @param string    $layer    要調用的控制層名稱
         * @param bool     $appendSuffix 是否添加類名后綴
         * @return mixed
         */
        public static function action($url, $vars = [], $layer = 'controller', $appendSuffix = false)
        {
          $info  = pathinfo($url);
          $action = $info['basename'];
          $module = '.' != $info['dirname'] ? $info['dirname'] : Request::instance()->controller();
          $class = self::controller($module, $layer, $appendSuffix);
          if ($class) {
            if (is_scalar($vars)) {
              if (strpos($vars, '=')) {
                parse_str($vars, $vars);
              } else {
                $vars = [$vars];
              }
            }
            return App::invokeMethod([$class, $action . Config::get('action_suffix')], $vars);
          }
        }
      
        /**
         * 字符串命名風格轉換
         * type 0 將Java風格轉換為C的風格 1 將C風格轉換為Java的風格
         * @param string $name 字符串
         * @param integer $type 轉換類型
         * @return string
         */
        public static function parseName($name, $type = 0)
        {
          if ($type) {
            return ucfirst(preg_replace_callback('/_([a-zA-Z])/', function ($match) {
              return strtoupper($match[1]);
            }, $name));
          } else {
            return strtolower(trim(preg_replace("/[A-Z]/", "_\\0", $name), "_"));
          }
        }
      
        /**
         * 解析應用類的類名
         * @param string $module 模塊名
         * @param string $layer 層名 controller model ...
         * @param string $name  類名
         * @param bool  $appendSuffix
         * @return string
         */
        public static function parseClass($module, $layer, $name, $appendSuffix = false)
        {
          $name = str_replace(['/', '.'], '\\', $name);
          $array = explode('\\', $name);
          $class = self::parseName(array_pop($array), 1) . (App::$suffix || $appendSuffix ? ucfirst($layer) : '');
          $path = $array ? implode('\\', $array) . '\\' : '';
          return App::$namespace . '\\' . ($module ? $module . '\\' : '') . $layer . '\\' . $path . $class;
        }
      
        /**
         * 初始化類的實例
         * @return void
         */
        public static function clearInstance()
        {
          self::$instance = [];
        }
      }
      
      /**
       * 作用范圍隔離
       *
       * @param $file
       * @return mixed
       */
      function __include_file($file)
      {
        return include $file;
      }
      
      function __require_file($file)
      {
        return require $file;
      }

      總結

      以上就是這篇文章的全部內容了,希望本文的內容對大家的學習或者工作具有一定的參考學習價值,謝謝大家對ASPKU源碼庫的支持。


      注:相關教程知識閱讀請移步到PHP教程頻道。
      下一篇:沒有了
      相關PHP教程
      熱門標簽

      PHP教程Rss訂閱PHP教程搜索

      撸吧撸吧