Modèle de chaîne de responsabilité

Comme son nom l'indique, le modèle de chaîne de responsabilité crée une chaîne d'objets récepteurs pour une demande. Ce modèle divise l'expéditeur et le destinataire d'une demande en fonction du type de demande. Ce modèle relève de modèles comportementaux.

Dans ce modèle, chaque récepteur contient normalement une référence à un autre récepteur. Si un objet ne peut pas gérer la demande, il la transmet au récepteur suivant et ainsi de suite.

la mise en oeuvre

Nous avons créé une classe abstraite AbstractLogger avec un niveau de journalisation. Ensuite, nous avons créé trois types de loggers étendant le AbstractLogger . Chaque enregistreur vérifie le niveau du message à son niveau et imprime en conséquence sinon n'imprime pas et transmet le message à son enregistreur suivant.

Étape 1

Créez une classe de journalisation abstraite.

AbstractLogger.java

public abstract class AbstractLogger {
   public static int INFO = 1;
   public static int DEBUG = 2;
   public static int ERROR = 3;

   protected int level;

   //next element in chain or responsibility
   protected AbstractLogger nextLogger;

   public void setNextLogger(AbstractLogger nextLogger){
      this.nextLogger = nextLogger;
   }

   public void logMessage(int level, String message){
      if(this.level <= level){
         write(message);
      }
      if(nextLogger !=null){
         nextLogger.logMessage(level, message);
      }
   }

   abstract protected void write(String message);
	
}

Étape 2

Créez des classes concrètes étendant le logger.

ConsoleLogger.java

public class ConsoleLogger extends AbstractLogger {

   public ConsoleLogger(int level){
      this.level = level;
   }

   @Override
   protected void write(String message) {		
      System.out.println("Standard Console::Logger: " + message);
   }
}

ErrorLogger.java

public class ErrorLogger extends AbstractLogger {

   public ErrorLogger(int level){
      this.level = level;
   }

   @Override
   protected void write(String message) {		
      System.out.println("Error Console::Logger: " + message);
   }
}

FileLogger.java

public class FileLogger extends AbstractLogger {

   public FileLogger(int level){
      this.level = level;
   }

   @Override
   protected void write(String message) {		
      System.out.println("File::Logger: " + message);
   }
}

Étape 3

Créez différents types d'enregistreurs. Attribuez-leur des niveaux d'erreur et définissez le prochain enregistreur dans chaque enregistreur. L'enregistreur suivant dans chaque enregistreur représente la partie de la chaîne.

ChainPatternDemo.java

public class ChainPatternDemo {
	
   private static AbstractLogger getChainOfLoggers(){

      AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
      AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
      AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);

      errorLogger.setNextLogger(fileLogger);
      fileLogger.setNextLogger(consoleLogger);

      return errorLogger;	
   }

   public static void main(String[] args) {
      AbstractLogger loggerChain = getChainOfLoggers();

      loggerChain.logMessage(AbstractLogger.INFO, 
         "This is an information.");

      loggerChain.logMessage(AbstractLogger.DEBUG, 
         "This is an debug level information.");

      loggerChain.logMessage(AbstractLogger.ERROR, 
         "This is an error information.");
   }
}

Étape 4

Vérifiez la sortie.

Standard Console::Logger: This is an information.
File::Logger: This is an debug level information.
Standard Console::Logger: This is an debug level information.
Error Console::Logger: This is an error information.
File::Logger: This is an error information.
Standard Console::Logger: This is an error information.