Conectarse a Zend_Amf_Server desde su proyecto Flex es bastante simple; solo necesita apuntar el final del URI a su script Zend_Amf_Server .

Por ejemplo, digamos que ya ha creado su servidor y lo ha puesto en el fichero server.php en el directorio raíz (root) de su aplicación, por lo tanto la URI es http://example.com/server.php . En este caso, usted debería modificar su fichero service-config.xml poniendo este valor como atributo al punto final del canal URI .

Si nunca ha creado un fichero service-config.xml puede hacerlo abriendo su proyecto en la ventana del navegador. Haga clic derecho sobre el nombre del proyecto y seleccione 'properties' (propiedades). En el cuadro de diálogo 'properties' del proyecto ir al menú 'Flex Build Path' (Crear ruta Flex), luego en la pestaña 'Library path' (ruta de biblioteca) asegúrese de que el fichero ' rpc.swc ' sea añadido a su ruta de proyectos y pulse Ok (Aceptar) para cerrar la ventana.

También necesitará indicarle al compilador que debe usar service-config.xml para encontrar el punto final de RemoteObject. Para hacerlo, abra de nuevo el panel de propiedades de su proyecto haciendo clic en el botón derecho sobre el proyecto en la carpeta del navegador y seleccione 'properties' (propiedades). Ahora seleccione 'Flex Compiler' (Compilador Flex) y añada la cadena: -services "services-config.xml" . Presione 'Apply' (Aplicar) y luego en OK para volver a actualizar la opción. Lo que acaba de hacer es decirle al compilador Flex que busque en el fichero services-config.xml aquellas variables que se usarán en tiempo de ejecución por la clase RemotingObject.

Ahora, para conectarnos a nuestros métodos remotos debemos indicarle a Flex qué fichero de configuración de servicios utilizar. Por esta razón creamos un nuevo fichero ' services-config.xml ' en la carpeta src del proyecto Flex. Con click derecho sobre el proyecto y seleccionando 'new'(nuevo) 'File' (fichero), se abrirá una nueva ventana. Seleccione la carpeta del proyecto y luego nombre el archivo ' services-config.xml ' y presione 'finish' (finalizar).

Flex ha creado y abierto el nuevo fichero services-config.xml . Utilice el siguiente texto de ejemplo para su fichero services-config.xml . Asegúrese de actualizar su punto final para que concuerde con el servidor. Asegúrese también de guardar el fichero.

<?xml version="1.0" encoding="UTF-8"?>
<services-config>
    <services>
        <service id="zend-service"
            class="flex.messaging.services.RemotingService"
            messageTypes="flex.messaging.messages.RemotingMessage">
            <destination id="zend">
                <channels>
                    <channel ref="zend-endpoint"/>
                </channels>
                <properties>
                    <source>*</source>
                </properties>
            </destination>
        </service>
    </services>
    <channels>
        <channel-definition id="zend-endpoint"
            class="mx.messaging.channels.AMFChannel">
            <endpoint uri="http://example.com/server.php"
                class="flex.messaging.endpoints.AMFEndpoint"/>
        </channel-definition>
    </channels>
</services-config>

Hay dos puntos clave en el ejemplo. En primer lugar, pero último en el listado, creamos un canal AMF , y especificamos el punto final como la URL a nuestro Zend_Amf_Server :

<channel-definition id="zend-endpoint"
    <endpoint uri="http://example.com/server.php"
        class="flex.messaging.endpoints.AMFEndpoint"/>
</channel-definition>

Advierta que a este canal le hemos dado un identificador, "zend-endpoint". El ejemplo crea un servicio cuyo destino hace referencia a este canal, asignándole también un ID, en este caso es "zend".

Dentro de nuestros ficheros Flex MXML , necesitamos vincular un RemoteObject al servicio. En MXML , esto podría hacerse así:

<mx:RemoteObject id="myservice"
    fault="faultHandler(event)"
    showBusyCursor="true"
    destination="zend">

Aquí, hemos definido un nuevo objeto remoto identificado por "myservice" vinculado destino de servicio "zend" que hemos definido en el fichero services-config.xml. Entonces invocamos sus métodos en nuestro ActionScript simplemente llamando a "myservice.<method>". . A modo de ejemplo:

myservice.hello("Wade");

Cuando se usan nombres-de-espacio, puede usarse "myservice.<namespace>.<method>":

myservice.world.hello("Wade");

Para más información sobre como invocar a Flex RemoteObject visite el sitio de ayuda de Adobe Flex 3 en: http://livedocs.adobe.com/flex/3/html/help.html?content=data_access_4.html .

Por defecto, todas las excepciones producidas en sus clases o funciones adjuntas serán capturados y devueltas como mensajes de error de AMF (AMF ErrorMessages). Sin embargo, el contenido de estos objetos de mensajes de error variará dependiendo de si el servidor está o no en modo "producción" (el estado por defecto).

Cuando se está en modo de producción, únicamente el código de excepción será devuelto. Si desactiva el modo de producción, algo que debe hacerse sólo para probar -- serán devueltos más detalles de la excepción: el mensaje de excepción (error), línea y backtrace serán adjuntados.

Para desactivar el modo de producción, haga lo siguiente:

$server->setProduction(false);

Para habilitarlo nuevamente, pase el valor TRUE en su lugar.

$server->setProduction(true);

Un área en la que se debe tener especialmente mucho cuidado son los errores propios de PHP . Cuando la directiva INI display_errors está habilitada, los errores de PHP de cualquier nivel del reporte actual serán pasados directamente a la salida, y potencialmente se podrían hacer estragos con las respuestas de AMF . Para prevenir estos problemas, sugerimos deshabilitar la directiva display_errors cuando se está en modo de producción.

En ocasiones es posible que quiera manipular ligeramente el objeto respuesta, es bastante usual querer devolver algunas cebeceras de mensajes adicionales. Puede hacerlo mediante el método del servidor handle() que devuelve el objeto respuesta.

$respuesta = $servidor->handle();
$respuesta->addAmfHeader(new Zend_Amf_Value_MessageHeader('foo', true, 'bar'))
echo $respuesta;

Similarmente a SOAP , AMF permite pasar objetos entre cliente y servidor. Esto le da una gran flexibilidad y coherencia a ambos entornos.

Zend_Amf ofrece tres métodos para mapear ActionScript y objetos PHP .

Aunque hemos creado ContactVO en el servidor, ahora tenemos que hacer su clase correspondiente en AS3 para que el servidor pueda mapear el objeto.

Haga clic derecho sobre la carpeta src del proyecto Flex y seleccione New -> ActionScript File. Nombre el fichero como ContactVO y pulse 'finish' (finalizar) para verlo. Copie el siguiente código en el fichero para terminar de crear la clase.

package
{
    [Bindable]
    [RemoteClass(alias="ContactVO")]
    public class ContactVO
    {
        public var id:int;
        public var firstname:String;
        public var lastname:String;
        public var email:String;
        public var mobile:String;
        public function ProductVO():void {
        }
    }
}

La clase es sintácticamente equivalente a la de PHP del mismo nombre. Los nombres de variables son exactamente los mismos y necesitan estar en el mismo contenedor para trabajar correctamente. Hay dos meta tags AS3 únicos en esta clase. El primero es vinculable y dispara un evento cuando es actualizada. El segundo es el tag RemoteClass y define que esta clase puede tener mapeado un objeto remoto con un nombre de alias, en este caso ContactVO Es obligatorio que en esta etiqueta(tag), el valor que se estableció es la clase PHP sea estrictamente equivalente.

[Bindable]
private var myContact:ContactVO;

private function getContactHandler(event:ResultEvent):void {
    myContact = ContactVO(event.result);
}

El siguiente resultado del evento debido a la llamada de servicio, se incorporó instantáneamente a ContactVO de Flex. Cualquier cosa que esté ligada a myContact será actualizada con los datos retornados por ContactVO .

Zend_Amf provides tools for mapping resource types returned by service classes into data consumable by ActionScript.

In order to handle specific resource type, the user needs to create a plugin class named after the resource name, with words capitalized and spaces removed (so, resource type "mysql result" becomes MysqlResult), with some prefix, e.g. My_MysqlResult . This class should implement one method, parse() , receiving one argument - the resource - and returning the value that should be sent to ActionScript. The class should be located in the file named after the last component of the name, e.g. MysqlResult.php .

The directory containing the resource handling plugins should be registered with Zend_Amf type loader:

Zend_Amf_Parse_TypeLoader::addResourceDirectory(
    "My",
    "application/library/resources/My"
);

For detailed discussion of loading plugins, please see the plugin loader section.

Default directory for Zend_Amf resources is registered automatically and currently contains handlers for "mysql result" and "stream" resources.

// Example class implementing handling resources of type mysql result
class Zend_Amf_Parse_Resource_MysqlResult
{
    /**
     * Parse resource into array
     *
     * @param resource $resource
     * @return array
     */
    public function parse($resource) {
        $result = array();
        while($row = mysql_fetch_assoc($resource)) {
            $result[] = $row;
        }
        return $result;
    }
}

Trying to return unknown resource type (i.e., one for which no handler plugin exists) will result in an exception.

La conexión a Zend_Amf_Server desde su proyecto Flash es ligeramente distinta a la de Flex. Sin embargo una vez que la conexión con Flash funcione con Zend_Amf_Server lo hará igual modo que con Flex. El siguiente ejemplo también puede ser utilizado desde un fichero Flex AS3 . Para nuestra conexión vamos a reutilizar la misma configuracion Zend_Amf_Server junto a la clase Mundo.

Abra Flash CS y cree un nuevo fichero Flash (ActionScript 3). Nombre al documento como ZendExample.fla y guárdelo en una carpeta que utilizará para este ejemplo. Cree una nuevo fichero AS3 en el mismo directorio y llámelo Main.as . Abra ambos ficheros con su editor. Ahora vamos a conectar las dos ficheros a través de la clase documento. Seleccione ZendExample y haga clic en el escenario. Desde el panel del escenario cambie la propiedad de la clase Document a Main. Esto vincula al fichero Main.as con la interfaz de usuario en ZendExample.fla Cuando ejecute el fichero ZendExample de Flash se ejecutará ahora la clase Main.as El paso siguiente será añadir ActionScript para hacer una lamada AMF .

Ahora vamos a hacer una clase Main(principal) para que podamos enviar los datos al servidor y mostrar el resultado. Copie el código siguiente en su fichero Main.as y luego vamos a recorrer el código para describir cuál es el papel de cada elemento.

package {
  import flash.display.MovieClip;
  import flash.events.*;
  import flash.net.NetConnection;
  import flash.net.Responder;

  public class Main extends MovieClip {
    private var gateway:String = "http://example.com/server.php";
    private var connection:NetConnection;
    private var responder:Responder;

    public function Main() {
      responder = new Responder(onResult, onFault);
      connection = new NetConnection;
      connection.connect(gateway);
    }

    public function onComplete( e:Event ):void{
      var params = "Sent to Server";
      connection.call("World.hello", responder, params);
    }

    private function onResult(result:Object):void {
      // Display the returned data
      trace(String(result));
    }
    private function onFault(fault:Object):void {
      trace(String(fault.description));
    }
  }
}

Primero tenemos que importar dos bibliotecas de ActionScript que realizan la mayor parte del trabajo. La primera es NetConnection que actúa como un tubo bidireccional entre el cliente y el servidor. La segunda es un objeto Responder que maneja los valores de retorno desde el servidor, y que están relacionados con el éxito o el fracaso de la llamada.

import flash.net.NetConnection;
import flash.net.Responder;

En la clase necesitaremos tres variables para representar a NetConnection, Responder, y la URL del gateway a nuestra instalación Zend_Amf_Server .

private var gateway:String = "http://example.com/server.php";
private var connection:NetConnection;
private var responder:Responder;

En el constructor Main creamos un Responder(respondedor) y una nueva conexión al punto final de Zend_Amf_Server . El respondedor define dos diferentes métodos para manejar la respuesta desde el servidor. Por simplicidad los hemos llamado onResult y onFault.

responder = new Responder(onResult, onFault);
connection = new NetConnection;
connection.connect(gateway);

La función onComplete se ejecuta tan pronto como la construcción ha concluido, enviando los datos al servidor. Necesitamos añadir una línea más que hace una llamada a la función Zend_Amf_Server Mundo->hola.

connection.call("Mundo.hola", responder, params);

Cuando creamos la variable responder hemos definido las funciones onResult y onFault para manejar la respuesta proveniente del servidor. Hemos añadido la función OnResult para el resultado exitoso desde el servidor. Cada vez que se ejecuta apropiadamente el manejo de conexión con el servidor, el manejador de eventos llama esta función.

private function onResult(result:Object):void {
    // Muestra los datos devueltos
    trace(String(result));
}

La función onFault, se llama si hubo una respuesta nula desde el servidor. Esto ocurre cuando hay un error en el servidor, la URL al servidor es inválida, el servicio remoto o método no existe o cualquier otra cuestión relacionada con la conexión.

private function onFault(fault:Object):void {
    trace(String(fault.description));
}

La inclusión de ActionScript para realizar la conexión remota ha finalizado. Al ejecutar el fichero ZendExample, se establece una conexión con Zend_Amf . En resumen, se han añadido las variables requeridas para abrir una conexión con el servidor remoto, se han definido qué métodos se deben utilizar cuando su aplicación recibe una respuesta desde el servidor, y finalmente se han mostrado los datos de salida devueltos a través de trace() .

Zend_Amf_Server allows you to specify authentication and authorization hooks to control access to the services. It is using the infrastructure provided by Zend_Auth and Zend_Acl components.

In order to define authentication, the user provides authentication adapter extening Zend_Amf_Auth_Abstract abstract class. The adapter should implement the authenticate() method just like regular authentication adapter .

The adapter should use properties _username and _password from the parent Zend_Amf_Auth_Abstract class in order to authenticate. These values are set by the server using setCredentials() method before call to authenticate() if the credentials are received in the AMF request headers.

The identity returned by the adapter should be an object containing property role for the ACL access control to work.

If the authentication result is not successful, the request is not proceseed further and failure message is returned with the reasons for failure taken from the result.

The adapter is connected to the server using setAuth() method:

$server->setAuth(new My_Amf_Auth());

Access control is performed by using Zend_Acl object set by setAcl() method:

$acl = new Zend_Acl();
createPermissions($acl); // create permission structure
$server->setAcl($acl);

If the ACL object is set, and the class being called defines initAcl() method, this method will be called with the ACL object as an argument. The class then can create additional ACL rules and return TRUE , or return FALSE if no access control is required for this class.

After ACL have been set up, the server will check if access is allowed with role set by the authentication, resource being the class name (or NULL for function calls) and privilege being the function name. If no authentication was provided, then if the anonymous role was defined, it will be used, otherwise the access will be denied.

if($this->_acl->isAllowed($role, $class, $function)) {
    return true;
} else {
    require_once 'Zend/Amf/Server/Exception.php';
    throw new Zend_Amf_Server_Exception("Access not allowed");
}