एक समय प्रबंधक खेल में Yii के ActiveRecord का उपयोग करना

सभी को नमस्कार!

आज मैं आपको बताना चाहता हूं कि सोशल गेम टाइम मैनेजर में कैश के साथ काम कैसे लागू किया गया था। आप इस लेख को इस एक की निरंतरता मान सकते हैं।

आपको याद दिला दूं कि परियोजना php (Yii), mysql और memcached का उपयोग करती है। परियोजना में बहुत सारी संस्थाएँ हैं, जिनमें से प्रत्येक का अपना मॉडल है, जो कि कैक्टिव रेकार्ड से विरासत में मिला है।

मॉडल फ़ाइलों को निम्नानुसार संग्रहीत किया जाता है। मॉडल फ़ोल्डर में, बेस फ़ोल्डर बनाएं। जब हम Gii के माध्यम से मॉडल उत्पन्न करते हैं, तो हम संकेत देते हैं कि हमें इसे मॉडल / बेस फ़ोल्डर में डालने और बेस को वर्ग नाम में जोड़ने की आवश्यकता है। फिर हम बेस के बिना मॉडल में एक समान वर्ग बनाते हैं, जो बेस क्लास से विरासत में मिला है और इसमें केवल मॉडल () विधि है।

वैसे, मैं पहले से कहता हूं कि बेस मॉडल CActiveRecord से विरासत में नहीं मिलते हैं, लेकिन ExtActiveRecord से - हम अपनी आवश्यकताओं के लिए CActiveRecord का विस्तार करते हैं। लेकिन उस पर और बाद में। अब तक, कोई फर्क नहीं।

एक उदाहरण:
मॉडल / बेस / BaseUser.php - मानक वर्ग जो Gii के माध्यम से उत्पन्न होता है
मॉडल / User.php - एक वर्ग जो बेसयूसर से विरासत में मिला है और इसमें एक मॉडल () विधि है

/** * Returns the static model of the specified AR class. * @param string $className active record class name. * @return User the static model class */ public static function model($className=__CLASS__) { return parent::model($className); } 

इस योजना का उपयोग इसलिए किया जाता है कि मॉडल फ़ाइल के बार-बार आने की स्थिति में, आप अपना कोड नहीं खोते हैं और केवल Yii के मानक कोड के साथ स्थान को रोकना नहीं चाहते हैं।

कॉन्फ़िगरेशन में 'application.models.base। *' जोड़ना न भूलें।

चलिए पोस्ट के विषय पर चलते हैं और उन कार्यों को सेट करते हैं जिन्हें हम हल करना चाहते हैं:

1. अपडेट करने के लिए डेटाबेस में प्रश्नों की संख्या कम करें
2. चयन के लिए डेटाबेस में प्रश्नों की संख्या कम करें

अद्यतन करने के लिए डेटाबेस के लिए अनुरोधों की संख्या कम करें

जैसा कि आप पिछले लेख से याद करते हैं, हम कमांड निष्पादित करने के लिए एक कतार का उपयोग करते हैं। और किसी विशेष उपयोगकर्ता के लिए, क्रमिक रूप से 2 से अधिक कमांड निष्पादित करना आवश्यक हो सकता है। उदाहरण के लिए, हमारे पास 3 टीमों का एक पैकेट है: अनुभव में वृद्धि, एक भवन खरीदना और खिलाड़ी का नाम बदलना। मान लीजिए कि अनुभव, पैसा और नाम एक ही उपयोगकर्ता तालिका में संग्रहीत हैं।

कतार प्रसंस्करण का कार्यान्वयन ऐसा है कि टीमों को एक दूसरे के बारे में कुछ भी पता नहीं है और मानक कार्यान्वयन में, प्रत्येक टीम उपयोगकर्ता मॉडल को लोड करेगी, इसे संशोधित करेगी और इसे बचाएगी।

अब हम यह सुनिश्चित करेंगे कि उपयोगकर्ता को पहली बार एक्सेस किए जाने के बाद लोड किया गया है, और केवल सभी कमांड सहेजे जाने के बाद। ऐसा करने के लिए, हम मॉडल का एक रजिस्टर बनाएंगे।
यह एक ऐसी चीज है जिसे हम उपयोगकर्ता :: मॉडल () -> findByPk () लिखने के बजाय उपयोगकर्ता मॉडल प्राप्त करने के लिए संदर्भित करेंगे।

मॉडल रजिस्ट्री एक घटक होगी और घटकों में कॉन्फ़िगरेशन में पंजीकृत होगी

 'components' => array( // ... 'modelRegistry'=>array( 'class' => 'ModelRegistry' ) // ... ) 

वर्ग ही इस प्रकार है

 class ModelRegistry { protected $registries = array(); public function init() {} /** *     * @param string $name * @param mixed $attr * @return ExtActiveRecord */ public function & registry($name, $attr = array()) { $key = $name . md5(serialize($attr)); if (!isset($this->registries[$key])) { $model = ucfirst($name); $obj = $model::model(); if (!is_array($attr)) $attr = array($attr); $this->registries[$key] = call_user_func_array(array(&$obj, 'registry'), $attr); } //         &    return $this->registries[$key]; } /** *   */ public function saveAll() { foreach ($this->registries as $obj) { $obj->save(); } } } 

हमारे प्रत्येक मॉडल जिसे हम मॉडल रजिस्ट्री के माध्यम से प्राप्त करना चाहते हैं, उसके पास एक रजिस्ट्री पद्धति होगी जो किसी वस्तु को वापस कर देगी। इस मामले में उपयोगकर्ता इस प्रकार है

 /** * @property integer $id * @property integer $exp * @property integer $money * @property integer $name */ class User extends BaseUser { /** * Returns the static model of the specified AR class. * @param string $className active record class name. * @return User the static model class */ public static function model($className=__CLASS__) { return parent::model($className); } /** *    * @param int $userID * @return User|bool */ public function registry($userID) { if ($obj = $this->findByPk($userID)) { $res = $obj; } else { $res = false; } return $res; } } 

यह सब क्या करने के लिए नेतृत्व किया। उदाहरण के लिए, हमारे पास एक नियंत्रक है जो उपयोगकर्ता को संशोधित करने वाले दो तरीकों को कहता है।

  /** * @var ModelRegistry */ protected $reg; public function actionRun() { $userID = 1; $this->reg = &Yii::app()->modelRegistry; $this->firstChange($userID); $this->secondChange($userID); $this->reg->saveAll(); } public function firstChange($userID) { //   .         // & ,        $user = &$this->reg->registry('user', $userID); $user->exp = 10; } public function secondChange($userID) { //    ,     .     // &  $user = &$this->reg->registry('user', $userID); $user->money = 20; } 

दरअसल डेटाबेस में सेलेक्ट पर एक और अपडेट पर एक कॉल होगी।
यहां हमें एक अतिरिक्त चुनौती का सामना करना पड़ रहा है। यदि आप इस कोड को दूसरी बार कहते हैं, तो उपयोगकर्ता फ़ील्ड समान रहेंगे, लेकिन बचत अभी भी की जाएगी। हमें यह सुनिश्चित करने की आवश्यकता है कि हमारा ActiveRecord केवल तभी सहेजा जाता है जब ऑब्जेक्ट में परिवर्तन हुआ हो।

यह वह जगह है जहां हमारा एक्स्टेक्टिव रीकार्ड हमारी सहायता के लिए आता है, जिसे हम कैक्टिव रेकार्ड का विस्तार करते थे।

 class ExtActiveRecord extends CActiveRecord { protected $_oldAttributes = array(); /** *   ,       */ public function registry() {} /** *     */ public function memoryAttributes() { $this->_oldAttributes = $this->attributes; } /** *    .     *           ,   false * @return array|false */ protected function getChanges() { $res = array(); if (empty($this->_oldAttributes)) { $res = false; } else { foreach ($this->_oldAttributes as $key => $value) { if ($this->$key != $value) { $res[] = $key; } } } return $res; } /** *    * @return bool */ public function save() { if (($attr = $this->getChanges()) === false) { $res = parent::save(); } elseif ($attr) { $res = $this->update($attr); } else { $res = false; } return $res; } } 

और उपयोगकर्ता मॉडल में रजिस्ट्री पद्धति को अपडेट करें

 public function registry($userID) { if ($obj = $this->findByPk($userID)) { $res = $obj; } else { $res = false; } if ($res) { //     $res->memoryAttributes(); } return $res; } 

वास्तव में अब केवल बदले हुए मॉडल फ़ील्ड्स को सम्मिलित या अद्यतन किया जाएगा।
मैं आपको रचनात्मकता के लिए जगह छोड़ता हूं और मुझे एक नया उपयोगकर्ता बनाने और स्क्रिप्ट निष्पादन के दौरान मॉडल रजिस्ट्री में डालने का तरीका बताता हूं।

मैंने आपको दिखाया कि रजिस्ट्री में किसी भी ऑब्जेक्ट को कैसे स्टोर किया जाए। लेकिन कभी-कभी ऐसे हालात पैदा हो जाते हैं जब हमें वहां एक सूची जमा करनी होती है। उदाहरण के लिए, प्रत्येक उपयोगकर्ता के लिए हमारे पास 10 कारें हैं। और हम चाहते हैं कि रजिस्ट्री में 10 कारें न हों, लेकिन एक वस्तु जिसमें सभी मशीनें हों। ऐसा करने के लिए, मॉडललिस्ट क्लास का उपयोग करें, जो मशीन मॉडल स्टोर करता है।

 class ModelList { /** * @var array   ExtActiveRecord */ public $list = array(); /** *    * @param array|bool $list   ExtActiveRecord * @return ModelList */ public static function make($list = array()) { if (!is_array($list) && empty($list)) { $list = array(); } $obj = new ModelList(); $obj->list = $list; return $obj; } /** *     * @param ExtActiveRecord $obj */ public function pushObject($obj) { $this->list[] = $obj; } /** *      * @param string $name */ public function callMethod($name) { foreach ($this->list as &$obj) { $obj->$name(); } } /** *    */ public function save() { $this->callMethod('save'); } } 

और यहाँ एक मॉडल कार है

 <?php /** * @property integer $id * @property integer $user_id * @property integer $car_id * @property integer $speed */ class Car extends BaseCar { /** * Returns the static model of the specified AR class. * @param string $className active record class name. * @return Car the static model class */ public static function model($className=__CLASS__) { return parent::model($className); } /** *      * @param int $userID * @return ModelList */ public function registry($userID) { $list = $this->findAllByAttributes(array('user_id'=>$userID)); $res = ModelList::make($list); //      $res->callMethod('memoryAttributes'); return $res; } /** * ,   . ,      ModelList  pushObject * @param int $userID * @param int $carID * @return Car */ public static function make($userID, $carID) { $obj = new Car(); $obj->user_id = $userID; $obj->car_id = $dict->area_id; $obj->speed = 10; return $obj; } } 

वास्तव में अब, जब हम निम्नलिखित कोड निष्पादित करते हैं,

 $carList = &Yii::app()->modelRegistry->registry('car', 1); 

फिर हमें मॉडललिस्ट क्लास की एक वस्तु मिलती है, जिसमें खिलाड़ी की सभी मशीनें होंगी। उन्हें बदला भी जा सकता है ($ carList-> सूची में लिंक पर क्लिक करने के लिए भूलकर) और फिर मानक saveAll के साथ मॉडल रजिस्ट्री के माध्यम से बचाया।

चूंकि लेख काफी बड़ा है, इसलिए मैं अगले लेख में यह सब कैशिंग के बारे में बात करूंगा।
मैं कह सकता हूं कि कैशिंग के साथ आदर्श परिस्थितियों में, यह कार्यान्वयन एक ही डेटा के लिए दो बार लागू नहीं होता है, भले ही यह पहली बार के बाद अपडेट किया गया हो।

मॉडल के साथ काम करने का यह विकल्प हमारी परियोजना में आसानी से उपयोग किया जाता है, लेकिन यह आपके अनुरूप नहीं हो सकता है।
मैं बस इतना करना चाहता था कि यह दिखाया जाए कि क्या कार्य हैं और उन्हें कैसे हल किया जा सकता है।