(Transfer) One of Yii's component mechanisms: Analysis of component base class CComponent_PHP tutorial

Yii’s component mechanism

component mechanism is the ideological essence of the entire system of Yii. Before using Yii, you should first understand its component mechanism. If you don’t understand this mechanism, then read YiiThe source code will be very laborious. The component mechanism gives infinite flexibility and scalability to the Yii framework. It is no exaggeration to say that the basic structure of the Yii framework is components. As large as CApplication objects, controllers, route managers (urlManager), as small as some other plug-ins, they all exist in the form of components.

What is the Yii component?

Almost all classes in

Yii that can be instantiated and inherit from CComponent can be called components.

What are the characteristics of components?

inherits from the CComponent class (direct inheritance or indirect inheritance), has event and behavior mechanisms, and can define its various properties in the configuration file.

How to create a component?

Write a custom class and inherit it from the CComponent class.

The

CComponent class is the base class for all components. This class is crucial in the Yii framework. Specifically, this class mainly implements the following three major functions:

1. Use the magic methods __set, __get of php to define the attributes of the class. That is to say, in addition to using the defined public member attributes, the attributes of a component can also take advantage of the functions implemented by CComponent and extend them by extending the setXXX, getXXX methods. Setting and obtaining attributes. For some special attributes, we may want to verify that the format is correct when setting it, which is more useful at this time.
class webpage extends CComponent {

public $title;

private $_url;

public function setUrl($value='') {

if(is_url($value)){

$this->_url = $value;

}

}

public function getUrl() {

return $this->_url ;

}

}

$page = new webpage();

$page->title = "page title";

$page->url = "/index.php"; # call $page->seturl("/index.php");

echo $page->url #$page->geturl();

In other words, if a component defines setXXX, getXXX, then you can use ordinary attribute access forms outside the class.

2. Also use setter, getter to implement event processing interface binding. The event mechanism is also everywhere in Yii. Yii uses a large number of event mechanisms to implement function calls between components (observer pattern).

So, how to define an event for a component? Yii specifies methods in the form of onXX, which are called events, as defined below:
class form extends CComponent {

public function onSubmit($event) {

$this->raiseEvent('onSubmit', $event);

}

}

Using the above fixed code, a onStop event is created for the car component. But what exactly is the use of binding events? The function of binding events is to notify each bound object of its own events through the event handler when the component generates a series of events. For example, we want to notify the log component of this event when the form is submitted and let it record it.

$form = new form();

$form ->attachEventHandler( 'onSubmit', array($logOjbect, "saveLog") );

$form->data = $_POST;

$form->onSubmit( new CEvent($form, array('data'=>$_POST) ) ); #Activate event execution and call event processing interface logObject ::saveLog

The code for logObject may be as follows:
class logObject {

public function saveLog($event) {

$event->sender === $form;

$event->params ;

}

}

Obviously this method is far more flexible and conceptually more advanced than the traditional method of calling.

In addition, you can use the setter method to bind events:

$form->onSubmit = array($logOjbect, "saveLog") ;

Note: The form class does not define the onSubmit member attribute.

At the same time, Yii implements a mechanism for binding multiple processing interfaces to the same event, similar to addEventListener in JavaScript.

The event handler interface Liuya uses the callback type format of php as the standard. For details, please refer to the following content: http://php.net/ manual/en/language.types.callable.php

Such as the code in CLogRouter::init() of Yii:
Yii::app()->attachEventHandler ('onEndRequest',array($this,'processLogs'));

Of course it can also be written as Yii::app()->onEndRequest = array($this,'processLogs');

The onEndRequest event is defined in CApplication:
public function onEndRequest($event){

if(!$this->_ended){

$this->_ended=true;

$this->raiseEvent('onEndRequest',$event);

}

}

It is not enough to define an event and bind a processor to the event. The event must be activated in the appropriate place, such as the logic in the CApplication::run() method:

public function run(){

if($this->hasEventHandler('onBeginRequest'))  

$this->onBeginRequest(new CEvent($this));

$this->processRequest();

if($this->hasEventHandler('onEndRequest'))

$this->onEndRequest(new CEvent($this));

}

In other words, to implement the event mechanism of the component, you need to define events, bind the event processing interface, and activate the event .

Behavior Mechanism

The behavior mechanism of

yii can be simply thought of as a component that directly uses the methods or properties of other objects (just like the traitphp 5.4 🎜>Structure, similar to behavior)

trait SayWorld {

public function sayHello() {

echo 'hello world!';

}

}

class MyHelloWorld extends Base {

use SayWorld;

}

$o = new MyHelloWorld();

$o->sayHello();

Output hello world!

A behavior is a special class that defines various events and their processing procedures. We first define a behavior class that includes events and their corresponding methods.

class MyAppBehavior extends CBehavior {

public $status = "app behavior ended.";

public function events() {

return array(

'onEndRequest' => 'appEnd', #After the specified component's onEndRequest event occurs, call the behavior's appEnd

);

}

 

public function appEnd($event = null) {

echo get_class($this);

}

}

$app->attachBehavior('myapp','MyAppBehavior');

$app->run();

echo $app->status ;

We found that behavioral methods and properties can be used directly by components.

Another common example is that we often need to filter the content input by users, such as preventing them from entering html tags. In this case, we can also consider using a behavioral mechanism to handle it.

$form = new FormModel;

If($_POST) {

$form->attributes = $_POST ;

$form->attachBehavior('myFilter', array(

'class' => '',

'strip_tags' => true ,

));

$form->filter(new CEvent($form) ) ;

}

class myHtmlFilter extends CBehavior {

public $strip_tags = false ;

public function events() {

return array(

'filter' => 'filterHtml',

);

}

public function filterHtml($event) {

if($event->sender instanceof CFormModel) {

$input = $event->sender->attributes ;

$event->sender->attributes = $this->filter($input);

}

}

public function filter(&$data) {

return is_array($data)?array_map(array($this, 'filter'),$data):strip_tags($data);

}

}

Through the above examples, you can find that the behavior method can be run directly as the normal method of the component. What is the use of behavior? I have not fully realized its advantages yet.

(reposted from: http://zhangxugg-163-com.iteye.com/blog/1673325)

Yii’s personal simple understanding
Components: Almost all classes in Yii that can be instantiated and inherit from CComponent can be called components.
Event: class method, for calling between components. It starts with on as an identifier
Behavior: a special class, for components to use directly, similar to trait characteristics

http://www.bkjia.com/PHPjc/815978.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/815978.htmlTechArticleYii’s component mechanism The component mechanism is the essence of Yii’s entire system. Before using Yii, you should first understand it. Its component mechanism, if you don’t understand this mechanism, then read the Yii source...