Konfigurationsdatei

Speicherort

Die Konfigurationsdatei von Webman befindet sich im Verzeichnis config/, und im Projekt kann die entsprechende Konfiguration über die Funktion config() abgerufen werden.

Abrufen von Konfigurationen

Alle Konfigurationen abrufen

config();

Alle Konfigurationen aus config/app.php abrufen

config('app');

Die debug-Konfiguration aus config/app.php abrufen

config('app.debug');

Wenn die Konfiguration ein Array ist, können Sie den Wert von Elemente im Array über . abrufen, zum Beispiel

config('file.key1.key2');

Standardwerte

config($key, $default);

Die Funktion config übergibt den Standardwert als zweiten Parameter. Wenn die Konfiguration nicht existiert, wird der Standardwert zurückgegeben.
Existiert die Konfiguration nicht und wurde kein Standardwert gesetzt, wird null zurückgegeben.

Benutzerdefinierte Konfigurationen

Entwickler können im Verzeichnis config/ ihre eigenen Konfigurationsdateien hinzufügen, zum Beispiel

config/payment.php

<?php
return [
    'key' => '...',
    'secret' => '...'
];

Bei der Nutzung von Konfigurationen

config('payment');
config('payment.key');
config('payment.key');

Konfiguration ändern

Webman unterstützt keine dynamische Änderung von Konfigurationen. Alle Konfigurationen müssen manuell in der entsprechenden Konfigurationsdatei geändert werden, und ein reload oder restart ist erforderlich.

Hinweis
Die Serverkonfiguration config/server.php und die Prozesskonfiguration config/process.php unterstützen kein reload und müssen neu gestartet werden, um wirksam zu werden.

Besondere Erinnerung

Wenn Sie eine Konfigurationsdatei im Unterverzeichnis von config erstellen und lesen möchten, z. B. config/order/status.php, dann muss im Verzeichnis config/order eine Datei mit dem Namen app.php vorhanden sein, deren Inhalt wie folgt aussieht:

<?php
return [
    'enable' => true,
];

enable auf true gesetzt bedeutet, dass das Framework die Konfiguration aus diesem Verzeichnis liest.
Die endgültige Verzeichnisstruktur der Konfigurationsdateien sieht in etwa so aus:

├── config
│   ├── order
│   │   ├── app.php
│   │   └── status.php

So können Sie config.order.status verwenden, um das Array oder spezifische Schlüsselwerte aus der Datei status.php zu lesen.

Erklärung der Konfigurationsdateien

server.php

return [
    'listen' => 'http://0.0.0.0:8787', // Port, auf dem gehört wird (in Version 1.6.0 entfernt, jetzt in config/process.php konfiguriert)
    'transport' => 'tcp', // Transportschichtprotokoll (in Version 1.6.0 entfernt, jetzt in config/process.php konfiguriert)
    'context' => [], // ssl und andere Konfigurationen (in Version 1.6.0 entfernt, jetzt in config/process.php konfiguriert)
    'name' => 'webman', // Prozessname (in Version 1.6.0 entfernt, jetzt in config/process.php konfiguriert)
    'count' => cpu_count() * 4, // Anzahl der Prozesse (in Version 1.6.0 entfernt, jetzt in config/process.php konfiguriert)
    'user' => '', // Benutzer (in Version 1.6.0 entfernt, jetzt in config/process.php konfiguriert)
    'group' => '', // Benutzergruppe (in Version 1.6.0 entfernt, jetzt in config/process.php konfiguriert)
    'reusePort' => false, // Ob die Portwiederverwendung aktiviert ist (in Version 1.6.0 entfernt, jetzt in config/process.php konfiguriert)
    'event_loop' => '',  // Ereignisschleifenklasse, standardmäßig automatisch gewählt
    'stop_timeout' => 2, // Maximale Wartezeit zum Abschluss der Verarbeitung nach dem Empfang des stop/restart/reload-Signals. Wenn diese Zeit überschritten wird, wird der Prozess gezwungen beendet
    'pid_file' => runtime_path() . '/webman.pid', // Speicherort der PID-Datei
    'status_file' => runtime_path() . '/webman.status', // Speicherort der Statusdatei
    'stdout_file' => runtime_path() . '/logs/stdout.log', // Speicherort der Standardausgabedatei, nach dem Start von webman werden alle Ausgaben in diese Datei geschrieben
    'log_file' => runtime_path() . '/logs/workerman.log', // Speicherort der Workerman-Protokolldatei
    'max_package_size' => 10 * 1024 * 1024 // Maximale Paketgröße, 10M. Die maximale Dateigröße beim Hochladen wird durch dieses Limit beeinflusst
];

app.php

return [
    'debug' => true,  // Ob der Debug-Modus aktiviert ist. Wenn aktiviert, werden Fehler auf der Seite ausgegeben, einschließlich Aufrufstapeln und anderen Debug-Informationen. Aus Sicherheitsgründen sollte der Debug-Modus in Produktionsumgebungen deaktiviert sein
    'error_reporting' => E_ALL, // Fehlerberichterstattungsebene
    'default_timezone' => 'Asia/Shanghai', // Standardzeitzone
    'public_path' => base_path() . DIRECTORY_SEPARATOR . 'public', // Speicherort des Public-Verzeichnisses
    'runtime_path' => base_path(false) . DIRECTORY_SEPARATOR . 'runtime', // Speicherort des Runtime-Verzeichnisses
    'controller_suffix' => 'Controller', // Suffix für den Controller
    'controller_reuse' => false, // Ob der Controller wiederverwendet wird
];

process.php

use support\Log;
use support\Request;
use app\process\Http;
global $argv;

return [
     // Webman-Prozesskonfiguration
    'webman' => [ 
        'handler' => Http::class, // Verarbeitungs-Klasse des Prozesses
        'listen' => 'http://0.0.0.0:8787', // Abhöradresse
        'count' => cpu_count() * 4, // Anzahl der Prozesse, standardmäßig das Vierfache der CPU
        'user' => '', // Benutzer unter dem der Prozess läuft, sollte ein Benutzer mit niedrigeren Rechten sein
        'group' => '', // Benutzergruppe unter der der Prozess läuft, sollte eine Gruppe mit niedrigeren Rechten sein
        'reusePort' => false, // Ob die Wiederverwendung des Ports aktiviert ist. Wenn aktiviert, werden die Verbindungen gleichmäßig auf verschiedene Worker-Prozesse verteilt
        'eventLoop' => '', // Ereignisschleifenklasse, wenn leer, wird die server.event_loop-Konfiguration automatisch verwendet
        'context' => [], // Abhörkontextkonfiguration, z. B. ssl
        'constructor' => [ // Konstruktorparameter der Verarbeitungs-Klasse, hier die Parameter des Konstruktors der Http-Klasse
            'requestClass' => Request::class, // Kann eine benutzerdefinierte Anforderungen-Klasse sein
            'logger' => Log::channel('default'), // Protokollinstanz
            'appPath' => app_path(), // Speicherort des App-Verzeichnisses
            'publicPath' => public_path() // Speicherort des Public-Verzeichnisses
        ]
    ],
    // Überwachungsprozess, zur Überwachung von Dateiaktualisierungen zur automatischen Lade und zur Erkennung von Speicherlecks
    'monitor' => [
        'handler' => app\process\Monitor::class, // Verarbeitungs-Klasse
        'reloadable' => false, // Der aktuelle Prozess führt kein Reload aus
        'constructor' => [ // Konstruktorparameter der Verarbeitungs-Klasse
            // Überwachungsverzeichnisse, nicht zu viele, da dies die Überwachung verlangsamen kann
            'monitorDir' => array_merge([
                app_path(),
                config_path(),
                base_path() . '/process',
                base_path() . '/support',
                base_path() . '/resource',
                base_path() . '/.env',
            ], glob(base_path() . '/plugin/*/app'), glob(base_path() . '/plugin/*/config'), glob(base_path() . '/plugin/*/api')),
            // Überwachungsdatei-Endungen
            'monitorExtensions' => [
                'php', 'html', 'htm', 'env'
            ],
            // Weitere Optionen
            'options' => [
                // Ob die Dateiwächter aktiviert sind, nur unter Linux wirksam, standardmäßig im Daemon-Modus werden keine Dateiwächter aktiviert
                'enable_file_monitor' => !in_array('-d', $argv) && DIRECTORY_SEPARATOR === '/',
                // Ob die Überwachung des Speichers aktiviert ist, wird nur unter Linux unterstützt
                'enable_memory_monitor' => DIRECTORY_SEPARATOR === '/',
            ]
        ]
    ]
];

container.php

// Gibt eine Instanz des psr-11 Abhängigkeitsinjektionscontainers zurück
return new Webman\Container;

dependence.php

// Zur Konfiguration von Services und Abhängigkeiten im Abhängigkeitsinjektionscontainer
return [];

route.php

use support\Route;
// Definiert die Route für den Pfad /test
Route::any('/test', function (Request $request) {
    return response('test');
});

view.php

use support\view\Raw;
use support\view\Twig;
use support\view\Blade;
use support\view\ThinkPHP;

return [
    'handler' => Raw::class // Standard-Ansichtsverarbeitungsklasse 
];

autoload.php

// Konfiguriert die automatisch zu ladenden Dateien des Frameworks
return [
    'files' => [
        base_path() . '/app/functions.php',
        base_path() . '/support/Request.php',
        base_path() . '/support/Response.php',
    ]
];

cache.php

// Cache-Konfiguration
return [
    'default' => 'file', // Standarddatei
    'stores' => [
        'file' => [
            'driver' => 'file',
            'path' => runtime_path('cache') // Speicherort der Cache-Dateien
        ],
        'redis' => [
            'driver' => 'redis',
            'connection' => 'default' // Redis-Verbindungsname, entsprechend der Konfiguration in redis.php
        ],
        'array' => [
            'driver' => 'array' // Speicher-Cache, verfällt nach einem Neustart
        ]
    ]
];

redis.php

return [
    'default' => [
        'host' => '127.0.0.1',
        'password' => null,
        'port' => 6379,
        'database' => 0,
    ],
];

database.php

return [
 // Standarddatenbank
 'default' => 'mysql',
 // Konfigurationen für verschiedene Datenbanken
 'connections' => [

     'mysql' => [
         'driver'      => 'mysql',
         'host'        => '127.0.0.1',
         'port'        => 3306,
         'database'    => 'webman',
         'username'    => 'webman',
         'password'    => '',
         'unix_socket' => '',
         'charset'     => 'utf8',
         'collation'   => 'utf8_unicode_ci',
         'prefix'      => '',
         'strict'      => true,
         'engine'      => null,
     ],

     'sqlite' => [
         'driver'   => 'sqlite',
         'database' => '',
         'prefix'   => '',
     ],

     'pgsql' => [
         'driver'   => 'pgsql',
         'host'     => '127.0.0.1',
         'port'     => 5432,
         'database' => 'webman',
         'username' => 'webman',
         'password' => '',
         'charset'  => 'utf8',
         'prefix'   => '',
         'schema'   => 'public',
         'sslmode'  => 'prefer',
     ],

     'sqlsrv' => [
         'driver'   => 'sqlsrv',
         'host'     => 'localhost',
         'port'     => 1433,
         'database' => 'webman',
         'username' => 'webman',
         'password' => '',
         'charset'  => 'utf8',
         'prefix'   => '',
     ],
 ],
];

exception.php

return [
    // Setzt die Ausnahmebehandlungs-Klasse 
    '' => support\exception\Handler::class,
];

log.php

return [
    'default' => [
        'handlers' => [
            [
                'class' => Monolog\Handler\RotatingFileHandler::class, // Handler
                'constructor' => [
                    runtime_path() . '/logs/webman.log', // Protokollname
                    7, //$maxFiles // Protokolle für die letzten 7 Tage aufbewahren
                    Monolog\Logger::DEBUG, // Protokollebene
                ],
                'formatter' => [
                    'class' => Monolog\Formatter\LineFormatter::class, // Formatter
                    'constructor' => [null, 'Y-m-d H:i:s', true], // Formatierungsparameter
                ],
            ]
        ],
    ],
];

session.php

return [
     // Typ
    'type' => 'file', // oder redis oder redis_cluster
     // Handler
    'handler' => FileSessionHandler::class,
     // Konfiguration
    'config' => [
        'file' => [
            'save_path' => runtime_path() . '/sessions', // Speicherort
        ],
        'redis' => [
            'host' => '127.0.0.1',
            'port' => 6379,
            'auth' => '',
            'timeout' => 2,
            'database' => '',
            'prefix' => 'redis_session_',
        ],
        'redis_cluster' => [
            'host' => ['127.0.0.1:7000', '127.0.0.1:7001', '127.0.0.1:7001'],
            'timeout' => 2,
            'auth' => '',
            'prefix' => 'redis_session_',
        ]
    ],
    'session_name' => 'PHPSID', // Sessionname
    'auto_update_timestamp' => false, // Ob der Zeitstempel automatisch aktualisiert wird, um Session-Ablauf zu vermeiden
    'lifetime' => 7*24*60*60, // Lebensdauer
    'cookie_lifetime' => 365*24*60*60, // Lebensdauer von Cookies
    'cookie_path' => '/', // Cookie-Pfad
    'domain' => '', // Cookie-Domain
    'http_only' => true, // Nur HTTP-Zugriff
    'secure' => false, // Nur HTTPS-Zugriff
    'same_site' => '', // SameSite-Attribut
    'gc_probability' => [1, 1000], // Wahrscheinlichkeit der Session-Reinigung
];

middleware.php

// Setzt Middleware
return [];

static.php

return [
    'enable' => true, // Ob der Zugriff auf statische Dateien in Webman aktiviert ist
    'middleware' => [ // Statische Datei-Middleware, kann zur Einstellung von Cache-Strategien, Cross-Origin usw. verwendet werden
        //app\middleware\StaticFile::class,
    ],
];

translation.php

return [
    // Standardsprache
    'locale' => 'zh_CN',
    // Rückfallebene
    'fallback_locale' => ['zh_CN', 'en'],
    // Speicherort der Sprachdateien
    'path' => base_path() . '/resource/translations',
];