Melaksanakan Corak Reka Bentuk Prototaip dalam But Spring

pengenalan

Dalam pembangunan aplikasi, mengurus penciptaan objek boleh menjadi rumit, terutamanya apabila berurusan dengan kejadian yang hampir sama tetapi berbeza dalam butiran khusus. Corak Reka Bentuk Prototaip menawarkan penyelesaian dengan membenarkan kami mencipta objek baharu dengan menyalin, atau "mengklon," objek sedia ada. Corak ini amat berguna apabila objek mahal untuk dibuat atau melibatkan pemulaan yang meluas.

Dalam artikel ini, kami akan meneroka cara melaksanakan Corak Reka Bentuk Prototaip dalam aplikasi Spring Boot, menggunakan kes penggunaan e-dagang praktikal: mencipta dan meneruskan varian produk. Melalui contoh ini, anda akan mempelajari bukan sahaja asas Corak Prototaip tetapi juga cara ia boleh menyelaraskan penciptaan objek dalam aplikasi dunia sebenar.

Memahami Corak Reka Bentuk Prototaip

Corak Prototaip ialah corak reka bentuk ciptaan yang membolehkan anda mencipta kejadian baharu dengan mengklon objek sedia ada, dikenali sebagai prototaip. Pendekatan ini amat berguna apabila anda mempunyai objek asas dengan pelbagai sifat dan mencipta setiap varian dari awal akan menjadi berlebihan dan tidak cekap.

Di Java, corak ini sering dilaksanakan menggunakan antara muka Boleh Diklon atau dengan mentakrifkan kaedah klon tersuai. Idea utama adalah untuk menyediakan "cetak biru" yang boleh direplikasi dengan pengubahsuaian, mengekalkan objek asal tetap utuh.

Faedah Utama Corak Prototaip:

1. Mengurangkan Masa Permulaan: Daripada mencipta objek dari awal, anda mengklon dan mengubah suai kejadian sedia ada, menjimatkan masa permulaan.

2. Merangkumi Logik Penciptaan Objek: Anda mentakrifkan cara objek diklon dalam objek itu sendiri, menyembunyikan butiran instantiasi.

3. Meningkatkan Prestasi: Untuk aplikasi yang kerap mencipta objek serupa, seperti varian produk, Corak Prototaip boleh meningkatkan prestasi.

Kes Penggunaan E-dagang: Mengurus Varian Produk

Bayangkan platform e-dagang di mana produk asas mempunyai pelbagai konfigurasi atau "varian" — contohnya, telefon pintar dengan warna yang berbeza, pilihan storan dan syarat jaminan. Daripada mencipta semula setiap varian dari awal, kami boleh mengklonkan produk asas dan kemudian melaraskan medan tertentu mengikut keperluan. Dengan cara ini, atribut yang dikongsi kekal konsisten dan kami hanya mengubah suai butiran khusus varian.

Dalam contoh kami, kami akan membina perkhidmatan Spring Boot yang ringkas untuk mencipta dan mengekalkan varian produk menggunakan Corak Prototaip.

Melaksanakan Corak Prototaip dalam But Spring

Langkah 1: Menentukan Produk Asas

Mulakan dengan menentukan kelas Produk dengan medan yang diperlukan untuk produk, seperti id, nama, warna, model, storan, waranti dan harga. Kami juga akan menambah kaedah klonProduk untuk membuat salinan produk.

public interface ProductPrototype extends Cloneable {
    ProductPrototype cloneProduct();
}

@Entity
@Table(name = "products")
@Data
public class Product implements ProductPrototype {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "product_id")
    private Long productId;

    @Column(name = "name")
    private String name;

    @Column(name = "model")
    private String model;

    @Column(name = "color")
    private String color;

    @Column(name = "storage")
    private int storage;

    @Column(name = "warranty")
    private int warranty;

    @Column(name = "price")
    private double price;

    @Override
    public ProductPrototype cloneProduct() {
        try {
            Product product = (Product) super.clone();
            product.setId(null); // database will assign new Id for each cloned instance
            return product;
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }
}

Dalam persediaan ini:

cloneProduct: Kaedah ini mencipta klon objek Produk, menetapkan ID kepada null untuk memastikan bahawa pangkalan data memberikan ID baharu untuk setiap contoh klon.

Langkah 2: Mencipta Perkhidmatan untuk Mengendalikan Varian

Seterusnya, buat ProductService dengan kaedah untuk menyimpan varian. Kaedah ini mengklonkan produk asas dan menggunakan atribut khusus varian, kemudian menyimpannya sebagai produk baharu.

public interface ProductService {

    // For saving the base product
    Product saveBaseProduct(Product product);

    // For saving the variants
    Product saveVariant(Long baseProductId, VariantRequest variant);
}

@Log4j2
@Service
public class ProductServiceImpl implements ProductService {

    private final ProductRepository productRepository;

    public ProductServiceImpl(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    /**
     * Saving Base product, Going to use this object for cloning
     *
     * @param product the input
     * @return Product Object
     */
    @Override
    public Product saveBaseProduct(Product product) {
        log.debug("Save base product with the detail {}", product);
        return productRepository.save(product);
    }

    /**
     * Fetching the base product and cloning it to add the variant informations
     *
     * @param baseProductId baseProductId
     * @param variant       The input request
     * @return Product
     */
    @Override
    public Product saveVariant(Long baseProductId, VariantRequest variant) {
        log.debug("Save variant for the base product {}", baseProductId);
        Product baseProduct = productRepository.findByProductId(baseProductId)
                .orElseThrow(() -> new NoSuchElementException("Base product not found!"));

        // Cloning the baseProduct and adding the variant details
        Product variantDetail = (Product) baseProduct.cloneProduct();
        variantDetail.setColor(variant.color());
        variantDetail.setModel(variant.model());
        variantDetail.setWarranty(variant.warranty());
        variantDetail.setPrice(variant.price());
        variantDetail.setStorage(variant.storage());

        // Save the variant details
        return productRepository.save(variantDetail);
    }
}

Dalam perkhidmatan ini:

saveVariant: Kaedah ini mendapatkan semula produk asas mengikut ID, mengklonkannya, menggunakan butiran varian dan menyimpannya sebagai entri baharu dalam pangkalan data.

Langkah 3: Pengawal untuk Mencipta Varian

Buat pengawal REST yang mudah untuk mendedahkan API penciptaan varian.

@RestController
@RequestMapping("/api/v1/products")
@Log4j2
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @PostMapping
    public ResponseEntity<Product> saveBaseProduct(@RequestBody Product product) {
        log.debug("Rest request to save the base product {}", product);
        return ResponseEntity.ok(productService.saveBaseProduct(product));
    }

    @PostMapping("/{baseProductId}/variants")
    public ResponseEntity<Product> saveVariants(@PathVariable Long baseProductId, @RequestBody VariantRequest variantRequest) {
        log.debug("Rest request to create the variant for the base product");
        return ResponseEntity.ok(productService.saveVariant(baseProductId, variantRequest));
    }
}

Di sini:

saveVariant: Titik akhir ini mengendalikan permintaan HTTP POST untuk mencipta varian untuk produk tertentu. Ia menyerahkan logik penciptaan kepada ProductService.

Faedah Menggunakan Corak Prototaip

Dengan pelaksanaan ini, kami melihat beberapa kelebihan yang jelas:

Kebolehgunaan Semula Kod: Dengan merangkum logik pengklonan dalam kelas Produk, kami mengelakkan pertindihan kod dalam lapisan perkhidmatan dan pengawal kami.

Penyelenggaraan Ringkas: Corak Prototaip memusatkan logik pengklonan, menjadikannya lebih mudah untuk mengurus perubahan pada struktur objek.

Penciptaan Varian Cekap: Setiap varian baharu ialah klon produk asas, mengurangkan kemasukan data berlebihan dan memastikan konsistensi merentas atribut dikongsi.

Jalankan program

Bina projek Spring Boot menggunakan Gradle

./gradlew build
./gradlew bootRun

Laksanakan melalui klien Rehat

Simpan produk asas

curl --location 'http://localhost:8080/api/v1/products' \
--header 'Content-Type: application/json' \
--data '{
    "productId": 101,
    "name": "Apple Iphone 16",
    "model": "Iphone 16",
    "color": "black",
    "storage": 128,
    "warranty": 1,
    "price": 12.5
}'

Simpan varian

curl --location 'http://localhost:8080/api/v1/products/101/variants' \
--header 'Content-Type: application/json' \
--data '{
    "model": "Iphone 16",
    "color": "dark night",
    "storage": 256,
    "warranty": 1,
    "price": 14.5
}'

Keputusan (Varian baharu berterusan tanpa sebarang isu)

Repositori GitHub

Anda boleh mendapatkan pelaksanaan penuh Corak Reka Bentuk Prototaip untuk varian produk dalam repositori GitHub berikut:

Pautan Repositori GitHub

Ikuti Saya di LinkedIn

Kekal berhubung dan ikuti saya untuk mendapatkan lebih banyak artikel, tutorial dan cerapan tentang pembangunan perisian, corak reka bentuk dan Spring Boot:

Ikuti saya di LinkedIn

Kesimpulan

Corak Reka Bentuk Prototaip ialah alat yang berkuasa untuk kes yang kerap berlaku pertindihan objek, seperti yang dilihat dengan varian produk dalam aplikasi e-dagang. Dengan melaksanakan corak ini dalam aplikasi Spring Boot, kami meningkatkan kecekapan penciptaan objek dan kebolehselenggaraan kod kami. Pendekatan ini amat berguna dalam senario yang menuntut penciptaan objek serupa dengan variasi kecil, menjadikannya teknik yang berharga untuk pembangunan aplikasi dunia sebenar.

Atas ialah kandungan terperinci Melaksanakan Corak Reka Bentuk Prototaip dalam But Spring. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!