repo_zf1/documentation/manual/es/module_specs/Zend_Application-Examples.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!-- EN-Revision: 17734 -->
    <!-- Reviewed: no -->
<sect1 id="zend.application.examples">
    <title>Ejemplos</title>

    <para>La propia clase Bootstrap suelen ser bastante mínima; a menudo, será
        simplemente un talón
        vacío ampliando la clase base bootstrap:</para>

    <programlisting language="php"><![CDATA[
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
}
]]></programlisting>

    <para>Con el archivo de configuración coresspondiente:</para>

    <programlisting language="ini"><![CDATA[
; APPLICATION_PATH/configs/application.ini
[production]
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

[testing : production]
[development : production]
]]></programlisting>

    <para>
        Sin embargo, si debiera ser necesaria un inicialización
        personalizada, usted tiene dos
        opciones. En primer lugar, usted puede
        escribir métodos prefijados con
        <emphasis>_init</emphasis>
        para
        especificar códigos distintos de arranque. Estos métodos pueden ser
        llamados por
        <methodname>bootstrap()</methodname>
        , y también pueden ser
        llamados como si fueran métodos públicos:
        <emphasis>bootstrap&lt;resource&gt;()</emphasis>
        . Deben
        aceptar opcionalmente un array de opciones.
    </para>

    <para>
        Si su método recurso devuelve un valor, será almacenado en un
        contenedor en el bootstrap.
        Esto puede ser útil cuando diferentes
        recursos necesitan interactuar (como un recurso
        inyectándose a sí mismo
        en otro). Luego, el método
        <methodname>getResource()</methodname>
        puede
        ser utilizado para recuperar esos valores.
    </para>

    <para>El siguiente ejemplo muestra un recurso de método para inicializar el
        objeto solicitado.
        Hace uso del segimiento de la dependencia (que
        depende del recurso Front Controller),
        obteniendo un recurso desde el
        bootstrap y devolver el valor para almacenar en el bootstrap.</para>

    <programlisting language="php"><![CDATA[
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initRequest(array $options = array())
    {
        // Garantizar que la instancia de front controller esté presente, y buscarla

        $this->bootstrap('FrontController');
        $front = $this->getResource('FrontController');

        // Inicializar el objeto requerido
        $request = new Zend_Controller_Request_Http();
        $request->setBaseUrl('/foo');

        // Agregarlo al front controller
        $front->setRequest($request);

        // Bootstrap guardará este valor en la clave 'request' de su contenedor
        return $request;
    }
}
]]></programlisting>

    <para>
        Nótese en este ejemplo la llamada a
        <methodname>bootstrap()</methodname>
        ; esto asegura que el front
        controller ha sido inicializado antes de llamar a este método.
        Esa
        llamada puede desencadenar tanto un recurso u otro método de la clase.
    </para>

    <para>La otra opción es usar plugins de recursos, estos son objetos que
        realizan inicializaciones
        específicas, y pueden ser especificados:</para>

    <itemizedlist>
        <listitem>
            <para>
                Cuando se instancia un onbeto de
                <classname>Zend_Application</classname>
            </para>
        </listitem>
        <listitem>
            <para>Durante la inicialización del objeto bootstrap (arranque)
           </para>
        </listitem>
        <listitem>
            <para>Habilitándolos explícitamente a través del método de llamada
                al objeto bootstrap</para>
        </listitem>
    </itemizedlist>

    <para>
        Los recursos de plugins implementan
        <classname>Zend_Application_Resource_ResourceAbstract</classname>
        ,
        que define simplemente que permitirán la inyección del llamador y
        opciones, y que tienen un
        método
        <methodname>init()</methodname>
        method.
        Como ejemplo, un recurso de una Vista (View) personalizada de bootstrap
        podría ser
        como lo siguiente:
    </para>

    <programlisting language="php"><![CDATA[
class My_Bootstrap_Resource_View
    extends Zend_Application_Resource_ResourceAbstract
{
    public function init()
    {
        $view = new Zend_View($this->getOptions());
        Zend_Dojo::enableView($view);

        $view->doctype('XHTML1_STRICT');
        $view->headTitle()->setSeparator(' - ')->append('My Site');
        $view->headMeta()->appendHttpEquiv('Content-Type',
                                           'text/html; charset=utf-8');

        $view->dojo()->setDjConfigOption('parseOnLoad', true)
                     ->setLocalPath('/js/dojo/dojo.js')
                     ->registerModulePath('../spindle', 'spindle')
                     ->addStylesheetModule('spindle.themes.spindle')
                     ->requireModule('spindle.main')
                     ->disable();

        $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper(
            'ViewRenderer'
        );
        $viewRenderer->setView($view);

        return $view;
    }
}
]]></programlisting>

    <para>Para decirle al bootstrap que utilice éste, se tendría que
        proporcionar ya sea el nombre de
        la clase del plugin del recurso, o una
        combinación del del prefijo de la ruta de carga del
        plugin y el nombre
        corto del plugin del recurso (por ejemplo, "view"):</para>

    <programlisting language="php"><![CDATA[
$application = new Zend_Application(
    APPLICATION_ENV,
    array(
        'resources' => array(
            'My_Bootstrap_Resource_View' => array(), // full class name; OR
            'view' => array(),                       // short name

            'FrontController' => array(
                'controllerDirectory' => APPLICATION_PATH . '/controllers',
            ),
        ),

        // For short names, define plugin path:
       'pluginPaths = array(
            'My_Bootstrap_Resource' => 'My/Bootstrap/Resource',
        )
    )
);
]]></programlisting>

    <para>Los recursos que son plugins puede llamar a otros recursos e
        inicializadores accediendo al
        bootstrap padre:</para>

    <programlisting language="php"><![CDATA[
class My_Bootstrap_Resource_Layout
    extends Zend_Application_Resource_ResourceAbstract
{
    public function init()
    {
        // ensure view is initialized...
        $this->getBootstrap()->bootstrap('view');

        // Get view object:
        $view = $this->getBootstrap()->getResource('view');

        // ...
    }
}
]]></programlisting>

    <para>En el uso normal, se podría instanciar la aplicación, arrancarla, y
        ejecutarla:</para>

    <programlisting language="php"><![CDATA[
$application = new Zend_Application(...);
$application->bootstrap()
            ->run();
]]></programlisting>

    <para>Para un script personalizado, se podría necesitar simplemente
        inicializar recursos
        específicos:</para>

    <programlisting language="php"><![CDATA[
$application = new Zend_Application(...);
$application->getBootstrap()->bootstrap('db');

$service = new Zend_XmlRpc_Server();
$service->setClass('Foo');  // uses database...
echo $service->handle();
]]></programlisting>

    <para>
        En lugar de utilizar el método
        <methodname>bootstrap()</methodname>
        para llamar a los métodos internos o recursos, también puede usar
        sobrecarga:
    </para>

    <programlisting language="php"><![CDATA[
$application = new Zend_Application(...);
$application->getBootstrap()->bootstrapDb();
]]></programlisting>
</sect1>