leveldb程式碼精讀 資料庫啟動和初始化

liiinuuux發表於2015-11-25
資料庫


基本概念
資料庫主要包括cache、日誌檔案、資料檔案、CURRENT檔案和manifest檔案幾大塊。


所有檔案都是依照型別+檔案號的命名規則，檔案號非常重要，類似oracle的sequence#。
其中cache是當前寫入的資料快取，寫入資料時
1 將資料寫入日誌檔案
2 將資料放入cache
當達到一定條件，如cache裡的資料夠多時
1 將cache轉成只讀cache，供查詢用。
2 新建一個讀寫cache和一個新日誌檔案。
3 將只讀cache裡的資料寫到資料檔案裡，這種新生成的資料檔案稱為level 0。


由於每次寫檔案後都會啟用新的cache，寫入的key可能和已有資料重複，將來也會落地成檔案。
因此leveldb會對檔案進行“壓縮”，在多個level 0檔案中給key去重，稱為level 1。
隨著資料庫執行，level 1還會進一步和level n+1的檔案合併，以此類推。
每次合併後刪除老檔案。
這樣做的結果就是從level 1開始，每層的檔案不會有重複的key，層與層之間的檔案也不會有重複的key，大大提高從檔案查詢的效率。
由於所有檔案的內容都是排序的，並且記錄了key的範圍，因此這些操作的成本非常可控。

當資料庫重啟時會根據日誌檔案重新構建cache並將cache裡的資料寫到level 0檔案裡。


上述所有資訊稱為資料庫的一個Version。
Version的增量叫VersionEdit，VersionEdit記錄了增加哪些檔案，減少哪些檔案，以及檔案的概要資訊等。
version1 + versionedit1 = version2
資料庫裡可能會儲存多個version資訊，所有version的載體是VersionSet。

這些資訊還記錄在manifest檔案內，相當於oracle的控制檔案。
CURRENT檔案記錄資料庫當前manifest檔案的檔名。

資料庫當機後，例項恢復的流程就是
1 根據檔案命名規則，在資料夾尋找之前的CURRENT 
2 尋找之前的manifest 
3 定位logfile 
4 將logfile資料復原到cache 
5 將cache裡的資料寫到level 0資料檔案


下面看程式碼
初始化資料庫包括新建資料庫和開啟已關閉的資料庫兩種情況
功能入口是DB::Open

點選(此處)摺疊或開啟

  1. Status DB::Open(const Options& options, const std::string& dbname,
  2.                 DB** dbptr) {
  3.   *dbptr = NULL;


  6.   /*
  7.   DBImpl是leveldb的“主類”，初始化配置資訊
  8.   dbname是資料庫的所在目錄
  9.   */
  10.   DBImpl* impl = new DBImpl(options, dbname);
  11.   impl->mutex_.Lock();


  14.   /*
  15.   開啟資料庫，如果不存在就建立。
  16.   如果存在就檢查manifest檔案，並根據其中的資訊建立一個VersionEdit，用這個VersionEdit還原資料庫的Version。
  17.   */
  18.   VersionEdit edit;
  19.   Status s = impl->Recover(&edit); // Handles create_if_missing, error_if_exists
  20.   if (s.ok()) {
  21.     uint64_t new_log_number = impl->versions_->NewFileNumber();
  22.     WritableFile* lfile;


  25.     /*
  26.     以w選項開啟一個新logfile。
  27.     lfile就是開啟的檔案，型別是PosixWritableFile，封裝了一些IO操作。
  28.     */
  29.     s = options.env->NewWritableFile(LogFileName(dbname, new_log_number),
  30.                                      &lfile);
  31.     if (s.ok()) {
  32.       // 初始化當前logfile檔案號
  33.       edit.SetLogNumber(new_log_number);
  34.       impl->logfile_ = lfile;
  35.       impl->logfile_number_ = new_log_number;
  36.       // log::Writer用來寫日誌，公共函式就一個AddRecord
  37.       impl->log_ = new log::Writer(lfile);


  40.       /*
  41.       1 結合VersionSet，進一步設定VersionEdit，
  42.       2 根據當前logfile號建立一個新version作為current version
  43.       3 建立manifest檔案
  44.       4 建立一個snapshot
  45.       */
  46.       s = impl->versions_->LogAndApply(&edit, &impl->mutex_);
  47.     }
  48.     if (s.ok()) {
  49.       // 根據檔案號等條件，刪除不再需要的檔案。
  50.       impl->DeleteObsoleteFiles();
  51.       // 進行一次壓縮，把重複鍵值的檔案由低階向高階合併。
  52.       impl->MaybeScheduleCompaction();
  53.     }
  54.   }
  55.   impl->mutex_.Unlock();
  56.   if (s.ok()) {
  57.     *dbptr = impl;
  58.   } else {
  59.     delete impl;
  60.   }
  61.   return s;
  62. }


下面是Open函式一上來呼叫的建構函式

點選(此處)摺疊或開啟

  1. DBImpl::DBImpl(const Options& raw_options, const std::string& dbname)
  2.       /*
  3.       leveldb將系統相關的操作封裝到env裡，
  4.       linux版的env是PosixEnv類，在util/env_posix.cc裡
  5.       */
  6.     : env_(raw_options.env),
  7.       // comparator用來比較key的大小，可以自己實現，也可以用leveldb預設的
  8.       internal_comparator_(raw_options.comparator),
  9.       // 定義過濾資料的演算法，比如布隆過濾等
  10.       internal_filter_policy_(raw_options.filter_policy),
  11.       // SanitizeOptions函式用來對引數raw_options的選項進行必要的處理，並封裝成一個處理後的Options
  12.       options_(SanitizeOptions(dbname, &internal_comparator_,
  13.                                &internal_filter_policy_, raw_options)),
  14.       owns_info_log_(options_.info_log != raw_options.info_log),
  15.       owns_cache_(options_.block_cache != raw_options.block_cache),
  16.       // dbname其實是指定資料庫的資料夾，所有資料檔案都會放到這個資料夾下。
  17.       dbname_(dbname),


  20.       // 用於鎖檔案，linux的是PosixFileLock類，裡面有一個檔案描述符和一個字串
  21.       db_lock_(NULL),
  22.       shutting_down_(NULL),


  25.       // 管理後臺執行緒的併發
  26.       bg_cv_(&mutex_),


  29.       /*
  30.       下面兩個memtable，是對SkipList類的封裝。
  31.       關於SkipList, 參考我之前的部落格 http://blog.itpub.net/26239116/viewspace-1839630/
  32.       具體封裝方式是在memtable.h裡定義typedef，並設定為成員變數
  33.       typedef SkipList<const char*, KeyComparator> Table;
  34.       ...
  35.       Table table_;
  36.       */
  37.       mem_(new MemTable(internal_comparator_)),
  38.       imm_(NULL),
  39.       logfile_(NULL),
  40.       logfile_number_(0),
  41.       log_(NULL),
  42.       seed_(0),
  43.       // 檔案IO的工具
  44.       tmp_batch_(new WriteBatch),
  45.       bg_compaction_scheduled_(false),
  46.       manual_compaction_(NULL) {
  47.   mem_->Ref();
  48.   has_imm_.Release_Store(NULL);


  51.   // Reserve ten files or so for other uses and give the rest to TableCache.
  52.   /*
  53.   最大檔案數減去預留的輔助檔案數，需要維護資料的檔案數
  54.   在建立TableCache的時候，這個檔案數對應的是TableCache裡lrucache的數量
  55.   關於lrucache，參考文獻之前的部落格 http://blog.itpub.net/26239116/viewspace-1842049/
  56.   */
  57.   const int table_cache_size = options_.max_open_files - kNumNonTableCacheFiles;
  58.   table_cache_ = new TableCache(dbname_, &options_, table_cache_size);


  61.   // 初始化VersionSet，用於存放資料庫裡所有version
  62.   versions_ = new VersionSet(dbname_, &options_, table_cache_,
  63.                              &internal_comparator_);
  64. }





建構函式里調的SanitizeOptions的具體內容。對option做了一下預處理

點選(此處)摺疊或開啟

  1. Options SanitizeOptions(const std::string& dbname,
  2.                         const InternalKeyComparator* icmp,
  3.                         const InternalFilterPolicy* ipolicy,
  4.                         const Options& src) {
  5.   // 複製一份呼叫者提供的Options，做返回值用。
  6.   Options result = src;
  7.   result.comparator = icmp;
  8.   result.filter_policy = (src.filter_policy != NULL) ? ipolicy : NULL;


  11.   // 校驗數值型引數，太大的設定為最大值，太小的設定為最小值
  12.   ClipToRange(&result.max_open_files, 64 + kNumNonTableCacheFiles, 50000);
  13.   ClipToRange(&result.write_buffer_size, 64<<10, 1<<30);
  14.   ClipToRange(&result.block_size, 1<<10, 4<<20);


  17.   // 如果沒有指定日誌，建立一個。
  18.   if (result.info_log == NULL) {
  19.     // Open a log file in the same directory as the db
  20.     src.env->CreateDir(dbname); // In case it does not exist
  21.     /*
  22.     日誌檔案的命名規則是 dbname + "/LOG"，
  23.     建立之前需要先原有的重新命名為 dbname + "/LOG.old"
  24.     */
  25.     src.env->RenameFile(InfoLogFileName(dbname), OldInfoLogFileName(dbname));


  28.     /*
  29.     建立一個logger，對於linux平臺，是建立一個PosixLogger
  30.     */
  31.     Status s = src.env->NewLogger(InfoLogFileName(dbname), &result.info_log);
  32.     if (!s.ok()) {
  33.       // No place suitable for logging
  34.       result.info_log = NULL;
  35.     }
  36.   }


  39.   /*
  40.   建立一個lru cache
  41.   關於lru cache，參考我前面的部落格 http://blog.itpub.net/26239116/viewspace-1842049/
  42.   */
  43.   if (result.block_cache == NULL) {
  44.     result.block_cache = NewLRUCache(8 << 20);
  45.   }
  46.   return result;
  47. }



資料庫初始化的主要工作由DBImpl::Recover函式完成

點選(此處)摺疊或開啟

  1. Status DBImpl::Recover(VersionEdit* edit) {
  2.   mutex_.AssertHeld();


  5.   // Ignore error from CreateDir since the creation of the DB is
  6.   // committed only when the descriptor is created, and this directory
  7.   // may already exist from a previous failed creation attempt.
  8.   env_->CreateDir(dbname_);
  9.   assert(db_lock_ == NULL);


  12.   /*
  13.     建立檔案鎖，格式是"dbname_/LOC"
  14.     linux版的env是env_posix.cc
  15.     大致過程是
  16.     1 對檔案資訊進行一系列記錄，如記錄到PosixFileLock類裡。
  17.     2 建立一個“鎖”檔案，寫入flock結構體寫進去。flock定義在fcntl.h裡。
  18.   */
  19.   Status s = env_->LockFile(LockFileName(dbname_), &db_lock_);
  20.   if (!s.ok()) {
  21.     return s;
  22.   }
  23.   
  24.   /*
  25.   判斷current檔案是否存在，格式是“dbname_/CURRENT”
  26.   用來記錄當前的manifest檔名，madifest檔案裡記錄當前資料庫的概要資訊，類似oracle的控制檔案
  27.   */
  28.   if (!env_->FileExists(CurrentFileName(dbname_))) {
  29.     if (options_.create_if_missing) {
  30.       // 初始化一個新的VersionEdit，設定logfile資訊，然後寫入manifest檔案。
  31.       s = NewDB();
  32.       if (!s.ok()) {
  33.         return s;
  34.       }
  35.     } else {
  36.       return Status::InvalidArgument(
  37.           dbname_, "does not exist (create_if_missing is false)");
  38.     }
  39.   } else {
  40.     if (options_.error_if_exists) {
  41.       return Status::InvalidArgument(
  42.           dbname_, "exists (error_if_exists is true)");
  43.     }
  44.   }


  47.   // 如果之前存在這個資料庫，開啟時需要做恢復工作，manifest檔案裡的資訊應用的當前version。
  48.   s = versions_->Recover();
  49.   if (s.ok()) {
  50.     SequenceNumber max_sequence(0);


  53.     // Recover from all newer log files than the ones named in the
  54.     // descriptor (new log files may have been added by the previous
  55.     // incarnation without registering them in the descriptor).
  56.     //
  57.     // Note that PrevLogNumber() is no longer used, but we pay
  58.     // attention to it in case we are recovering a database
  59.     // produced by an older version of leveldb.
  60.     const uint64_t min_log = versions_->LogNumber();
  61.     const uint64_t prev_log = versions_->PrevLogNumber();
  62.     std::vector<std::string> filenames;
  63.     s = env_->GetChildren(dbname_, &filenames);
  64.     if (!s.ok()) {
  65.       return s;
  66.     }
  67.     std::set<uint64_t> expected;


  70.     // 從所有version裡獲得所有檔案號
  71.     versions_->AddLiveFiles(&expected);
  72.     uint64_t number;
  73.     FileType type;
  74.     std::vector<uint64_t> logs;


  77.     /*
  78.     從資料夾內所有檔名中提取檔案型別和檔案號
  79.     從versions_提取的expected中移除這些檔案號
  80.     同時記錄其中有哪些log檔案
  81.     */
  82.     for (size_t i = 0; i < filenames.size(); i++) {
  83.       if (ParseFileName(filenames[i], &number, &type)) {
  84.         expected.erase(number);
  85.         if (type == kLogFile && ((number >= min_log) || (number == prev_log)))
  86.           logs.push_back(number);
  87.       }
  88.     }


  91.     // 如果expected的內容麼有全部清空，說明丟失檔案了。
  92.     if (!expected.empty()) {
  93.       char buf[50];
  94.       snprintf(buf, sizeof(buf), "%d missing files; e.g.",
  95.                static_cast<int>(expected.size()));
  96.       return Status::Corruption(buf, TableFileName(dbname_, *(expected.begin())));
  97.     }


  100.     // 按順序逐個恢復log檔案
  101.     // Recover in the order in which the logs were generated
  102.     std::sort(logs.begin(), logs.end());
  103.     for (size_t i = 0; i < logs.size(); i++) {
  104.       s = RecoverLogFile(logs[i], edit, &max_sequence);


  107.       // The previous incarnation may not have written any MANIFEST
  108.       // records after allocating this log number. So we manually
  109.       // update the file number allocation counter in VersionSet.
  110.       versions_->MarkFileNumberUsed(logs[i]);
  111.     }


  114.     if (s.ok()) {
  115.       if (versions_->LastSequence() < max_sequence) {
  116.         versions_->SetLastSequence(max_sequence);
  117.       }
  118.     }
  119.   }


  122.   return s;
  123. }



由於DBImpl::Recover前面已經判斷過CURRENT檔案是否存在，如果不存在就建立新資料庫了，
因此這裡就是要處理新的或者曾經關閉過的資料庫。

點選(此處)摺疊或開啟

  1. Status VersionSet::Recover() {
  2.   struct LogReporter : public log::Reader::Reporter {
  3.     Status* status;
  4.     virtual void Corruption(size_t bytes, const Status& s) {
  5.       if (this->status->ok()) *this->status = s;
  6.     }
  7.   };


  10.   // Read "CURRENT" file, which contains a pointer to the current manifest file
  11.   std::string current;
  12.   // 從CURRENT檔案把當前的manifest檔名讀到字串裡current裡
  13.   Status s = ReadFileToString(env_, CurrentFileName(dbname_), &current);
  14.   if (!s.ok()) {
  15.     return s;
  16.   }


  19.   /*
  20.   CURRENT檔案應該只有一行，就是當前manifest檔名。
  21.   要求CURRENT檔案必須以換行符結尾
  22.   這樣resize後就只剩檔名了。
  23.   */
  24.   if (current.empty() || current[current.size()-1] != '\n') {
  25.     return Status::Corruption("CURRENT file does not end with newline");
  26.   }
  27.   current.resize(current.size() - 1);
  28.   
  29.   // 開啟manifest檔案
  30.   std::string dscname = dbname_ + "/" + current;
  31.   SequentialFile* file;
  32.   s = env_->NewSequentialFile(dscname, &file);
  33.   if (!s.ok()) {
  34.     return s;
  35.   }
  36.  
  37.   // 初始化logfile資訊，構建一個新的Version作為current version
  38.   bool have_log_number = false;
  39.   bool have_prev_log_number = false;
  40.   bool have_next_file = false;
  41.   bool have_last_sequence = false;
  42.   uint64_t next_file = 0;
  43.   uint64_t last_sequence = 0;
  44.   uint64_t log_number = 0;
  45.   uint64_t prev_log_number = 0;


  48.   /*
  49.   此時的current_，也就是current version是之前在建構函式里初始化的
  50.   AppendVersion(new Version(this));
  51.   在AppendVersion中會把新初始化的Version作為current version
  52.   current_ = v;
  53.   因此到builder這一步，一切都值是初始化，還沒有正式開始真正恢復操作
  54.   */
  55.   Builder builder(this, current_);


  58.   {
  59.     LogReporter reporter;
  60.     reporter.status = &s;
  61.     log::Reader reader(file, &reporter, true/*checksum*/, 0/*initial_offset*/);
  62.     Slice record;
  63.     std::string scratch;
  64.     // 解析manifest的內容，還原出上次關閉的資料庫的logfile等資訊，裝入VersionEdit
  65.     while (reader.ReadRecord(&record, &scratch) && s.ok()) {
  66.       /*
  67.       建立一個edit，要改變Version的狀態，就需要用VersionEdit
  68.       version1 + edit1 = verion2
  69.       */
  70.       VersionEdit edit;


  73.       /*
  74.       leveldb的儲存是按一定格式的，需要decode還原
  75.       將manifest中讀到的資訊decode後放入edit，後面恢復會用到。
  76.       只是概要資訊，比如新檔案，刪除了哪些檔案等。
  77.       */
  78.       s = edit.DecodeFrom(record);
  79.       if (s.ok()) {
  80.         if (edit.has_comparator_ &&
  81.             edit.comparator_ != icmp_.user_comparator()->Name()) {
  82.           s = Status::InvalidArgument(
  83.               edit.comparator_ + " does not match existing comparator ",
  84.               icmp_.user_comparator()->Name());
  85.         }
  86.       }


  89.       if (s.ok()) {
  90.         /*
  91.         將edit的內容封裝到builder裡。
  92.         */
  93.         builder.Apply(&edit);
  94.       }


  97.       if (edit.has_log_number_) {
  98.         log_number = edit.log_number_;
  99.         have_log_number = true;
  100.       }


  103.       if (edit.has_prev_log_number_) {
  104.         prev_log_number = edit.prev_log_number_;
  105.         have_prev_log_number = true;
  106.       }


  109.       if (edit.has_next_file_number_) {
  110.         next_file = edit.next_file_number_;
  111.         have_next_file = true;
  112.       }


  115.       if (edit.has_last_sequence_) {
  116.         last_sequence = edit.last_sequence_;
  117.         have_last_sequence = true;
  118.       }
  119.     }
  120.   }
  121.   delete file;
  122.   file = NULL;


  125.   if (s.ok()) {
  126.     if (!have_next_file) {
  127.       s = Status::Corruption("no meta-nextfile entry in descriptor");
  128.     } else if (!have_log_number) {
  129.       s = Status::Corruption("no meta-lognumber entry in descriptor");
  130.     } else if (!have_last_sequence) {
  131.       s = Status::Corruption("no last-sequence-number entry in descriptor");
  132.     }


  135.     if (!have_prev_log_number) {
  136.       prev_log_number = 0;
  137.     }


  140.     MarkFileNumberUsed(prev_log_number);
  141.     MarkFileNumberUsed(log_number);
  142.   }


  145.   if (s.ok()) {
  146.     // 利用builder的資訊封裝一個新的version，追加到VersionSet裡
  147.     Version* v = new Version(this);


  150.     /*
  151.     builder前面從edit裡讀了manifest檔案，
  152.     SaveTo會將從manifest檔案裡讀到的檔案新增到Version.files_裡
  153.     在開啟資料庫操作的後面步驟裡，會讀取files_裡的檔案資訊，與目錄下的實體檔案進行對照，看檔案全不全。
  154.     這個過程就是version + edit，只不過這個version是新建的空version。
  155.     最終得到的是上次關閉的資料庫version
  156.     */
  157.     builder.SaveTo(v);
  158.     // Install recovered version
  159.     // 根據各level的檔案大小計算一個“得分”，以後影響壓縮行為
  160.     Finalize(v);
  161.     // 將新封裝好的Version放到VersionSet裡，作為current version
  162.     AppendVersion(v);
  163.     manifest_file_number_ = next_file;
  164.     next_file_number_ = next_file + 1;
  165.     last_sequence_ = last_sequence;
  166.     log_number_ = log_number;
  167.     prev_log_number_ = prev_log_number;
  168.   }


  171.   return s;
  172. }


逐個恢復logfile

點選(此處)摺疊或開啟

  1. Status DBImpl::RecoverLogFile(uint64_t log_number,
  2.                               VersionEdit* edit,
  3.                               SequenceNumber* max_sequence) {
  4.   struct LogReporter : public log::Reader::Reporter {
  5.     Env* env;
  6.     Logger* info_log;
  7.     const char* fname;
  8.     Status* status; // NULL if options_.paranoid_checks==false
  9.     virtual void Corruption(size_t bytes, const Status& s) {
  10.       Log(info_log, "%s%s: dropping %d bytes; %s",
  11.           (this->status == NULL ? "(ignoring error) " : ""),
  12.           fname, static_cast<int>(bytes), s.ToString().c_str());
  13.       if (this->status != NULL && this->status->ok()) *this->status = s;
  14.     }
  15.   };


  18.   mutex_.AssertHeld();


  21.   // Open the log file
  22.   std::string fname = LogFileName(dbname_, log_number);
  23.   SequentialFile* file;
  24.   // 只讀開啟logfile
  25.   Status status = env_->NewSequentialFile(fname, &file);
  26.   if (!status.ok()) {
  27.     MaybeIgnoreError(&status);
  28.     return status;
  29.   }


  32.   // Create the log reader.
  33.   LogReporter reporter;
  34.   reporter.env = env_;
  35.   reporter.info_log = options_.info_log;
  36.   reporter.fname = fname.c_str();
  37.   reporter.status = (options_.paranoid_checks ? &status : NULL);
  38.   // We intentionally make log::Reader do checksumming even if
  39.   // paranoid_checks==false so that corruptions cause entire commits
  40.   // to be skipped instead of propagating bad information (like overly
  41.   // large sequence numbers).
  42.   log::Reader reader(file, &reporter, true/*checksum*/,
  43.                      0/*initial_offset*/);
  44.   Log(options_.info_log, "Recovering log #%llu",
  45.       (unsigned long long) log_number);


  48.   // Read all the records and add to a memtable
  49.   std::string scratch;
  50.   Slice record;
  51.   WriteBatch batch;
  52.   MemTable* mem = NULL;
  53.   /*
  54.   逐行讀取logfile
  55.   將得到的資料放入memtable mm裡
  56.   */
  57.   while (reader.ReadRecord(&record, &scratch) &&
  58.          status.ok()) {
  59.     if (record.size() < 12) {
  60.       reporter.Corruption(
  61.           record.size(), Status::Corruption("log record too small"));
  62.       continue;
  63.     }
  64.     WriteBatchInternal::SetContents(&batch, record);


  67.     if (mem == NULL) {
  68.       mem = new MemTable(internal_comparator_);
  69.       mem->Ref();
  70.     }
  71.     status = WriteBatchInternal::InsertInto(&batch, mem);
  72.     MaybeIgnoreError(&status);
  73.     if (!status.ok()) {
  74.       break;
  75.     }
  76.     const SequenceNumber last_seq =
  77.         WriteBatchInternal::Sequence(&batch) +
  78.         WriteBatchInternal::Count(&batch) - 1;
  79.     if (last_seq > *max_sequence) {
  80.       *max_sequence = last_seq;
  81.     }
  82.     
  83.     // 當memtable使用量超過設定的值時，將資料刷到level 0 資料檔案裡。
  84.     // 這樣在恢復過程中不會將記憶體撐爆
  85.     if (mem->ApproximateMemoryUsage() > options_.write_buffer_size) {
  86.       status = WriteLevel0Table(mem, edit, NULL);
  87.       if (!status.ok()) {
  88.         // Reflect errors immediately so that conditions like full
  89.         // file-systems cause the DB::Open() to fail.
  90.         break;
  91.       }
  92.       mem->Unref();
  93.       mem = NULL;
  94.     }
  95.   }


  98.   if (status.ok() && mem != NULL) {
  99.     status = WriteLevel0Table(mem, edit, NULL);
  100.     // Reflect errors immediately so that conditions like full
  101.     // file-systems cause the DB::Open() to fail.
  102.   }


  105.   if (mem != NULL) mem->Unref();
  106.   delete file;
  107.   return status;
  108. }



















來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/26239116/viewspace-1846192/，如需轉載，請註明出處，否則將追究法律責任。

相關文章