Actions

API16

Difference between revisions of "JObservable"

From Joomla! Documentation

(New page: <span class="editsection" style="font-size:76%;"> <nowiki>[</nowiki>Edit Descripton<nowiki>]</nowiki> </span> {{Description:JObservable}} ===Defined in==...)
 
m (Examples: fixing)
 
(One intermediate revision by one user not shown)
Line 27: Line 27:
 
|Detach an observer object
 
|Detach an observer object
 
|}
 
|}
 +
 
===Importing===
 
===Importing===
 
<source lang="php">jimport( 'joomla.base.observable' );</source>
 
<source lang="php">jimport( 'joomla.base.observable' );</source>
Line 39: Line 40:
 
<dpl>
 
<dpl>
 
  noresultsheader=\n
 
  noresultsheader=\n
 +
namespace=CodeExample
 
  category=JObservable
 
  category=JObservable
 
  category=CodeExample
 
  category=CodeExample

Latest revision as of 20:17, 4 July 2013

Replacement filing cabinet.png
This Namespace has been archived - Please Do Not Edit or Create Pages in this namespace. Pages contain information for a Joomla! version which is no longer supported. It exists only as a historical reference, will not be improved and its content may be incomplete.

[Edit Descripton] JObservable is an abstract class which allows you to simply implement a Observer/Observable pattern within an application.

In order to avoid strong dependencies between objects, which reduces reusability of the individual classes, it is common to use the Observer/Observable design pattern. The JObservable class can be used where one or more objects need to be informed when the state of another object changes. Objects derived from the JObserver class can register themselves with an object derived from the JObservable class and will be informed as required.

Contents

Defined in

libraries/joomla/base/observable.php

Methods

Method name Description
__construct Constructor
getState Get the state of the JObservable object
notify Update each attached observer object and return an array of their return values
attach Attach an observer object
detach Detach an observer object

Importing

jimport( 'joomla.base.observable' );

[Edit See Also] SeeAlso:JObservable

Examples

<CodeExamplesForm />

Example

Let's say, we want to integrate Error-Handling in our application, but we don't know yet, if we want the error to be display, logged in a file, stored to the database, or all of the above. Our goal is, to keep the object that raises the error independent of the objects that store the error message.

class MyError extends JObservable {
   public $msg = NULL;
 
   function raiseError($msg){
      $this->msg = $msg;
      //Notify all attached ErrorHandlers of the state change.
      $this->notify();
   }
}
 
//We now implement the Observers, thus the error handlers
class ErrorHandlerDisplay extends JObserver {
   function update(){
      echo $this->subject->msg;
   }
}
class ErrorHandlerFileStorage extends JObserver {
   function update(){
      error_log($this->subject->msg;);
   }
}
class ErrorHandlerDB extends JObserver {
   function update(){
      $db = JFactory::getDBO();
      $sql = "INSERT INTO #__myerrors (message) VALUES (".$db->quote($this->subject->msg).")";
      $db->setQuery($sql);
      $db->query();
   }
}
 
//Now we can use newly implemented MyError class to raise Errors.
$error = new MyError();
 
/* The constructor of the observers automatically attaches the observer to the subject
 * In our example that means that the constructor of the error handler automatically
 * attaches the handler to the MyError Object.
 */
new ErrorHandlerDisplay($error);
new ErrorHandlerFileStorate($error);
new ErrorHandlerDB($error);
 
$error->raiseError('Help!!!');
 
/*
 * Would cause 'Help!!!' to be display, logged in a file, and stored in the database.
 * You can simply add and remove the error handlers as you like
 */

What happened here? We separated the functionality of raising an error of the functionality of handling an error. In the future you can add additional ErrorHandlers, or remove some of the existing handlers, without the need to change any classes at all. Furthermore you can simply change an Errorhandler, without the need to change the MyError class. This greatly increases the reusability of your code.

This example was originally provided by Batch1211.


Chris Davenport 04:54, 17 April 2011 (CDT) Edit comment