策略模式与责任链模式_责任链和策略模式一起使用-CSDN博客

本文链接：https://blog.csdn.net/FitDoctor/article/details/125693123

目标

1.掌握策略模式和责任链模式的使用场景
2.通过学习策略模式来消除程序中大量的if…else和switch语句
3.掌握策略模式和委派模式的结合使用
4.深刻理解责任链模式和建造者模式的结合应用

策略模式定义

策略模式又叫政策模式，它是将定义的算法家族分别封装起来，让它们之间可以相互替换，从而让算法的变化不会影响到使用算法的用户。
可以避免多冲分支的if…else…和switch语句
属于行为型模式

策略模式的应用场景

1.假如系统中有很多类，而它们之间的区别仅在于它们的行为不同。
2.一个系统需要动态的在几中算法中选择一种
3.需要屏蔽算法规则

// 假如某个商品不同的时期有不同的优惠，平时的写法
public class Test {

    public static void main(String[] args) {
        String promotion = "Empty";
        if("Empty".equals(promotion)){
            System.out.println("当前无优惠");
            //todo  something
        }else if ("九折".equals(promotion)){
            System.out.println("九折优惠");
            //todo  something
        }
    }
}

策略模式进行优化

//优化1
//创建一个优惠处理接口
public interface IPromotionStrategy {
    void doPromotion();
}
//无优惠处理类
public class EmptyStrategy implements IPromotionStrategy{
    @Override
    public void doPromotion() {
        System.out.println("没有优惠");
        //todo
    }
}
//返现优惠处理类
public class CashBackStrategy implements IPromotionStrategy{
    @Override
    public void doPromotion() {
        System.out.println("返现优惠，返回支付宝");
        //todo
    }
}
//团购优惠处理类
public class GroupByStrategy implements IPromotionStrategy{
    @Override
    public void doPromotion() {
        System.out.println("团购优惠，5人成团");
        //todo
    }
}
public class Test {

    public static void main(String[] args) {
        String promotion = "Empty";
        IPromotionStrategy promotionStrategy = null;
        if("Empty".equals(promotion)){
            System.out.println("当前无优惠");
            promotionStrategy = new EmptyStrategy();
        }else if ("团购".equals(promotion)){
            System.out.println("九折优惠");
            promotionStrategy = new GroupByStrategy();
        }
    }
}
发现同样没有解决问题，缺少一个上下文来承接 每种优惠的算法逻辑和去除if...else...
public class PromotionActivity {
    private IPromotionStrategy strategy;
    public PromotionActivity(IPromotionStrategy strategy) {
        this.strategy = strategy;
    }
    public void execute(){
        strategy.doPromotion();
    }
}
public class Test {
    public static void main(String[] args) {
        String promotion = "Empty";

        PromotionActivity promotionStrategy = null;
        if("Empty".equals(promotion)){
            promotionStrategy = new PromotionActivity(new EmptyStrategy());
        }else if ("团购".equals(promotion)){
            promotionStrategy = new PromotionActivity(new GroupBuyStrategy());
        }
    }
}
算法问题解决了  if...else..如何解决呢

使用静态工厂初始化所有的策略类

// An highlighted block
//创建一个策略工厂
public class PromotionStrategyFactory {

    private static Map<String,IPromotionStrategy> PROMOTIONS = new HashMap<>();
	//工厂初始化所有的策略类
    static {
        PROMOTIONS.put(PromotionKey.EMPTY,new EmptyStrategy());
        PROMOTIONS.put(PromotionKey.GROUPBUY,new GroupBuyStrategy());
        PROMOTIONS.put(PromotionKey.CASHBACK,new CashBackStrategy());
    }

    private static final IPromotionStrategy EMPTY = new EmptyStrategy();

    public PromotionStrategyFactory() {
    }
    //根据客户端传入的key获取具体策略
    public static IPromotionStrategy getPromotionStrategy(String promotionKey){
        IPromotionStrategy promotionStrategy = PROMOTIONS.get(promotionKey);
        return promotionStrategy == null ? EMPTY : promotionStrategy;
    }
    //内部类定义策略种类
    private interface PromotionKey{
        String EMPTY = "EMPTY";
        String GROUPBUY = "GROUPBUY";
        String CASHBACK = "CASHBACK";
    }
    //返回客户端所有的策略
    public static Set<String> getPromotionKey(){
        return PROMOTIONS.keySet();
    }
}
public class Test {

    public static void main(String[] args) {
        //供客户端选择
        Set<String> promotionKeys = PromotionStrategyFactory.getPromotionKey();
        //传入进来
        String promotion = "GROUPBUY";
        IPromotionStrategy promotionStrategy = PromotionStrategyFactory.getPromotionStrategy(promotion);
        promotionStrategy.doPromotion();

    }
}

策略模式在源码中的体现
InstantiationStrategy
策略模式的优点
1.策略模式符合开闭原则
2.避免使用多重条件转移语句，如if…else…语句、switch语句
3.使用策略模式可以提高算法的保密性和安全性
策略模式的缺点
1.客户端必需知道所有的策略，并且自行决定使用哪一个策略
2.代码中会禅城非常多的策略类，增加维护难度

责任链模式的定义

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

责任链模式的使用场景

1.一个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定
2.在不明确指定接受者的情况下，向多个对象中的一个提交一个请求
3.可动态指定一组对象处理请求

优化案例

// An highlighted block
@Data
public class Member {
    private String loginName;
    private String loginPass;
    private String roleName;

    public Member(String loginName, String loginPass) {
        this.loginName = loginName;
        this.loginPass = loginPass;
    }
}

public class MemberService {
    public void login(String loginName,String loginPass){
        if("".equals(loginName) || "".equals(loginPass)){
            System.out.println("用户名和密码为空");
            return;
        }
        System.out.println("用户名和密码不为空，可以往下执行");

        Member member = checkExists(loginName,loginPass);
        if(null == member){
            System.out.println("用户不存在");
            return;
        }
        System.out.println("登录成功！");

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

    }
    private Member checkExists(String loginName,String loginPass){
        Member member = new Member(loginName,loginPass);
        member.setRoleName("管理员");
        return member;
    }
    public static void main(String[] args) {
        MemberService service = new MemberService();
        service.login("zhangsan","666");
    }
}
上方逻辑主要是有三部分 参数校验、登录校验、用户权限校验

优化

// 
public abstract class Handler {
    protected Handler next;
    //形成一个链向下传播
    public void next(Handler next){ this.next = next;}
    //子类去实现具体的处理逻辑
    public abstract void doHandler(Member member);
}
//校验逻辑
public class ValidateHandler extends Handler {
    public void doHandler(Member member) {
        if("".equals(member.getLoginName()) || "".equals(member.getLoginPass())){
            System.out.println("用户名和密码为空");
            return;
        }
        System.out.println("用户名和密码不为空，可以往下执行");
        next.doHandler(member);
    }
}
//登录校验
public class LoginHandler extends Handler {
    public void doHandler(Member member) {
        System.out.println("登录成功！");
        member.setRoleName("管理员");
        next.doHandler(member);
    }
}
//用户权限校验
public class AuthHandler extends Handler {
    public void doHandler(Member member) {
        if(!"管理员".equals(member.getRoleName())){
            System.out.println("您不是管理员，没有操作权限");
            return;
        }
        System.out.println("允许操作");
    }
}
//service层
public class MemberService {
    public void login(String loginName,String loginPass){
        Handler validateHandler = new ValidateHandler();
        Handler loginHandler = new LoginHandler();
        Handler authHandler = new AuthHandler();

        validateHandler.next(loginHandler);
        loginHandler.next(authHandler);

        validateHandler.doHandler(new Member(loginName,loginPass));
    }
}
public class Test {
    public static void main(String[] args) {
        MemberService memberService = new MemberService();
        memberService.login("zhangsan","666");
    }
}
有时候一些节点并不分前后的执行顺序，如何将他们形成链式结构呢，联想到StringBuilder的 append()方法
就是使用建造者模式实现的

优化

// Handler处理类
public abstract class Handler<T> {
    protected Handler next;
    public void next(Handler next){ this.next = next;}
    //每个节点来实现不同的处理逻辑
    public abstract void doHandler(Member member);
    //内部类来构建链表结构
    public static class Builder<T>{
        private Handler<T> head;
        private Handler<T> tail;

        public Builder<T> addHandler(Handler handler){
            //do{
            //将头节点和尾结点都指向第一个传入进来的handler
                if (this.head == null) {
                    this.head = this.tail = handler;
                    return this;
                }
                //第二个传入进来的节点放到第一个节点后面然后将 后传入的赋值给tail
                this.tail.next(handler);
                this.tail = handler;
//            }while (false);//真正框架中，如果是双向链表，会判断是否已经到了尾部
            return this;
        }
        public Handler<T> build(){
            return this.head;
        }
    }
}
//校验参数
public class ValidateHandler extends Handler {
    public void doHandler(Member member) {
        if("".equals(member.getLoginName()) || "".equals(member.getLoginPass())){
            System.out.println("用户名和密码为空");
            return;
        }
        System.out.println("用户名和密码不为空，可以往下执行");
        next.doHandler(member);
    }
}
//登录
public class LoginHandler extends Handler {
    public void doHandler(Member member) {
        System.out.println("登录成功！");
        member.setRoleName("管理员");
        if(null != next) {
            next.doHandler(member);
        }
    }
}
//权限校验
public class AuthHandler extends Handler {
    public void doHandler(Member member) {
        if(!"管理员".equals(member.getRoleName())){
            System.out.println("您不是管理员，没有操作权限");
            return;
        }
        System.out.println("允许操作");
    }
}
//service层
public class MemberService {
    public void login(String loginName,String loginPass){
        Handler.Builder builder = new Handler.Builder();
        builder.addHandler(new ValidateHandler())
                .addHandler(new LoginHandler())
                .addHandler(new AuthHandler());
        builder.build().doHandler(new Member(loginName,loginPass));
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        MemberService memberService = new MemberService();
        memberService.login("zhangsan","666");
    }
}
可以根据实际业务来处理每个节点处理完成之后是否需要终止

责任链模式在源码中的体现
Filter类中的doFilter(xx,xx,FilterChain chain)
ChannelHandler类

责任链模式的优点

1.将请求与处理解耦
2.请求处理者（节点对象）只需要关注自己感兴趣的请求进行处理即可，对于不感兴趣的请求，直接转发给下一级节点对象；
3.具备链式传递处理请求的功能，请求发送者无需知晓链路结构，只需要等待请求处理结果
4.链路结构灵活，可以通过改变链路结构动态的新增或删减责任
5.易于扩展的请求处理类（节点），符合开闭原则