设计模式-责任链模式

设计模式-责任链模式

定义

责任链模式（Chain of Responsibility Pattern）是将链中的每一个节点当做一个对象，每个节点处理的请求不同，且内部自动维护一个下一个节点的对象。当一个请求从链的首端出发时，会沿着链的路径依次传递给每一个节点对象，直至有对象处理这个请求为止。

属于行为模式

适用场景

多个对象可以处理一个请求，但具体由哪个对象处理由动态决定。
在不指定明确接收者的情况下，向多个对象中的一个提交一个请求。
可动态地指定一组对象处理请求

代码示例

普通写法

拿处理请求举例：

定义 Handler 抽象类，提供设置下一 handler 方法

package com.black.design.pattern.responsibilitychain.general;

// 抽象类
public abstract class Handler {

    protected Handler sucessor;
    
    public  void setNextHandler(Handler sucessor) {
        this.sucessor = sucessor;
    }

    public abstract  void handleRequest(String request) ;
    
}

定义 ConcreHandlerA 类，只能处理 requestA 请求，其他请求则让下一个处理类处理

package com.black.design.pattern.responsibilitychain.general;

public class ConcreHandlerA extends Handler {

    @Override
    public void handleRequest(String request) {

        if("requestA".equals(request)) {
            System.out.println(this.getClass().getSimpleName() +  "handle with request [" +request +"]");
            return;
        }
        if (this.sucessor != null) {
            sucessor.handleRequest(request);
        }
    }

}

定义 ConcreHandlerB 类，只能处理 requestB 请求，其他请求则让下一个处理类处理

package com.black.design.pattern.responsibilitychain.general;

public class ConcreHandlerB extends Handler {

    @Override
    public void handleRequest(String request) {
        if("requestB".equals(request)) {
            System.out.println(this.getClass().getSimpleName() +  "handle with request [" +request +"]");
            return;
        }
        if (this.sucessor != null) {
            sucessor.handleRequest(request);
        }
    }

}

测试

package com.black.design.pattern.responsibilitychain.general;
//测试类
public class HandlerTest {
    
    public static void main(String[] args) {
		// 实例化 handlerA 处理类
        Handler handlerA = new ConcreHandlerA();
		// 实例化 handlerB 处理类
        Handler handlerB = new ConcreHandlerB();
        // handlerA 下一节点是 handlerB 处理类
        handlerA.setNextHandler(handlerB);
        // 定义 3 个请求
        String[] reqs = {"requestA","requestB","requestC"};
        // 循环处理
        for (int i = 0; i < reqs.length; i++) {
            handlerA.handleRequest(reqs[i]);
        }
       
    }
}

结果：

ConcreHandlerAhandle with request [requestA]
ConcreHandlerBhandle with request [requestB]

登录场景

基本流程：

验证用户名和密码是否为空
登录验证，成功后获取用户权限
验证权限

代码如下：

登录接口


package com.black.design.pattern.responsibilitychain.auth;

// 登录接口类
public interface LoginService {

    // 根据用户名和密码登录
    public void login(String userName, String password);
}

package com.black.design.pattern.responsibilitychain.auth;

// 登录接口实现类
public class LoginServiceImpl implements LoginService {

    public void login(String userName, String password) {
        // 校验用户名密码是否为null 
        Handler vHandler = new ValidatorHandler();
        // 登录
        Handler loginHandler = new LoginHandler();
        // 校验是否有权限
        Handler authHandler = new AuthHandler();
        //执行
        vHandler.next(loginHandler);
        loginHandler.next(authHandler);
        vHandler.doHandle(new UserInfo(userName, password));
    }
}

package com.black.design.pattern.responsibilitychain.auth;

 // 用户信息
public class UserInfo {
    // 用户名
    private String userName;
    // 密码
    private String password;
    // 角色
    private String role;

    public UserInfo(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }

    public String getUserName() {
        return userName;
    }

    public String getPassword() {
        return password;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }
}

创建抽象处理类

package com.black.design.pattern.responsibilitychain.auth;

// 处理类
public abstract class Handler {

    // 下一处理类
    protected Handler nextHandler;
    
    // 处理方法
    protected  abstract void doHandle(UserInfo userInfo) ;
    
	// 设置下一处理
    public void next(Handler h) {
        this.nextHandler = h;
    }
}

登录参数校验处理类

package com.black.design.pattern.responsibilitychain.auth;

// 登录参数验证处理类
public class ValidatorHandler extends Handler {

    @Override
    protected void doHandle(UserInfo userInfo) {
        // 校验参数
        if(userInfo.getUserName() == null || 
                userInfo.getPassword() == null) {
            System.out.println("用户名或密码为空，不允许登录！");
            return;
        }
        System.out.println("用户名和密码不为空，继续");
       nextHandler.doHandle(userInfo);
    }

}

登录处理类

package com.black.design.pattern.responsibilitychain.auth;

// 登录处理类
public class LoginHandler extends Handler {

    @Override
    protected void doHandle(UserInfo userInfo) {

        System.out.println("登录成功！");
        // 登录成功设置用户权限
        //userInfo.setRole("业务员");
        userInfo.setRole("管理员");
        nextHandler.doHandle(userInfo);
    }
}

权限验证处理类

package com.black.design.pattern.responsibilitychain.auth;

// 权限验证处理类
public class AuthHandler extends Handler {

    @Override
    protected void doHandle(UserInfo userInfo) {

        if(!"管理员".equals(userInfo.getRole())) {
            System.out.println("您不是管理员，没有操作权限");
            return;
        }
        System.out.println("允许操作");
    }

}

测试类

package com.black.design.pattern.responsibilitychain.auth;

// 测试类
public class AuthTest {

    public static void main(String[] args) {
        LoginService loginService = new LoginServiceImpl();
        loginService.login("black", "abc");
    }
}

测试结果：

用户名和密码不为空，继续
登录成功！
允许操作

优化版：

主要优化点：增加 Handler Builder 类，用于构建 Handler 处理链。只需要调整 Handler 类和 LoginServiceImpl 类即可。

package com.black.design.pattern.responsibilitychain.auth;

// 处理类
public abstract class Handler {

    // 下一处理类
    protected Handler nextHandler;
    
    // 处理
    protected  abstract void doHandle(UserInfo userInfo) ;
    
    public void next(Handler h) {
        this.nextHandler = h;
    }
    
    // 用于构建 handler 处理链
    public static  class Builder{
        
        private Handler first;// 首节点
        
        private Handler last;// 尾节点
        
        // 设置下一节点
        public Builder next(Handler handler) {
            if(first == null ) {
                // 如果 首节点是null 那么 handler 就是第一个节点
                first = last = handler;
            }
            // 如果 首节点不是null 那么 handler 就加入到最后一个节点
            last.next(handler);
            last = handler;
            return this;
        }
        
        public Handler build() {
            // 每次返回链的首节点
            return first;
        }
    }
}

package com.black.design.pattern.responsibilitychain.auth;

// 登录接口实现类
public class LoginServiceImpl implements LoginService {

    public void login(String userName, String password) {
        // 校验用户名密码是否为null 
        Handler vHandler = new ValidatorHandler();
        // 登录
        Handler loginHandler = new LoginHandler();
        // 校验是否有权限
        Handler authHandler = new AuthHandler();
        
        // 构建 handler 处理链
        Handler.Builder builder = new  Handler.Builder();
        builder.next(vHandler).next(loginHandler).next(authHandler);
        
     
        builder.build().doHandle(new UserInfo(userName, password));
    }
}

测试结果：

用户名和密码不为空，继续
登录成功！
允许操作

设计模式-责任链模式

设计模式-责任链模式

定义

适用场景

代码示例

普通写法

登录场景

推荐阅读