Menggunakan konteks terhad untuk membina aplikasi Java

Apakah konteks terikat?

Konteks terikat ialah salah satu corak teras dalam Reka Bentuk Dipacu Domain (DDD). Ia mewakili cara membahagikan projek besar kepada domain. Pemisahan ini membolehkan fleksibiliti dan penyelenggaraan yang lebih mudah.

Apakah Seni Bina Heksagon?

Seni bina heksagon memisahkan teras aplikasi daripada kebergantungan luarannya. Ia menggunakan port dan penyesuai untuk memisahkan logik perniagaan daripada perkhidmatan luar. Menjadikan logik perniagaan bebas daripada rangka kerja, pangkalan data atau antara muka pengguna membolehkan aplikasi menyesuaikan diri dengan mudah kepada keperluan masa hadapan.

Seni bina diperbuat daripada tiga komponen utama:

1. Model Perniagaan: peraturan perniagaan dan logik teras. Ia diasingkan sepenuhnya daripada kebergantungan luaran dan hanya berkomunikasi melalui port.
2. Pelabuhan: keluar dan masuk ke model perniagaan. Ia memisahkan teras daripada lapisan luar.
3. Penyesuai: menterjemah interaksi luaran (permintaan HTTP, operasi pangkalan data) kepada sesuatu yang difahami oleh teras. Terdapat penyesuai dalam yang digunakan untuk komunikasi masuk dan penyesuai keluar digunakan untuk komunikasi keluar.

Mengapa menggunakan Seni Bina Heksagon?

• Kebolehujian: anda boleh menulis ujian unit untuk logik perniagaan tanpa mengejek pangkalan data, API luaran atau rangka kerja.
• Kebolehselenggaraan: anda boleh menukar kebergantungan dengan mudah tanpa menjejaskan logik perniagaan teras.
• Skalabiliti: penskalaan bebas lapisan, meningkatkan prestasi keseluruhan.
• Fleksibiliti: sistem luaran yang berbeza boleh berinteraksi dengan logik teras yang sama.

Membina aplikasi menggunakan Seni Bina Heksagon di Jawa

Projek berjalan-lalu ini menggunakan konteks bersempadan dan seni bina heksagon di Jawa.

Matlamatnya adalah untuk mencipta sistem tiket untuk taman hiburan yang dipanggil Techtopia. Projek ini mempunyai 3 konteks sempadan utama: Tiket, Tarikan dan Pintu Masuk. Setiap konteks bersempadan mempunyai direktorinya dan termasuk komponen seperti dalam dan port, penyesuai, kes penggunaan kami, dsb.

Kami akan melalui proses kod untuk membeli tiket untuk taman itu.

1. Tentukan Domain

Buat direktori " domain " dan sertakan logik perniagaan, bebas daripada sebarang rangka kerja atau pergantungan luaran.

Buat entiti "Tiket".

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);
    }
}

Selain itu, buat kelas domain lain bernama "BeliTiket".

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);
    }
}

*BeliTiket * mewakili logik untuk membeli tiket. Dengan menjadikannya komponen Spring yang berasingan, anda boleh mengasingkan logik pembelian tiket dalam kelasnya, yang boleh berkembang secara bebas daripada komponen lain. Pemisahan ini meningkatkan kebolehselenggaraan dan menjadikan pangkalan kod lebih modular.

1. Buat port

Dalam direktori "ports/in" anda mencipta kes penggunaan. Di sini, kami akan membuat use case di mana tiket dibeli.

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);
    }
}

Buat rekod tiket untuk menyimpannya.

package java.boundedContextA.ports.in;

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

Seterusnya, dalam direktori "ports/out" anda mencipta port yang mewakili setiap langkah pembelian tiket tersebut. Cipta antara muka seperti "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. Buat antara muka port

Dalam direktori berasingan, bernama "teras", laksanakan antara muka kes penggunaan tiket pembelian.

package java.boundedContextA.ports.out;

import java.boundedContextA.domain.Ticket;

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

1. Buat penyesuai

Dalam direktori "penyesuai/keluar", buat entiti JPA Tiket untuk mencerminkan domain. Beginilah cara aplikasi berkomunikasi dengan pangkalan data dan mencipta jadual tiket.

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));
    }
}

Jangan lupa untuk mencipta repositori entiti. Repositori ini akan berkomunikasi dengan perkhidmatan, sama seperti seni bina lain.

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;
}

Dalam direktori "adapters/in", buat pengawal Tiket. Aplikasi ini akan berkomunikasi dengan sumber luaran.

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. Tamatkan proses pembelian tiket

Untuk menandakan tiket telah dibeli, buat rekod acara dalam direktori "acara".

Peristiwa mewakili kejadian penting dalam aplikasi yang penting untuk sistem berkomunikasi dengan sistem atau komponen lain. Ia berfungsi sebagai cara lain untuk berkomunikasi dengan pihak luar tentang proses yang telah selesai, keadaan yang berubah atau keperluan untuk tindakan selanjutnya.

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());
        }
    }
}

Jangan lupa sertakan kelas utama untuk menjalankan semuanya sekaligus.

package java.boundedContextA.events;

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

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

**Ini adalah penjelasan yang sangat ringkas, untuk kod yang lebih mendalam dan cara menyambung ke antara muka React, lihat repositori GitHub ini: https://github.com/alexiacismaru/techtopia.

Kesimpulan

Melaksanakan seni bina ini dalam Java melibatkan penentuan domain teras bersih dengan logik dan antara muka perniagaan, mencipta penyesuai untuk berinteraksi dengan sistem luaran dan menulis segala-galanya bersama-sama sambil mengekalkan teras terasing.

Dengan mengikuti seni bina ini, aplikasi Java anda akan lebih berstruktur, lebih mudah diselenggara dan cukup fleksibel untuk menyesuaikan diri dengan perubahan masa hadapan.

Atas ialah kandungan terperinci Menggunakan konteks terhad untuk membina aplikasi Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!