Beim Umgang mit mehrsprachigen Inhalten ist es oft effizienter, Übersetzungen in einer JSON-Spalte zu speichern, statt einzelne Zeilen für jedes Attribut. Dieser Ansatz konsolidiert Übersetzungen in einer einzigen Spalte und vereinfacht so die Datenverwaltung und den Abruf.

Einrichten des Übersetzungssystems

Wir werden unser Übersetzungsmodell und unsere Übersetzungstabelle erweitern, um eine JSON-Spalte zum Speichern von Übersetzungen zu verwenden. Dies erfordert die Aktualisierung des Tabellenschemas und die Änderung des Translatable-Merkmals für die Verarbeitung von JSON-Daten.

Schritt 1: Übersetzungstabellenmigration erstellen

Wenn die Übersetzungstabelle noch nicht vorhanden ist, erstellen Sie eine neue Migration:

php artisan make:migration create_translations_table

Schritt 2: Definieren Sie die Tabellenstruktur

Öffnen Sie die generierte Migrationsdatei in Datenbank/Migrationen. Definieren Sie eine neue Tabelle wie folgt:

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateTranslationsTable extends Migration
{
    public function up()
    {
        Schema::create('translations', function (Blueprint $table) {
            $table->id();
            $table->string('locale'); // Stores the locale, e.g., 'en', 'fr'
            $table->string('translatable_type'); // Stores the related model type, e.g., 'Post', 'Product'
            $table->unsignedBigInteger('translatable_id'); // Stores the ID of the related model
            $table->json('translations'); // Stores all translations as a JSON object
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('translations');
    }
}

Schritt 3: Führen Sie die Migration aus
Wenden Sie die Migration auf Ihre Datenbank an:

php artisan migrate

Schritt 4: Erstellen Sie das Übersetzungsmodell

Als nächstes erstellen Sie das Übersetzungsmodell, um die polymorphe Beziehung zu verarbeiten:

php artisan make:model Translation

Definieren Sie im Übersetzungsmodell die polymorphe Beziehung:

class Translation extends Model
{
    protected $fillable = ['locale', 'translatable_type', 'translatable_id', 'translations'];

    protected $casts = [
        'translations' => 'array',
    ];

    public function translatable()
    {
        return $this->morphTo();
    }
}

Implementierung des übersetzbaren Merkmals mit JSON-Speicher

Um die Handhabung von Übersetzungen über mehrere Modelle hinweg wiederverwendbar zu machen, erstellen wir ein Translatable-Merkmal, das den übersetzten Inhalt basierend auf dem vom Benutzer ausgewählten Gebietsschema automatisch lädt. Darüber hinaus fügen wir einen Fallback-Mechanismus hinzu, um Inhalte aus dem Standardgebietsschema zu laden, wenn für das ausgewählte Gebietsschema keine Übersetzung verfügbar ist.

Schritt 1: Erstellen Sie das übersetzbare Merkmal mit JSON-Handhabung

namespace App\Traits;

use App\Models\Translation;
use Illuminate\Support\Facades\App;

trait Translatable
{
    public static function bootTranslatable()
    {
        static::retrieved(function ($model) {
            $model->loadTranslations();
        });
    }

    public function translations()
    {
        return $this->morphMany(Translation::class, 'translatable');
    }

    public function loadTranslations()
    {
        $locale = App::getLocale();
        $defaultLocale = config('app.default_locale', 'en'); // Fallback to the default locale

        // Try to load translations for the current locale
        $translation = $this->translations()->where('locale', $locale)->first();

        if (!$translation && $locale !== $defaultLocale) {
            // If no translations are found for the current locale, fallback to the default locale
            $translation = $this->translations()->where('locale', $defaultLocale)->first();
        }

        if ($translation) {
            $translations = $translation->translations;
            foreach ($translations as $key => $value) {
                $this->{$key} = $value;
            }
        }
    }

    public function addTranslations(array $translations, $locale = null)
    {
        $locale = $locale ?? App::getLocale();
        return $this->translations()->updateOrCreate(
            ['locale' => $locale],
            ['translations' => $translations]
        );
    }
}

Schritt 2: Wenden Sie das übersetzbare Merkmal auf Ihr Modell an
Fügen Sie die Eigenschaft „Übersetzbar“ zu jedem Modell hinzu, das Übersetzungsunterstützung erfordert.

namespace App\Models;

use App\Traits\Translatable;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    use Translatable;

    protected $fillable = ['title', 'content'];
}

Beispiel: Erstellen eines übersetzten Modells

Übersetzungen als JSON-Objekt hinzufügen:

$post = Post::create(['title' => 'Default Title', 'content' => 'Default Content']);

// Adding translations
$post->addTranslations([
    'title' => 'Hello World',
    'content' => 'Welcome to our website'
], 'en');

$post->addTranslations([
    'title' => 'Bonjour le monde',
    'content' => 'Bienvenue sur notre site Web'
], 'fr');

Übersetzte Modelle abrufen

Wenn Sie das Post-Modell abrufen, lädt es automatisch den übersetzten Inhalt basierend auf dem aktuellen Gebietsschema oder greift bei Bedarf auf das Standardgebietsschema zurück:

App::setLocale('fr');
$post = Post::find(1);
echo $post->title; // Displays "Bonjour le monde" if French translation exists

App::setLocale('es');
$post = Post::find(1);
echo $post->title; // Displays "Hello World" as it falls back to the English translation

Übersetzte Inhalte in Ansichten anzeigen

In Ihren Blade-Ansichten können Sie den übersetzten Inhalt wie jedes andere Modellattribut anzeigen:

{{ $post->title }}
{{ $post->content }}

Abschluss

Durch die Verwendung einer JSON-Spalte zum Speichern von Übersetzungen und die Implementierung eines Fallback-Mechanismus optimieren Sie die Verwaltung mehrsprachiger Inhalte in Ihrer Laravel-Anwendung. Dieser Ansatz konsolidiert Übersetzungen in einer einzigen Spalte, vereinfacht die Datenverarbeitung und macht Ihre Codebasis wartbarer. Unabhängig davon, ob Sie ein Blog, eine E-Commerce-Website oder eine andere mehrsprachige Anwendung erstellen, gewährleistet diese Methode eine reibungslose und effiziente Benutzererfahrung.

Genießen!