原文地址http://symfony.com/doc/current/bundles/FOSUserBundle/groups.html

FOSUserBundle允许你对用户进行分组. 分组是区分角色集合的一种方式. 一个组里面的用户会被授予这个组里面所有角色的权限.

Symfony支持角色继承, 所以从组中继承角色不是必须的. 如果在你的使用场景中继承了足够多的角色, 最好还是使用继承, 因为它更为高效.(分组功能需要数据库的驱动.)

你需要在配置文件中明确启用这个启用分组功能. 唯一强制性的就是要配置你实现了FOS\UserBundle\Model\GroupInterface接口的Group类的完全限定名(fully qualified class name).

下面是一个支持分组功能的配置例子:

1
2
3
4
5
6
7

# app/config/config.yml
fos_user:
    db_driver: orm
    firewall_name: main
    user_class: AppBundle\Entity\User
    group:
        group_class: AppBundle\Entity\Group

分组类

创建分组类的最简单的方式就是去继承FOSUserBundle提供的映射过的超类.

ORM 分组类的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<?php
// src/AppBundle/Entity/Group.php

namespace AppBundle\Entity;

use FOS\UserBundle\Model\Group as BaseGroup;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="fos_group")
 */
class Group extends BaseGroup
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
     protected $id;
}

因为Group是SQL中的一个保留的关键字, 所以它不能用于表名.

MongoDB 分组类的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<?php
// src/AppBundle/Document/Group.php

namespace AppBundle\Document;

use FOS\UserBundle\Model\Group as BaseGroup;
use Doctrine\ODM\MongoDB\Mapping\Annotations as MongoDB;

/**
 * @MongoDB\Document
 */
class Group extends BaseGroup
{
    /**
     * @MongoDB\Id(strategy="auto")
     */
    protected $id;
}

CouchDB 分组类的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<?php
// src/AppBundle/CouchDocument/Group.php

namespace AppBundle\CouchDocument;

use FOS\UserBundle\Model\Group as BaseGroup;
use Doctrine\ODM\CouchDB\Mapping\Annotations as CouchDB;

/**
 * @CouchDB\Document
 */
class Group extends BaseGroup
{
    /**
     * @CouchDB\Id
     */
    protected $id;
}

定义用户与分组的关系

下一步就是在你的User类中进行关系映射

ORM用户-分组映射

Annotations 配置方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<?php
// src/AppBundle/Entity/User.php

namespace AppBundle\Entity;

use FOS\UserBundle\Model\User as BaseUser;

/**
 * @ORM\Entity
 * @ORM\Table(name="fos_user")
 */
class User extends BaseUser
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;

    /**
     * @ORM\ManyToMany(targetEntity="AppBundle\Entity\Group")
     * @ORM\JoinTable(name="fos_user_user_group",
     *      joinColumns={@ORM\JoinColumn(name="user_id", referencedColumnName="id")},
     *      inverseJoinColumns={@ORM\JoinColumn(name="group_id", referencedColumnName="id")}
     * )
     */
    protected $groups;
}

YAML配置方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# src/AppBundle/Resources/config/doctrine/User.orm.yml
AppBundle\Entity\User:
    type:  entity
    table: fos_user
    id:
        id:
            type: integer
            generator:
                strategy: AUTO
    manyToMany:
        groups:
            targetEntity: Group
            joinTable:
                name: fos_user_group
                joinColumns:
                    user_id:
                        referencedColumnName: id
                inverseJoinColumns:
                    group_id:
                        referencedColumnName: id

MongoDB用户-分组映射

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<?php
// src/AppBundle/Document/User.php

namespace AppBundle\Document;

use FOS\UserBundle\Model\User as BaseUser;
use Doctrine\ODM\MongoDB\Mapping\Annotations as MongoDB;

/**
 * @MongoDB\Document
 */
class User extends BaseUser
{
    /** @MongoDB\Id(strategy="auto") */
    protected $id;

    /**
     * @MongoDB\ReferenceMany(targetDocument="AppBundle\Document\Group")
     */
    protected $groups;
}

CouchDB用户-分组映射

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<?php
// src/AppBundle/CouchDocument/User.php

namespace AppBundle\CouchDocument;

use FOS\UserBundle\Model\User as BaseUser;
use Doctrine\ODM\CouchDB\Mapping\Annotations as CouchDB;

/**
 * @CouchDB\Document
 */
class User extends BaseUser
{
    /**
     * @CouchDB\Id
     */
    protected $id;

    /**
     * @CouchDB\ReferenceMany(targetDocument="AppBundle\CouchDocument\Group")
     */
    protected $groups;
}

启用分组控制器的路由

你可以导入group.xml路由文件来使用内置的控制器来操作分组.

1
2
3
4

# app/config/routing.yml
fos_user_group:
    resource: "@FOSUserBundle/Resources/config/routing/group.xml"
    prefix: /group

原文地址: http://symfony.com/doc/current/bundles/FOSUserBundle/emails.html

FOSUserBundle内置了两种不同的发送邮件的实例.

注册确认

在一个新用户注册完成之前, 如果在FOSUserBundle中配置了必须通过邮件确认的步骤, 系统会发送一封带有链接的邮件到用户邮箱中. 用户访问链接之后会对用户账户进行验证并且激活.

通过邮件验证新用户注册默认是关闭的. 若要启用, 则需修改配置文件:

1
2
3
4
5
6

# app/config/config.yml
fos_user:
    # ...
    registration:
        confirmation:
            enabled: true

重置密码

当用户需要重置密码的时候, 通常也是通过发送邮件的方式进行的. FOSUserBundle提供了一个通过两个步骤重置密码的功能. 首先, 用户必须发送一个重置密码的请求. 在发送完请求之后, 会发送一封带有访问链接的邮件. 当访问链接时, 用户会通过被包含在url中的token识别出来. 当用户访问了链接并且token被验证之后, 一个要求输入新密码的表单将呈现在用户面前.

默认的发送邮件实现

FOSUserBundle带有三种邮件实现. 他们的服务id如下:

• fos_user.mailer.default使用Swiftmailer来发送邮件的默认实现.
• fos_user.mailer.twig_swift使用Swiftmailer发送邮件并且用twig区块来渲染消息.
• fos_user.mailer.noop是一个不执行任何操作的邮件实现, 所以他不会发送邮件.

fos_user.mailer.noop邮件服务是在你不需要发送邮件服务, 并且不在应用中安装SwiftmailerBundle的时候使用的. 如果你留下了默认的邮件配置, 并且没有注册SwiftmailerBundle, 你会收到一个依赖缺失的异常.

配置发送邮件的地址

FOSUserBundle默认的邮件服务允许你设置发送邮件的邮件地址. 你可以配置全局的邮件地址, 也可以为每一封邮件配置地址.

若要为所有发送出去的邮件设置地址, 仅需像下面这样更新你的fos_user配置:

1
2
3
4
5
6

# app/config/config.yml
fos_user:
    #...
    from_email:
        address:        noreply@example.com
        sender_name:    Demo App

FOSUserBundle也提供了为每一封邮件设置邮件地址的灵活性.

若要为注册确认邮件设置地址, 仅需像下面这样更新你的fos_user配置:

1
2
3
4
5
6
7
8

# app/config/config.yml
fos_user:
    #...
    registration:
        confirmation:
            from_email:
                address:        registration@example.com
                sender_name:    Demo Registration

你也可以通过配置fos_user来设置重置密码请求发送出去的邮件地址:

1
2
3
4
5
6
7
8

# app/config/config.yml
fos_user:
    #...
    resetting:
        email:
            from_email:
                address:        resetting@example.com
                sender_name:    Demo Resetting

发送HTML邮件

默认的邮件服务只是单纯的发送文本信息. 如果你想发送复合信息, 最简单的解决方案就是使用TwigSwiftMailer实现. 他为你的twig模板定义了三个区块:

• subject 包含了邮件的主题
• body_text 渲染纯文本版本的消息
• body_html渲染html邮件

下面是如何使用的方法, 你可以参考下面两种引用邮件模板文件的方法.

1
2
3
4
5
6
7
8
9
10
11

# app/config/config.yml
fos_user:
    # ...
    service:
        mailer: fos_user.mailer.twig_swift
    resetting:
        email:
            template:   email/password_resetting.email.twig
    registration:
        confirmation:
            template:   FOSUserBundle:Registration:email.txt.twig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{# app/Resources/views/email/password_resetting.email.twig #}

{% block subject %}Resetting your password{% endblock %}

{% block body_text %}
{% autoescape false %}
Hello {{ user.username }} !

You can reset your password by accessing {{ confirmationUrl }}

Greetings,
the App team
{% endautoescape %}
{% endblock %}

{% block body_html %}
{#
    You can of course render the html directly here.
    Including a template as done here allows keeping things DRY by using
    the template inheritance in it
#}
{% include 'email/password_resetting.html.twig' %}
{% endblock %}

HTML部分仅在body_html区块不为空的情况下才会显示在信息中.

你可以在FOSUserBundle:Registration:email.txt.twig和FOSUserBundle:Resetting:email.txt.twig中查看默认的邮件模板.

使用自定义邮件服务

FOSUserBundle使用的默认的邮件服务依赖于Swiftmailer类库. 如果你想使用其他的类库来发送邮件, 发送HTML邮件或者简单的修改邮件内容, 你可以向下面这样来定义你自己的邮件服务.

首先你得创建一个实现了FOS\UserBundle\Mailer\MailerInterface接口的类. 接口如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<?php

namespace FOS\UserBundle\Mailer;

use FOS\UserBundle\Model\UserInterface;

/**
 * @author Thibault Duplessis <thibault.duplessis@gmail.com>
 */
interface MailerInterface
{
    /**
     * Send an email to a user to confirm the account creation
     *
     * @param UserInterface $user
     */
    function sendConfirmationEmailMessage(UserInterface $user);

    /**
     * Send an email to a user to confirm the password reset
     *
     * @param UserInterface $user
     */
    function sendResettingEmailMessage(UserInterface $user);
}

在你实现了你的自定义邮件类并且将它定义成了服务之后, 你需要更新你的配置文件, 以便FOSUserBundle能够正确的使用. 只要设置在service部分的mailer参数即可. 就像下面这样:

1
2
3
4
5

# app/config/config.yml
fos_user:
    # ...
    service:
        mailer: app.custom_fos_user_mailer

你可以查看ZetaWebmailBundle中的ZetaMailer类是如何实现MailerInterface的. 这个实现使用了 Zeta Components Mail 来发送邮件, 而不是Swiftmailer.

原文地址: http://symfony.com/doc/current/bundles/FOSUserBundle/form_type.html

FOSUserBundle提供了一个名为fos_user_username的用户名表单字段. 它是一个文本输入框, 接受用户名并且将其添加至用户实例中:

1
2
3
4
5
6
7
8
9
10

class MessageFormType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('recipient', 'FOS\UserBundle\Form\Type\UsernameFormType');

        // if you are using Symfony < 2.8 you should use the old name instead
        // $builder->add('recipient', 'fos_user_username');
    }
}

假如你不想在应用中使用这种表单字段, 可以删除容器服务中的配置来禁用它:

# app/config/config.ymlfos_user:    use_username_form_type: false

原文地址http://symfony.com/doc/current/bundles/FOSUserBundle/logging_by_username_or_email.html

在FOSUserBundle的1.3.0版本中, 内建了通过用户名或者邮件字段登录功能的实现. 要启用这个功能只需修改配置中的用户服务提供器的id即可.

1
2
3
4
5

# app/config/security.yml
security:
    providers:
        fos_userbundle:
            id: fos_user.user_provider.username_email

原文地址http://symfony.com/doc/current/bundles/FOSUserBundle/command_line_tools.html

FOSUserBundle提供了大量的命令行工具来帮助你管理应用中的用户. 有这些命令任务可用:

1. Create a User (创建用户)
2. Activate a User (激活用户)
3. Deactivate a User (停用用户)
4. Promote a User (设置用户权限)
5. Demote a User (清除用户权限)
6. Change a User’s Password ( 重置用户密码)

在使用这些命令行之前, 你需要正确的安装以及配置好FOSUserBundle

此文中引用的是Symfony3的控制bin/console. 如果你使用的Symfony2, 请调用app/console.

创建用户

你可以在应用中使用fos:user:create命令来创建用户. 这个命令包含三个参数, username, email, 和 password.
假如你需要创建一个用户名为testuser, 邮箱为`test@example.com, 密码为p@ssword`的用户, 则执行下面的命令

1

php bin/console fos:user:create testuser test@example.com p@ssword

若没有传递任何参数到此命令中, 则程序会自动询问你相应的信息. 假设你运行了下面这条命令, 你则会被询问去输入用户的email 和 password.

1

php bin/console fos:user:create testuser

你还可在命令中添加两个选项. --super-admin以及--inactive.
若输入了--super-admin选项, 则会将创建的用户标记为超级管理员. 超级管理员拥有应用中的所有权限. 下面是例子:

1

php bin/console fos:user:create adminuser --super-admin

若输入了--inactive, 则创建的用户将无法登陆, 除非该用户被激活.

1

php bin/console fos:user:create testuser --inactive

激活用户

fos:user:activate命令将激活一个未激活用户. 此命令必须包含一个username的参数来指定激活哪一个用户. 若为输入username 则会提示你来输入用户名. 下面是例子:

1
2
3

$ php app/console fos:user:activate testuser
$ # OR if you are using Symfony >= 2.8 with the new directory structure
$ php bin/console fos:user:activate testuser

停用用户

fos:user:deactivate命令可以禁用用户. 和激活用户的命令一样, 此命令也必须包含一个username的参数来指定禁用哪一个用户. 若未提供用户名, 则会被提示输入username. 下面是例子

1
2
3

$ php app/console fos:user:deactivate testuser
$ # OR if you are using Symfony >= 2.8 with the new directory structure
$ php bin/console fos:user:deactivate testuser

设置用户权限

fos:user:promote命令能够让你为一个用户添加一个角色或者使用户成为一个超级管理员.
假如你要为一个用户添加一个role (角色), 你只需要将第一个参数设定为要添加的用户名, 第二个参数作为角色名即可.

1

php bin/console fos:user:promote testuser ROLE_ADMIN

你可以通过在用户名后面添加--super选项, 将一个用户设定为超级管理员.

1

$ php bin/console fos:user:promote testuser --super

若你没有输入任何参数, 则你会被询问来输入这些参数.

你可以不同时指定role参数和--super选项.

清除用户权限

fos:user:demote命令与为用户添加权限相似, 但功能相反. 你也可以使用这个命令来撤销一个超级管理员用户.
假如要移除一个用户的权限, 则需要将命令中的第一个参数设置为用户名, 第二个参数则为用户的角色.

1

php bin/console fos:user:demote testuser ROLE_ADMIN

要撤销一个超级管理员用户, 仅需设置用户名参数, 然后再加上--super选项即可.

1

php bin/console fos:user:demote testuser --super

你可以不同时指定role参数和--super选项.

重置用户密码

fos:user:change-password命令提供一个简单的方式来修改用户密码. 这个命令有两个参数: 用户名(username), 新密码(password).

1

php bin/console fos:user:change-password testuser newp@ssword

原文地址http://symfony.com/doc/current/bundles/FOSUserBundle/user_manager.html

所有用户操作都实现了FOS\UserBundle\Model\UserManagerInterface接口, 从而实现了与存储方式的分离. 使用这个接口可以确保你能够随意的改变存储方式. FOSUserBundle提供的默认控制器使用的是配置中的用户管理, 而不是直接调用的数据存储层.

如果将db_driver配置为orm, 这个服务则为FOS\UserBundle\Doctrine\UserManager的实例.

如果将db_driver配置为mongodb, 这个服务则为FOS\UserBundle\Doctrine\UserManager的实例.

如果将db_driver配置为couchdb, 这个服务则为FOS\UserBundle\Doctrine\UserManager的实例.

如果将db_driver配置为propel, 这个服务则为FOS\UserBundle\Propel\UserManager的实例.

调用用户管理服务

用户管理是作为fos_user.user_manager服务在容器中使用的.

1

$userManager = $container->get('fos_user.user_manager');

创建一个新用户

可以使用用户管理来创建一个用户类的实例.

1

$user = $userManager->createUser();

$user则为用户类的一个实例.

如果你的构造函数中强制了一些参数, 这个方法会变得不可用.

检索用户

用户管理服务有一些基于唯一字段(用户名, 电子邮件, 已验证的token)的查询方法和一个提取已有用户的方法.

• findUserByUsername($username)
• findUserByEmail($email)
• findUserByUsernameOrEmail($value)
• findUserByConfirmationToken($token)
• findUserBy(array('id'=>$id))
• findUsers()

你可以使用用户服务中的updateUser方法来保存用户对象. 这个方法会更新编码后的密码以及一些常用字段, 然后保存.

更新用户对象

1
2
3
4
5

$user = $userManager->createUser();
$user->setUsername('John');
$user->setEmail('john.doe@example.com');

$userManager->updateUser($user);

FOSUserBundle在程序中自带一个Doctrine监听器来处理密码以及常用字段的更新. 假如你始终使用用户管理服务来保存用户, 你也许会想禁用这个监听器来提高应用的性能.

# app/config/config.ymlfos_user:    # ...   use_listener: false

Propel实现中没有添加此监听器, 所以你需要调用用户管理服务中的方法来保存用户信息.

对于Doctrine实现, 当在请求updateUser方法时, 默认的行为会去刷新工作单元. 你可以添加一个false参数来禁止刷新. 这相当于请求updateCanonicalFields和updatePassword方法.

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class MainController extends Controller
{
    public function updateAction($id)
    {
        $user = // get a user from the datastore

        $user->setEmail($newEmail);

        $this->get('fos_user.user_manager')->updateUser($user, false);

        // make more modifications to the database

        $this->getDoctrine()->getManager()->flush();
    }
}

重写用户管理服务

你可以配置一个实现了FOS\UserBundle\Model\UserManagerInterface接口的服务来替代默认的用户管理服务. 默认实现的id为fos_user.user_manager.default.

1
2
3
4

fos_user:
    # ...
    service:
        user_manager: custom_user_manager_id

自定义的实现可以继承FOS\UserBundle\Model\UserManager从而复用现成逻辑.

整合SecurityBundle

FOSUserBundle在UserManagerInterface顶部提供了一些Symfony\Component\Security\Core\UserProviderInterface的实现.

虽然框架內建的用户管理服务也实现了Symfony\Component\Security\Core\User\UserProviderInterface, 使用这个实现作为用户生成器已经过时了并且将在将来的版本中移除.
请使用FOS\UserBundle\Security\UserProvider来替换它.

原文地址http://symfony.com/doc/current/bundles/FOSUserBundle/overriding_forms.html

重写表单类型

FOSUserBundle为新用户注册, 更新用户信息, 修改密码等功能封装了默认的表单. 这些表单能很好的作用在默认的类以及控制器上. 但假如你想在你的User类里面添加更多的属性, 或者想在注册表单里面添加一些选项时, 就得去修改默认的表单.

假设你创建了一个AppBundle\Entity\User的用户类. 在这个类里面, 你必须添加一个name属性跟用户名以及邮箱地址同时保存下来.此时, 当一个用户在你的网站注册时, 他必须填写他们的姓名以及用户名和邮箱, 密码. 下面的代码是添加了$name属性以及验证的例子.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// src/AppBundle/Entity/User.php

use FOS\UserBundle\Model\User as BaseUser;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;

class User extends BaseUser
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;

    /**
     * @ORM\Column(type="string", length=255)
     *
     * @Assert\NotBlank(message="Please enter your name.", groups={"Registration", "Profile"})
     * @Assert\Length(
     *     min=3,
     *     max=255,
     *     minMessage="The name is too short.",
     *     maxMessage="The name is too long.",
     *     groups={"Registration", "Profile"}
     * )
     */
    protected $name;

    // ...
}

默认情况下, Registration验证组是在一个新用户注册时被使用的. 请确保将你的name属性添加到了命名为Registration的验证组, 除非你在配置文件中修改了这个值.

如果你尝试使用默认的表单进行注册, 你会发现新添加的name属性并不在表单中. 你需要通过创建一个自定义表单类型并且进行配置, 才能使表单正常运作.

第一步是在你的bundle中添加一个新的表单类型. 下面这个类继承自FOSUserBundle的fos_user_registration类型表单, 并且添加了自定义的name字段.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<?php
// src/AppBundle/Form/RegistrationType.php

namespace AppBundle\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;

class RegistrationType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('name');
    }

    public function getParent()
    {
        return 'FOS\UserBundle\Form\Type\RegistrationFormType';

        // Or for Symfony < 2.8
        // return 'fos_user_registration';
    }

    public function getBlockPrefix()
    {
        return 'app_user_registration';
    }

    // For Symfony 2.x
    public function getName()
    {
        return $this->getBlockPrefix();
    }
}

如果你不想复用FOSUserBundle提供的默认字段, 则可以忽略getParent方法, 自己添加所有的字段.

你已经创建好了自定义表单类型, 接着就是将它定义为一个服务并且添加相应的tag. tag的name值必须为form.type并且alias值必须与在添加的表单类型中的getName方法返回的字符串相同. alias是要告诉FOSUserBundle使用哪个自定义表单类型的名称.
下面是你的表单服务的配置示例:

1
2
3
4
5
6

# app/config/services.yml
services:
    app.form.registration:
        class: AppBundle\Form\RegistrationType
        tags:
            - { name: form.type, alias: app_user_registration }

最后你需要更新你的FOSUserBundle的配置信息, 以便让FOSUserBundle知道要使用哪个表单来替换默认的表单. 下面是替换注册表单的示例配置.

1
2
3
4
5
6
7
8

# app/config/config.yml
fos_user:
    # ...
    registration:
        form:
            type: AppBundle\Form\RegistrationType
            # if you are using Symfony < 2.8 you should use the type name instead
            # type: app_user_registration

注意在配置文件中是如何使用你的表单类型服务配置中tag的alias值来告诉FOSUserBundle使用你的自定义表单的.

如果你需要在处理表单的时候添加一些逻辑, 你可以添加一个监听者挂载到控制器

原文地址http://symfony.com/doc/current/bundles/FOSUserBundle/overriding_controllers.html

FOSUserBundle中默认的控制器提供了大量的功能来满足日常使用. 但在你的应用中, 通常需要继承这些功能, 并且在里面添加你自己的业务逻辑.

重写控制器需要复制所有的action逻辑. 大多数情况下使用事件来实现功能会更简单一些. 只有在没有其他办法的情况下才会考虑重写控制器.

重写控制器的第一步是创建一个继承FOSUserBundle的子bundle. 下面的代码片段定义了一个名为AcmeUserBundle的继承自FOSUserBundle的子bundle.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php
// src/Acme/UserBundle/AcmeUserBundle.php

namespace Acme\UserBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;

class AcmeUserBundle extends Bundle
{
    public function getParent()
    {
        return 'FOSUserBundle';
    }
}

Symfony框架只中每个bundle只能有一个子bundle. 这意味着你不能再创建另外一个继承自FOSUserBundle的子bundle.

现在你已经创建了一个新的子bundle, 你可以创建一个与你想重写的控制器路径以及名称相同的控制器类. 在这个例子中,通过扩展FOSUserBundle中的RegistrationController类来实现对RegistrationController的方法中额外的功能的重写.
下面的例子中重写了registerAction方法. 它使用了base 控制器的代码并且添加了新用户登录的逻辑.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

<?php
// src/Acme/UserBundle/Controller/RegistrationController.php

namespace Acme\UserBundle\Controller;

use Symfony\Component\HttpFoundation\RedirectResponse;
use FOS\UserBundle\Controller\RegistrationController as BaseController;
use Symfony\Component\HttpFoundation\Request;

class RegistrationController extends BaseController
{
    public function registerAction(Request $request)
    {
        $form = $this->container->get('fos_user.registration.form');
        $formHandler = $this->container->get('fos_user.registration.form.handler');
        $confirmationEnabled = $this->container->getParameter('fos_user.registration.confirmation.enabled');

        $process = $formHandler->process($confirmationEnabled);
        if ($process) {
            $user = $form->getData();

            /*****************************************************
             * Add new functionality (e.g. log the registration) *
             *****************************************************/
            $this->container->get('logger')->info(
                sprintf('New user registration: %s', $user)
            );

            if ($confirmationEnabled) {
                $this->container->get('session')->set('fos_user_send_confirmation_email/email', $user->getEmail());
                $route = 'fos_user_registration_check_email';
            } else {
                $this->authenticateUser($user);
                $route = 'fos_user_registration_confirmed';
            }

            $this->setFlash('fos_user_success', 'registration.flash.user_created');
            $url = $this->container->get('router')->generate($route);

            return new RedirectResponse($url);
        }

        return $this->container->get('templating')->renderResponse('FOSUserBundle:Registration:register.html.twig', array(
            'form' => $form->createView(),
        ));
    }
}

如果在你想重写时不继承FOSUserBundle控制器类而是继承自FrameworkBundle提供的容器或者控制器, 那你就必须实现FOSUserBundle 的控制器所有的方法.

原文地址http://symfony.com/doc/current/bundles/FOSUserBundle/controller_events.html

通过FOSUserBundle包装过的控制器提供了一些能够满足一般需要的功能. 不过你可能需要在你的应用中扩展这些功能, 并且加入你自己的业务逻辑.

出于此目的, 控制器在他们的逻辑中的多个地方触发了一些事件. 所有的事件都能在FOS\UserBundle\FOSUserEvents类中的常量找到.

所有的控制器都遵循一个约定: 他们会在表单验证之后保存用户数据之前触发一个SUCCESS事件, 并且在保存用户数据之后触发一个COMPLETED事件.因此你不想使用默认的重定向, 你可以在所有的SUCCESS事件之后你可以设置一个响应. 所有的COMPLETED事件允许你在控制器返回之前设置一个响应.

带表单的控制器在实体加载完毕之后通常会触发一个INITIALIZE事件, 而不是在表单创建之后.

例如,下面这个监听器会在重置密码之后跳转到homepage, 而不是profile页面:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// src/Acme/UserBundle/EventListener/PasswordResettingListener.php

namespace Acme\UserBundle\EventListener;

use FOS\UserBundle\FOSUserEvents;
use FOS\UserBundle\Event\FormEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

/**
 * Listener responsible to change the redirection at the end of the password resetting
 */
class PasswordResettingListener implements EventSubscriberInterface
{
    private $router;

    public function __construct(UrlGeneratorInterface $router)
    {
        $this->router = $router;
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return array(
            FOSUserEvents::RESETTING_RESET_SUCCESS => 'onPasswordResettingSuccess',
        );
    }

    public function onPasswordResettingSuccess(FormEvent $event)
    {
        $url = $this->router->generate('homepage');

        $event->setResponse(new RedirectResponse($url));
    }
}

然后你可以在配置中注册这个监听器:

1
2
3
4
5
6
7

# src/Acme/UserBundle/Resources/config/services.yml
services:
    acme_user.password_resetting:
        class: Acme\UserBundle\EventListener\PasswordResettingListener
        arguments: ['@router']
        tags:
            - { name: kernel.event_subscriber }

原文地址: http://symfony.com/doc/current/bundles/FOSUserBundle/overriding_templates.html

如果你在应用中使用了FOSUserBundle, 你势必会想办法去重写这个bundle提供的默认模板.
虽然模板的名称是不可配置的, 但是Symfony框架也为我们提供了两种重写模板的方式.

1. 在app/Resources文件夹中定义一个同名模板文件.
2. 创建一个继承了FOSUserBundle的bundle.

举例:重写默认的 layout.html.twig

推荐的做法是重写Resources/views/layout.html.twig模板, 这样能保证FOSUserBundle提供的页面能与你应用的页面风格保持一致. 下面是一个重写layout.html.twig的例子, 它包含了所有的重写选项.

FOSUserBundle提供的默认的layout.html.twig:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8" />
    </head>
    <body>
        <div>
            {% if is_granted("IS_AUTHENTICATED_REMEMBERED") %}
                {{ 'layout.logged_in_as'|trans({'%username%': app.user.username}, 'FOSUserBundle') }} |
                <a href="{{ path('fos_user_security_logout') }}">
                    {{ 'layout.logout'|trans({}, 'FOSUserBundle') }}
                </a>
            {% else %}
                <a href="{{ path('fos_user_security_login') }}">{{ 'layout.login'|trans({}, 'FOSUserBundle') }}</a>
            {% endif %}
        </div>

        {% for type, messages in app.session.flashBag.all %}
            {% for message in messages %}
                <div class="{{ type }}">
                    {{ message|trans({}, 'FOSUserBundle') }}
                </div>
            {% endfor %}
        {% endfor %}

        <div>
            {% block fos_user_content %}
            {% endblock fos_user_content %}
        </div>
    </body>
</html>

如你所见, 它非常的简洁, 没有太多的结构, 所以你肯定会想用你应用中的布局文件来替换他. 在这个模板文件中主要要注意的地方就是名为fos_user_content的区块. 这是FOSUserBundle要在不同bundle的action中显示的内容, 所以你必须在你要重写的布局文件中包含这个区块.

下面的Twig模板是复写布局文件的例子.

1
2
3
4
5

{% block title %}Demo Application{% endblock %}

{% block content %}
    {% block fos_user_content %}{% endblock %}
{% endblock %}

上面的例子继承了你的应用中的布局. content 区块是每个页面中显示内容的主要区域. 这就是为何fos_user_content 区块要包含在它里面的原因. 这将使FOSUserBundle的输出能够像预期的一样集成到应用的布局中去, 看上去像一个整体.

a)在app/Resources中创建一个新的模板文件

重写模板的最简单的方式是在你的app/Resources文件夹中创建一个新的模板. 为了重写FOSUserBundle文件夹中的Resources/views/layout.html.twig文件, 你应该将新的模板文件保存在app/Resources/FOSUserBundle/views/layout.html.twig

正如你看到的, 这种方式是在你的app/Resources目录中直接创建一个同名bundle的文件夹. 然后将你要重写的模板按照原来的目录结构保存在里面.

b)创建一个继承FOSUserBundle的bundle并且重写模板

这种方式相对上面的方式来说会复杂一些.除非你计划重写控制器以及模板, 不然还是使用另外一个方法比较好.

如上所述, 你可以创建一个FOSUserBundle的子bundle, 并且将要重写的模板保存在与FOSUserBundle相同的位置.首先要做的是在你的bundle类中重写getParent方法.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php
// src/Acme/UserBundle/AcmeUserBundle.php

namespace Acme\UserBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;

class AcmeUserBundle extends Bundle
{
    public function getParent()
    {
        return 'FOSUserBundle';
    }
}

通过你的bundle类中getParent方法返回的bundle的名称, 你可以告诉Symfony框架你的bundle是继承自FOSUserBundle的.

一旦你将你的bundle定义成了FOSUserBundle的子bundle, 你就可以重写父级bundle中的模板文件了. 若要重写布局文件, 只需要在src/Acme/UserBundle/Resources/views文件夹中创建一个名为layout.html.twig的文件. 注意此文件在bundle中的路径应该与在FOSUserBundle中的路径一样.

一旦在你的子bundle中重写了模板, 你就需要清理缓存, 即使是在开发环境中也要清理.

重写FOSUserBundle中其他的模板文件的方式跟此文中介绍的方式相同.

原文地址: http://symfony.com/doc/current/bundles/FOSUserBundle/index.html

Symfony的安全组件为你提供了一个灵活的框架, 它允许你从配置文件, 数据库, 或者其他任何你想象的到的地方来加载用户. FOSUserBundle则建立在此基础上, 更方便快速的将用户信息存储到数据库之中.

准备工作
1.3.x版本的FOSUserBundle依赖于Symfony2.1+. 如果你使用的是Symfony2.0.x, 请使用1.2.x系列的版本.

翻译
如果你要使用此bundle提供的默认文本, 你必须保证你的配置文件中已经开启了翻译功能.

1
2
3
4

# app/config/config.yml

framework:
    translator: ~

更多关于翻译的信息, 请点击Symfonydocumentation

安装
整个安装过程有7个步骤:

1. 使用composer下载FOSUserBundle
2. 启用Bundle
3. 创建你的User类
4. 配置应用中的security.yml文件
5. 配置FOSUserBundle
6. 导入FOSUserBundle的路由文件
7. 更新数据库的Schema

步骤1:使用Composer下载FOSUserBundle

使用composer安装bundle:

1

$ composer require friendsofsymfony/user-bundle "~2.0@dev"

Composer会将bundle安装到你项目中的vendor/friendsofsymfony/user-bundle文件夹内.
如果你遇到了缺少配置参数的错误, 例如 The child node "db_driver" at path "fos_user" must be configured, 你应该先完成步骤5, 然后再重新执行这一步.

步骤2: 启用Bundle

在kernel中启用此bundle:

1
2
3
4
5
6
7
8
9
10
11

<?php
// app/AppKernel.php

public function registerBundles()
{
    $bundles = array(
        // ...
        new FOS\UserBundle\FOSUserBundle(),
        // ...
    );
}

步骤3:创建你的用户类

FOSUserBundle自始至终是使用一些User类来操作数据库的 (MySql, MongoDB, CouchDB, 等等). 你首先应该为你的应用创建一个User类.这个类可以包含任何你觉得有用的方法和属性. 因为这是你的User类.
FOSUserBundle提供了一些已经映射了大多数字段的基类, 这个类能让你更简单的创建entity. 你可以这么使用:

1. 继承User的基类.
2. 映射id字段. 它必须被设为protected, 因为在父类中他已经被定义过了.

当你继承了FOSUserBundle提供的已经做过映射的超类时, 不要定义其他已经定义好的映射.

接下来你将看到根据你存储方式的不同如何来定义你的User类(Doctrine ORM, MongoDB ODM, 或 CouchDB ODM).

如果在你的 User 类中重写了__construct()方法, 请务必执行 parent::__construct(), 因为User基类通过这个方法初始化了一些字段.

a)Doctrine ORM User class

如果你通过Doctrine ORM来管理用户, 你的User类应该存在Entity命名空间之内, 就像这样.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?php
// src/AppBundle/Entity/User.php

namespace AppBundle\Entity;

use FOS\UserBundle\Model\User as BaseUser;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="fos_user")
 */
class User extends BaseUser
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;

    public function __construct()
    {
        parent::__construct();
        // your own logic
    }
}

user在标准SQL中是一个保留字, 如果你需要使用这个保留字, 那就要用反引号把它包围起来.就像这样 @ORM\Table(name=”`user`“)

b)MongoDB User class

假如你使用 Doctrine MongoDB ODM来操作你的用户, 那你的User类应该在你的bundle中的Document命名空间之内, 就像下面这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?php
// src/AppBundle/Document/User.php

namespace AppBundle\Document;

use FOS\UserBundle\Model\User as BaseUser;
use Doctrine\ODM\MongoDB\Mapping\Annotations as MongoDB;

/**
 * @MongoDB\Document
 */
class User extends BaseUser
{
    /**
     * @MongoDB\Id(strategy="auto")
     */
    protected $id;

    public function __construct()
    {
        parent::__construct();
        // your own logic
    }
}

c) CouchDB User class
如果你通过Doctrine CouchDB ODM来错做用户, 你的User类应该在CouchDocument命名空间中, 就像这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?php
// src/AppBundle/CouchDocument/User.php

namespace AppBundle\CouchDocument;

use FOS\UserBundle\Model\User as BaseUser;
use Doctrine\ODM\CouchDB\Mapping\Annotations as CouchDB;

/**
 * @CouchDB\Document
 */
class User extends BaseUser
{
    /**
     * @CouchDB\Id
     */
    protected $id;

    public function __construct()
    {
        parent::__construct();
        // your own logic
    }
}

步骤4:配置应用中的security.yml文件

为了让Symfony的安全组件能够使用FOSUserBundle, 你需要配置security.yml文件. security.yml包含了应用安全组件的基本配置.
下面是能够使用FOSUserBundle的必须配置.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# app/config/security.yml
security:
    encoders:
        FOS\UserBundle\Model\UserInterface: bcrypt

    role_hierarchy:
        ROLE_ADMIN:       ROLE_USER
        ROLE_SUPER_ADMIN: ROLE_ADMIN

    providers:
        fos_userbundle:
            id: fos_user.user_provider.username

    firewalls:
        main:
            pattern: ^/
            form_login:
                provider: fos_userbundle
                csrf_token_generator: security.csrf.token_manager
                # if you are using Symfony < 2.8, use the following config instead:
                # csrf_provider: form.csrf_provider

            logout:       true
            anonymous:    true

    access_control:
        - { path: ^/login$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/register, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/resetting, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/admin/, role: ROLE_ADMIN }

在providers部分, 你通过fos_userbundle别名来使用FOSUserBundle中可用的的用户服务提供者.它的id是fos_user.user_provider.username.

下面我们来看firewalls部分. 这里我们申明了一个防火墙名为main. 通过指定form_login, 你需要告诉Symfony框架在任何时候的请求发送到这个防火墙时
都将引导用户进行认证, 不然用户将被重定向到一个表单页来输入他的凭证.

在access_control部分你可以指定用户在访问你应用中特殊的地址时所需要的凭证.bundle指定未认证用户能够在登录表单以及所有的路由中创建用户和重置密码.
这就是为什么你指定任何请求去匹配/login或者以/register 和 /resetting开头的地址时,将用户类型指定为匿名用户了.你肯定也注意到了, 任何以/admin开头的请求地址都需要用户为ROLE_ADMIN的身份.

更多关于security.yml文件的配置, 请查阅Symfony安全组件文档

请注意我们在防火墙中配置的名称main, 你将在下一个步骤中使用它来配置FOSUserBundle.

步骤5:配置FOSUserBundle

现在我们配置的security.yml已经能够让FOSUserBundle正确的运行了, 接下来我们来为应用配置一些特定的需求.
根据你使用的数据库类型, 添加下面的配置信息到你的config.yml文件中.

1
2
3
4
5

# app/config/config.yml
fos_user:
    db_driver: orm # other valid values are 'mongodb', 'couchdb' and 'propel'
    firewall_name: main
    user_class: AppBundle\Entity\User

仅需配置三个必须的配置项:

• 你使用的数据库类型.(orm, mongodb, couchdb)
• 你在步骤4中配置的防火墙名字.
• 在步骤3中创建的User类的全路径名.

步骤6:导入FOSUserBundle的路由文件

现在你已经配置并且启用了整个bundle, 剩下的就是要导入所有的FOSUserBundle路由文件.
通过导入路由文件, 你将会生成一些现成的页面, 比如登录, 创建用户等等.

1
2
3

# app/config/routing.yml
fos_user:
    resource: "@FOSUserBundle/Resources/config/routing/all.xml"

为了正常的使用内部的邮件功能(用于用户激活以及重置密码功能), 你必须配置并且启用了SwiftmailerBundle

步骤7:更新数据库的Schema

至此, 整个bundle已经配置完毕, 因为在步骤4中你创建了User类并且添加了新的entity, 所以现在你要做的就是更新你的数据库Schema.
如果使用ORM,请执行下面命令.

1

$ php bin/console doctrine:schema:update --force

若使用的是MongoDB, 你则需要执行下面命令来创建索引.

1

$ php bin/console doctrine:mongodb:schema:create --index

现在你可以在http://app.com/app_dev.php/login地址中登录了.

下一步
现在你已经完成了FOSUserBundle的基本安装与配置, 可以了解一些更高级的特性.
比如下面这些可用的文档:
重写FOSUserBundle的默认模板
挂载到控制器
重写FOSUserBundle的默认控制器
重写FOSUserBundle的默认表单
关于FOSUserBundle的用户管理服务
FOSUserBundle命令行管理工具
FOSUserBundle之使用用户名或密码登录
FOSUserBundle用户名表单字段
FOSUserBundle的邮件服务
使用FOSUserBundle进行分组(待翻译)

前期准备

• 将phpstorm跟项目所在的vagrant虚拟机做关联:
  依次进入 Settings -> Tools -> Vagrant

  

  注意配置好红框里面的本地vagrant环境变量以及对应的vagrant虚拟机目录

然后就可以使用工具栏中的vagrant来管理对应的虚拟机了, 详见工具栏: Tools -> Vagrant

• 配置好phpstorm中的php解释器 进入下面的页面添加php解释器

  

  注意设置好宿主机与vagrant虚拟机之间的目录映射关系.

  

  配置完全之后, php的解释器就如上图所示, 注意将 PHP language level 与你配置的解释器版本对应好.

配置PHPUnit

• 进入 Settings -> Language & Frameworks -> PHP -> PHPUnit 远程PHPUnit解释器

  

  注意选好对应的PHPUnit类库, 通常是选择 Use custom autoloader 或者 phpunit.phar

  • 选择 autoloader 的时候, 我们将对应的 path 设置成 vender 目录中的 autoloader.php 文件
    并且在项目中使用 composer 安装好相应的 PHPUnti 扩展即可.
  • 选择 phpunit.phar 需将 Path 设置为 vagrant 虚拟机中安装好的 PHPUnit 扩展路径.

配置测试目录

点击工具栏 Run -> Edit Configuration 进行相应配置

添加PHPUnit配置

设置好要测试的文件夹或者文件

参考文章

PHPUnit手册
PhpStorm中测试应用
在PhpStorm中管理vagrant
使用PhpStorm在远程服务器上执行PHPUnit测试
Symfony测试文档

1
2
3
4
5
6
7
8
9
10
11
12

project/
--app/
----controllers/
------dashboard.controller.js
----directives/
------yep-nope.directive.js
----services/
------github-status.service.js
----app.js
--js/
----angular.min.js
--index.html

• 步骤一
  为了达到减少网络请求的目的, 我们希望最终的html文件里面仅存在两个js文件 vendor.bundle.js 和
  app.bundle.js 所以咱们可以现在 index.html页面里面引入这两个js文件, 例如:

  <script src='js/vendor.bundle.js'></script><script src='js/app.bundle.js'></script>

• 步骤二: 安装依赖
  进入项目目录, 进行npm的初始化, 在终端键入 npm init -y
  安装必须的依赖包

  1	npm install angular webpack --save-dev

• 步骤三: 配置webpack
  在你的项目根目录创建 webpack.config.js 文件
  内容如下:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  var webpack = require('webpack'); module.exports = { context: __dirname + '/app', entry: { app: './app.js', vendor: ['angular'] }, output: { path: __dirname + '/js', filename: 'app.bundle.js' }, plugins: [ new webpack.optimize.CommonsChunkPlugin("vendor", "vendor.bundle.js") ] };

  这个文件中主要包含三个关键点context, entry, 和 output.

  • context: 项目源文件的绝对路径
  • entry: 你的angular应用的主文件. 在这个例子中, 我们设置了一个包含app和vendor键名的对象, 一边产生多个bundle文件.

  • output: 定义编译后的bundle的文件保存的路径以及文件名.

    这里还有一个plugins选项. 他允许我们将一些第三方的库文件合并为一个js文件. 更多配置

• 步骤四: 引入模块
  如果此时你打包你的代码, webpack只会将app.js中的代码打包起来. 那是因为我们并没有在app.js里面引入其他代码.
  接下来你可以引入任何你需要的代码就像这样:

  1 2 3 4 5

  // app.js ... require('./directives/yep-nope.controller'); require('./services/github-status.service'); require('./controllers/dashboard.controller');

  在一些小的项目里面可以这么做, 但在大型的项目中, 这样做并不合适.

  相比在文件中直接引入一些控制器文件, 我们可以在controllers文件夹内创建一个index.js文件. 这个文件将为我们引入所有控制器的入口:

  1 2 3 4 5 6

  'use strict'; var angular = require('angular'); angular.module('dashboard') .controller('dashboardController', require('./dashboard.controller'));

  现在你controller文件夹下面的控制器文件看起来应该是像这样的:

  1 2 3 4 5 6 7 8 9 10

  'use strict'; DashboardController.$inject = ['GithubStatusService']; function DashboardController(gh) { var _this = this; _this.github = ''; gh.getStatus().success(function(status) { _this.github = status; }); } module.exports = DashboardController;

  同样, 在directives文件夹中我们也可以这么做. 创建一个index.js文件来引导所有的指令. directives文件夹下的index.js文件可以这么写

  1 2 3 4 5

  'use strict'; var angular = require('angular'); angular.module('dashboard').directive('yepNope', require('./yep-nope.directive'));

  services目录下的index.js文件

  1 2 3 4 5 6 7

  'use strict'; var angular = require(‘angular’); angular.module(‘dashboard’).service(‘GithubStatusService’, require(‘./github-status.service’)); module.exports = GithubStatusService;

  最后一行应该是 module.exports = GithubStatusService;

  最终我们的app.js文件仅有这些:

  1 2 3 4 5

  // app.js ... require('./directives'); require('./services'); require('./controllers');

  当你的应用越来越大的时候, 你需要添加新的directives, services , 以及 controllers 你仅需要在directives/index.js services/index.js, 或者 controllers/index.js 中添加你要引入的文件.

  OK, 我们的angular应用已经准备好了. 接下来就是使用webpack来进行打包了.

• 步骤五: 配置任务
  我们在根目录下的 package.json 文件中的script 选项中添加任务, 然他来执行webpack, 就像这样.

  1 2 3 4

  "scripts": { "test": "echo \"Error: no test specified\" && exit 1", "bundle": "webpack" },

  在终端中, 你输入命令: npm run bundle

  稍等片刻, 打包完毕之后你会看见:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  angular-webpack@1.0.0 bundle /Users/ken/Projects/angular-webpack webpack Hash: fa17ee9ecec0b19a73ae Version: webpack 1.12.12 Time: 550ms Asset Size Chunks Chunk Names app.bundle.js 1.42 kB 0 [emitted] app vendor.bundle.js 1.12 MB 1 [emitted] vendor [0] ./app.js 82 bytes {0} [built] [0] multi vendor 28 bytes {1} [built] [1] ./services/index.js 145 bytes {0} [built] [4] ./services/github-status.service.js 373 bytes {0} [built] [5] ./controllers/index.js 147 bytes {0} [built] [6] ./controllers/dashboard.controller.js 278 bytes {0} [built] + 2 hidden modules

  在浏览器中运行应用

  >> open index.html

基于webpack的angular开发环境就搭建结束.

原文链接
翻译水平有限, 如果有看不懂的地方, 可以直接查看项目源码

示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

//定义Persion 类
function Persion(name, age) {
    this.name = name;
    this.age = age;
}

Persion.prototype.hi = function(){
    console.log("Hi my name is " + this.name + ", I'm " + this.age + ' years old now.');
}

Persion.prototype.LEGS_NUM = 2;
Persion.prototype.ARMS_NUM = 2;
Persion.prototype.walk = function(){
    console.log(this.name + " is walking...");
}

//定义Student 类
function Student(name, age, className){
Persion.call(this, name, age);
this.className = className;
}

//将Student类的原型指向Persion的原型
Student.prototype = Object.create(Persion.prototype);
Student.prototype.constructor = Student;

//复写Persion中的hi 方法
Student.prototype.hi = function(){
console.log("Hi my name is " + this.name + ", I'm " + this.age + " years old now, and from " + this.className + "." );
}

//定义Student中的learn 方法
Student.prototype.learn = function(subject){
console.log(this.name + " is learning " + subject + " at " + this.className);
}




//实例化Student类
var jack = new Student("Jack", 27, 'Class 3, Greade 2');

jack.hi();//Hi, my name is Jack, I'm 27 years old now, and from Class 3, Greade 2.
jack.LEGS_NUM;// 2
jack.ARMS_NUM;// 2
jack.learn('math')  // Jack is learning math at Class 3, Greade 2.

单元测试是专注于那些不连续的代码. 在面向对象的代码里,单元测试的重点是在一个对象里面的每个方法上. 在程序代码中,单元测试专注于函数,甚至偶尔在全局变量中. 其目的仅仅是为了去确认每个单元都能按照预期的职责去运行.

大多数为Drupal编写的测试都不是单元测试.相反,他们是一些功能测试. 也就是说, 测试是为了验证在Drupal中插入的代码是否与预期的功能一样,并且与其他代码相吻合. 这是一个比单元测试更广泛的测试种类. 测试可以精确的测量更大的代码块的准确性.

测试模块已经默认包含在Drupal7中,但是他是没有被默认启用的.一旦他启用了,你就可以在 Configuration->Development 找到Testing的配置页面.

测试应该存在自己的文件中,就像模块的主代码存放在 modulename/modulename.module之中一样,测试文件也应该在
modulename/modulename.test中,这样测试框架变会自动去检索到它

起步:

就像在模块里的其他文件一样,测试文件也必须被写在.info文件当中.所有我们需要加入的文件都必须填写在 .info文件里面的 files 数组之中.

;$Id$name = Firstdescription = A first module.core = 7.xpackage = Drupal 7 Developmentfiles[] = first.modulefiles[] = first.test

每当你的模块安装了之后,Drupal都会去缓存.info文件里面的内容.一旦你在.info文件里面添加了一个新的项目,你就必须去重新访问一下Drupal的模块页面,来强制Drupal重新解析.info文件.
(保险起见,这里建议 进入 Configuration->Development->Performance 中Clear all caches)

编写测试部件:

大多数部件遵循下面这个简单的样本:

1. 创建一个继承DrupalWebTestCase 类
2. 添加一个getInfo() 函数
3. 在setUp() 方法里面设置一些必要的配置
4. 以单词test开始来编写一些方法
5. 在每个测试方法中,为测试的实际值来使用一个或多个声明

当我们在进行我们自己的测试的时候,我们将按照上面的每一步来测试.

<?php/*** @file* Tests for the first module*/class FirstTestCase extends DrupalWebTestCase {// Methods will go here.}

这个测试部件继承了一个叫做 DrupalWebTestCase的基类. 这个基类为测试提供了许多工具.测试案例不必要陈列或者使用核心逻辑.
出于这两种原因,每个Drupal测试必须继承这个基类,或者继承另外一个继承了这个基类的其他类.
一旦我们声明了这个类,我们就可以创建我们的第一个方法,getInfo().

命名约定与类
Drupal的function命名都是以小写字母命名的,并且用下划线来分割单词,但是类和方法的命名却不是这样的.类的命名应该以大写字母开头的驼峰式写法,例如”CamelCase”,方法的命名则是以小写字母开头的驼峰试写法,例如 “camelCase”.下划线是不允许出现在类与类方法的名称当中的.

在之前,我们已经看到Drupal使用一些嵌套的数组来传递信息.例如我们之前创建的 first_block_info() 方法就是这样做的.
在DrupalWebTestCase::getInfo() 方法里面,同样也是返回一个关联数组.此时返回的信息就是关于这个测试的.

<?php/** * @file * Tests for the first module */class FirstTestCase extends DrupalWebTestCase {    public function setUp() {      parent::setUp('first');    }    public static function getInfo() {      return array(        'name' => 'First module block functionality',        'description' => 'Test blocks in the First module',        'group' => 'First',      );    }}

这个getInfo()方法返回的是一个带有三个项目的数组,这三个项目分别是:

1. name: 测试的名称
2. description:关于这个测试的一句话描述
3. grup:这个测试所属于的组

这三个项目都是旨在为人类所读取的信息. 前面两个是纯粹的参考信息,第三个是将类似的测试罗列在相同的标题下.
getInfo()函数看上去是不起眼的,但你的测试必须得包含他,也就是说,如果没有这个函数,你的测试将无法被执行 .

设置测试:

<?php/*** @file* Tests for the first module*/class FirstTestCase extends DrupalWebTestCase {  public function setUp() {    parent::setUp('first');  }  public function getInfo() {    return array(      'name' => 'First module block functionality',      'description' => 'Test blocks in the First module.',      'group' => 'First',    );  }}

setUp()方法不是必须的,但当你一旦使用他的时候,你就必须写一行上述代码,就是如下:

parent::setUp('first');

这是告诉setUp()方法去启用存在于DrupalWebTestCase类里面的setUp()方法.
这么做的目的,是为了去初始化我们要测试的模块,这也意味着我们不需要去启动我们的模块,来进行测试代码的编写.
当你在编写你的测试部件的时候,你也可以在parent::setUp()请求下方编写你自己的配置信息,在之后我们将看到相关例子.

编写测试方法:

测试部件的大多数的方法是测试方法,他们仅仅是用来验证模块是否正常工作.就像你看到的一样,没有任何代码中调用了这些方法.
那么简单测试是如何调用我们的方法呢?就像Drupal的钩子约定一样,任何以test开头的方法是会被测试框架自动执行.

<?php/** * @file * Tests for the first module */class FirstTestCase extends DrupalWebTestCase {    public function setUp() {      parent::setUp('first');    }    public static function getInfo() {      return array(        'name' => 'First module block functionality',        'description' => 'Test blocks in the First module',        'group' => 'First',      );    }    public function testBlockInfo() {      $info = module_invoke('first', 'block_info');      $this->assertEqual(1, count($info),        t('Module define a block.'));      $this->assertTrue(isset($info['list_modules']),        t('Module list exists.'));    }    public function testBlockView() {      $data = module_invoke('first', 'block_view','list_modules');      $this->assertTrue(is_array($data),        t('Block returns readerable array.'));      $this->assertEqual(t('Enabled Modules'), $data['subject'],        t('Subject is set'));    }}

上面的代码包含了两个测试的成员方法,就像他们的名字一样,每个方法都是负责之前创建的两个区块方法的测试.
他们做了三个事情:
首先,他运行了一个叫做 module_invoke()的函数,并且用$info来存储了他的结果.module_invoke()函数主要是用来请求特定的模块里面的特定的钩子. module_invoke()方法有两个参数: 模块的名称,钩子的名称. 类似与module_invoke('first','block_info')这样的请求就好比在请求first_block_info()钩子,这样做的好处就是能确保他被钩子系统所挂载.为达到我们的预期,我们做了一个成对的断言. 测试框架会有效的验证这些断言,如果方法正如预期,则通过,否则失败.
我们先看看 first_block_info() 测试方法
这里做了两个测试:

$this->assertEqual(1, count($info),  t('Module defines a block.));$this->assertTrue(isset($info['list_modules']),  t('Module list exists.'));

(注意,这些代码都为了格式化,把一行分割成了两行)

每个断言都有$this->assertSOMETHING($conditions,$message) 这样的格式,其中 SOMETHING表示断言的种类,$conditions 是断言满足并且可以通过的条件,$message就是一个测试的描述. 在我们的第一个测试中,1 与 count($info) 应该是相等的.断言方法都存在于 DrupalWebTestCase这个父类当中,这个类提供了十几种断言方法来使测试进行的更简单.

在例子中我们的断言是这样的:

• $this->assertEqual():第一个值(已知)等于第二值(测试值)的断言.
• $this->assertTrue():给定结果为TRUE的断言.
  第一个断言验证了我们在block_info()钩子里面定义的block,第二个断言验证了这个block的名字是否为list_modules.
  这样,当我们的测试进行的时候,我们就可以确定我们的info钩子是否返回了关于我们的简单的区块的信息.

再看看first_block_view()的测试.

public function testBlockView() {    $data = module_invoke('first', 'block_view',        'list_modules');    $this->assertTrue(is_array($data),        t('Block returns renderable array.'));    $this->assertEqual(t('Enabled Modules'), $data['subject'],        t('Subject is set'));}

这次我们执行的是 block_view()钩子.并且再次执行了两个断言.第一个断言确认了first_block_view()返回的是否是一个数组.第二个断言验证了他的标题是否与我们预期的一样,为 Enabled Modules.

编写完毕,我们就可以去 Configuration-> Testing 里面去选中我们的测试,并且运行他了,看看结果吧,你的测试是否都通过了呢!

Drupal7模块开发 系列是 由 Drupal 7 Module Development 英文版翻译过来的, 主要用于学习drupal的模块开发. 至于翻译质量, 我只能说尽力了, 大家凑活看吧, 鄙人文字功底有限. 如果有些地方真的被我翻译到误人子弟的地步, 恳请大家指正.

模块命名

Drupal的模块有两个名字,人读名与机读名.

人读名: 是由首字母大写的且用空格分开的单词组成,例如:Views, Eldorado Superfly等等.

机读名: 是由小写字母,数字和下划线组成的字符串,且不允许有其他字母.例如上面两个模块的机读名字则应该为:views和eldorado_superfly.

按照惯例这两个名字应该差不多,而且通常应该将大写祖母转化为小写字母.

模块存放位置

Drupal 的自定义模块通常是用来存放在 /sites/default/modules 文件夹下面, 这样做的好处是可以与标准模块分开,以便更容易找到自己没有整理的杂乱的代码.

Drupal中自定义模块如果放在 /sites/default 文件夹中, 只能被默认站点所加载. 这意味着, 在实践中如果把模块放在 /sites/default/modules 文件夹下,根本不会加载到其他站点中. 在这种情况下, 一般会建议把自定义模块放在/sites/all/modules/custom 这个文件夹下.

创建模块文件夹

模块可以以多种途径来进行组织, 但是实践证明, 最好的选择还是得将模块放在 /sites/defualt/modules 文件夹下,并且模块中至少得有两个文件a.info以及a.module

文件夹,以及文件夹下的.info文件和.module文件,都必须以机读名的方式来命名. 且.info和.module文件只能被设定为只读模式

• 编写.info文件
  .info 文件是为Drupal提供信息的文件. 其中的信息包括:模块人读名, 此模块所要请求的其他模块, 以及此模块提供了哪些代码文件.
  一个.info文件是一个类似于.ini标准的控制文件. 在.info文件中的指令是由: 名称, 等号, 值.这三个元素组成的. 例如:

  name = value

  或者以数组的形式进行申明,例如:

  name[] = value1name[] = value2

  (注意,两个方括号中间没有空格)

  drupal的编码规范中,在等号两端通常都有一个空格符号.
  如果一个值的跨度超过一行, 那他应该被包含在一个括号之中.
  在drupal的ini解释器中,任何以分号开头的代码都将作为注释,被忽略掉.

• 编写.module文件
  .module 文件一般是一个包含了模块所使用的主要的钩子的PHP文件.
  下面是一个简单的help钩子的代码

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  <?php
  // $Id$
  /**
   * @file
   * A module exemplifying Drupal coding practices and APIs.
   *
   * This module provides a block that lists all of the
   * installed modules. It illustrates coding standards,
   * practices, and API use for Drupal 7.
   */
  
   /**
    * Implements hook_help().
    */
   function first_help($path, $arg) {
     if ($path == 'admin/help#first') {
       return t('A demonstration module.');
     }
   }
  

  在上述代码中有以下代码规范:

  • 所有的PHP 和 Javascript文件的都使用两格空格来进行缩进, tab是不允许使用在任何代码里.
  • 在一个完全的PHP文件代码中,通常是省略结尾部的结束标签代码 ‘?>’. 这是要防止夹杂着的空白来打断HTTP的标头.
  • Drupal 是使用 Doxygen-styel风格来注释(/* /)方法,类,界面,常亮,文件,全局文件的. #号是不允许使用在注释之中的.
  • 在运算符两边必须有一个空格的.
  • 所有的控制流程代码都必须包括在大括号之内.即使if的控制流程代码只有一行主体代码,也是需要用大括号包裹起来.
  • 方法的命名都是用小写字母以及下划线来分割单词.
  • 变量名是使用小写字母以及下划线来分割单词之间的空格的.

• 翻译函数 t() 和翻译
  翻译函数必须遵循如下写法:

  t('This is my string');

  不能以下面的方式来写:

  $variable = 'This is a string';t($variable);

  这是因为t()函数, 他不执行代码, 只是读取代码.
  t()函数接受一个可选参数，这是个关联数组. 例如:

  $values = array('@user' => $username);print t('Welcome, @user', $values);

  这两行代码中,申明@user为占位符,值为变量$username的值.当t()函数被调用时, $values的映射将替换掉要被翻译语句中的占位符.
  如果占位符使用@符号开头, 则Drupal将在插入翻译之前, 对这个值使用check_plain()方法来进行过滤.
  如果你确定你的字符串没有任何危险,则可以使用感叹号(!)开头来命名占位符.但这样做,drupal将直接插入这个值,而不进行过滤.这在不需要对你要插入的数据进行翻译的时候,是非常有用的. 像这样写:

  $values = array('!url' => 'http://example.com');print t('The website can be found at !url', $values);

  百分号开头的占位符,可以在值插入之前进行安全过滤,并且强制值为文本类型;(用em标签包围),像这样写:

  $values = array('%color' => 'blue');print t('My favorite color is %color.', $values);