HttpFoundation 组件

1
2
3
4
5
6
7
8
9
10

// the query string is '?foo=bar'

$request->query->get('foo');
// returns 'bar'

$request->query->get('bar');
// returns null

$request->query->get('bar', 'baz');
// returns 'baz'

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

// the query string is '?foo[bar]=baz'

// don't use $request->query->get('foo'); use the following instead:
$request->query->all('foo');
// returns ['bar' => 'baz']

// if the requested parameter does not exist, an empty array is returned:
$request->query->all('qux');
// returns []

$request->query->get('foo[bar]');
// returns null

$request->query->all()['foo']['bar'];
// returns 'baz'

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

use Symfony\Component\HttpFoundation\HeaderUtils;

// Splits an HTTP header by one or more separators
HeaderUtils::split('da, en-gb;q=0.8', ',;');
// => [['da'], ['en-gb','q=0.8']]

// Combines an array of arrays into one associative array
HeaderUtils::combine([['foo', 'abc'], ['bar']]);
// => ['foo' => 'abc', 'bar' => true]

// Joins an associative array into a string for use in an HTTP header
HeaderUtils::toString(['foo' => 'abc', 'bar' => true, 'baz' => 'a b c'], ',');
// => 'foo=abc, bar, baz="a b c"'

// Encodes a string as a quoted string, if necessary
HeaderUtils::quote('foo "bar"');
// => '"foo \"bar\""'

// Decodes a quoted string
HeaderUtils::unquote('"foo \"bar\""');
// => 'foo "bar"'

// Parses a query string but maintains dots (PHP parse_str() replaces '.' by '_')
HeaderUtils::parseQuery('foo[bar.baz]=qux');
// => ['foo' => ['bar.baz' => 'qux']]

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

use Symfony\Component\HttpFoundation\AcceptHeader;

$acceptHeader = AcceptHeader::fromString($request->headers->get('Accept'));
if ($acceptHeader->has('text/html')) {
    $item = $acceptHeader->get('text/html');
    $charset = $item->getAttribute('charset', 'utf-8');
    $quality = $item->getQuality();
}

// Accept header items are sorted by descending quality
$acceptHeaders = AcceptHeader::fromString($request->headers->get('Accept'))
    ->all();

1
2
3
4
5
6
7
8
9
10
11

use Symfony\Component\HttpFoundation\IpUtils;

$ipv4 = '192.168.1.56';
$CIDRv4 = '192.168.1.0/16';
$isIpInCIDRv4 = IpUtils::checkIp($ipv4, $CIDRv4);
// $isIpInCIDRv4 = true

$ipv6 = '2001:db8:abcd:1234::1';
$CIDRv6 = '2001:db8:abcd::/48';
$isIpInCIDRv6 = IpUtils::checkIp($ipv6, $CIDRv6);
// $isIpInCIDRv6 = true

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

use Symfony\Component\HttpFoundation\ChainRequestMatcher;
use Symfony\Component\HttpFoundation\RequestMatcher\HostRequestMatcher;
use Symfony\Component\HttpFoundation\RequestMatcher\PathRequestMatcher;
use Symfony\Component\HttpFoundation\RequestMatcher\SchemeRequestMatcher;

// use only one criteria to match the request
$schemeMatcher = new SchemeRequestMatcher('https');
if ($schemeMatcher->matches($request)) {
    // ...
}

// use a set of criteria to match the request
$matcher = new ChainRequestMatcher([
    new HostRequestMatcher('example.com'),
    new PathRequestMatcher('/admin'),
]);

if ($matcher->matches($request)) {
    // ...
}

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

use App\Http\SpecialRequest;
use Symfony\Component\HttpFoundation\Request;

Request::setFactory(function (
    array $query = [],
    array $request = [],
    array $attributes = [],
    array $cookies = [],
    array $files = [],
    array $server = [],
    $content = null
) {
    return new SpecialRequest(
        $query,
        $request,
        $attributes,
        $cookies,
        $files,
        $server,
        $content
    );
});

$request = Request::createFromGlobals();

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

$response->setCache([
    'must_revalidate'  => false,
    'no_cache'         => false,
    'no_store'         => false,
    'no_transform'     => false,
    'public'           => true,
    'private'          => false,
    'proxy_revalidate' => false,
    'max_age'          => 600,
    's_maxage'         => 600,
    'stale_if_error'   => 86400,
    'stale_while_revalidate' => 60,
    'immutable'        => true,
    'last_modified'    => new \DateTime(),
    'etag'             => 'abcdef',
]);

1
2
3
4
5
6
7
8
9
10
11

use Symfony\Component\HttpFoundation\StreamedResponse;

$response = new StreamedResponse();
$response->setCallback(function (): void {
    var_dump('Hello World');
    flush();
    sleep(2);
    var_dump('Hello World');
    flush();
});
$response->send();

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

use Symfony\Component\HttpFoundation\StreamedJsonResponse;

// any method or function returning a PHP Generator
function loadArticles(): \Generator {
    yield ['title' => 'Article 1'];
    yield ['title' => 'Article 2'];
    yield ['title' => 'Article 3'];
};

$response = new StreamedJsonResponse(
    // JSON structure with generators in which will be streamed as a list
    [
        '_embedded' => [
            'articles' => loadArticles(),
        ],
    ],
);

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

public function __invoke(): Response
{
    return new StreamedJsonResponse(
        [
            '_embedded' => [
                'articles' => $this->loadArticles(),
            ],
        ],
    );
}

public function loadArticles(): \Generator
{
    // get the $entityManager somehow (e.g. via constructor injection)
    $entityManager = ...

    $queryBuilder = $entityManager->createQueryBuilder();
    $queryBuilder->from(Article::class, 'article');
    $queryBuilder->select('article.id')
        ->addSelect('article.title')
        ->addSelect('article.description');

    return $queryBuilder->getQuery()->toIterable();
}

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

public function loadArticles(): \Generator
{
    // ...

    $count = 0;
    foreach ($queryBuilder->getQuery()->toIterable() as $article) {
        yield $article;

        if (0 === ++$count % 100) {
            flush();
        }
    }
}

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

public function loadArticles(): \Generator
{
    yield ['title' => 'Article 1'];
    yield ['title' => 'Article 2'];
    yield ['title' => 'Article 3'];
}

public function __invoke(): Response
{
    // ...

    return new StreamedJsonResponse(loadArticles());
}

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

use Symfony\Component\HttpFoundation\HeaderUtils;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\ResponseHeaderBag;

$fileContent = ...; // the generated file content
$response = new Response($fileContent);

$disposition = HeaderUtils::makeDisposition(
    HeaderUtils::DISPOSITION_ATTACHMENT,
    'foo.pdf'
);

$response->headers->set('Content-Disposition', $disposition);

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

use Symfony\Component\HttpFoundation\JsonResponse;

// if you know the data to send when creating the response
$response = new JsonResponse(['data' => 123]);

// if you don't know the data to send or if you want to customize the encoding options
$response = new JsonResponse();
// ...
// configure any custom encoding options (if needed, it must be called before "setData()")
//$response->setEncodingOptions(JsonResponse::DEFAULT_ENCODING_OPTIONS | \JSON_PRESERVE_ZERO_FRACTION);
$response->setData(['data' => 123]);

// if the data to send is already encoded in JSON
$response = JsonResponse::fromJsonString('{ "data": 123 }');