Info

Datum: 08. 10. 2025 um 21:14:10

Schlagworte:

erstellt von Stephan Bösebeck

logged in

ADMIN

Morphium in der Version 6

Morphium 6.0: Modernes Java ODM mit integrierter Message Queue

Heute freuen wir uns, Morphium 6.0 anzukündigen – ein Major Release unseres feature-reichen MongoDB Object Document Mappers für Java. Diese Version bringt vollständige JDK 21-Unterstützung, ein komplett überarbeitetes Messaging-System und umfassende neue Dokumentation.

Was macht Morphium besonders?

Morphium ist nicht einfach nur ein weiterer MongoDB ODM. Es ist eine vollständige Datenschicht-Lösung die beinhaltet:

🗄️ Leistungsstarkes Object Mapping mit Annotation-basierter Konfiguration
📨 Integrierte Message Queue die MongoDB als Backend nutzt
⚡ Multi-Level Caching mit automatischer Cluster-Synchronisation
🧪 In-Memory-Treiber für blitzschnelle Tests (kein MongoDB nötig!)
🎯 JMS API Unterstützung für standardbasiertes Messaging

Der entscheidende Unterschied? Sie erhalten verteiltes Messaging ohne RabbitMQ, Kafka oder ActiveMQ zu Ihrer Infrastruktur hinzuzufügen. Wenn Sie bereits MongoDB nutzen, haben Sie alles was Sie brauchen.

Highlights von Version 6.0

JDK 21 & Modernes Java

Morphium 6.0 nutzt moderne Java-Features:

Virtual Threads für verbesserte Messaging-Concurrency
Pattern Matching für saubereren Code
Volle Unterstützung für Records als Entities
Sealed Classes für bessere Domain-Modellierung

Verbessertes Messaging-System

Das MongoDB-basierte Messaging-System wurde von Grund auf neu geschrieben:

// Setup ist einfach
Messaging messaging = new Messaging(morphium, 100, true);
messaging.start();

// Nachrichten mit Prioritäten und TTL senden
Msg message = new Msg("orderQueue", "Process Order", orderData);
message.setPriority(5);
message.setTtl(300000); // 5 Minuten
messaging.sendMessage(message);

// Nachrichten verarbeiten
messaging.addMessageListener((msg, m) -> {
processOrder(msg.getValue());
return true; // Nachricht verarbeitet
});

Warum Morphium Messaging nutzen?

✅ Keine zusätzliche Infrastruktur (nutzt Ihre vorhandene MongoDB) ✅ Standardmäßig persistent (Nachrichten überleben Neustarts) ✅ Distributed Locking eingebaut ✅ Unterstützt Prioritäten, TTL, Exklusiv- & Broadcast-Modi ✅ JMS-kompatibel für Legacy-Integration

Performance in 6.0:

90% weniger doppelt verarbeitete Nachrichten
Virtual Thread Integration für bessere Concurrency
Optimierte Queries für 5.000-8.000 msg/sec Durchsatz
Verbesserte Multi-Instance-Koordination

In-Memory-Treiber für Testing

Eines der Killer-Features von Morphium ist der InMemoryDriver:

# Führen Sie Ihre komplette Test-Suite ohne MongoDB aus
./runtests.sh --driver inmem --tags core,messaging

# 10-100x schneller als Tests gegen echten MongoDB
# Perfekt für CI/CD-Pipelines
# Keine externen Abhängigkeiten benötigt

Der InMemoryDriver bietet ~93% MongoDB-Feature-Abdeckung inklusive:

Volle CRUD-Operationen mit allen Standard-Operatoren
Vollständige Aggregation-Pipeline mit $lookup, $graphLookup, $bucket, $mergeObjects
MapReduce-Unterstützung mit JavaScript-Engine-Integration
Array-Operatoren inklusive $pop, $push, $pull, $addToSet
Transaktionen (Single-Instance)
Change Streams (Basis)
Drop-in-Ersatz für die meisten Entwicklungs- und Test-Szenarien

Schneller Vergleich: Morphium vs. Alternativen

Aspekt	Morphium	Spring Data + RabbitMQ	Kafka
Infrastruktur	Nur MongoDB	MongoDB + RabbitMQ	MongoDB + Kafka
Setup-Komplexität	⭐ Sehr niedrig	⭐⭐⭐ Mittel	⭐⭐⭐⭐⭐ Hoch
Nachrichten-Persistenz	Eingebaut	Konfigurieren	Eingebaut
Nachrichten-Prioritäten	✅ Ja	✅ Ja	❌ Nein
Distributed Locks	✅ Ja	❌ Nein	❌ Nein
Durchsatz	Mittel (8K msg/s)	Hoch (50K msg/s)	Sehr hoch (100K+ msg/s)
Betrieb	⭐ Sehr einfach	⭐⭐ Mittel	⭐⭐⭐⭐ Komplex

Nutzen Sie Morphium wenn:

Sie bereits MongoDB einsetzen
Sie einfaches, zuverlässiges Messaging benötigen (<10K msg/sec)
Sie operationelle Komplexität minimieren möchten
Sie standardmäßig persistente Nachrichten brauchen

Erwägen Sie Alternativen wenn:

Sie ultra-hohen Durchsatz brauchen (>100K msg/sec)
Sie komplexe Routing-Patterns benötigen
Sie eine Streaming-Plattform aufbauen

Real-World Use Case

Hier ein vereinfachtes Beispiel aus einer E-Commerce-Anwendung:

@Entity
@Cache(readCache = true, writeCache = true, syncCache = true)
public class Order {
    @Id private ObjectId id;
    private String customerId;
    private List<OrderItem> items;
    private OrderStatus status;
    private LocalDateTime createdAt;
}

// Service-Layer mit Caching
public class OrderService {
    private final Morphium morphium;
    private final Messaging messaging;

    public Order createOrder(Order order) {
        // Speichern mit automatischem Caching
        order.setCreatedAt(LocalDateTime.now());
        order.setStatus(OrderStatus.PENDING);
        morphium.store(order);

        // Asynchrone Benachrichtigung senden
        Msg msg = new Msg("order.created", "New Order", order.getId());
        msg.setPriority(5);
        messaging.sendMessage(msg);

        return order;
    }

    public void processOrders() {
        // Auf Order-Events lauschen
        messaging.addMessageListener((msg, m) -> {
            ObjectId orderId = new ObjectId(msg.getValue().toString());

            // Query mit Caching - weitere Aufrufe treffen den Cache
            Order order = morphium.findById(Order.class, orderId);

            // Order verarbeiten...
            order.setStatus(OrderStatus.PROCESSING);
            morphium.store(order); // Cache wird automatisch invalidiert

            return true;
        });
    }
}

Dieses Beispiel zeigt:

Automatisches Caching mit Cluster-Synchronisation (syncCache = true)
Asynchrones Messaging für Event-Driven Architecture
Saubere, intuitive API
Keine zusätzliche Infrastruktur

Erste Schritte

Fügen Sie zu Ihrer pom.xml hinzu:

<dependency>
    <groupId>de.caluga</groupId>
    <artifactId>morphium</artifactId>
    <version>6.0.0</version>
</dependency>

Basis-Konfiguration (morphium.properties):

morphium.hosts=mongo1.example.com:27017,mongo2.example.com:27017
morphium.database=myapp
morphium.replicaSet=myReplicaSet
morphium.safe=true
morphium.writeTimeout=5000

Initialisierung:

MorphiumConfig config = MorphiumConfig.fromProperties(
getClass().getResourceAsStream("/morphium.properties")
);
Morphium morphium = new Morphium(config);

Das war's! Sie sind startklar.

Migration von 5.x

Morphium 6.0 behält die Rückwärtskompatibilität für die meisten Features. Wichtigste Änderungen:

JDK 21 erforderlich - Aktualisieren Sie Ihre Java-Version
Kleinere API-Änderungen im Messaging für Virtual Thread-Unterstützung
Deprecated Methods entfernt - Update auf empfohlene Alternativen

Siehe unseren detaillierten Migration Guide für vollständige Anweisungen.

Dokumentation & Ressourcen

Wir haben die Dokumentation komplett neu geschrieben:

Vollständige Dokumentation - Alles was Sie wissen müssen
GitHub Repository - Quellcode und Beispiele
Test Scripts Guide - Erweiterte Testing-Strategien

Was kommt als Nächstes?

Wir planen bereits Verbesserungen für 6.x und darüber hinaus:

Geplant für 6.x:

Erweiterter InMemoryDriver mit mehr MongoDB 7.0-Features
Bessere Change Streams Integration
Eingebaute Prometheus-Metriken

Ausblick auf 7.0:

MongoDB 8.0-Unterstützung
Native GraalVM-Unterstützung
Vector Search Integration
Reactive Streams API

Heute ausprobieren!

# Maven Central
6.0.0

# Oder aus dem Quellcode bauen
git clone https://github.com/sboesebeck/morphium.git
mvn clean install

Wir würden uns über Ihr Feedback freuen! Öffnen Sie Issues, tragen Sie Code bei oder teilen Sie Ihre Use Cases auf GitHub.

Fragen? Schauen Sie in unsere Dokumentation oder öffnen Sie ein Issue auf GitHub.

Upgrade geplant? Siehe den Migration Guide für Schritt-für-Schritt-Anleitung.

Viel Erfolg beim Programmieren! 🚀