设计模式：责任链模式

设计模式：责任链模式

• 真正让自己提升的不是自己知道多少，而是自己知道多少，并且属于自己的有多少。自己知道的广泛让自己选择的时候考虑更加的全面，自己掌握的让自己实现的时候更加得心应手
• 责任链模式简介：
  1. 简介：为请求创造了一个接受者对象的链。
  2. 主要解决：职责链上的处理者负责处理请求，客户只需要将请求发送到职责连上，无需关心请求的处理细节和请求的传递，所以这种模式将请求的发送者和接受者解耦。
  3. 何时使用：在处理消息的时候以过滤很多道。
  4. 应用实例： tomcat中Encoding处理，拦截器
• 责任链模式成分
  1. 请求接受者：
     1. 下一个请求接受者对象。
     2. 判断是否处理的一个参数
     3. 统一的消息处理方法
• 责任链模式优缺点：
  1. 优点：
     1. 降低耦合度，它将请求的发送者和接受者解耦
     2. 简化对象，对象不需要知道链的结构
     3. 增强新的请求处理类很方便
     4. 增强给对象指派职责的灵活性。
  2. 缺点：
     1. 不能保证请求一定被接收
     2. 系统性能将受到一定的影响，而且对代码进行调试不是很方便
     3. 可能不容易观察运行的特征，有碍于除错
• 责任链模式实现：
  1. 抽象类：

     package com.fg.java.chainofResponsibility;
     
     /**
      * 定义一个对象的抽象类
      */
     public abstract class AbstractLogger {
         public static int INFO = 1;
         public static int DEBUG = 2;
         public static int ERROR = 3;
     
         protected int level;
     
         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){
                 this.nextLogger.logMessage(level,message);
             }
         }
     
         abstract protected void write(String message);
     }
     

      

  2. 实现类

     package com.fg.java.chainofResponsibility;
     
     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);
         }
     }
     

     package com.fg.java.chainofResponsibility;
     
     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);
         }
     }
     

     package com.fg.java.chainofResponsibility;
     
     public class FileLogger extends AbstractLogger {
         public FileLogger(int level) {
             this.level = level;
         }
     
         @Override
         protected void write(String message) {
             System.out.println("File logger::"+message);
         }
     }
     

      

  3. Demo

     package com.fg.java.chainofResponsibility;
     
     public class ChainOfResponsibilityDemo {
     
         private static  AbstractLogger getChainOfLoggers(){
             AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
             AbstractLogger fileLogger = new FileLogger(AbstractLogger.INFO);
             AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.DEBUG);
             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 information");
             loggerChain.logMessage(AbstractLogger.ERROR,"this is  an error information");
         }
     }