Implémentation du modèle de conception de prototype dans Spring Boot

Introduction

Dans le développement d'applications, la gestion de la création d'objets peut être complexe, en particulier lorsqu'il s'agit d'instances presque identiques mais qui varient dans des détails spécifiques. Le Prototype Design Pattern offre une solution en nous permettant de créer de nouveaux objets en copiant ou en « clonant » des objets existants. Ce modèle est particulièrement utile lorsque les objets sont coûteux à créer ou impliquent une initialisation approfondie.

Dans cet article, nous explorerons comment implémenter le modèle de conception de prototype dans une application Spring Boot, en utilisant un cas d'utilisation pratique du commerce électronique : créer et conserver des variantes de produits. Grâce à cet exemple, vous apprendrez non seulement les principes fondamentaux du modèle de prototype, mais également comment il peut rationaliser la création d'objets dans des applications du monde réel.

Comprendre le modèle de conception de prototype

Le Prototype Pattern est un modèle de conception créationnel qui vous permet de créer de nouvelles instances en clonant un objet existant, appelé prototype. Cette approche est particulièrement utile lorsque vous disposez d'un objet de base avec diverses propriétés, et que créer chaque variante à partir de zéro serait redondant et inefficace.

En Java, ce modèle est souvent implémenté à l'aide de l'interface Cloneable ou en définissant une méthode de clonage personnalisée. L'idée principale est de fournir un « plan » qui peut être reproduit avec des modifications, en gardant l'objet original intact.

Principaux avantages du modèle prototype :

1. Réduit le temps d'initialisation : au lieu de créer des objets à partir de zéro, vous clonez et modifiez des instances existantes, économisant ainsi le temps d'initialisation.

2. Encapsule la logique de création d'objet : vous définissez la manière dont les objets sont clonés dans l'objet lui-même, en gardant les détails d'instanciation cachés.

3. Améliore les performances : pour les applications qui créent fréquemment des objets similaires, tels que des variantes de produits, le modèle de prototype peut améliorer les performances.

Cas d'utilisation du commerce électronique : gestion des variantes de produits

Imaginez une plate-forme de commerce électronique où un produit de base a diverses configurations ou « variantes » — par exemple, un smartphone avec différentes couleurs, options de stockage et conditions de garantie. Plutôt que de recréer chaque variante à partir de zéro, nous pouvons cloner un produit de base, puis ajuster des champs spécifiques si nécessaire. De cette façon, les attributs partagés restent cohérents et nous modifions uniquement les détails spécifiques aux variantes.

Dans notre exemple, nous allons créer un service Spring Boot simple pour créer et conserver des variantes de produits à l'aide du modèle de prototype.

Implémentation du modèle de prototype dans Spring Boot

Étape 1 : Définition du produit de base

Commencez par définir une classe de produit avec les champs nécessaires pour un produit, comme l'identifiant, le nom, la couleur, le modèle, le stockage, la garantie et le prix. Nous ajouterons également une méthode cloneProduct pour créer une copie d’un produit.

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

Dans cette configuration :

cloneProduct : Cette méthode crée un clone de l'objet Product, en définissant l'ID sur null pour garantir que la base de données attribue un nouvel ID pour chaque instance clonée.

Étape 2 : Création d'un service pour gérer les variantes

Ensuite, créez un ProductService avec une méthode pour enregistrer la variante. Cette méthode clone un produit de base et applique les attributs spécifiques à la variante, puis l'enregistre en tant que nouveau produit.

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

Dans ce service :

saveVariant : Cette méthode récupère le produit de base par ID, le clone, applique les détails de la variante et l'enregistre en tant que nouvelle entrée dans la base de données.

Étape 3 : Contrôleur pour la création de variantes

Créez un contrôleur REST simple pour exposer l'API de création de variantes.

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

Ici :

saveVariant : Ce point de terminaison gère les requêtes HTTP POST pour créer une variante pour un produit spécifié. Il délègue la logique de création à ProductService.

Avantages de l'utilisation du modèle de prototype

Avec cette mise en œuvre, nous voyons plusieurs avantages évidents :

Réutilisabilité du code : En encapsulant la logique de clonage dans la classe Product, nous évitons la duplication de code dans nos couches de service et de contrôleur.

Maintenance simplifiée : Le modèle de prototype centralise la logique de clonage, facilitant ainsi la gestion des modifications apportées à la structure de l'objet.

Création efficace de variantes : Chaque nouvelle variante est un clone du produit de base, réduisant ainsi la saisie de données redondantes et garantissant la cohérence entre les attributs partagés.

Exécutez le programme

Construisez le projet Spring Boot à l'aide de Gradle

./gradlew build
./gradlew bootRun

Exécuter via le client Rest

Enregistrer le produit de base

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

Enregistrer les variantes

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

Résultat (nouvelle variante persistée sans aucun problème)

Dépôt GitHub

Vous pouvez trouver l'implémentation complète du Prototype Design Pattern pour les variantes de produits dans le référentiel GitHub suivant :

Lien du référentiel GitHub

Suivez-moi sur LinkedIn

Restez connecté et suivez-moi pour plus d'articles, de tutoriels et d'informations sur le développement de logiciels, les modèles de conception et Spring Boot :

Suivez-moi sur LinkedIn

Conclusion

Le Prototype Design Pattern est un outil puissant pour les cas où la duplication d'objets est fréquente, comme on le voit avec les variantes de produits dans les applications de commerce électronique. En implémentant ce modèle dans une application Spring Boot, nous améliorons à la fois l'efficacité de la création d'objets et la maintenabilité de notre code. Cette approche est particulièrement utile dans les scénarios qui nécessitent la création d'objets similaires avec de petites variations, ce qui en fait une technique précieuse pour le développement d'applications réelles.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!