当前位置：首页 > CMS教程 > 其它CMS > 列表

Symfony2框架学习笔记之表单用法详解

发布:smiling　来源: PHP粉丝网 　添加日期：2021-07-18 10:02:22　浏览: 评论：0　

这篇文章主要介绍了Symfony2框架学习笔记之表单用法,结合实例形式详细分析了Symfony2针对表单的创建,校验,提交等各种常用技巧,需要的朋友可以参考下。

本文实例讲述了Symfony2框架表单用法，分享给大家供大家参考，具体如下：

对于一个Web开发者来说，处理HTML表单是一个最为普通又具挑战的任务。Symfony2集成了一个Form组件，让处理表单变的容易起来。在这一节里，我们将

从基础开始创建一个复杂的表单，学习表单类库中最重要的内容。

Symfony2 的Form组件是一个独立的类库，你可以在Symfony2项目之外使用它。

创建一个简单的表单：

假设你要创建一个应用程序的todo列表，需要显示一些任务，因为你的用户需要编辑和创建任务，所以你需要创建一个表单，在你开始之前，首先来看通用的Task类，用来表示和存储一个单一任务的数据：

  1. // src/Acme/TaskBundle/Entity/Task.php 
  2. namespace Acme\TaskBundle\Entity; 
  3. class Task 
  4. { 
  5.   protected $task; 
  6.   protected $dueDate; 
  7.   public function getTask() 
  8.   { 
  9.     return $this->task; 
  10.   } 
  11.   public function setTask($task) 
  12.   { 
  13.     $this->task = $task; 
  14.   } 
  15.   public function getDueDate() 
  16.   { 
  17.     return $this->dueDate; 
  18.   } 
  19.   public function setDueDate(\DateTime $dueDate = null) 
  20.   { 
  21.     $this->dueDate = $dueDate; 
  22.   } 
  23. } 

如果你是按照我们提供的示例编码，那么你需要先创建一个AcmeTaskBundle：

$ php app/console generate:bundle --namespace=Acme/TaskBundle

该类是一个普通的PHP对象类，因为他们没有任何Symfony或者其它类库引用。非常简单的一个PHP对象类，它直接解决的是你程序中表现task的数据。当然，在本节的最后，你将能够通过HTML表单提交一个Task实例数据，校验它的数值，并把它持久化到数据库。

创建一个Form

现在已经创建了一个Task类，下一步就是创建和渲染一个真正的HTML表单了。在symfony2中，它是通过创建一个表单对象并渲染到模板的。现在，可以从controller内部处理form。

  1. //src/Acme/TaskBundle/Controller/DefaultController.php 
  2. namespace Acme\TaskBundle\Controller; 
  3. use Symfony\Bundle\FrameworkBundle\Controller\Controller; 
  4. use Symfony\Component\HttpFoundation\Request; 
  5. use Acme\TaskBundle\Entity\Task; 
  6. class DefaultController extends Controller 
  7. { 
  8.     //创建一个任务并给它一些假数据作为示例 
  9.     $task = new Task(); 
  10.     $task->setTask('Write a blog post'); 
  11.     $task->setDueDate(new \DateTime('tomorrow')); 
  12.     $form = $this->createFormBuilder($task) 
  13.        ->add('task','text') 
  14.        ->add('dueDate','date') 
  15.        ->getForm(); 
  16.     return $this->render('AcmeTaskBundle:Default:new.html.twig',array( 
  17.         'form' =>$form->createView(), 
  18.     )); 
  19. } 

上面的示例显示了如何直接在Controller中创建一个表单，为了可以让表单重用你完全可以在一个单独的类文件中创建表单。

因为Symfony2通过一个表单生成器“form builder"来创建表单对象，所以你可以使用很少的代码就能完成创建表单任务。表单生成器的目的是让你能编写简单的表单创建方法，让它来负责繁重的创建任务。

在这个示例中，你已经添加了两个字段到你的表单，一个是task一个是dueDate。它们关联到Task类的task和dueDate属性。你已经为它们分别指定了类型（比如，text，date等），由这些类型来决定为这些字段生成什么样的HTML表单标签。

Symfony2 拥有许多内建的类型，接下来我们将简单的介绍。

渲染一个表单

表单创建以后，下一步就是渲染它。这是通过传递一个特定的表单”view"对象（就是上例中的 $form->createView()返回的view对象）到你的模板并通过一些列的表单帮助函数来实现的。

Twig格式：

  1. {# src/Acme/TaskBundle/Resources/views/Default/new.html.twig #} 
  2. <form action="{{ path('task_new') }}" method ="post" {{ form_enctype(form) }}> 
  3.   {{ form_widget(form) }} 
  4.    <input type="submit" /> 
  5. </form> 

PHP代码格式：

  1. <!-- src/Acme/TaskBundle/Resources/views/Default/new.html.php --> 
  2. <form action="<?php echo $view['router']->generate('task_new') ?>" method="post" <?php echo $view['form']->enctype($form) ?> > 
  3.    <?php echo $view['form']->widget($form) ?> 
  4.    <input type="submit" /> 
  5. </form> 

在这里假设你已经创建了一个名叫task_new的路由指向AcmeTaskBundle:Default:new Controller。

就是这些了，通过打印form_widget(form),表单中的每个字段都会被渲染出来。同时还有一个文本标签和错误信息。是不是很简单，不过现在它还不够灵活。通常情况下，我们渴望单独渲染表单中的每一个字段，这样我们可以更好的控制表单的样式。我们会在在模板中渲染表单一节介绍。

在继续下去之前，我们注意到，为什么我们渲染出来的task输入框中有一个来自$task对象的属性值“Write a blog post"。这是表单的第一个工作：从一个对象中获取数据并把它转换为合适的格式渲染到一个HTML表单中。

注意，表单系统已经足够聪明，它们能够通过像getTask()和setTask()方法来访问Task类中受保护的属性task。除非一个是公共属性，否则必须有一个getter和setter方法被定义来用于表单组件从这些属性中获取和保持数据。对于布尔型的属性，你可以使用一个”isser"方法（比如 isPublished())替代getter方法(getPublished())。

处理表单提交

表单系统的第二个任务就是传递用户提交的数据回到一个对象的属性中，要做到这一点，用户提交的数据必须绑定到表单才行。添加如下代码到你的Controller类：

  1. //... 
  2. public function newAction(Request $request) 
  3. { 
  4.      //只是创建一个新的$task对象（不需要假数据） 
  5.     $task = new Task(); 
  6.     $form= $this->createFormBuilder($task) 
  7.        ->add('task','text') 
  8.        ->add('dueDate','date') 
  9.        ->getForm(); 
  10.     if($request->getMethod() == "POST"){ 
  11.        $form->bindRequest($request); 
  12.        if($form->isValid()){ 
  13.            //执行一些行为，比如保持task到数据库 
  14.            return $this->redirect($this->generateUrl('task_success')); 
  15.        } 
  16.     } 
  17.     //... 
  18. } 

现在，当表单被提交时，Controller可以绑定被提交的数据到表单，表单会把数据传回$task对象的task和dueDate属性。这些都在bindRequest()方法中完成。只要bindRequest()方法被调用，提交的数据就会立刻被传输到底层对象。不管数据是否被真正的校验通过。

controller一般会遵循一个通用的模式来处理表单，它有三个可能的途径：

1.当在浏览器初始加载一个页面时，请求方法是GET，表单处理仅仅是创建和渲染。

2.当用户提交带有不合法数据的表单（方法为POST)时，表单会并绑定然后渲染，这时候显示所有校验错误。

3.当用户提交的表单带有的数据均合法时，表单绑定并且在页面跳转之前你有机会去使用数据去执行一些业务逻辑活动，比如持久化它到数据库）。

表单校验

在前面我们提到了，如何提交一个带有合法数据和非法数据的表单。在Symfony2中，校验是在底层对象上进行的。换句话说，form表单合法与否不重要，主要看在表单提交数据以后，底层对象比如$task对象是否合法。调用$form->isvalid() 是一个询问底层对象是否获得合法数据的快捷方式。

校验是通过添加一些列规则（约束）到一个类来完成的。我们给Task类添加规则和约束，使它的task属性不能为空，duDate字段不能空并且是一个合法的DateTime对象。

YAML格式：

  1. # Acme/TaskBundle/Resources/config/validation.yml 
  2. Acme\TaskBundle\Entity\Task: 
  3.   properties: 
  4.     task: 
  5.       - NotBlank: ~ 
  6.     dueDate: 
  7.       - NotBlank: ~ 
  8.       - Type: \DateTime 

在Task类中声明格式：

  1. // Acme/TaskBundle/Entity/Task.php 
  2. use Symfony\Component\Validator\Constraints as Assert; 
  3. class Task 
  4. { 
  5.   /** 
  6.    * @Assert\NotBlank() 
  7.    */ 
  8.   public $task; 
  9.   /** 
  10.    * @Assert\NotBlank() 
  11.    * @Assert\Type("\DateTime") 
  12.    */ 
  13.   protected $dueDate; 
  14. } 

XML格式：

  1. <!-- Acme/TaskBundle/Resources/config/validation.xml --> 
  2. <class name="Acme\TaskBundle\Entity\Task"> 
  3.   <property name="task"> 
  4.     <constraint name="NotBlank" /> 
  5.   </property> 
  6.   <property name="dueDate"> 
  7.     <constraint name="NotBlank" /> 
  8.     <constraint name="Type"> 
  9.       <value>\DateTime</value> 
  10.     </constraint> 
  11.   </property> 
  12. </class> 

PHP代码格式：

  1. // Acme/TaskBundle/Entity/Task.php 
  2. use Symfony\Component\Validator\Mapping\ClassMetadata; 
  3. use Symfony\Component\Validator\Constraints\NotBlank; 
  4. use Symfony\Component\Validator\Constraints\Type; 
  5. class Task 
  6. { 
  7.   // ... 
  8.   public static function loadValidatorMetadata(ClassMetadata $metadata) 
  9.   { 
  10.     $metadata->addPropertyConstraint('task', new NotBlank()); 
  11.     $metadata->addPropertyConstraint('dueDate', new NotBlank()); 
  12.     $metadata->addPropertyConstraint('dueDate', new Type('\DateTime')); 
  13.   } 
  14. } 

就是这样了，如果你现在再提交包含非法数据的表单，你将会看到相应的错误被打印在表单上。

HTML5 校验

作为HTML5，许多浏览器都加强了客户端某些校验约束。最常用的校验活动是在一个必须的字段上渲染一个required属性。对于支持HTML5的浏览器来说，如果用户此时提交一个空字段到表单时，浏览器会显示提示信息。生成的表单广泛吸收了这些新内容的优点，通过添加一些HTML属性来监控校验。客户端校验可以通过添加novalidate属性到form标签或者formnovalidate 到提交标签而关闭。这对你想检查服务端校验规则时非常有用。

校验分组

如果你的对象想从校验组中受益，你需要指定你的表单使用哪个校验组。

  1. $form = $this->createFormBuilder($users, array( 
  2.   'validation_groups' => array('registration'), 
  3. ))->add(...) 
  4. ; 

如果你创建表单类，你需要添加羡慕的getDefaultOptions()方法：

  1. public function getDefaultOptions(array $options) 
  2. { 
  3.   return array( 
  4.     'validation_groups' => array('registration') 
  5.   ); 
  6. } 

在这两种情况下，只有registration 校验组将被用于校验底层对象。

内建字段类型

Symfony标准版含有大量的字段类型，它们几乎涵盖了所有通用表单的字段和数据类型。

文本字段：

  1. text 
  2. textarea 
  3. email 
  4. integer 
  5. money 
  6. number 
  7. password 
  8. percent 
  9. search 
  10. url 

选择字段：

  1. choice 
  2. entity 
  3. country 
  4. language 
  5. locale 
  6. timezone 

日期和时间字段：

  1. date 
  2. datetime 
  3. time 
  4. birthday 

其它字段：

checkbox

file

radio

字段组：

collection

repeated

隐藏字段：

hidden

csrf

基础字段：

field

form

当然，你也可以定义自己的字段类型。

字段类型选项

每一个字段类型都有一定数量的选项用于配置。比如，dueDate字段当前被渲染成3个选择框。而日期字段可以被配置渲染成一个单一的文本框，用户可以输入字符串作为日期。

->add('dueData','data', array('widget' = 'single_text'))

required选项:

最常用到的选项是required选项，它可以应用于任何字段。默认情况下它被设置为true。这就意味着支持HTML5的浏览器会使用客户端校验来判断字段是否为空。如果你不想让它发生，或者把在你的字段上把required选项设置为false，或者关闭HTML5校验。设置required为true并不意味着服务端校验被应用。换句话说，如果用户提交一个空数值到该字段，它将接受这个控制除非你使用Symfony的NotBlank或者NotNull校验约束。也就是说，required选项是很好，但是服务端校验还是要继续用。

label选项：

表单字段可以使用label选项设置显示字符标签，可以应用于任何字段：

  1. ->add('dueDate', 'date',array( 
  2.   'widget' =>'single_text', 
  3.   'label' => 'Due Date', 
  4. )) 

字段类型猜测：

现在你已经添加了校验元数据到Task类，Symfony早已经了解一点关于你的字段了。如果你允许，Symfony可以猜到你的字段数据类型并为你设置它。在下面的例子中，Symfony可以根据校验规则猜测到task字段是一个标准的text字段，dueDate是date字段。

  1. public function newAction() 
  2. { 
  3.   $task = new Task(); 
  4.   $form = $this->createFormBuilder($task) 
  5.     ->add('task') 
  6.     ->add('dueDate', null, array('widget' => 'single_text')) 
  7.     ->getForm(); 
  8. } 

当你省略了add方法的第二个参数（或者你输入null)时，Symfony的猜测能力就起作用了。如果你输入一个选项数组作为第三个参数（比如上面的dueDate),那么这些选项会成为Symfony猜测的依据。如果你的表单使用了指定的校验数组，字段类型猜测器将还是要考虑所有的校验规则来综合猜测你的字段类型。

字段类型可选项猜测

除了猜测字段类型，Symfony还能是这猜测一些可选项字段值。当这些可选项被设置时，字段将会被渲染到特定HTML属性中，让HTML5客户端来提供校验。

然而，它们不会在服务端生成相应的校验规则。尽管你需要手动的在服务端添加这些规则，但是这些字段类型选项还是能根据这些信息猜测到。

required： required规则可以在校验规则或者Doctrine元数据的基础上猜测到。这当你的客户端校验将自动匹配你的校验规则时很有用。

max_length: 如果字段是一些列文本字段，那么max_length选项可以从校验规则或者Doctrine元数据中猜到。

如果你喜欢改变一个猜到的数值，你可以通过在可选项数组中传递该选项来重写它。

->add('task',null, array('max_length'=>4))

在模板中渲染表单

到目前为止，我们已经看了一个完整的表单是如何通过一行代码被渲染的。当然，你通常需要更加灵活的渲染方式：

Twig格式：

  1. {# src/Acme/TaskBundle/Resources/views/Default/new.html.twig #} 
  2. <form action="{{ path('task_new') }}" method="post" {{ form_enctype(form) }}> 
  3.   {{ form_errors(form) }} 
  4.   {{ form_row(form.task) }} 
  5.   {{ form_row(form.dueDate) }} 
  6.   {{ form_rest(form) }} 
  7.   <input type="submit" /> 
  8. </form> 

PHP代码格式：

  1. <!-- // src/Acme/TaskBundle/Resources/views/Default/newAction.html.php --> 
  2. <form action="<?php echo $view['router']->generate('task_new') ?>" method="post" <?php echo $view['form']->enctype($form) ?>> 
  3.   <?php echo $view['form']->errors($form) ?> 
  4.   <?php echo $view['form']->row($form['task']) ?> 
  5.   <?php echo $view['form']->row($form['dueDate']) ?> 
  6.   <?php echo $view['form']->rest($form) ?> 
  7.   <input type="submit" /> 
  8. </form> 

让我们看看这组代码的详细：

form_enctype(form) 只要有一个字段是文件上传，那么它就会义务的设置为 enctype="multipart/form-data";

form_errors(form) 渲染任何整个form的任何错误信息(特定字段的错误，会显示在每个字段的下面一行）。

form_row(form.dueDate) 默认情况下，为给定的字段在一个div中渲染一个文本标签，任何错误，和HTML表单部件。

form_rest(form) 渲染没有指出的其余任何字段，通常在表单的末尾调用它防止遗忘或者渲染一些你不愿意手动设置的隐藏字段。它同时还能为我们提供CSRF保护。

大部分工作是由form_row帮助方法类完成的，它默认在一个div中为每个字段渲染显示标签，错误信息和HTML表单部件。

注意，你可以通过form.vars.value 来访问你当前是表当数据：

Twig格式：

{{ form.vars.value.task }}

PHP代码格式：

<?php echo $view['form']->get('value')->getTask() ?>

手工渲染每一个表单字段

form_row帮助器能让你很快的渲染你表单中的每一个字段，并且每一行可以被自定义化。但是生活不总是那么简单的，你也可能要手动的渲染每一个字段。

Twig格式：

  1. {{ form_errors(form) }} 
  2. <div> 
  3.   {{ form_label(form.task) }} 
  4.   {{ form_errors(form.task) }} 
  5.   {{ form_widget(form.task) }} 
  6. </div> 
  7. <div> 
  8.   {{ form_label(form.dueDate) }} 
  9.   {{ form_errors(form.dueDate) }} 
  10.   {{ form_widget(form.dueDate) }} 
  11. </div> 
  12. {{ form_rest(form) }} 

PHP代码格式:

  1. <?php echo $view['form']->errors($form) ?> 
  2. <div> 
  3.   <?php echo $view['form']->label($form['task']) ?> 
  4.   <?php echo $view['form']->errors($form['task']) ?> 
  5.   <?php echo $view['form']->widget($form['task']) ?> 
  6. </div> 
  7. <div> 
  8.   <?php echo $view['form']->label($form['dueDate']) ?> 
  9.   <?php echo $view['form']->errors($form['dueDate']) ?> 
  10.   <?php echo $view['form']->widget($form['dueDate']) ?> 
  11. </div> 
  12. <?php echo $view['form']->rest($form) ?> 

如果自动生成显示标签不准确，那么你可以显式的指定它：

Twig格式：

{{ form_label(form.task, 'Task Description') }}

PHP代码格式：

<?php echo $view['form']->label($form['task'], 'Task Description') ?>

一些字段类型有一些额外的渲染选项可以传入widget，一个常用的选项为attr，它允许你修改表单元素的属性。下面的示例将添加task_field class到渲染的文本输入字段：

Twig格式：

{{ form_widget(form.task, {'attr': {'class':'task_field'} }) }}

PHP代码格式：

<?php echo $view['form']->widget($form['task'], array(

'attr' => array('class' => 'task_field'),

)) ?>

如果你想手工渲染表单字段，你可以单独访问每个字段的值，比如id,name和label，这里我们获取id

Twig格式：

{{ form.task.vars.id }}

PHP代码格式：

<?php echo $form['task']->get('id') ?>

需要获取表单字段名称属性你需要使用full_name值：

Twig格式：

{{ form.task.vars.full_name }}

PHP代码格式：

<?php echo $form['task']->get('full_name') ?>

创建表单类

正如你看到的，一个表单可以直接在controller类中被创建和使用。然而，一个更好的做法是在一个单独的PHP类中创建表单。它可以被重用到你应用程序的任何地方。创建一个新类来保存生成task表单的逻辑：

  1. // src/Acme/TaskBundle/Form/Type/TaskType.php 
  2. namespace Acme\TaskBundle\Form\Type; 
  3. use Symfony\Component\Form\AbstractType; 
  4. use Symfony\Component\Form\FormBuilder; 
  5. class TaskType extends AbstractType 
  6. { 
  7.   public function buildForm(FormBuilder $builder, array $options) 
  8.   { 
  9.     $builder->add('task'); 
  10.     $builder->add('dueDate', null, array('widget' => 'single_text')); 
  11.   } 
  12.   public function getName() 
  13.   { 
  14.     return 'task'; 
  15.   } 
  16. } 

这个新类包含了所有创建一个task表单所需要的内容，注意getName()方法将返回一个该表单类型的唯一标识，用于快速创建该表单。

  1. // src/Acme/TaskBundle/Controller/DefaultController.php 
  2. // 在类上添加这个新的引用语句 
  3. use Acme\TaskBundle\Form\Type\TaskType; 
  4. public function newAction() 
  5. { 
  6.     $task = // ... 
  7.     $form = $this->createForm(new TaskType(), $task); 
  8.     // ... 
  9. } 

设置data_class

每个表单都需要知道它底层保存数据的类名称，（比如Acme\TaskBundle\Entity\Task)。通常情况下，是根据createForm方法的第二个参数来猜测的。以后，当你开始嵌入表单时，这个可能就不怎么充分了，所以，通常一个好的方法是通过添加下面代码到你的表单类型类来显式的指定data_class 选项。

  1. public function getDefaultOptions(array $options) 
  2. { 
  3.    return array( 
  4.         'data_class' => 'Acme\TaskBundle\Entity\Task', 
  5.    ); 
  6. } 

当然，这种做法也不总是必须的。

当你映射表单到一个对象是，所有的字段都被映射。 表单的任何字段如果在映射的对象上不存在那么就会造成抛出异常。在这种情况下，你需要在表单中获取字段（比如，一个“你同意这些说法吗？”复选框）将不能映射到底层对象，那么你需要设置property_path为false以避免抛出异常。

  1. public function buildForm(FormBuilder $builder, array $options) 
  2. { 
  3.      $builder->add('task'); 
  4.      $builder->add('dueDate', null, array('property_path' => false)); 
  5. } 

另外，如果有任何的表单字段没有被包含着提交的数据中，那么这些字段需要显式的设置为null。

在controller类中我们可以访问字段数据：

$form->get('dueDate')->getData();

Forms和Doctrine

表单的目的是把数据从一个底层对象传递给一个HTML表单然后把用户提交的数据传回到原先的底层对象。因此，底层对象把数据持久化到数据库就跟表单没有任何的关系了。但是，如果你已经配置了底层类是通过Doctrine来持久化，（你已经定义了映射元数据在底层类），接下来当表单提交数据后，当表单合法后就可以持久化它了。

  1. if ($form->isValid()) { 
  2.   $em = $this->getDoctrine()->getEntityManager(); 
  3.   $em->persist($task); 
  4.   $em->flush(); 
  5.   return $this->redirect($this->generateUrl('task_success')); 
  6. } 

如果处于某种原因，你不想访问原有的$task对象，你可以从表单中直接获取数据：

$task = $form->getData();

在这里，关键要理解当表单跟底层对象绑定后，用户提交的数据会立刻传递给底层对象。如果你想持久化这些数据，你只需要持久化对象本身即可。

嵌入式表单：（Embedded Forms)

通常，你可能想生成一个表单，它包含来自不同对象的字段。比如，一个注册表单可能包含属于User对象和Address对象的字段。幸运的是，这些对于form组件来说都是很容易很自然的事。嵌入一个单独对象：假设每个Task属于一个Category对象，首先创建这个Category对象：

  1. // src/Acme/TaskBundle/Entity/Category.php 
  2. namespace Acme\TaskBundle\Entity; 
  3. use Symfony\Component\Validator\Constraints as Assert; 
  4. class Category 
  5. { 
  6.   /** 
  7.    * @Assert\NotBlank() 
  8.    */ 
  9.   public $name; 
  10. } 

接下来，添加一个新的category属性到Task类：

  1. // ... 
  2. class Task 
  3. { 
  4.   // ... 
  5.   /** 
  6.    * @Assert\Type(type="Acme\TaskBundle\Entity\Category") 
  7.    */ 
  8.   protected $category; 
  9.   // ... 
  10.   public function getCategory() 
  11.   { 
  12.     return $this->category; 
  13.   } 
  14.   public function setCategory(Category $category = null) 
  15.   { 
  16.     $this->category = $category; 
  17.   } 
  18. } 

现在我们来相应我们应用程序的一个新需求，需要创建一个 表单可以让用户修改Category对象。

  1. // src/Acme/TaskBundle/Form/Type/CategoryType.php 
  2. namespace Acme\TaskBundle\Form\Type; 
  3. use Symfony\Component\Form\AbstractType; 
  4. use Symfony\Component\Form\FormBuilder; 
  5. class CategoryType extends AbstractType 
  6. { 
  7.   public function buildForm(FormBuilder $builder, array $options) 
  8.   { 
  9.     $builder->add('name'); 
  10.   } 
  11.   public function getDefaultOptions(array $options) 
  12.   { 
  13.     return array( 
  14.       'data_class' => 'Acme\TaskBundle\Entity\Category', 
  15.     ); 
  16.   } 
  17.   public function getName() 
  18.   { 
  19.     return 'category'; 
  20.   } 
  21. } 

我们的最终目的是能够让用户在Task表单中修改Category对象，所以，我们需要添加一个类型为CategoryType表单类的category字段到TaskType 表单类。

  1. public function buildForm(FormBuilder $builder, array $options) 
  2. { 
  3.   // ... 
  4.   $builder->add('category', new CategoryType()); 
  5. } 

这时我们可以在TaskType类字段渲染的旁边渲染CategoryType类的字段了：

Twig格式:

  1. {# ... #} 
  2. <h3>Category</h3> 
  3. <div class="category"> 
  4.   {{ form_row(form.category.name) }} 
  5. </div> 
  6. {{ form_rest(form) }} 
  7. {# ... #} 

PHP代码格式：

  1. <!-- ... --> 
  2. <h3>Category</h3> 
  3. <div class="category"> 
  4.   <?php echo $view['form']->row($form['category']['name']) ?> 
  5. </div> 
  6. <?php echo $view['form']->rest($form) ?> 
  7. <!-- ... --> 

当用户提交表单时，提交的Category字段数据被用于创建一个Category实例，然后被设置到Task实例的category字段。该Category实例可以通过Task实例来访问,同时也能被持久化到数据或者用作它用。

$task->getCategory()

嵌入一个表单集合

你也可以将一个表单集合嵌入到一个表单（想象一个Category 表单和许多Product子表单），它是通过一个字段类型集合类实现的。

表单主题化

表单的每一部分渲染都是可以被自定义个性化的。你可以自由的改变每一个表单行的渲染，改变渲染错误的标志，更或者是textarea标签应该怎样显示等。没有任何限制，不同的个性化设置能用到不同的区域。

Symfony使用模板渲染每一个或者部分表单，比如label标签，input标签，错误信息以及任何其它内容，在Twig中，每个表单片段会被一个Twig block来渲染，要个性化渲染表单，你只需要重写相应的block即可。在PHP模板中，它是通过单独的模板文件来渲染表单片段的，所以你需要通过编写新的模板来替代旧的模板即可。在理解了它们是怎么工作的之后，让我们来个性化form_row片段并添加一个class属性到包裹每一表单行的div元素，首先创建一个新模板文件用于存放新的标志：

Twig格式：

  1. {# src/Acme/TaskBundle/Resources/views/Form/fields.html.twig #} 
  2. {% block field_row %} 
  3. {% spaceless %} 
  4.   <div class="form_row"> 
  5.     {{ form_label(form) }} 
  6.     {{ form_errors(form) }} 
  7.     {{ form_widget(form) }} 
  8.   </div> 
  9. {% endspaceless %} 
  10. {% endblock field_row %} 

PHP代码格式：

  1. <!-- src/Acme/TaskBundle/Resources/views/Form/field_row.html.php --> 
  2. <div class="form_row"> 
  3.   <?php echo $view['form']->label($form, $label) ?> 
  4.   <?php echo $view['form']->errors($form) ?> 
  5.   <?php echo $view['form']->widget($form, $parameters) ?> 
  6. </div> 

field_row表单片段会在通过form_row函数渲染大部分的表单字段时使用。 要告诉你的表单组件使用你的新的field_row片段，需要添加下面的内容到你渲染该表单的模板顶部：

Twig格式：

  1. {# src/Acme/TaskBundle/Resources/views/Default/new.html.twig #} 
  2. {% form_theme form 'AcmeTaskBundle:Form:fields.html.twig' %} 
  3. {% form_theme form 'AcmeTaskBundle:Form:fields.html.twig' 'AcmeTaskBundle:Form:fields2.html.twig' %} 
  4. <form ...> 

PHP代码格式：

  1. <!-- src/Acme/TaskBundle/Resources/views/Default/new.html.php --> 
  2. <?php $view['form']->setTheme($form, array('AcmeTaskBundle:Form')) ?> 
  3. <?php $view['form']->setTheme($form, array('AcmeTaskBundle:Form', 'AcmeTaskBundle:Form')) ?> 
  4. <form ...> 

其中的form_theme 标签导入前面定义的片段。换句话说，当form_row函数在模板中被调用后，它将从你的自定义主题中使用field_row 块（替代Symfony已有的field_row block）。你的个性化主题不必重写所有的块。当渲染一个你没有重写过的块时，主题引起会找全局的主题（定义在bundle级的主题）使用。

在拥有多个个性化主题的情况下，它会在使用全局主题之前查找定制列表。要个性化你表单的任何部分，你只需要重写相关的片段即可。

表单片段命名

在symfony中，表单的每一部分都会被渲染，HTML表单元素，错误消息，显示标签等这些都是被定义在基础主题里的。它组成了一个Twig的块集合和一个PHP模板集合。

在Twig中，每个需要的块都被定义到一个单独的模板文件中（form_dive_layout.html.twig),它们被保存在Twig Bridge里。在这个文件中，你可以看到渲染一个表单多需要的每一个block和默认的字段类型。

在PHP模板中，片段是单独的模板文件。 默认情况下它们位于框架bundle的Resources/views/Form 目录下。每个偏度名称都遵循相同的基本模式，用一个下划线（_）分为两部分，比如：

field_row 用于form_row渲染大部分的字段

textarea_widget 用于form_widget渲染一个textarea字段类型

field_errors 用于form_errors渲染一个字段的错误信息

每个片段都命名都遵循:type_part 模式。type部分对应被渲染的字段类型（比如textarea,checkbox,date等），而part部分对应着是什么被渲染（比如label，widget，errors等）

默认情况下，有4种可能的表单part被用来渲染：

label 渲染字段的标签 如field_label

widget 渲染字段的HTML表示 如field_widget

errors 渲染字段的错误信息 如field_errors

row 渲染字段的整个行（包括label，widget和errors） 如 filed_row

还有其它3个part类型，分别是rows，rest和enctype,不过这三个一般不会用到。

通过知道字段类型(比如：textarea)和你想渲染那一部分（比如：widget)，你可以创建一个你需要重写的片段名称(比如：textarea_widget).

模板片段继承

在某些情况下，你个性化的片段可能会丢失。比如，在Symfony提供的默认主题中没有提供textarea_errors片段。那么如何来渲染一个textarea字段的错误信息呢？

答案是通过field_errors片段。当Symfony渲染一个textarea类型的错误时，它首先查找一个textarea_errors片段，如果没有找到则会回到field_errors片段。

每个field类型有一个parenttype（textarea的父类型为field),Symfony如果没有发现本身的片段，就会转而使用父类片段。

所以，要重写textarea字段的errors，拷贝field_errors片段，重命名为textarea_errors并个性化它们。为所有字段重写默认的error渲染，则需要直接拷贝和个性化field_errors片段。

全局表单主题

在上面的示例中，我们使用了form_theme helper来导入自定义个的表单片段到表单。你也可以告诉Symfony在全项目中导入自定义的form。

Twig

为了从所有之前创建的fileds.html.twig模板中自动包含个性化的block，修改你的应用程序配置文件：

YAML格式：

  1. # app/config/config.yml 
  2. twig: 
  3.   form: 
  4.     resources: 
  5.       - 'AcmeTaskBundle:Form:fields.html.twig' 
  6.   # ... 

XML格式：

  1. <!-- app/config/config.xml --> 
  2. <twig:config ...> 
  3.     <twig:form> 
  4.       <resource>AcmeTaskBundle:Form:fields.html.twig</resource> 
  5.     </twig:form> 
  6.     <!-- ... --> 
  7. </twig:config> 

PHP代码格式：

  1. // app/config/config.php 
  2. $container->loadFromExtension('twig', array( 
  3.   'form' => array('resources' => array( 
  4.     'AcmeTaskBundle:Form:fields.html.twig', 
  5.    )) 
  6.   // ... 
  7. )); 

现在在fields.html.twig模板中的任何块都可以被广泛的使用来定义表单输出了。

自定义表单输出到一个单一的Twig文件中

在Twig中，你也可以个性化一个表单块在模板中

  1. {% extends '::base.html.twig'%} 
  2. {# 导入"_self" 作为一个表单主题 #} 
  3. {% form_theme form _self %} 
  4. {# 个性化表单片段 #} 
  5. {% block field_row %} 
  6.     {# 自定义字段行输出 #} 
  7. {% endblock field_row %} 
  8. {% block content %} 
  9.     {# ... #} 
  10.     {{ form_row(form.task) }} 
  11. {% endblock %} 

这里{% form_theme form _self %}标签允许表单块在使用那些自动化内容的模板中被直接自定义化。使用这个方法来快速的生成个性化输出。

注意，{% form_theme form _self %}的功能只有在继承自其它模板时才能起作用，如果不是继承自其它模板，则需要指出form_theme 到单独模板中。

PHP

从以前在所有模板中创建的Acme/TaskBundle/Resources/views/Form 目录自动导入个性化模板，修改你的配置文件：

YAML格式：

  1. # app/config/config.yml 
  2. framework: 
  3.   templating: 
  4.     form: 
  5.       resources: 
  6.         - 'AcmeTaskBundle:Form' 
  7. # ... 

XML格式：

  1. <!-- app/config/config.xml --> 
  2. <framework:config ...> 
  3.   <framework:templating> 
  4.     <framework:form> 
  5.       <resource>AcmeTaskBundle:Form</resource> 
  6.     </framework:form> 
  7.   </framework:templating> 
  8.   <!-- ... --> 
  9. </framework:config> 

PHP代码格式：

  1. // app/config/config.php 
  2. $container->loadFromExtension('framework', array( 
  3.   'templating' => array('form' => 
  4.     array('resources' => array( 
  5.       'AcmeTaskBundle:Form', 
  6.    ))) 
  7.   // ... 
  8. )); 

此时在Acme/TaskBundle/Resources/views/Form目录中的任何片段都可以全局范围内定义表单输出了。

CSRF 保护

CSRF--Cross-site request forgery，跨站伪造请求 是恶意攻击者试图让你的合法用户在不知不觉中提交他们本不想提交的数据的一种方法。

幸运的是，CSRF攻击可以通过在你的表单中使用CSRF 记号来阻止。

默认情况下，Symfony自动为你嵌入一个合法的CSRF令牌。这就意味着你不需要做任何事情就可以得到CSRF保护。CSRF保护是通过在你的表单中添加一个隐藏字段，默认的名叫_token。它包含一个值，这个值只有你和你的用户知道。这确保了是用户而不是其它实体在提交数据。Symfony自动校验该token是否存在以及其准确性。

_token 字段是一个隐藏字段并且会自动的渲染，只要你在你的模板中包含了form_rest()函数。它确保了没有被渲染过的字段全部渲染出来。CSRF令牌可以按照表单来个性化，比如：

  1. class TaskType extends AbstractType 
  2. { 
  3.    // ... 
  4.    public function getDefaultOptions(array $options) 
  5.    { 
  6.       return array( 
  7.           'data_class' => 'Acme\TaskBundle\Entity\Task', 
  8.           'csrf_protection' => true, 
  9.           'csrf_field_name' => '_token', 
  10.           // 一个唯一的键值来保证生成令牌 
  11.           'intention' => 'task_item', 
  12.       ); 
  13.    } 
  14.    // ... 
  15. } 

要关闭CSRF保护，设置csrf_protection 选项为false。intentsion选项是可选的，但为不同的表单生成不同的令牌极大的加强了安全性。

使用一个无底层类表单

大多数情况下，一个表单要绑定一个对象的，并且表单中所有的字段获取或者保存它们的数据到该对象属性。但有时候，你可能只想使用一个没有类的表单，返回一个提交数据的数组，这个非常容易实现：

  1. // 确认你在类上方导入了Request对象 
  2. use Symfony\Component\HttpFoundation\Request 
  3. // ... 
  4. public function contactAction(Request $request) 
  5. { 
  6.     $defaultData = array('message' => 'Type your message here'); 
  7.     $form = $this->createFormBuilder($defaultData) 
  8.        ->add('name', 'text') 
  9.        ->add('email', 'email') 
  10.        ->add('message', 'textarea') 
  11.        ->getForm(); 
  12.      if ($request->getMethod() == 'POST') { 
  13.         $form->bindRequest($request); 
  14.         // 数据是一个数组并包含 "name", "email", 和"message" 键 
  15.         $data = $form->getData(); 
  16.      } 
  17.     // ... 渲染表单 
  18. } 

默认情况下，一个表单真的假设你想要一个数据数组而不是数据对象。

这里有两种方式你可以改变它的行为并绑定一个对象;

1.当创建表单时传入一个对象（作为createFormBuilder的第一个参数或者createForm的第二个参数）。

2.在你的表单中声明data_class 选项

如果以上两种方式都没有，那么表单会返回一个数组数据。在这个示例中因为$defaultData不是一个对象，又没有设置data_class选项，则$form->getData()最终返回一个数组。

你也可以通过Request对象直接访问POST的值，

$this->get('request')->request->get('name');

注意,大多数的情况下我们使用getData()方法是更好一点的选择。因为它返回的是经过表单框架转换过的数据。

添加校验规则

唯一遗漏的地方就是校验规则了，通常当你调用$form->isvalid()时，对象会调用你在类东提供的校验规则进行校验。但如果没有类，你怎么来添加对你表单数据的约束规则呢？答案是自己创建约束，然后传入到表单。

  1. // 在controller类前导入命名空间 
  2. use Symfony\Component\Validator\Constraints\Email; 
  3. use Symfony\Component\Validator\Constraints\MinLength; 
  4. use Symfony\Component\Validator\Constraints\Collection; 
  5. $collectionConstraint = new Collection(array( 
  6.       'name' => new MinLength(5), 
  7.       'email' => new Email(array('message' => 'Invalid email address')), 
  8. )); 
  9. // 创建一个表单没有默认值，传入约束选项。 
  10. $form = $this->createFormBuilder(null, array( 
  11.            'validation_constraint' => $collectionConstraint, 
  12.     ))->add('email', 'email') 
  13. // ... 
  14. ; 

现在，当你调用$form->bindRequest($request)时，约束就会被创建并作用于你的表单数据。如果你使用表单类，重写getDefaultOptions 方法来指定可选项：

  1. namespace Acme\TaskBundle\Form\Type; 
  2. use Symfony\Component\Form\AbstractType; 
  3. use Symfony\Component\Form\FormBuilder; 
  4. use Symfony\Component\Validator\Constraints\Email; 
  5. use Symfony\Component\Validator\Constraints\MinLength; 
  6. use Symfony\Component\Validator\Constraints\Collection; 
  7. class ContactType extends AbstractType 
  8. { 
  9.   // ... 
  10.   public function getDefaultOptions(array $options) 
  11.   { 
  12.     $collectionConstraint = new Collection(array( 
  13.       'name' => new MinLength(5), 
  14.       'email' => new Email(array('message' => 'Invalid email address')), 
  15.     )); 
  16.     return array('validation_constraint' => $collectionConstraint); 
  17.   } 
  18. } 

这样你有了足够的灵活性来创建表单类和约束了，它返回一个数据数组而不是一个对象。大多数情况下，这个是不错的，而绑定一个表单到一个对象，从某种程度上说更加健壮。对于简单表单来说是个不错的选择。

总结思考

你现在已经了解了所有建造复杂功能性的表单所需要的所有建造块。当生成表单时，记住一个表单的首要目标是从一个对象把数据传递给一个HTML表单以方便用户修改它们。第二个目标就是把用户提交的数据重写提交回对象。

希望本文所述对大家基于Symfony框架的PHP程序设计有所帮助。

Tags: Symfony2框架

分享到：

推荐文章

热门文章

最新评论文章