Modèles de conception courants dans les frameworks Java

Les modèles de conception dans le framework Java sont utilisés pour améliorer l'évolutivité, la maintenabilité et la réutilisabilité du code. Les modèles couramment utilisés incluent : Modèle Singleton : garantit qu'une seule instance d'une classe existe et y accède dans toute l'application. Modèle de méthode d'usine : créez une interface pour les objets et la sous-classe décide quel objet instancier. Modèle d'observateur : définissez une relation de dépendance un-à-plusieurs. Lorsqu'un objet change, les autres objets reçoivent des notifications et mettent à jour leur statut. Modèle de stratégie : définissez une série d'algorithmes et rendez-les interchangeables, rendant la classe d'algorithmes indépendante de la classe client.

Modèles de conception couramment utilisés dans les frameworks Java

Dans le processus de développement logiciel, un modèle de conception est une structure d'organisation de code éprouvée utilisée pour résoudre des problèmes courants. Dans les frameworks Java, les modèles de conception sont largement utilisés pour améliorer l'évolutivité, la maintenabilité et la réutilisation du code. Voici quelques-uns des modèles de conception les plus couramment utilisés dans les frameworks Java :

Modèle Singleton

• Objectif : Assurer qu'une seule instance d'une classe existe et accéder à cette instance dans toute l'application.

  public class Singleton {
    private static Singleton instance;
  
    private Singleton() { /* Private constructor to prevent instantiation */ }
  
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
  }

Factory Method Pattern

• Objectif : Définir une interface pour créer des objets et laisser les sous-classes décider quelle classe instancier.

  public interface ShapeFactory {
    Shape createShape();
  }
  
  public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
  }
  
  public class SquareFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Square();
    }
  }

Modèle d'observateur

• Objectif : Définir une relation de dépendance un-à-plusieurs entre les objets Lorsqu'un objet change, les autres objets recevront des notifications et mettront à jour leur statut.

  public interface Observer {
    void update(Subject subject);
  }
  
  public class Subject {
    private List<Observer> observers = new ArrayList<>();
  
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
  
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
  
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(this);
        }
    }
  }

Strategy Pattern

• Objectif : Définir une famille d'algorithmes, les encapsuler et les rendre interchangeables. Ce modèle rend les classes d'algorithmes indépendantes des classes clientes qui les utilisent.

  public interface Strategy {
    int calculate(int num1, int num2);
  }
  
  public class AdditionStrategy implements Strategy {
    @Override
    public int calculate(int num1, int num2) {
        return num1 + num2;
    }
  }
  
  public class SubtractionStrategy implements Strategy {
    @Override
    public int calculate(int num1, int num2) {
        return num1 - num2;
    }
  }

Cas pratique : modèle d'observateur dans Spring Framework

Spring Framework utilise le modèle d'observateur pour notifier les événements du bean. Lorsqu'un bean est créé, détruit ou modifié, Spring publie des événements auxquels les applications peuvent s'abonner et agir en conséquence.

@EventListener(ApplicationReadyEvent.class)
public void handleApplicationReadyEvent() {
    // 在应用程序启动时执行的操作
}

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!