sábado, 29 de noviembre de 2014

Hola mundo!

En muchas ocasiones, cuando empezados a realizar nuestra primera aplicación en algún lenguaje de programación, nos enseñan a mostrar un texto muy básico... El mítico Hola Mundo!

En este caso, en nuestra aplicación vamos a crear una nueva página llamada "hola", por lo que tendremos que crear una vista y un controlador que realicen:
  • la aplicación despachará la página solicitada a la acción
  • y la acción devolverá la vista con el mensaje "Hola mundo!"

Creando la Acción

Crearemos una acción llamada decir que recibirá un parámetro de nombre mensaje. El mensaje recibido en el parámetro será el que se muestre. Si no se recibe ningún valor, se desplegará por defecto Hola Mundo! 

Si hemos trabajado antes con Yii en su versión 1, recordaremos que los controladores agrupan a las acciones. Por ahora, utilizaremos unos de los controladores ya existentes, el SiteController.

Localizamos el archivo
basic/controllers/SiteController.php
y añadimos el siguiente código:

    public function actionDecir($mensaje 'Hola Mundo!')
    {
        return $this->render('decir', ['mensaje' => $mensaje]);
    }

Dentro de nuestra clase de controlador SiteController hemos añadido la acción decir como un método de nombre actionDecir. Al igual que en la versión 1, Yii utiliza el prefijo action para cada identificador de las acciones.

El código en si mismo no es difícil de comprenderlo. Recibimos el parámetro mensaje cuyo valor por defecto es Hola Mundo!

El método render() devuelve la vista decir, a la cual le pasa el parámetro mensaje para que pueda ser utilizado por la misma.

Cuando demos nombre a nuestras acciones, debemos entender cómo trata Yii a los identificadores de las acciones. Un identificador de acción siempre es referenciado en minúsculas. Si se requiere de múltiples palabras, se debe separar con guiones (por ejemplo, crear-comentario). Los nombres de los métodos de las acciones son mapeados removiendo todos los guiones, colocando en mayúscula la primera letra de cada palabra y añadiendo el prefijo action. Por ejemplo, la acción crear-comentario se corresponde con el método actionCrearComentario.

Creando la Vista

Las vistas son escritas para generar el contenido de respuesta.

Continuando con nuestro ejercicio, crearemos el archivo
views/site/decir.php
con el siguiente contenido:

<?phpuse yii\helpers\Html;?>
<?= Html::encode($mensaje?>

Hay que notar que utilizamos Html::encode antes de mostrar el mensaje. Esto es necesario porque el parámetro proviene de un usuario final, y se puede sufrir de un ataque cross-site scripting (XSS) al recibir código malicioso JavaScript en el parámetro.

Obviamente podemos añadir código adicional a nuestra vista, como texto plano, código PHP, tags HTML.

Probando

Escribiendo la url http://hostname/index.php?r=site/decir obtenemos un resultado como el siguiente:




En este caso no hemos pasado el parámetro mensaje y se ha mostrado el texto por defecto. Pero si escribimos algo como http://hostname/index.php?r=site/decir&mensaje=Mi+propio+mensaje se presenta algo similar a ésta imagen:



Hasta aquí hemos dado un vistazo a lo que es MVC, aunque en éste ejemplo no hemos utilizado un modelo. Conforme avancemos iremos profundizando en todos estos temas.


También te puede interesar:
Instalando Yii 2
Funcionamiento y Arquitectura de Yii 2
Trabajando con bases de datos

Funcionamiento y Arquitectura de Yii 2

Como hemos visto, luego de instalar Yii accedemos a nuestra aplicación a través de la url http://hostname/basic/web/index.php o http://hostname/index.php, dependiendo de la configuración de nuestro servidor. Recordemos que en este caso, basic es el nombre de nuestra aplicación.

Funcionalidad

Al instalar Yii 2, nuestra aplicación básica tiene cuatro páginas:
  1. La página de inicio
  2. La página "About" (Acerca de)
  3. La página "Contact" (Contacto) que despliga un formulario de contacto.
  4. La página "Login" (Ingreso) que permite ingresar nuestro nombre de usuario y clave.
Éstas paginas comparten una cabecera y un pie de página. La cabecera contiene un menú principal que permite navegar entre las diferentes páginas.

Hasta aquí, se parece mucho a la versión 1.

En ésta nueva versión, en la parte inferior del navegador tenemos una barra de herramientas con información útil que nos permite depurar nuestra aplicación. Podemos ver mensajes, estatus, consultas a la base en ejecución, y más.

Estructura de la aplicación

Como habíamos mencionado, basic es el nombre de nuestra aplicación. Partiendo de éste directorio, nuestra estructura de directorios y archivos sería:

basic/                  directorio principal de la aplicación
    composer.json       usado por Composer, información del paquete
    config/             contiene configuraciones
        console.php     configuración de la consola de aplicaciones
        web.php         configuración de la aplicación web
    commands/           contiene clases de la consola de comandos
    controllers/        contiene los controladores
    models/             contiene los modelos
    runtime/            contiene archivos generados por Yii durante                           el tiempo de ejecución, como archivos logs                            y de caché
    vendor/             contiene paquetes instalados por Composer,                            incluyendo el framework Yii en sí mismo
    views/              contiene las vistas
    web/                raíz de la nuestra aplicación Web,                                    contiene los archivos accesibles
        assets/         contiene archivos publicados por Yii                                  (javascript y css)
        index.php       script de entrada a la aplicación (bootstrap)
    yii                 script de ejecución de la                                             consola de comandos  Yii

En general, los archivos pueden ser divididos en dos tipos:  los que están bajo el directorio basic/web y los que están en otro directorios. A los primeros se puede acceder vía HTTP (un navegador web), mientras que los segundos no pueden y no deberían ser accesibles.

Al igual que en la versión 1, Yii implementa el patrón de diseño Modelo-Vista-Controlador (MVC). El siguiente diagrama muestra la estructura estática de una aplicación.



Cada aplicación tiene un script de entrada web/index.php que debe ser el único accesible. El script de entrada toma la petición de entrada y crea una instancia de la aplicación. La aplicación resuelve la petición con ayuda de sus componentes, y despacha la petición a los elementos MVC. Los widgest son utilizados en las vistas para ayudar a construir interfaces de usuario más complejas y dinámicas.

Ciclo de vida de una petición

Al realizar una petición se siguen los siguientes pasos:

  1. Un usuario realiza una petición a través del script de entrada web/index.php
  2. El script de entrada llama a la configuración de la aplicación y crea una instancia de la aplicación que maneje la petición.
  3. La aplicación resuelve la petición con ayuda de sus componentes.
  4. La aplicación crea una instancia de controlador para manejar la petición.
  5. La aplicación crea una instancia de acción y ejecuta los filtros para la acción.
  6. Si cualquier filtro falla, la acción es cancelada.
  7. Si todos los filtros pasan, la acción es ejecutada.
  8. La acción llama a un modelo, posiblemente de base de datos.
  9. La acción devuelve (renderiza) una vista, junto con el modelo de datos.
  10. El resultado proveído (renderizado) se devuelve al componente de aplicación de respuesta.
  11. El componente de respuesta envía el resultado proveído (renderizado) al navegador del usuario.

La siguiente imagen describe gráficamente éstos pasos.



También te puede interesar:
Instalando Yii 2
Configurando el servidor web
Yii Framework 2

Configurando el servidor web

Después de instalar Yii, podemos acceder a través de la url http://hostname/basic/web/index.php pero seguramente queremos que la url de acceso sea similar a http://hostname/index.php. Para ello, debemos realizar la configuración de manera que el documento raíz apunte al directorio basic/web. Recordemos que basic es el nombre de nuestro proyecto. También podemos necesitar ocultar el archivo index.php

Al configurar la ruta basic/web como la raíz, también prevenimos que los usuarios finales accedan al código privado de nuestra aplicación y archivos sensibles. El negar el acceso a éste directorio es una mejora de seguridad.

Si estamos ejecutando nuestra aplicación en un ambiente de hosting compartido y no tenemos permiso para modificar la configuración del servidor web, debemos considerar ajustar la estructura de nuestra aplicación para tener una mejor seguridad. En la entrada Ambiente de hosting compartido tendremos más detalles. (próximamente).

Configuración Apache recomendada

Modificando el archivo httpd.conf de Apache podemos cambiar la manera de acceder a nuestra aplicación.

En este archivo, debemos buscar  DocumentRoot (que no esté comentado con #) y actualizar el path al nuestro apuntando a basic/web.

En mi caso, localmente utilizo EasyPHP 14.1. Modifiqué
DocumentRoot "${path}/data/localweb"
por
DocumentRoot "${path}/data/localweb/projects/basic/web"

También hay un añadir un tag <Directory> con el siguiente contenido:
<Directory "${path}/data/localweb/projects/basic/web">
    # use mod_rewrite for pretty URL support
    RewriteEngine on
    # If a directory or a file exists, use the request directly
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d
    # Otherwise forward the request to index.php
    RewriteRule . index.php
</Directory>

Es posible que tengamos que modificar VirtualHost que también tiene DocumentRoot y Directory. Solo hay que actualizarlos con el path apuntando a nuestro directorio basic/web.
Nos queda algo similar a lo siguiente:
<VirtualHost 127.0.0.1>
DocumentRoot "${path}/data/localweb/projects/basic/web"
ServerName 127.0.0.1
<Directory "${path}/data/localweb/projects/basic/web">
Options FollowSymLinks Indexes
AllowOverride All
Order deny,allow
Allow from 127.0.0.1
Deny from all
Require all granted
</Directory>
</VirtualHost>



También te puede interesar:
Instalando Yii 2
Funcionamiento y Arquitectura de Yii 2
Yii Framework 2

domingo, 23 de noviembre de 2014

Instalando Yii 2

Se puede instalar Yii 2, de dos maneras diferentes. Utilizando Composer o por descarga. La primera es la preferida, ya que permite instalar extensiones o actualizaciones con un simple comando.

Instalación usando Composer

Desde el siguiente link se puede descargar tanto para Linux, Mac OS X o Windows: descargar composer.
En dicha página constan los comandos y opciones para Linux. O el enlace de descarga para el ejecutable en el caso de Windows. También hay los correspondientes manuales.

En Windows, descargamos el archivo Composer-Setup.exe y ejecutamos el instalador siguiendo las instrucciones.



Uno de los problemas que tuve, es que Composer valida que la extensión OpenSSL de PHP esté habilitada. Si tienen el mismo error se les presentará un mensaje de error que dice:
Some settings on your machine make Composer unable to work properly.
Make sure that you fix the issues listed below and run this script again:
The openssl extension is missing, which means that secure HTTPS transfers are impossible.
If possible you should enable it or recompile php with --with-openssl

No es difícil corregirlo. Solo hay que retroceder un paso, activar la extensión php_openssl.dll en el archivo de configuración de PHP (php.ini) y volver a intentar la instalación. Esta vez no habrá problemas.

Por otro lado, necesitamos una cuenta en GitHub. Es gratuito.

Luego debemos abrirnos una ventana de consola (cmd), e ir al directorio en el cual queremos instalar nuestra aplicación Yii, el cual debe ser accesible desde nuestro servidor web.

Ejecutamos el comando:
composer global require "fxp/composer-asset-plugin:1.0.0-beta3"



Este comando lo hay que ejecutar una sola vez, el cual instala el plugin que permite administrar las dependencias a través de Composer.

Luego, ejecutamos el siguiente comando:
composer create-project --prefer-dist yiisoft/yii2-app-basic basic
Este comando lo utilizamos para instalar Yii en un directorio llamado basic. Si queremos otro directorio, debemos escribir el adecuado a nuestras necesidades.


Cuando nos solicite el username y el password debemos utilizar los de nuestra cuenta de GitHub.

También es posible tener la última versión de desarrollo de Yii. Recordemos que la versión de desarrollo no debe ser utilizada en producción, o nuestros ambientes definitivos. Solo debe ser utilizada para pruebas. El comando que debemos seguir es el siguiente:
composer create-project --prefer-dist --stability=dev yiisoft/yii2-app-basic basic

Verificando la instalación

Después de haber realizado estos pasos, podemos ir a nuestro navegador web para probar. Escribimos la dirección similar a la siguiente:

http://127.0.0.1/projects/basic/web/

donde:
127.0.0.1 es mi servidor web, que en este caso estoy trabajando de forma local en mi computadora.
projects es el directorio en el cual se alojan mis proyectos y depende del servidor web que utilicemos. En otros casos suele ser www. O en otros casos no requiere.
basic es el directorio en el cual está nuestra aplicación y es el que especificamos anteriormente como basic
web es el subdirectorio de yii desde el cual se inicia la aplicación.

Si todo es correcto, veremos una pantalla como la de la imagen:


Posibles errores en la instalación de Yii 2

A pesar de haber realizado los pasos tal cual se describen aquí, es posible que obtengamos algún error como el siguiente:

Warning: require(D:\Archivos de programa\EasyPHP-DevServer-14.1VC9\data\localweb\projects\yii2\basic\web/../vendor/autoload.php): failed to open stream: No such file or directory in D:\Archivos de programa\EasyPHP-DevServer-14.1VC9\data\localweb\projects\yii2\basic\web\index.php on line 7

Fatal error: require(): Failed opening required 'D:\Archivos de programa\EasyPHP-DevServer-14.1VC9\data\localweb\projects\yii2\basic\web/../vendor/autoload.php' (include_path='.;C:\php\pear') in D:\Archivos de programa\EasyPHP-DevServer-14.1VC9\data\localweb\projects\yii2\basic\web\index.php on line 7

En este caso hay que revisar que tengamos el archivo autoload.php; y es muy probable que no le tengamos. Simplemente hay que borrar todos los archivos y el directorio en el cual íbamos a instalar yii y repetir nuestro segundo comando (el primero ya no es necesario), es decir:
composer create-project --prefer-dist --stability=dev yiisoft/yii2-app-basic basic

Durante la instalación debemos ver que descarga varios paquetes al 100%.



Luego podemos volver a probar a través de nuestro navegador web.

Instalando desde un archivo

También se puede instalar Yii 2 desde un archivo y para ello hay que seguir estos pasos:

  1. Descargar el archivo desde el sitio web de Yii Framework.
  2. Descomprimir el archivo descargado en una directorio web accesible.
  3. Modificar el archivo config/web.php ingresando una clave secreta para la configuración de cookieValidationKey (Utilizando Composer, esto es automático)

// !!! insert a secret key in the following (if it is empty) - this is required by cookie validation'cookieValidationKey' => 'enter your secret key here',
Nuestra clave secreta la debemos escribir en lugar de enter your secret key here


Otras opciones de instalación

Las formas de instalación vistas nos ayudan a tener un esqueleto de nuestra aplicación web, útil para aprender Yii 2 o proyectos pequeños. Otras opciones disponibles que se pueden considerar son:

  • Si se requiere instalar el framework completo (el core o núcleo) y construir una aplicación completa desde cero, se pueden seguir las instrucciones de la entrada La construcción de aplicaciones desde cero (próximamente).
  • Si se necesita iniciar con una aplicación más sofisticada, más adecuada a equipos en ambientes de desarrollo, se puede revisar la entrada Plantilla de aplicación avanzada (próximamente).


Revisando requerimientos

Si durante la verificación de la instalación no se presenta la página de "Congratulations" se debe revisar que se cumplen con los requisitos mínimos para el funcionamiento de Yii.

Se puede acceder a la URL http://127.0.0.1/projects/basic/requirements.php en la cual se nos presentará una pantalla con todos los detalles. Los requisitos que se cumplen y los que fallan; así como la conclusión.



Otra manera es ejecutar el comando:

cd basic
php requirements.php


Lo más importante es que por lo menos sea la versión de PHP 5.4 la que utilizamos. Y habilitar la extensión PDO y el correspondiente driver de la base de datos que vayamos a utilizar (si vamos a utilizar una).

Instalando Yii 2 en producción

Como habremos notado, hay un subdirectorio llamado web que debemos añadir en nuestra dirección url si queremos acceder a nuestro archivo index.php y toda nuestra aplicación. Seguramente, en nuestro ambiente de producción ya no queremos que aparezca este subdirectorio, incluso tal vez sea nuestra intención ocultar el archivo index.php. El cómo instalar Yii 2 en producción lo podemos revisar en Configurando el servidor web



También te puede interesar:
Yii Framework 2
Configurando el servidor web

martes, 18 de noviembre de 2014

Actualizando Yii desde la versión 1 (Parte II)

Como habíamos mencionado anteriormente, las diferencias entre las versiones 1 y 2 son algunas, ya que la versión 2 ha sido totalmente reescrita. Así que actualizar desde la versión 1 no es algo trivial. Continuando con las diferencias tenemos:

Aplicaciones de Consola

Las aplicaciones de consola ahora están organizadas como controladores, como una aplicación web. Los controladores de consola se extienden  yii\console\Controller, similar a CConsoleCommand de la versión 1.

Para ejecutar un comando de consola se utiliza yii <route>, where <route> es la ruta de un controlador (ejemplo: sitemap/index)

 I18N

Yii 2 deja de lado todo el formato de fechas y números incorporados en favor del paquete  PECL intl PHP.

La traducción de mensajes ahora se realiza a través del componente i18n. Este componente administra un conjunto de mensajes fuente, que permite usar diferentes mensajes distribuidos en categorías.

Filtros de Acción  

Los filtros de acción (los filtros que definíamos en el controlador), ahora se implementan a través de los comportamientos (behaviors). Para definir uno nuevo, se extiende de yii\base\ActionFilter. Por ejemplo, para utilizar el filtro yii\filters\AccessControl se debe escribir el siguiente código en un controlador.

public function behaviors()
{
    return [
        'access' => [
            'class' => 'yii\filters\AccessControl',
            'rules' => [
                ['allow' => true'actions' => ['admin'], 'roles' => ['@']],
            ],
        ],
    ];
}

Assets

Yii 2 introduce un nuevo concepto llamado asset bundle que reemplaza el concepto de paquetes de script de la versión 1.

Un asset bundle es un conjunto de archivos (por ejemplo: archivos JavaScript, hojas de estilo CSS, imágenes) dentro de un directorio. Cada asset bundle se representa como una clase que se extiende de yii\web\AssetBundle. Se registra vía yii\web\AssetBundle::register().

Helpers

Yii 2 introduce algunas de las clases helper (asistentes) comúnmente utilizadas, incluyendo:

  • yii\helpers\Html
  • yii\helpers\ArrayHelper
  • yii\helpers\StringHelper
  • yii\helpers\FileHelper
  • yii\helpers\Json


Formularios

Yii 2 introduce el concepto de field (campo) para construir un formulario utilizando yii\widgets\ActiveForm. Un field es un contenedor compuesto de una etiqueta, una entrada, un mensaje de error y/o un texto de indicio (hint). Un formulario se puede construir más limpiamente, algo similar a:

<?php $form yii\widgets\ActiveForm::begin(); ?>
    <?= $form->field($model'username'?>
    <?= $form->field($model'password')->passwordInput() ?>
    <div class="form-group">
        <?= Html::submitButton('Login'?>
    </div>
<?php yii\widgets\ActiveForm::end(); ?>


Query Builder (Constructor de Consultas)

En la versión 1 utilizábamos una serie de clases para construir nuestras sentencias, que incluía el uso de  CDbCommand, CDbCriteria, y CDbCommandBuilder. Yii 2 representa una consulta en términos de un objeto Query. Por ejemplo:

$query = new \yii\db\Query();
$query->select('id, name')
      ->from('user')
      ->limit(10);
$command $query->createCommand();
$sql $command->sql;
$rows $command->queryAll();

Active Record (Registro Activo)

Yii 2 introduce muchos cambios a nivel del Registro Activo. Los más obvios es el Query Builder y el manejo de consultas relacionadas. En la versión 1 la clase utilizada era CDbCriteria. En ésta nueva versión se utiliza yii\db\ActiveQuery la cual es una extensión de yii\db\Query. Una consulta sería:

$customers Customer::find()
    ->where(['status' => $active])
    ->orderBy('id')
    ->all();

Para declarar una relación, se define un método que retorne un objeto tipo ActiveQuery . Por ejemplo:

class Customer extends \yii\db\ActiveRecord{
    public function getOrders()
    {
        return $this->hasMany('Order', ['customer_id' => 'id']);
    }
}

De esta manera se puede utilizar  $customer->orders para acceder a las órdenes de compra de un cliente. También se puede usar el siguiente código para realizar una consulta relacionada condicionada:

$orders $customer->getOrders()->andWhere('status=1')->all();

En general, la manera de ejecutar las consultas no es muy diferente, aunque en Yii 2 se optimiza la manera de obtener los resultados con el fin de reducir significativamente el tiempo de CPU y la memoria, especialmente con una gran cantidad de registros, como por ejemplo al ejecutar:

$customers Customer::find()->asArray()->all();

Otro cambio es que no se puede definir un valor por defecto de los atributos a través de las propiedades públicas. Para poder realizar ésto, se lo debe hacer en el método init.

public function init()
{
    parent::init();
    $this->status self::STATUS_NEW;
}

Algunos problemas de la versión 1 al sobreescribir el constructor ya no se encuentran en la versión 2. Otros cambios y mejoras se las verá en entradas posteriores.

Active Record Behaviors (Comportamiento del Registro Activo)

La clase CActiveRecordBehavior ha sido eliminada en la versión 2. Para crear un Active Record Behavior, hay que extenderlo directamente de yii\base\Behavior. Si el behavior necesita responder a un evento en particular, hay que sobreescribir el método events(). Por ejemplo:

namespace app\components;

use yii\db\ActiveRecord;
use yii\base\Behavior;

class MyBehavior extends Behavior{
    // ...

    public function events()
    {
        return [
            ActiveRecord::EVENT_BEFORE_VALIDATE => 'beforeValidate',
        ];
    }

    public function beforeValidate($event)
    {
        // ...
    } 
}

Usuarios e Interfaces de Identidad

La clase CWebUser utilizada en la versión 1, es reemplazada por yii\web\User, y ya no hay la clase CUserIdentity. Ahora se debe implementar yii\web\IdentityInterface que es mucho más sencillo de usar. Las plantillas proveen un ejemplo, aunque conforme avancemos en la revisión de ésta versión, en las entradas se irá viendo acerca de Autentificación, Autorización y Técnicas de Aplicaciones Avanzadas.

Administración de URL

El administrador de URLs de la versión 2 es similar al de la versión 1. Una mejora es que ahora soporta parámetros. Por ejemplo, se puede tener una regla que hace coincidir post/popular con post/1/popular. En la versión 1 se requiere de dos reglas para este objetivo, mientras que en la nueva versión quedaría algo como lo siguiente:

[
    'pattern' => 'post/<page:\d+>/<tag>',
    'route' => 'post/index',
    'defaults' => ['page' => 1],
]


También te puede interesar:
Actualizando Yii desde la versión 1 (Parte I)

domingo, 9 de noviembre de 2014

Actualizando Yii desde la versión 1 (Parte I)

Las diferencias entre las versiones 1 y 2 son algunas, ya que la versión 2 ha sido totalmente reescrita. Así que actualizar desde la versión 1 no es algo trivial.

Mi recomendación... Inicia desde cero con Yii 2!

A continuación las diferencias entre ambas versiones para que las tomes muy cuenta si definitivamente quieres migrar.

Instalación

Yii 2 es muy cercano de Composer, ya que es el administrador de paquetes de facto para PHP. La instalación del core como de las extensiones se las realiza a través de Composer.

Requerimientos de PHP

Yii 2 necesita de PHP 5.4, mientras que Yii 1 requiere de la 5.2. Las diferencias entre las versiones de PHP incluyen:

  • Namespaces o Espacios de nombres: es un conjunto de nombres en el cual todos los nombres son únicos.
  • Funciones anónimas: también conocidas como clausuras (closures), permiten la creación de funciones que no tienen un nombre especificado. Son más útiles como valor de los parámetros de llamadas de retorno.
  • Sintaxis de arreglos corta: se utiliza [...elementos...] en lugar de array(...elementos...)
  • Tags echo corto: en las vistas se utiliza <?=
  • Interfaces y clases SPL: La Biblioteca Estándar de PHP (SPL por sus siglas en inglés) es una colección de interfaces y clases que están pensadas para solucionar problemas comunes.
  • Enlace estático en tiempo de ejecución: permite hacer referencias a la clase en uso dentro de un contexto de herencia estática.
  • Fecha y hora
  • Traits: o rasgos, son un mecanismo de reutilización de código en lenguajes de herencia simple, como PHP.
  • intl: Yii 2 utiliza ésta extensión de PHP para soporte de funciones de internacionalización


Espacios de nombres

En Yii 1 se utiliza el prefijo "C" para los nombres de las clases. En Yii se utiliza la estructuras de directorios. Por ejemplo, yii\web\Request indica que la clase está en web/Request.php bajo el directorio de Yii.

Es posible utilizar cualquier clase sin ser explícitos, gracias a la clase loader de Yii.

Componentes y Objetos

Yii 2 divide la clase CComponent en dos clases:  yii\base\Object y yii\base\Component. La clase Object es una clase base más ligera que permite definir propiedades haciendo uso de getters (para obtener datos) y setters (para inicializar). La clase Component extiende Object y soporta events (eventos) y behaviors (comportamientos).

Configuración de Objetos

La clase Object introduce una manera uniforme de configurar objetos. Cualquier clase descendiente debería declarar su constructor de la siguiente manera:

class MyClass extends \yii\base\Object{
    public function __construct($param1$param2$config = [])
    {
        // ... initialization before configuration is applied

        parent::__construct($config);
    }

    public function init()
    {
        parent::init();

        // ... initialization after configuration is applied
    }
}

 Siguiendo ésta convención, para crear y configurar nuevos objetos la manera adecuada sería:

$object Yii::createObject([
    'class' => 'MyClass',
    'property1' => 'abc',
    'property2' => 'cde',
], [$param1$param2]);

Eventos

En Yii 1, los eventos se definían a través de un método con el prefijo on (por ejemplo, onBeforeSave). En Yii 2 se puede utilizar cualquier nombre de evento. Para disparar un evento se llama al método trigger():

$event = new \yii\base\Event;$component->trigger($eventName$event);
Para adjuntar un manejador a un evento, se utiliza el método on().

$component->on($eventName$handler);// To detach the handler, use:
// $component->off($eventName, $handler);

Alias de Rutas

Yii 2 extiende el uso de los alias, tanto a los directorios/archivos como a las URLs.

Vistas

El cambio más significativo en Yii 2 es acerca de la variable $this. En una vista, ya no hace referencia al controlador o widget, sino que ahora se refiere a un objeto view. El objeto view es del tipo yii\web\View que representa la parte del diseño MVC. Para acceder al controlador o widget desde la vista, se debe utilizar $this->context

Para renderizar una vista parcial dentro de otra vista se debe utilizar $this->render(), y no $this->renderPartial(). La llamada a render ahora tiene que ser explícita a través de echo. Por ejemplo:

echo $this->render('_item', ['item' => $item]);

Modelos

Yii 2 utiliza como la clase modelo base a yii\base\Model. La clase CFormModel ha sido eliminada completamente, por lo que, en Yii 2 se debe utilizar yii\base\Model para crear un modelo de formulario.

Yii 2 introduce un nuevo método llamado scenarios(), e indica qué atributos deben ser validados bajo cuáles escenarios. Por ejemplo:

public function scenarios()
{
    return [
        'backend' => ['email''role'],
        'frontend' => ['email''!role'],
    ];
}

Bajo este contexto, los campos email y role se validarán en el escenario backend; mientras que en el escenario frontend se valida email pero role no.

El método rules() aún es usado para declarar las reglas de validación.

Controladores

Yii 2 utiliza como la clase controlador base a yii\web\Controller. El impacto más sobresaliente de éste cambio es que el controlador debe retornar el contenido que se quiere renderizar. Por ejemplo:

public function actionView($id)
{
    $model = \app\models\Post::findOne($id);
    if ($model) {
        return $this->render('view', ['model' => $model]);
    } else {
        throw new \yii\web\NotFoundHttpException;
    }
}

Widgets

Yii 2 utiliza como la clase widget base a yii\base\Widget. Yii 2 utiliza una nueva sintaxis para usar widgets. Utiliza los métodos estáticos  begin(), end(), y widget(). Por ejemplo:

use yii\widgets\Menu;
use yii\widgets\ActiveForm;
// Note that you have to "echo" the result to display it
echo Menu::widget(['items' => $items]);
// Passing an array to initialize the object properties
$form ActiveForm::begin([
    'options' => ['class' => 'form-horizontal'],
    'fieldConfig' => ['inputOptions' => ['class' => 'input-xlarge']],
]);
... campos del formulario ...
ActiveForm::end();

Temas

Los temas trabajan de manera completamente en Yii 2. Están basados en un mecanismo de asignación de ruta que asigna una ruta a una vista del tema. Los temas pueden ser aplicados a cualquier vista, incluso si está renderizada fuera del contexto original de un controlador o widget.

Además, ya no existe el componente CThemeManager. En su lugar, theme es una propiedad configurable de la vista.

Otras diferencias

Con Yii 2 también se tienen diferencias con Aplicaciones de Consola, I18N, Filtros, Assets, Helpers, Formularios, Constructor de Consultas, Registro Activo, Usuarios e Interfaces de Identidad, Administración de URLs. Las demás diferencias las revisaremos en la siguiente entrada: Actualizando Yii desde la versión 1 (Parte II)