Before I proceed to demonstrate how the Observer pattern can be used inside a data validation application, I’m going to take a logical path and start defining some independent classes, all of them aimed at validating different types of user-supplied input.

Once these classes have been created, I’ll show you how to implement an observer object that will be able to perform an efficient validation process on the data entered by users. Considering this schema, below I listed the first set of classes that I plan to use inside the data checking application:

  // define DataValidator class

  class DataValidator{
    protected $method;
    protected $formObserver;
    public function __construct(FormObserver $formObserver){
        $this->formObserver=$formObserver;
        $this->method=$_POST;
    }
    protected function notifyObserver($errorMessage){
        $this->formObserver->addNotification($errorMessage);
    }
  }
  // define StringValidator class
  class StringValidator extends DataValidator{
    public function __construct($formObserver){
        parent::__construct($formObserver);
    }
    // validate strings
    public function validate($field,$errorMessage,$min=4,$max=32){
        if(!isset($this->method[$field])||trim($this->method
[$field])==''||strlen($this->method[$field])<$min||strlen($this-
>method[$field])>$max){
            $this->notifyObserver($errorMessage);
        }
    }
  }
  // define IntegerValidator class
  class IntegerValidator extends DataValidator{
    public function __construct($formObserver){
        parent::__construct($formObserver);
    }
    // validate integers
    public function validate($field,$errorMessage){
        if(!isset($this->method[$field])||!is_numeric($this-
>method[$field])||intval($this->method[$field])!=$this->method
[$field]){
            $this->notifyObserver($errorMessage);
        }
    }
  }
  // define NumberValidator class
  class NumberValidator extends DataValidator{
    public function __construct($formObserver){
        parent::__construct($formObserver);
    }
    // validate numbers
    public function validate($field,$errorMessage){
        if(!isset($this->method[$field])||!is_numeric($this-
>method[$field])){
            $this->notifyObserver($errorMessage);
        }
    }
  }
  // define RangeValidator class
  class RangeValidator extends DataValidator{
    public function __construct($formObserver){
        parent::__construct($formObserver);
    }
    // validate ranges
    public function validate($field,$errorMessage,$min=1,$max=99){
        if(!isset($this->method[$field])||$this->method[$field]
<$min||$this->method[$field]>$max){
            $this->notifyObserver($errorMessage);
        }
    }
  }

Okay, that’s all for the moment about the data checking classes. As you can see above, I defined a highly generic “DataValidator” class, which takes as an input parameter an object of the type “FormObserver” and then assigns it as a class property.

Please don’t worry about the meaning of this object right now, since I’ll explain later how it will fit into the whole context of the application. Pay strong attention to the additional “notifyObserver()” method, however, which will be responsible for sending the corresponding error messages to the “FormObserver” object whenever a user-supplied input is considered invalid by a particular data checking class.

As you’ll realize, after defining this base “DataValidator” class, creating a fine-tuned class to validate specific data types is indeed a straightforward process, which is reflected precisely by the definition of these classes.

With reference to the validation of specific data, you can see that I created a set of classes that check for valid strings, integers, floating numbers, and ranges respectively. In addition, when a given input fails the checking process (no matter what class is used), then the respective “notifyObserver()” method is called, in order to send a notification about the error that happened.

At this stage, even though I still didn’t show you a single clue about how an observer object can be coded inside the application, quite probably you’ve guessed its driving logic. Yes, you’re correct, when a particular user input is considered not valid by the corresponding class, a notification message will be sent to the observer, and it will decide what action to take. Now, hopefully you’re beginning to see how all these validation objects are decoupled from the application, right?

All right, now that you have taken a look at the definition of the previous classes, let’s move forward and create some additional ones to tackle the validation of alphabetic and alphanumeric data, as well as the verification of email addresses.

To see how this will be done, please read the next section.