Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Symfony2 Clase 3

Introduccion al funcionamiento de Symfony
by

Tomas Cordoba

on 19 September 2012

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Symfony2 Clase 3

Lic. Tomás Córdoba cordoba.tomas@gmail.com Es un Framework PHP para la creación ágil de sitios web.

¿Porque eligir utilizar Symfony?
- Mas rápido y menos codicioso
- Flexibilidad ilimitada
- Estable y sustentable
- Fácil de usar
- Interoperable
- Innovación Introducción a Symfony 2 Arquitectura de Symfony 2 Manos a la obra! ¿Como funciona...? Routing Controladores Plantillas Boundles (paquetes) La Vista Conceptos que debemos recordar ¿Consultas? Descargar Symfony http://symfony.com/download www/ <- el directorio raíz de tu servidor web
Symfony/ <- el archivo desempacado
app/
cache/
config/
logs/
Resources/
bin/
src/
Acme/
DemoBundle/
Controller/
Resources/
...
vendor/
symfony/
doctrine/
...
web/
app.php
... Estructura de directorios de Symfony2 Symfony2 integra una interfaz visual para probar la configuración del servidor, muy útil para solucionar problemas relacionados con el servidor Web o una incorrecta configuración de PHP. Usa la siguiente url para examinar el diagnóstico: Verificando la configuración http://localhost/Symfony/web/config.php http://localhost/Symfony/web/app_dev.php/ Viendo la primera pagina web real de Symfony2 http://localhost/Symfony/web/app_dev.php/demo/hello/Tomas app_dev.php: Es un controlador frontal. Es el único punto de entrada de la aplicación, mismo que responde a todas las peticiones del usuario;
/demo/hello/Tomas: Esta es la ruta virtual a los recursos que el usuario quiere acceder.

Nuestra responsabilidad como desarrolladores es escribir el código que asigna la petición del usuario (/demo/hello/Tomas) al recurso asociado con ella (la página HTML ¡Hola Tomas!). # app/config/routing_dev.yml
_welcome:
pattern: /
defaults: { _controller: AcmeDemoBundle:Welcome:index }

_demo:
resource: "@AcmeDemoBundle/Controller/DemoController.php"
type: annotation
prefix: /demo

# ...

Las primeras tres líneas (después del comentario) definen el código que se ejecuta cuando el usuario solicita el recurso “/” (es decir, la página de bienvenida que viste anteriormente).

Cuando así lo solicites, el controlador AcmeDemoBundle:Welcome:index será ejecutado. Symfony2 encamina la petición al código que la maneja tratando de hacer coincidir la URL solicitada contra algunos patrones configurados.

De forma predeterminada, estos patrones (llamados rutas) se definen en el archivo de configuración app/config/routing.yml.

Cuando estás en el entorno dev —indicado por el controlador frontal app_dev.php— también se carga el archivo de configuración app/config/routing_dev.yml. “Controlador” es un nombre elegante para una función o método PHP que se encarga de las peticiones entrantes y devuelve las respuestas (a menudo código HTML). En lugar de utilizar variables globales y funciones PHP (como $_GET o header()) para manejar estos mensajes HTTP, Symfony utiliza objetos:

Symfony\Component\HttpFoundation\Request
Symfony\Component\HttpFoundation\Response El controlador más simple posible crea la respuesta a mano, basándose en la petición:

<?php
use Symfony\Component\HttpFoundation\Response;
$name = $request->query->get('name');
return new Response('Hello '.$name, 200, array('Content-Type' => 'text/plain')); Symfony2 elige el controlador basándose en el valor del _controller de la configuración de enrutado: AcmeDemoBundle:Welcome:index. Esta cadena es el nombre lógico del controlador, y hace referencia al método indexAction de la clase Acme\DemoBundle\Controller\WelcomeController:

// src/Acme/DemoBundle/Controller/WelcomeController.php
namespace Acme\DemoBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class WelcomeController extends Controller
{
public function indexAction()
{
return $this->render('AcmeDemoBundle:Welcome:index.html.twig');
}
} La clase WelcomeController extiende la clase integrada Controller, la cual proporciona útiles atajos a métodos, como el render() que carga y reproduce una plantilla (AcmeDemoBundle:Welcome:index.html.twig). El valor devuelto es un objeto Respuesta poblado con el contenido reproducido. Por lo tanto, si surge la necesidad, la Respuesta se puede ajustar antes de enviarla al navegador:

public function indexAction()
{
$response = $this->render('AcmeDemoBundle:Welcome:index.txt.twig');
$response->headers->set('Content-Type', 'text/plain');

return $response;
}

Pero en todos los casos, el trabajo final del controlador es devolver siempre el objeto Respuesta que será entregado al usuario. Este objeto Respuesta se puede poblar con código HTML, representar una redirección al cliente, e incluso devolver el contenido de una imagen JPG con una cabecera Content-Type de image/jpg. El nombre de la plantilla, AcmeDemoBundle:Welcome:index.html.twig, es el nombre lógico de la plantilla y hace referencia al archivo Resources/views/Welcome/index.html.twig dentro del AcmeDemoBundle (ubicado en src/Acme/DemoBundle). Symfony2 puede leer/importar la información de enrutado desde diferentes archivos escritos en YAML, XML, PHP o, incluso, incorporada en anotaciones PHP.
En este caso, el nombre lógico del recurso es @AcmeDemoBundle/Controller/DemoController.php y se refiere al archivo src/Acme/DemoBundle/Controller/DemoController.php. En este archivo, las rutas se definen como anotaciones sobre los métodos de acción:

// src/Acme/DemoBundle/Controller/DemoController.php
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;

class DemoController extends Controller
{
/**
* @Route("/hello/{name}", name="_demo_hello")
* @Template()
*/
public function helloAction($name)
{
return array('name' => $name);
}

// ...
}
La anotación @Route() define una nueva ruta con un patrón de /hello/{name} que ejecuta el método helloAction cuando concuerda. Una cadena encerrada entre llaves como {name} se conoce como marcador de posición. Como puedes ver, su valor se puede recuperar a través del argumento $name del método.

La anotación @Template() le dice a Symfony que reproduzca la plantilla por ti, pasando cada variable del arreglo a la plantilla. El nombre de la plantilla reproducida sigue al nombre del controlador. Por lo tanto, en este ejemplo, se reproduce la plantilla AcmeDemoBundle:Demo:hello.html.twig (ubicada en src/Acme/DemoBundle/Resources/views/Demo/hello.html.twig). El controlador procesa la plantilla src/Acme/DemoBundle/Resources/views/Demo/hello.html.twig (o AcmeDemoBundle:Demo:hello.html.twig si utilizas el nombre lógico):

{# src/Acme/DemoBundle/Resources/views/Demo/hello.html.twig #}
{% extends "AcmeDemoBundle::base.html.twig" %}

{% block title "Hello " ~ name %}

{% block content %}
<h1>Hello {{ name }}!</h1>
{% endblock %}

Por omisión, Symfony2 utiliza Twig como motor de plantillas, pero también puede utilizar plantillas PHP tradicionales si lo deseas. Posiblemente te hayas preguntado por qué la palabra bundle (paquete en adelante), se utiliza en muchos de los nombres que hemos visto hasta ahora. Todo el código que escribas para tu aplicación está organizado en paquetes. Hablando en Symfony2, un paquete es un conjunto estructurado de archivos (archivos PHP, hojas de estilo, JavaScript, imágenes, ...) que implementa una sola característica (un blog, un foro, ...) y que fácilmente se puede compartir con otros desarrolladores. Hasta ahora, hemos manipulado un paquete, AcmeDemoBundle Cache Para hacer que la aplicación responda más rápido, Symfony2 mantiene una caché en el directorio app/cache/. En el entorno de desarrollo (app_dev.php), esta caché se vacía automáticamente cada vez que realizas cambios en cualquier código o configuración. Pero ese no es el caso en el entorno de producción (app.php) donde el rendimiento es clave. Es por eso que siempre debes utilizar el entorno de desarrollo al estar desarrollando tu aplicación. Twig es el motor de templates default de Symfony2

http://gitnacho.github.com/Twig/


Una plantilla Twig es un archivo de texto que puede generar cualquier tipo de contenido (HTML, XML, CSV, LaTeX, ...). Twig define dos tipos de delimitadores:

{{ ... }}: Imprime una variable o el resultado de una expresión;
{% ... %}: Controla la lógica de la plantilla; se utiliza para ejecutar bucles for y declaraciones if, por ejemplo. <!DOCTYPE html>
<html>
<head>
<title>{{ page_title }}</title>
</head>
<body>
<h1>{{ page_title }}</h1>

<ul id="navigation">
{% for item in navigation %}
<li><a href="{{ item.href }}">{{ item.caption }}</a></li>
{% endfor %}
</ul>
</body>
</html>

{# Esto es un comentario #} Ejemplo $this->render('AcmeDemoBundle:Demo:hello.html.twig', array(
'name' => $name,
));

Las variables pasadas a una plantilla pueden ser cadenas, matrices e incluso objetos. Twig abstrae la diferencia entre ellas y te permite acceder a los “atributos” de una variable con la notación de punto (.):

{# array('name' => 'Fabien') #}
{{ name }}

{# array('user' => array('name' => 'Fabien')) #}
{{ user.name }}

{# obliga a verlo como arreglo #}
{{ user['name'] }}

{# array('user' => new User('Fabien')) #}
{{ user.name }}
{{ user.getName }}

{# obliga a ver el nombre como método #}
{{ user.name() }}
{{ user.getName() }}

{# pasa argumentos al método #}
{{ user.date('Y-m-d') }} La herencia de plantillas te permite crear un “esqueleto” de plantilla base que contenga todos los elementos comunes de tu sitio y define los bloques que las plantillas descendientes pueden sustituir.

La plantilla hello.html.twig hereda de base.html.twig, gracias a la etiqueta extends:

{# src/Acme/DemoBundle/Resources/views/Demo/hello.html.twig #}
{% extends "AcmeDemoBundle::base.html.twig" %}

{% block title "Hello " ~ name %}

{% block content %}
<h1>Hello {{ name }}!</h1>
{% endblock %}

La notación AcmeDemoBundle::base.html.twig suena familiar, ¿no? Es la misma notación utilizada para hacer referencia a una plantilla regular. La parte :: simplemente significa que el elemento controlador está vacío, por lo tanto el archivo correspondiente se almacena directamente bajo el directorio Resources/views/. Ahora, echemos un vistazo a un base.html.twig simplificado:

{# src/Acme/DemoBundle/Resources/views/base.html.twig #}
<div class="symfony-content">
{% block content %}
{% endblock %}
</div>

La etiqueta {% block %} define bloques que las plantillas derivadas pueden llenar. Todas las etiquetas de bloque le dicen al motor de plantillas que una plantilla derivada puede reemplazar esas porciones de la plantilla.

En este ejemplo, la plantilla hello.html.twig sustituye el bloque content, lo cual significa que el texto "Hello Fabien" se reproduce dentro del elemento div.symfony-content.

{# sustituye el bloque 'content' por embedded.html.twig #}
{% block content %}
{% include "AcmeDemoBundle:Demo:embedded.html.twig" %}
{% endblock %} {# src/Acme/DemoBundle/Resources/views/Demo/embedded.html.twig #}
Hello {{ name }}

Y cambia la plantilla index.html.twig para incluirla:

{# src/Acme/DemoBundle/Resources/views/Demo/hello.html.twig #}
{% extends "AcmeDemoBundle::base.html.twig" %}

{# sustituye el bloque 'content' por embedded.html.twig #}
{% block content %}
{% include "AcmeDemoBundle:Demo:embedded.html.twig" %}
{% endblock %} Supongamos que has creado una acción fancy, y deseas incluirla dentro de la plantilla index principal. Para ello, utiliza la etiqueta render:

{# src/Acme/DemoBundle/Resources/views/Demo/index.html.twig #}
{% render "AcmeDemoBundle:Demo:fancy" with { 'name': name, 'color': 'green' } %}

Aquí, la cadena AcmeDemoBundle:Demo:fancy se refiere a la acción fancy del controlador Demo. Los argumentos (name y color) actúan como variables de la petición simulada (como si fancyAction estuviera manejando una petición completamente nueva) y se ponen a disposición del controlador:

// src/Acme/DemoBundle/Controller/DemoController.php

class DemoController extends Controller
{
public function fancyAction($name, $color)
{
// crea algún objeto, basándose en la variable $color
$object = ...;

return $this->render('AcmeDemoBundle:Demo:fancy.html.twig', array('name' => $name, 'object' => $object));
}

// ...
} Hablando de aplicaciones web, forzosamente tienes que crear enlaces entre páginas. En lugar de codificar las URL en las plantillas, la función path sabe cómo generar URL basándose en la configuración de enrutado. De esta manera, todas tus URL se pueden actualizar fácilmente con sólo cambiar la configuración:

<a href="{{ path('_demo_hello', { 'name': 'Tomas' }) }}">Hello Tomas!</a>

{{ url('_demo_hello', {'name': 'Thomas' }) }}

Incluyendo activos: imágenes, JavaScript y hojas de estilo

<link href="{{ asset('css/blog.css') }}" rel="stylesheet" type="text/css" />

<img src="{{ asset('images/logo.png') }}" /> Introducción a Symfony2 Flujo de trabajo
1. Request de usuario
2. Matching en routing.yml
3. Procesar request en controlador
4. Generar respuesta (templating twig) Gracias! Estructura de Symfony
- app (configuracion de la aplicacion)
- src (codigo fuente de nuestra aplicacion)
- web (punto de entrada de las peticiones del usuario)
- vendor (librerias de los proveedores, core de symfony2, doctrine, twig, etc)
- bin (scripts ejecutables) Boundles (paquete de código que cumple una función)
Estructura de un bundle:
- Commands............................................. Command/
- Controllers.............................................. Controller/
- Service Container Extensions.................. DependencyInjection/
- Event Listeners....................................... EventListener/
- Configuration.......................................... Resources/config/
- Web Resources....................................... Resources/public/
- Translation files....................................... Resources/translations/
- Templates............................................... Resources/views/
- Unit and Functional Tests........................ Tests/ Otros conceptos a recordar:
- Anotaciones
- YML
- Mapeadores ORM (doctrine)
Full transcript