Verwenden begrenzter Kontexte zum Erstellen einer Java-Anwendung

Was sind begrenzte Kontexte?

Ein begrenzter Kontext ist eines der Kernmuster im Domain-Driven Design (DDD). Es stellt dar, wie ein großes Projekt in Domänen unterteilt wird. Diese Trennung ermöglicht Flexibilität und einfachere Wartung.

Was ist eine sechseckige Architektur?

Die sechseckige Architektur trennt den Kern der Anwendung von ihren externen Abhängigkeiten. Es verwendet Ports und Adapter, um die Geschäftslogik von externen Diensten zu entkoppeln. Durch die Unabhängigkeit der Geschäftslogik von Frameworks, Datenbanken oder Benutzeroberflächen kann die Anwendung problemlos an zukünftige Anforderungen angepasst werden.

Die Architektur besteht aus drei Hauptkomponenten:

1. Geschäftsmodell: die Geschäftsregeln und die Kernlogik. Es ist vollständig von externen Abhängigkeiten isoliert und kommuniziert nur über Ports.
2. Häfen: Ausstieg und Einstieg in das Geschäftsmodell. Sie trennen den Kern von den äußeren Schichten.
3. Adapter: Übersetzen Sie externe Interaktionen (HTTP-Anfragen, Datenbankoperationen) in etwas, das der Kern versteht. Es gibt Eingangsadapter für die eingehende Kommunikation und Ausgangsadapter für die ausgehende Kommunikation.

Warum sechseckige Architektur verwenden?

• Testbarkeit: Sie können Komponententests für die Geschäftslogik schreiben, ohne Datenbanken, externe APIs oder Frameworks zu verspotten.
• Wartbarkeit: Sie können Abhängigkeiten problemlos austauschen, ohne die Kerngeschäftslogik zu beeinträchtigen.
• Skalierbarkeit: unabhängige Skalierung der Ebenen, wodurch die Gesamtleistung verbessert wird.
• Flexibilität: Verschiedene externe Systeme können mit derselben Kernlogik interagieren.

Erstellen einer Anwendung mit Hexagonal Architecture in Java

Dieses Walk-through-Projekt verwendet begrenzte Kontexte und hexagonale Architektur in Java.

Ziel ist die Schaffung eines Ticketingsystems für einen Vergnügungspark namens Techtopia. Das Projekt hat drei Hauptkontexte: Tickets, Attraktionen und Eingangstore. Jeder begrenzte Kontext hat sein Verzeichnis und enthält Komponenten wie in und unsere Ports, Adapter, Anwendungsfälle usw.

Wir werden den Code-Prozess zum Kauf eines Tickets für den Park durchgehen.

1. Definieren Sie die Domäne

Erstellen Sie ein „Domänen“-Verzeichnis und schließen Sie die Geschäftslogik ein, frei von jeglichem Framework oder externen Abhängigkeiten.

Erstellen Sie die Entität „Ticket“.

package java.boundedContextA.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.UUID;

@Getter
@Setter
@ToString
public class Ticket {
    private TicketUUID ticketUUID;
    private LocalDateTime start;
    private LocalDateTime end;
    private double price;
    private TicketAction ticketAction;
    private final Guest.GuestUUID owner;
    private ActivityWindow activityWindow;

    public record TicketUUID(UUID uuid) {
    }

    public Ticket(TicketUUID ticketUUID, Guest.GuestUUID owner) {
        this.ticketUUID = ticketUUID;
        this.owner = owner;
    }

    public Ticket(TicketUUID ticketUUID, LocalDateTime start, LocalDateTime end, double price, TicketAction ticketAction, Guest.GuestUUID owner) {
        this.ticketUUID = ticketUUID;
        this.start = start;
        this.end = end;
        this.price = price;
        this.ticketAction = ticketAction;
        this.owner = owner;
    }

    public Ticket(TicketUUID ticketUUID, LocalDateTime start, LocalDateTime end, double price, Guest.GuestUUID owner, ActivityWindow activityWindow) {
        this.ticketUUID = ticketUUID;
        this.start = start;
        this.end = end;
        this.price = price;
        this.owner = owner;
        this.activityWindow = activityWindow;
    }

    public void addTicketActivity(TicketActivity ticketActivity) {
        this.activityWindow.add(ticketActivity);
    }
}

Erstellen Sie außerdem eine weitere Domänenklasse mit dem Namen "BuyTicket".

package java.boundedContextA.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.UUID;

@Getter
@Setter
@ToString
public class Ticket {
    private TicketUUID ticketUUID;
    private LocalDateTime start;
    private LocalDateTime end;
    private double price;
    private TicketAction ticketAction;
    private final Guest.GuestUUID owner;
    private ActivityWindow activityWindow;

    public record TicketUUID(UUID uuid) {
    }

    public Ticket(TicketUUID ticketUUID, Guest.GuestUUID owner) {
        this.ticketUUID = ticketUUID;
        this.owner = owner;
    }

    public Ticket(TicketUUID ticketUUID, LocalDateTime start, LocalDateTime end, double price, TicketAction ticketAction, Guest.GuestUUID owner) {
        this.ticketUUID = ticketUUID;
        this.start = start;
        this.end = end;
        this.price = price;
        this.ticketAction = ticketAction;
        this.owner = owner;
    }

    public Ticket(TicketUUID ticketUUID, LocalDateTime start, LocalDateTime end, double price, Guest.GuestUUID owner, ActivityWindow activityWindow) {
        this.ticketUUID = ticketUUID;
        this.start = start;
        this.end = end;
        this.price = price;
        this.owner = owner;
        this.activityWindow = activityWindow;
    }

    public void addTicketActivity(TicketActivity ticketActivity) {
        this.activityWindow.add(ticketActivity);
    }
}

*BuyTicket * stellt die Logik für den Kauf eines Tickets dar. Indem Sie es zu einer separaten Spring-Komponente machen, können Sie die Ticketkauflogik in seiner Klasse isolieren, die sich unabhängig von anderen Komponenten weiterentwickeln kann. Diese Trennung verbessert die Wartbarkeit und macht die Codebasis modularer.

1. Ports erstellen

Im Verzeichnis „ports/in“ erstellen Sie Anwendungsfälle. Hier werden wir den Anwendungsfall behandeln, bei dem ein Ticket gekauft wird.

package java.boundedContextA.domain;

import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.UUID;

@Component
public class BuyTicket {
    public Ticket buyTicket(TicketAction ticketAction, LocalDateTime start, LocalDateTime end, double price, Guest.GuestUUID owner) {
        return new Ticket(new Ticket.TicketUUID(UUID.randomUUID()), start, end, price, ticketAction, owner);
    }
}

Erstellen Sie einen Datensatz eines Tickets, um es zu speichern.

package java.boundedContextA.ports.in;

public interface BuyingATicketUseCase {
    void buyTicket(BuyTicketsAmountCommand buyTicketsAmountCommand);
}

Als nächstes erstellen Sie im Verzeichnis "ports/out" Ports, die jeden Schritt des Ticketkaufs darstellen. Erstellen Sie Schnittstellen wie "CreateTicketPort", "TicketLoadPort", "TicketUpdatePort".

package java.boundedContextA.ports.in;

import java.boundedContextA.domain.Guest;
import java.boundedContextA.domain.TicketAction;

import java.time.LocalDateTime;

public record BuyTicketsAmountCommand(double price, TicketAction action, LocalDateTime start, LocalDateTime end, Guest.GuestUUID owner) {}

1. Portschnittstellen erstellen

Implementieren Sie in einem separaten Verzeichnis mit dem Namen „core“ die Schnittstelle des Anwendungsfalls „Ticketkauf“.

package java.boundedContextA.ports.out;

import java.boundedContextA.domain.Ticket;

public interface TicketCreatePort {
    void createTicket(Ticket ticket);
}

1. Adapter erstellen

Erstellen Sie im Verzeichnis „adapters/out“ JPA-Entitäten des Tickets, um die Domäne zu spiegeln. Auf diese Weise kommuniziert die Anwendung mit der Datenbank und erstellt eine Tabelle der Tickets.

package java.boundedContextA.core;

import java.boundedContextA.domain.BuyTicket;
import java.boundedContextA.ports.in.BuyTicketsAmountCommand;
import java.boundedContextA.ports.in.BuyingATicketUseCase;
import java.boundedContextA.ports.out.TicketCreatePort;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@AllArgsConstructor
public class DefaultBuyingATicketUseCase implements BuyingATicketUseCase {
    final BuyTicket buyTicket;
    private final List<TicketCreatePort> ticketCreatePorts;

    @Override
    public void buyTicket(BuyTicketsAmountCommand buyTicketsAmountCommand) {
        var ticket = buyTicket.buyTicket(buyTicketsAmountCommand.action(), buyTicketsAmountCommand.start(), buyTicketsAmountCommand.end(), buyTicketsAmountCommand.price(), buyTicketsAmountCommand.owner());
        ticketCreatePorts.stream().forEach(ticketCreatedPort -> ticketCreatedPort.createTicket(ticket));
    }
}

Vergessen Sie nicht, ein Repository der Entität zu erstellen. Dieses Repository kommuniziert wie jede andere Architektur mit dem Dienst.

package java.adapters.out.db;

import java.boundedContextA.domain.TicketAction;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.hibernate.annotations.JdbcTypeCode;

import java.sql.Types;
import java.time.LocalDateTime;
import java.util.UUID;

@Entity
@Table(schema="boundedContextA",name = "boundedContextA.tickets")
@Getter
@Setter
@NoArgsConstructor
public class TicketBoughtJpaEntity {
    @Id
    @JdbcTypeCode(Types.VARCHAR)
    private UUID uuid;

    public TicketBoughtJpaEntity(UUID uuid) {
        this.uuid = uuid;
    }

    @JdbcTypeCode(Types.VARCHAR)
    private UUID owner;

    @Column
    private LocalDateTime start;
    @Column
    private LocalDateTime end;

    @Column
    private double price;
}

Erstellen Sie im Verzeichnis „adapters/in“ einen Controller des Tickets. Diese Anwendung kommuniziert mit externen Quellen.

package java.boundedContextA.adapters.out.db;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;
import java.util.UUID;

public interface TicketRepository extends JpaRepository<TicketBoughtJpaEntity, UUID> {
    Optional<TicketBoughtJpaEntity> findByOwner(UUID uuid);
}

1. Schließen Sie den Ticketkaufvorgang ab

Um anzuzeigen, dass das Ticket gekauft wurde, erstellen Sie einen Datensatz der Veranstaltung in einem Verzeichnis „Veranstaltungen“.

Ereignisse stellen bedeutende Ereignisse in der Anwendung dar, die für die Kommunikation des Systems mit anderen Systemen oder Komponenten wichtig sind. Sie dienen als weitere Möglichkeit, mit der Außenwelt über einen abgeschlossenen Prozess, einen veränderten Zustand oder die Notwendigkeit weiterer Maßnahmen zu kommunizieren.

package java.boundedContextA.adapters.in;

import java.boundedContextA.ports.in.BuyTicketsAmountCommand;
import java.boundedContextA.ports.in.BuyingATicketUseCase;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class TicketsController {
    private final BuyingATicketUseCase buyingATicketUseCase;

    public TicketsController(BuyingATicketUseCase buyingATicketUseCase) {
        this.buyingATicketUseCase = buyingATicketUseCase;
    }

    @PostMapping("/ticket")
    public void receiveMoney(@RequestBody BuyTicketsAmountCommand command) {
        try {
            buyingATicketUseCase.buyTicket(command);
        } catch (IllegalArgumentException e) {
            System.out.println("An IllegalArgumentException occurred: " + e.getMessage());
        }
    }
}

Vergessen Sie nicht, eine Hauptklasse einzuschließen, um alles auf einmal auszuführen.

package java.boundedContextA.events;

import java.time.LocalDateTime;
import java.util.UUID;

public record TicketIsBoughtEvent(UUID uuid, LocalDateTime start, LocalDateTime end) {
}

**Dies ist eine sehr kurze Erklärung. Für einen ausführlicheren Code und wie man eine Verbindung zu einer React-Schnittstelle herstellt, schauen Sie sich dieses GitHub-Repository an: https://github.com/alexiacismaru/techtopia.

Abschluss

Um diese Architektur in Java zu implementieren, müssen Sie eine saubere Kerndomäne mit Geschäftslogik und Schnittstellen definieren, Adapter für die Interaktion mit externen Systemen erstellen und alles zusammen schreiben, während der Kern isoliert bleibt.

Durch die Einhaltung dieser Architektur werden Ihre Java-Anwendungen besser strukturiert, einfacher zu warten und flexibel genug, um sich an zukünftige Änderungen anzupassen.

Das obige ist der detaillierte Inhalt vonVerwenden begrenzter Kontexte zum Erstellen einer Java-Anwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!