areas

News
Projects
Software
Specifications
Tutorials

members

First Glimpse

December 8, 2004

If you're new here, and if you're not familiar with enterprise-level development concepts, then you're probably wondering what exactly phpBeans are. Either way, an introduction is only proper.

The basic concept of phpBeans is a client/server model, where objects that live on the server are accessible to the client via a TCP/IP-based protocol.

Calling objects via the phpBeans client API is almost completely transparent, the only difference being the way the objects are instantiated within the client (via the phpBeans API instead of with the usual $instance = new ObjectName () syntax).

Similarly on the server-side, creating objects (called 'beans' in phpBeans terminology) is simply a matter of writing an ordinary PHP class, with the only difference being that these classes extend a generic PHP_Bean class, and there are a few simply lines to be copied into the constructor method of each class.

With that small of a difference, your PHP applications have instantly gained a host of benefits, including:

Increased scalability. A true separation of your application logic (beans) and your publishing code (the client, usually -- but not necessarily -- a web server serving a web-based application) enables you to better scale your applications by inserting redundancies, such as load-balancing, extra hardware, optimized operating systems, into each stage of the application execution. This is referred to as an n-tier application architecture.
Increased security. By keeping your business logic a layer away from your public-facing servers, you gain more control over who can access your code and how.
Increased flexibility. Having a solid, standards-based foundation to build on means more options as your application and company needs grow. And having a well architected application structure allows you to get more out of your code, without the worries of it growing into unmanageable spaghetti code that are often associated with Open Source technologies.

Some additional benefits offered specifically by the phpBeans specification include:

Passworded access control based on a client's username and hostname/IP. You can also restrict any user to specific objects.
Introspection and auto-discovery of object and method names and descriptions.
Beans are simply ordinary PHP classes, nothing fancy or new to learn. The client API transparently mimicks the remote objects, so there really is nothing fancy or new to learn.
Beans are documented using standard phpDoc documentation syntax. Methods are only published which have an @access public tag. And because phpDoc is used by the server itself, it encourages class writers to better document their code for use by others.
Very simple object persistence layer, which enables storing and restoring of live objects in a single line of code.
Built-in access log API for better visibility into your applications and their day-to-day real-world usage.
The communication protocol is both very simple and very lightweight. Clients pass the server URI-formatted requests, and the server responds with serialized PHP data structures.
While phpBeans is admittedly a PHP-centric specification, by no means does that exclude other languages and technologies, nor does it imply that either the client or the server must be written in PHP. In fact, projects are being planned that will expand the phpBeans compatibility to other languages as well.

I'm guessing all this sounds appealing, but you'd like some proof. Well, as seeing is believing, let's have a look.

Here is a class definition for a real (but rather basic) bean object:

<?php

class Bean_Test extends PHP_Bean {
    var $values = array ();

    function Bean_Test (&$server) {
        $this->init ($server);
        $this->namespace = 'test';
        $this->addMethods (__FILE__);
    }

    /**
     * Sets a named value.
     * @access public
     * @param string
     * @param string
     */
    function set ($name, $value) {
        $this->values[$name] = $value;
    }

    /**
     * Gets a named value.
     * @access public
     * @param string
     * @return string
     */
    function get ($name) {
        return $this->values[$name];
    }
}

?>

That's all there is to a bean. Install that into a file named Test.php in the obj/ folder of your phpBeans server, restart the server, and you're ready to write some client code to access it.

A basic client that sets and then gets a value from the server would be as follows:

<?php

include_once ('phpBeans.php');

$client = new PHP_Bean_Client ('localhost', 3843, 2);
if (! $client->connect ()) {
    die ($client->error);
}

if (! $client->authenticate ('admin', 'admin')) {
    die ($client->error);
}

$test =& $client->getObject ('test');

$test->set ('foo', 'bar');

echo $test->get ('foo');

?>

That's all there is to it. If you run this script, assuming your connection parameters are correct, you should see the text 'bar' printed on the screen. This value was first sent and then retrieved from the remote object on the server, yet notice that the object used on the client-side acts just as if it was an ordinary local object. That's the phpBeans standard at work.

So as you can see, phpBeans is a powerful new option available to PHP developers, which has the potential to help usher in a new wave of enterprise-class PHP applications.

More News

Return to Top