First of all, install the Composer package manager on your system.

In Mac or Linux download the installer from https://getcomposer.org/download/ and install it globally by using the following command:

sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

In Windows without OpenServer download and run Composer-Setup.exe from the https://getcomposer.org/doc/00-intro.md page.

If you do not have administrative privileges on the system then as an alternative you can just download the https://getcomposer.org/composer.phar raw file and use the php composer.phar call instead of single the composer command.

After installation run in your terminal:

composer

Or (if you just download archive) its alternative:

php composer.phar

When the installation succeeds you will see the following response:

   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ '__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 1.2.0 2016-07-18 11:27:19

Right now you can install any package from the https://packagist.org repository.

You can install basic or advanced application templates. In order to learn about the differences between the templates see the Application templates recipe.

First of all, we installed the Composer package manager and the Bower asset plugin.

After we installed the application via the composer create-project command, the command creates a new empty directory, clones the source code of application template and loads all its inner dependencies (framework and other components) into the vendor subdirectory.

If needed, we will initialize application configuration and set up a new database.

We can check system requirements via running the requirements.php script in console or browser mode.

And after cloning of the code we can configure our own PHP server to work with the web directories as the server's document roots.

Please refer to the Installing the framework recipe's How to do it… section to understand and learn how to install different templates.

The advanced template has a custom system of configurations. It is developed so that a team can work together on a project but each developer can customize their own configurations for development, testing, and other environments.

Configuration environments can be complicated and normally aren't used when you develop alone.

The advanced template has frontend and backend folders for the frontend and backend parts of the web application accordingly. So you can configure a separate host for each folder and thereby isolate the frontend and backend part.

This is a simple way to organize files into directories and configure the web server. You can easily do the same thing in the basic template.

Neither front/back-end separation nor user management is on its own a good reason to choose the advanced template. It's better to adapt these features to your app—you'll learn more and won't get the difficult config problem.

If you will be working on the project with a team and you might need configuration flexibility, use different environments to develop and in this case a better choice would be the advanced application template. If you will be working alone and your project is simple you should choose the basic application template.

Create a new application by using the Composer package manager, as described in the official guide at http://www.yiiframework.com/doc-2.0/guide-startinstallation.html.

Carry out the following steps:

In this case we have the main ShoppingCart class with a low-level dependency, defined by an abstraction interface:

class ShoppingCart
{
    public function __construct(StorageInterface $storage) { … }
}

interface StorageInterface
{
   public function load();
   public function save(array $items);
}

And we have some an implementation of the abstraction:

class SessionStorage implements StorageInterface
{
    public function __construct(Session $session, $key) { … }
}

Right now we can create an instance of the cart manually like this:

$storage = new SessionStorage(Yii::$app->session, 'primary-cart');
$cart = new ShoppingCart($storage)

It allows us to create a lot of different implementations such as SessionStorage, CookieStorage, or DbStorage. And we can reuse the framework-independent ShoppingCart class with StorageInterface in different projects and different frameworks. We must only implement the storage class with the interface's methods for needed framework.

But instead of manually creating an instance with all dependencies, we can use a dependency injection container.

By default the container parses the constructors of all classes and recursively creates all the required instances. For example, if we have four classes:

class A {
     public function __construct(B $b, C $c) { … }
}

class B {
    ...
}

class C {
    public function __construct(D $d) { … }
}

class D {
    ...
}

We can retrieve the instance of class A in two ways:

$a = Yii::$container->get('app\services\A')
// or
$a = Yii::createObject('app\services\A')

And the container automatically creates instances of the B, D, C, and A classes and injects them into each other.

In our case we mark the cart instance as a singleton:

Yii::$container->setSingleton('app\cart\ShoppingCart');

This means that the container will return a single instance for every repeated call instead of creating the cart again and again.

Besides, our ShoppingCart has the StorageInterface type in its own constructor and the container does know what class it must instantiate for this type. We must manually bind the class to the interface like this:

Yii::$container->set('app\cart\storage\StorageInterface', 'app\cart\storage\CustomStorage',);

But our SessionStorage class has non-standard constructor:

class SessionStorage implements StorageInterface
{
    public function __construct(Session $session, $key) { … }
}

Therefore we use an anonymous function to manually creatie the instance:

Yii::$container->set('app\cart\storage\StorageInterface', function() {
    return new SessionStorage(Yii::$app->session, 'primary-cart');
});

And after all we can retrieve the cart object from the container manually in our own controllers, widgets, and other places:

$cart = Yii::createObject('app\cart\ShoppingCart')

But every controller and other object will be created via the createObject method inside the framework. And we can use injection of cart via the controller constructor:

class CartController extends Controller
{
    private $cart;

    public function __construct($id, $module, ShoppingCart $cart, $config = [])
    {
        $this->cart = $cart;
        parent::__construct($id, $module, $config);
    }

    // ...
}

Use this injected cart object:

public function actionDelete($id)
{
    $this->cart->remove($id);
    return $this->redirect(['index']);
}

Create a new application by using the Composer package manager, as described in the official guide at http://www.yiiframework.com/doc-2.0/guide-start-installation.html.

Carry out the following steps to create a shopping cart component:

First of all we created our own class with a public sessionKey option:

<?php
namespace app\components;
use yii\base\Component;

class ShoppingCart extends Component
{
    public $sessionKey = 'cart';

    // …
}

Secondly, we added the component definition into the components section of the configuration file:

'components' => [
    …
    'cart => [
        'class' => 'app\components\ShoppingCart',
        'sessionKey' => 'primary-cart',
    ],
]

Right now we can retrieve the component instance in two ways:

$cart = Yii::$app->cart;
$cart = Yii::$app->get('cart');

And we can use this object in our own controllers, widgets, and other places.

When we call any component such as cart:

Yii::$app->cart

We call the virtual property of the Application class instance in the Yii::$app static variable. But the yii\base\Application class extends the yii\base\Module class, which extends the yii\di\ServiceLocator class with the __get magic method. This magic method just calls the get() method of the yii\di\ServiceLocator class:

namespace yii\di;

class ServiceLocator extends Component
{
    private $_components = [];
    private $_definitions = [];

    public function __get($name)
    {
        if ($this->has($name)) {
            return $this->get($name);
        } else {
            return parent::__get($name);
        }
    }
    // …
}

As a result it is an alternative to directly calling the service via the get method:

Yii::$app->get('cart);

When we get a component from the get method of service locator, the locator finds needed definition in its _definitions list and if successful it creates a new object by the definition on the fly, registers it in its own list of complete instances _components and returns the object.

If we get some component, multiplying the locator will always return the previous saved instance again and again:

$cart1 = Yii::$app->cart;
$cart2 = Yii::$app->cart;
var_dump($cart1 === $cart2); // bool(true)

It allows us to use the shared single cart instance Yii::$app->cart or single database connection Yii::$app->db instead of creating one large set from scratch again and again.

If you check your project structure you will see autogenerated code:

Firstly we've created an Actor model. Gii automatically creates all model rules which depends on mysql field types. For example, if in your MySQL actor table's fields first_name and last_name have IS NOT NULL flag then Yii automatically creates rule for it required and sets max length 45 symbols because in our database max length of this field is set up as 45.

public function rules()
{
    return [
        [['first_name', 'last_name'], 'required'],
        [['last_update'], 'safe'],
        [['first_name', 'last_name'], 'string', 'max' => 45],
    ];
}

Also Yii creates relationship between models automatically, based on foreign keys you added to your database. In our case two relations were created automatically.

public function getFilmActors()
{
    return $this->hasMany(FilmActor::className(), ['actor_id' => 'actor_id']);
}

public function getFilms()
{
    return $this->hasMany(Film::className(), ['film_id' => 'film_id'])->viaTable('film_actor', ['actor_id' => 'actor_id']);
}

This relationship has been created because we have two foreign keys in our database. The film_actor table has foreign key fk_film_actor_actor which points to actor table fields actor_id and fk_film_actor_film which points to film table field film_id.

Notice that you haven't generated FilmActor model yet. So if you would develop full-app versus demo you had to generate Film, FilmActor models also. For the rest of the pieces, refer to http://www.yiiframework.com/doc-2.0/guide-start-gii.html.

Create a new application by using the Composer package manager as described in the official guide at http://www.yiiframework.com/doc-2.0/guide-startinstallation.html.

If you have worked with Yii before, then you have probably configured a database connection:

return [
    …
    'components' => [
        'db' => [
            'class' => 'system.db.CDbConnection',
            'dsn' => 'mysql:host=localhost;dbname=database_name',
            'username' => 'root',
            'password' => '',
            'charset' => 'utf8',
        ],
        …
    ],
    …
];

This way of configuring components is used when you want to use a component across all application parts. With the preceding configuration, you can access a component by its name, such as Yii::$app->db.

When you are using the Yii::$app->db component for the first time directly or through an Active Record model, Yii creates a component and initializes its public properties with the corresponding values provided in db array under the components section of the application configuration file. In the preceding code, dsn value will be assigned to yii\db\Connection::dsn, username will be assigned to Connection::username, and so on.

If you want to find out what charset stands for or want to know what else you can configure in the db component, then you need to know its class. In the case of the db component, the class is yii\db\Connection. You can just open the class and look for its public properties, which you can set from config.

In the preceding code, the class property is a bit special because it is used to specify the component class name. It does not exist in the yii\db\Connection class. Therefore, it can be used to override a class as follows:

return [
    …
    'components' => [
        'db' => [
            'class' => app\components\MyConnection',
            …
        ],
        …
    ],
     …
);

This way, you can override each application component; this is very useful whenever a standard component does not fit your application.

We've created an Article model and added a handler for the ActiveRecord::EVENT_AFTER_INSERT event to our Article model. It means that every time we save a new article an event is triggered and our attached handler will be called.

In the real-world, we would like to notify our blog followers each time we publish a new article. In a real application we would have a follower or user table and with different blog sections not only single blog. In this example, after saving our model we notify our followers john2@teleworm.us, shivawhite@cuvox.de, and kate@dayrep.com. In the last step we just prove that users have received our notifications, particularly john2. You can create your own event with any name. In this example we use a built-in event called ActiveRecord::EVENT_AFTER_INSERT, which is called after each insert to the database.

For example, we can create our own event. Just add a new actionTestNew with the following code:

public function actionTestNew()
{
    $article = new Article();
    $article->name = 'Valentine\'s Day\'s coming? Aw crap! I forgot to get a girlfriend again!';
    $article->description = 'Bender is angry at Fry for dating a robot. Stay away from our women.
    You've got metal fever, boy. Metal fever';

    // $event is an object of yii\base\Event or a child class
    $article->on(Article::EVENT_OUR_CUSTOM_EVENT, function($event) {
        $followers = ['john2@teleworm.us', 'shivawhite@cuvox.de', 'kate@dayrep.com' ];
        foreach($followers as $follower) {
            Yii::$app->mailer->compose()
                ->setFrom('techblog@teleworm.us')
                ->setTo($follower)
                ->setSubject($event->sender->name)
                ->setTextBody($event->sender->description)
                ->send();
        }
        echo 'Emails have been sent';
    });

    if ($article->save()) {
        $article->trigger(Article::EVENT_OUR_CUSTOM_EVENT);
    }
}

Also add the EVENT_OUR_CUSTOM_EVENT constant to models/Article as:

class Article extends \yii\db\ActiveRecord
{
    CONST EVENT_OUR_CUSTOM_EVENT = 'eventOurCustomEvent';
…
}

Run http://localhost:8080/index.php?r=site/test-new.

You should see the same result and all notifications to followers will be sent again. The main difference is we used our custom event name.

After the save, we've triggered our event. Events may be triggered by calling the yii\base\Component::trigger() method. The method requires an event name, and optionally an event object that describes the parameters to be passed to the event handlers.

For more information about events refer to http://www.yiiframework.com/doc-2.0/guide-concept-events.html

Create a new application by using the Composer package manager as described in the official guide at http://www.yiiframework.com/doc-2.0/guide-start-installation.html.

In this recipe we will try to attach some libraries manually and via Composer.

{
    ...
    "extra": {
        "asset-installer-paths": {
            "npm-asset-library": "vendor/npm",
            "bower-asset-library": "vendor/bower"
        }
    }
}

composer require yiisoft/yii2

require(__DIR__ . '/../vendor/autoload.php');
require(__DIR__ . '/../vendor/yiisoft/yii2/Yii.php');
$config = require(__DIR__ . '/../config/yii/web.php');
new yii\web\Application($config);

In the first case we just install a new Composer package in our project and use it, because its composer.json file defines all aspects of autoloading library files.

But in the second case we did not have Composer packages and registered the files in the autoloading mechanism manually. In Yii2 we can use aliases and Yii::$classMap for registering the roots of PSR-4 namespaces and for single files.

But as an alternative we can use Composer autoloader for all cases. Just define an extended autoload section in the composer.json file like this:

"autoload": {
    "psr-0": { "": "old/" },
    "psr-4": {"awesome\\": "awesome/"},
    "files": ["old/functions.php"]
}

Apply the changes using this command:

composer update

Right now you can remove aliases and $classMap definitions from your configuration files and ensure the example page still works correctly:

This example completely uses Composer's autoloader instead of the framework's autoloader.