PHP

Referenční příručka k vývoji v PHP: seniorní kompetence, standardy PSR, testování PHPUnit/Behat, Laravel a Symfony, bezpečnost a nasazení.

Co tato dovednost pokrývá

Referenční příručka k vývoji v PHP — od kompetenčního přehledu pro seniorního PHP vývojáře přes kódovací standardy a testování až po frameworky Laravel/Symfony, zabezpečení, ladění výkonu a nasazení pomocí Dockeru.

Kdy ji použít

Ověření, co má pokrývat role seniorního PHP vývojáře, jako kompetenční checklist
Aplikace PSR kódovacích standardů nebo strukturování try/catch/finally ošetření chyb
Psaní PHPUnit unit testů nebo Behat BDD feature souborů pro PHP kódovou základnu
Návrh nebo revize Laravel controlleru či Symfony controlleru/služby
Zabezpečení PHP kódu proti SQL injection, XSS nebo CSRF
Ladění PHP-FPM poolů, OPcache nebo APCu, případně optimalizace databázových dotazů
Kontejnerizace PHP aplikace pomocí Dockeru a nastavení CI/CD pipeline

Přehled úrovní PHP vývojáře

Seniorní PHP vývojář

Klíčové kompetence:

PHP runtime, I/O, ošetření chyb, PHP-FPM, garbage collection, optimalizace výkonu
Frameworky: Symfony, Laravel
Datové struktury a algoritmy (grafy, stromy, pole, kolekce)
Autentizace a autorizace: JWT, OAuth
Nefunkční požadavky (bezpečnost, výkon, škálovatelnost, odolnost)

Vývojářské nástroje:

IDE: PHPStorm
DevTools: Postman, DataGrip

Komunikace mezi službami:

Messaging: RabbitMQ, Pub/Sub, SNS/SQS, Kafka
REST(ful), WebSocket, RPC/gRPC, HATEOAS
Vzory výměny zpráv

Cachovací strategie:

Cache aside, read through, write through
Politiky nahrazování cache: RR, LIFO, LRU
Koherence cache

Databázové dovednosti:

RDBMS: MySQL, PostgreSQL
NoSQL: MongoDB, Redis, Elasticsearch
Výkon: ANALYZE, EXPLAIN, VACUUM, Query Planner, pomalé dotazy, indexy
Normalizace/denormalizace

Bezpečnost:

SQL injection, CSRF, XSS, CORS

Cloud computing:

AWS, GCP (VM, kontejnery EKS/ECS, souborové úložiště, cloud funkce, messaging, aplikační nástroje)

Testování a kvalita:

Testování: akceptační kritéria, verifikace, automatizované testy (unit, integrační, e2e)
Nástroje kvality: PHPUnit, Behat, PHPSpec
Quality Gates: SonarQube, nástroje kvality PHP (phpmd, phpcs, phpstan, psalm)
Code review, monitoring, logování, řízení technického dluhu

Computer science:

OOP, SOLID, GRASP, DRY, KISS, YAGNI, DDD
Algoritmy a datové struktury
GoF vzory, Enterprise Application Patterns, Enterprise Integration Patterns
Vzory distribuovaných systémů, metodologie 12 Factor

Softwarová architektura:

Monolit, mikroslužby/SOA, Event Driven, Hexagonal, Event sourcing, CQRS
Architektonické diagramy: UML, C4, 4+1, Flow, Actors
Dokumentace API: OpenAPI/Swagger

Kontejnerizace a nasazení:

Docker, Kubernetes
CI/CD: GitLab, Jenkins, GitHub Actions
Branching strategie: git-flow
Nasazovací strategie: Blue-green, Canary
Multi-region aplikace

Správa serveru:

*nix, bash
Sítě: TCP/IP, UDP, HTTP
API gateway, SSL terminace, Load Balancing (L4, L7)
Proxy, Service Mesh

Osvědčené postupy v PHP

Kvalita kódu

PSR standardy:

<?php
// PSR-1: Basic Coding Standard
// PSR-2: Coding Style Guide
// PSR-4: Autoloading Standard

namespace Vendor\Package;

use FooInterface;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;

class Foo extends Bar implements FooInterface
{
    public function sampleMethod($a, $b = null)
    {
        if ($a === $b) {
            bar();
        } elseif ($a > $b) {
            $foo->bar($arg1);
        } else {
            BazClass::bar($arg2, $arg3);
        }
    }

    final public static function bar()
    {
        // method body
    }
}

Ošetření chyb

<?php
try {
    // Code that may throw an exception
    $result = riskyOperation();
} catch (SpecificException $e) {
    // Handle specific exception
    logError($e->getMessage());
} catch (Exception $e) {
    // Handle general exception
    logError('General error: ' . $e->getMessage());
} finally {
    // Cleanup code that always runs
    cleanup();
}

Optimalizace výkonu

Opcode caching:

; php.ini
opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=7963
opcache.revalidate_freq=0

Optimalizace databáze:

<?php
// Use prepared statements
$stmt = $pdo->prepare('SELECT * FROM users WHERE id = ?');
$stmt->execute([$userId]);
$user = $stmt->fetch();

// Use indexes effectively
// CREATE INDEX idx_users_email ON users(email);
// CREATE INDEX idx_users_status_created ON users(status, created_at);

Testování

PHPUnit

Základní struktura testu:

<?php
use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase
{
    public function testAddition()
    {
        $calculator = new Calculator();
        $result = $calculator->add(2, 3);
        $this->assertEquals(5, $result);
    }

    public function testDivisionByZero()
    {
        $this->expectException(\InvalidArgumentException::class);
        $calculator = new Calculator();
        $calculator->divide(10, 0);
    }
}

Behat (BDD)

Feature soubor:

Feature: User login
  In order to access my account
  As a registered user
  I need to be able to log in

  Scenario: Successful login
    Given I am on the login page
    When I enter valid credentials
    And I click the login button
    Then I should be logged in
    And I should see a welcome message

Třída Context:

<?php
use Behat\Behat\Context\Context;
use Behat\Gherkin\Node\PyStringNode;
use Behat\Gherkin\Node\TableNode;

class FeatureContext implements Context
{
    /** @Given I am on the login page */
    public function iAmOnTheLoginPage()
    {
        // Implementation
    }

    /** @When I enter valid credentials */
    public function iEnterValidCredentials()
    {
        // Implementation
    }
}

Frameworky

Laravel

Základní struktura aplikace:

app/
├── Console/
├── Exceptions/
├── Http/
│   ├── Controllers/
│   ├── Middleware/
│   └── Requests/
├── Models/
├── Providers/
└── Services/

routes/
├── api.php
├── web.php
└── channels.php

database/
├── migrations/
├── seeders/
└── factories/

Příklad controlleru:

<?php
namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function index()
    {
        return User::paginate(15);
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users',
            'password' => 'required|string|min:8',
        ]);

        $user = User::create($validated);
        return response()->json($user, 201);
    }

    public function show(User $user)
    {
        return $user;
    }

    public function update(Request $request, User $user)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users,email,' . $user->id,
        ]);

        $user->update($validated);
        return $user;
    }

    public function destroy(User $user)
    {
        $user->delete();
        return response()->noContent();
    }
}

Symfony

Příklad controlleru:

<?php
namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Annotation\Route;

class ApiController extends AbstractController
{
    #[Route('/api/users', name: 'api_users', methods: ['GET'])]
    public function getUsers(): JsonResponse
    {
        // Implementation
        return $this->json(['users' => []]);
    }
}

Konfigurace služby:

# config/services.yaml
services:
    App\Service\UserService:
        arguments:
            $entityManager: '@doctrine.orm.entity_manager'

Bezpečnost

Běžné zranitelnosti

Prevence SQL injection:

<?php
// Vulnerable (DON'T DO THIS)
$userId = $_GET['id'];
$query = "SELECT * FROM users WHERE id = $userId";

// Safe - Prepared statements
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$userId]);

Prevence XSS:

<?php
// Vulnerable
echo $_GET['name'];

// Safe - Escape output
echo htmlspecialchars($_GET['name'], ENT_QUOTES, 'UTF-8');

Ochrana proti CSRF:

<?php
// Generate token
$token = bin2hex(random_bytes(32));
$_SESSION['csrf_token'] = $token;

// In form
<input type="hidden" name="csrf_token" value="<?php echo $token; ?>">

// Verify token
if (!hash_equals($_SESSION['csrf_token'], $_POST['csrf_token'])) {
    die('CSRF token validation failed');
}

Optimalizace výkonu

Konfigurace PHP-FPM

; php-fpm.conf
[www]
user = www-data
group = www-data
listen = /var/run/php/php8.3-fpm.sock
pm = dynamic
pm.max_children = 50
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 35

Cachovací strategie

OPcache:

opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=7963
opcache.revalidate_freq=0
opcache.save_comments=0

Cachování na úrovni aplikace:

<?php
// Using APCu for user cache
apcu_store('user_' . $userId, $userData, 3600);
$userData = apcu_fetch('user_' . $userId);

Nasazení

Docker

Dockerfile:

FROM php:8.3-fpm-alpine

# Install system dependencies
RUN apk add --no-cache \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip

# Install PHP extensions
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# Get latest Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Set working directory
WORKDIR /var/www

# Copy application
COPY . .

# Install dependencies
RUN composer install --optimize-autoloader --no-dev

# Set permissions
RUN chown -R www-data:www-data /var/www

# Expose port
EXPOSE 9000

CMD ["php-fpm"]

CI/CD pipeline

Příklad GitLab CI:

stages:
  - test
  - build
  - deploy

test:
  stage: test
  script:
    - composer install
    - ./vendor/bin/phpunit
    - ./vendor/bin/phpstan analyse

build:
  stage: build
  script:
    - docker build -t myapp:$CI_COMMIT_SHA .
  only:
    - main

deploy:
  stage: deploy
  script:
    - docker-compose up -d
  only:
    - main

← Zpět na úvod