Building and Processing Forms in Symfony 2

This tutorial explores two approaches to form handling in Symfony 2. The first demonstrates embedding form elements directly within the view and manually processing them in the controller. The second utilizes Symfony's form system for object-oriented form declaration and automated processing and persistence.

We'll use Symfony's default AcmeDemoBundle for illustration. The complete code is available in [this repository](repository_link_here - replace with actual link if available).

Key Concepts:

• Symfony 2 offers two primary methods for form creation and handling: manual HTML embedding in the view with controller-based processing, and Symfony's object-oriented form system.
• Non-entity forms are created by adding standard HTML form elements to a Symfony view file. This involves a view file containing the form HTML, a controller method for logic handling (rendering, processing), and a route mapping a URL to the controller method.
• Symfony Entities and Forms offer a more efficient approach. This involves creating a form for a Symfony entity, using the Symfony form builder, and defining methods for form construction, naming, and default options. These forms are built and displayed via controller methods.
• Symfony's form system is flexible, adapting to various needs. For database-related CRUD operations, the Symfony form system is preferred. For simple, non-persistent forms, direct HTML embedding in the view is sufficient.

Non-Entity Forms:

This example demonstrates processing forms defined as standard HTML within a Symfony view file. The process involves three steps:

1. View File Creation: A form1.html.twig file (located in src/Acme/DemoBundle/Resources/views/Welcome) contains the form's HTML:

<code class="language-twig">{% extends "AcmeDemoBundle::layout.html.twig" %}

{% block content %}

<h1>Form values</h1>

{% if name is defined %}
<p>Name: {{ name }} </p>
{% endif %}

<form method="post" action="%7B%7B%20path('_form1')%20%7D%7D">
    <label for="name">Name:</label>
    <input type="text" id="name" name="name"><br>
    <input type="submit" name="submit" value="Submit">
</form>

{% endblock %}</code>

2. Controller Method: The WelcomeController includes a form1Action method:

<code class="language-php">use Symfony\Component\HttpFoundation\Request;

// ... other code ...

public function form1Action(Request $request)
{
    $name = 'Not submitted yet';
    if ($request->isMethod('POST') && $request->request->has('submit')) {
        $name = $request->request->get('name');
    }

    return $this->render('AcmeDemoBundle:Welcome:form1.html.twig', ['name' => $name]);
}</code>

3. Route Definition: The routing.yml file (in src/Acme/DemoBundle/Resources/config) includes:

<code class="language-yaml">_form1:
    path: /form1
    defaults: { _controller: AcmeDemoBundle:Welcome:form1 }</code>

This maps /form1 to the form1Action method.

This approach, while functional, is less suitable for complex forms or data persistence.

Symfony Entities and Forms:

This section illustrates creating and processing a form for a Symfony entity (e.g., Article). We'll use five files: the controller, routing.yml, two view files (form2.html.twig, form2saved.html.twig), and an ArticleType.php form type class.

1. ArticleType.php: (Located in src/Acme/DemoBundle/Form)

<code class="language-twig">{% extends "AcmeDemoBundle::layout.html.twig" %}

{% block content %}

<h1>Form values</h1>

{% if name is defined %}
<p>Name: {{ name }} </p>
{% endif %}

<form method="post" action="%7B%7B%20path('_form1')%20%7D%7D">
    <label for="name">Name:</label>
    <input type="text" id="name" name="name"><br>
    <input type="submit" name="submit" value="Submit">
</form>

{% endblock %}</code>

2. WelcomeController:

<code class="language-php">use Symfony\Component\HttpFoundation\Request;

// ... other code ...

public function form1Action(Request $request)
{
    $name = 'Not submitted yet';
    if ($request->isMethod('POST') && $request->request->has('submit')) {
        $name = $request->request->get('name');
    }

    return $this->render('AcmeDemoBundle:Welcome:form1.html.twig', ['name' => $name]);
}</code>

3. form2.html.twig:

<code class="language-yaml">_form1:
    path: /form1
    defaults: { _controller: AcmeDemoBundle:Welcome:form1 }</code>

4. form2saved.html.twig:

<code class="language-php"><?php

namespace Acme\DemoBundle\Form;

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

class ArticleType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('title', 'text', ['label' => 'Title'])
            ->add('body', 'textarea')
            ->add('save', 'submit')
        ;
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults(['data_class' => 'Acme\DemoBundle\Entity\Article']);
    }

    public function getName()
    {
        return 'article';
    }
}</code>

5. routing.yml:

<code class="language-php">// ... other uses ...
use Acme\DemoBundle\Entity\Article;
use Acme\DemoBundle\Form\ArticleType;

// ... other methods ...

public function form2Action(Request $request)
{
    $article = new Article();
    $form = $this->createForm(ArticleType::class, $article);
    $form->handleRequest($request);

    if ($form->isSubmitted() && $form->isValid()) {
        $em = $this->getDoctrine()->getManager();
        $em->persist($article);
        $em->flush();
        $this->addFlash('message', 'Article saved!');
        return $this->redirectToRoute('_form2saved');
    }

    return $this->render('AcmeDemoBundle:Welcome:form2.html.twig', ['form' => $form->createView()]);
}

public function form2savedAction()
{
    return $this->render('AcmeDemoBundle:Welcome:form2saved.html.twig');
}
</code>

This approach leverages Symfony's features for a more robust and maintainable solution. Choose the method best suited to your form's complexity and data handling needs. For complex forms or database interactions, the entity/form approach is strongly recommended.

The above is the detailed content of Building and Processing Forms in Symfony 2. For more information, please follow other related articles on the PHP Chinese website!