Java设计模式之策略模式

在一个收银系统中,如果普通用户、中级会员、高级会员分别对应着不同的优惠策略,常规编程就要使用一系列的判断语句,判断用户类型,这种情况下就可以使用策略模式。

一、概念理解

策略模式的概念很好理解,它将对象和行为分开,将行为定义为 一个行为接口和具体行为的实现,每个if判断都可以理解为一个策略。

如果在收银系统中使用策略模式,要将普通、中级、高级会员分别定义一个具体策略类,并实现各自的方法,定义一个环境类,持有策略类的引用,由引用调用相应的策略类方法,客户端传入相应的具体策略对象就会调用各自的策略方法。

学过了状态模式,很多人也把状态模式和状态模式搞混,现在就可以考虑一下为什么不使用状态模式?

各个策略之间并不存在流转(比如:状态1234切换)关系,都是各自的算法实现各自的逻辑,客户端控制调用哪个策略,如果使用状态模式就变成了,先调用普通会员的策略,再调用中级会员的策略,再调用高级会员的策略,看到最后的优惠用户估计会乐疯吧!

和状态模式一样,策略模式也应包含三个角色:

抽象策略类:策略是一个接口,该接口定义若干个算法标识,即定义了若干个抽象方法

具体策略类:具体策略是实现策略接口的类

环境类 /上下文类:上下文提供一个方法,持有一个策略类的引用,最终给客户端调用。

相比于状态模式,策略模式各个角色的职责更简单,我们基于收银案例实现策略模式demo。

二、案例实现

抽象策略类:

定义业务抽象方法,我们主要是计算价格

/**
 * 策略抽象类
 * @author tcy
 * @Date 21-09-2022
 */
public interface AbstractMemberStrategy {
    // 一个计算价格的抽象方法
    //price商品的价格 n商品的个数
    public double calcPrice(double price, int n);
}

具体策略-高级会员:

各个具体策略实现各自的计算方法

/**高级会员
 * @author tcy
 * @Date 21-09-2022
 */
public class StrategyAdvanceMember implements AbstractMemberStrategy {
    @Override
    public double calcPrice(double price, int n) {
        double money = price * n *0.8;
        return money;
    }
}

具体策略-中级会员:

/**
 * 中级会员
 * @author tcy
 * @Date 21-09-2022
 */
public class StrategyIntermediateMember implements AbstractMemberStrategy {
    @Override
    public double calcPrice(double price, int n) {
        double money = price * n*0.9;
        return money;
    }
}

具体策略-普通会员:

/**
 * 初级会员
 * @author tcy
 * @Date 21-09-2022
 */
public class StrategyPrimaryMember implements AbstractMemberStrategy {
    @Override
    public double calcPrice(double price, int n) {
        return price * n;
    }
}

环境类:

持有策略类的引用,调用时传入相应的具体策略对象,就会调用策略各自的方法。

/**环境类
 * @author tcy
 * @Date 21-09-2022
 */
public class Context {
    // 用户折扣策略接口
    private AbstractMemberStrategy memberStrategy;

    // 注入构造方法
    public Context(AbstractMemberStrategy memberStrategy) {
        this.memberStrategy = memberStrategy;
    }

    // 计算价格
    public double qoutePrice(double goodsPrice, int n){
        // 通过接口变量调用对应的具体策略
        return memberStrategy.calcPrice(goodsPrice, n);
    }

}

客户端调用:

/**
 * @author tcy
 * @Date 21-09-2022
 */
public class Client {
    public static void main(String[] args) {

        // 具体策略类
        AbstractMemberStrategy primaryMemberStrategy = new StrategyPrimaryMember();
        AbstractMemberStrategy intermediateMemberStrategy = new StrategyIntermediateMember();
        AbstractMemberStrategy advanceMemberStrategy = new StrategyAdvanceMember();

        // 用户选择不同策略
        Context primaryContext = new Context(primaryMemberStrategy);
        Context intermediateContext = new Context(intermediateMemberStrategy);
        Context advanceContext = new Context(advanceMemberStrategy);

        //一本100块钱的书
        // 普通会员:100
        System.out.println("普通会员的价格:"+ primaryContext.qoutePrice(100,1));
        // 中级会员 90
        System.out.println("中级会员的价格:"+ intermediateContext.qoutePrice(100,1));
        // 高级会员 80
        System.out.println("高级会员的价格:"+ advanceContext.qoutePrice(100,1));

    }
}

策略模式相对于状态模式理解起来更没有任何难度。

三、Jdk中的应用

策略模式的典型应用是Jdk中线程池满之后的拒绝策略,我们在创建一个线程池时会传入以下参数:

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
                          TimeUnit unit,BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

其中 RejectedExecutionHandler 是线程池满之后的拒绝策略,jdk中的多线程内置了四种拒绝策略,如下图:

①ThreadPoolExecutor.AbortPolicy 默认拒绝策略,拒绝任务并抛出任务

②ThreadPoolExecutor.CallerRunsPolicy 使用调用线程直接运行任务

③ThreadPoolExecutor.DiscardPolicy 直接拒绝任务,不抛出错误

④ThreadPoolExecutor.DiscardOldestPolicy 触发拒绝策略,只要还有任务新增,一直会丢弃阻塞队列的最老的任务,并将新的任务加入

这四种拒绝策略就代表策略模式角色中的具体策略角色,ThreadPoolExecutor类我们可以将其看做环境类。

我们知道执行多线程中的方法是schedule方法,可以就认为这就是角色中的客户端:

public ScheduledFuture<?> schedule(Runnable command,
                                   long delay,
                                   TimeUnit unit) {
    if (command == null || unit == null)
        throw new NullPointerException();
    RunnableScheduledFuture<?> t = decorateTask(command,
        new ScheduledFutureTask<Void>(command, null,
                                      triggerTime(delay, unit)));
    delayedExecute(t);
    return t;
}

既然是客户端,就会有时机调用拒绝策略方法,我们点进去看delayedExecute()方法。

private void delayedExecute(RunnableScheduledFuture<?> task) {
    if (isShutdown())
        reject(task);
    else {
        super.getQueue().add(task);
        if (isShutdown() &&
            !canRunInCurrentRunState(task.isPeriodic()) &&
            remove(task))
            task.cancel(false);
        else
            ensurePrestart();
    }
}

接着看reject()方法,该方法时机上调用的就是拒绝策略方法。传入相应的this对象,调用不同的拒绝策略。

final void reject(Runnable command) {
    handler.rejectedExecution(command, this);
}

调用时序如下图:

何时调用何种拒绝策略,由delayedExecute()方法自己来决定,各个拒绝策略有各自的业务逻辑,这就是策略模式的典型应用。

四、策略模式和状态模式区别

策略模式和状态模式虽然类图一模一样,很多博客也将他们混为一谈,实际上策略模式和状态模式没有半毛钱的关系,只有理解了两种模式的使用场景,在运用时才能游刃有余,以下为我总结的四点不同之处,状态模式的博客可以参考状态模式。

①策略模式中的各策略相互之间没有什么关系,比如支付方式选择、优惠策略选择;状态模式往往是一套流程,比如订单状态流转、请假流程审批等。

②在策略模式下,调用哪个策略由客户端决定;状态模式中,客户端只管调用,各个具体状态类定义切换下一状态。

③状态模式强调状态变化、策略模式强调的是策略的选择。

五、总结

使用策略模式会让我们的代码更加的“干净”,但是如果实际的if判断中的逻辑很简单,我们仍然使用策略模式,就变成了为了使用设计模式而使用,这无疑加重系统的复杂程度。

就像商城系统中,微信支付、支付宝支付、银联支付,业务逻辑没那么简单的,使用策略模式就是一个好的选择。

整体来说策略模式在行为型模式中还属于一种比较简单的模式,无论是理解起来还是写起来都属极简单,难度堪比结构型设计模式中的单例模式。

到此这篇关于Java设计模式之策略模式的文章就介绍到这了。希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Java中常用的设计模式之策略模式详解

    目录 优点 缺点 使用场景 一.实现方式 1.订单类型枚举类 2.订单处理接口 3.普通订单处理器 4.秒杀订单处理器 5.拼团订单处理器 6.下单管理器 二.测试 1.引入依赖 2.测试用例 总结 优点 1.算法可以自由切换. 2.避免使用多重条件判断. 3.扩展性良好. 缺点 1.策略类会增多. 2.所有策略类都需要对外暴露. 使用场景 1.如果在一个系统里面有许多类,它们之间的区别仅在于它们的行为,那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为. 2.一个系统需要动态地在几种

  • 深入理解Java设计模式之策略模式

    目录 一.什么是策略模式 二.策略模式的结构 三.策略模式的应用场景 四.策略模式的优缺点 六.策略模式的实现 七.策略模式和简单工厂模式的结合 八.策略枚举的实现 九.总结 一.什么是策略模式 策略模式定义了一系列算法,并将每个算法封装起来,使他们可以相互替换,且算法的变化不会影响到使用算法的客户.需要设计一个接口,为一系列实现类提供统一的方法,多个实现类实现该接口,设计一个抽象类(可有可无,属于辅助类),提供辅助函数. 策略模式定义和封装了一系列的算法,它们是可以相互替换的,也就是说它们具有

  • 一起来了解Java的策略模式

    目录 策略模式 1.什么是策略模式 2.策略模式的优缺点 3.策略模式的结构 4.代码实现 5.策略模式的应用场景 总结 策略模式 策略模式属于Java 23种设计模式中行为模式之一,那先看看什么是策略模式. 1.什么是策略模式 策略模式的定义: 该模式定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的变化不会影响使用算法的客户.策略模式属于对象行为模式,它通过对算法进行封装,把使用算法的责任和算法的实现分割开来,并委派给不同的对象对这些算法进行管理. 其实我们在现实生活中常常

  • Java设计模式之策略模式案例详解

    目录 优缺点 Spring中哪里使用策略模式 策略模式设计图 代码案例 为什么使用策略模式? 答:策略模式是解决过多if-else (或者switch-case)代码块的方法之一,提高代码的可维护性.可扩展性和可读性. 优缺点 优点 算法可以自由切换(高层屏蔽算法,角色自由切换). 避免使用多重条件判断(如果算法过多就会出现很多种相同的判断,很难维护) 扩展性好(可自由添加取消算法而不影响整个功能). 缺点 策略类数量增多(每一个策略类复用性很小,如果需要增加算法,就只能新增类).所有的策略类都

  • 深入了解Java行为型设计模式之策略模式

    目录 策略模式 应用场景 优缺点 主要角色 策略模式的基本使用 创建抽象策略角色 创建具体策略角色 创建上下文角色 客户端执行 策略模式实现支付方式的选择 创建抽象策略角色 创建具体策略角色 创建上下文角色 客户端执行 策略模式 策略模式(Strategy Pattern)也叫政策模式(Policy Pattern),属于行为型模式. 它是将定义的一系列算法.分别封装起来,让它们之间可以互相替换,从而让算法的变化不会影响到使用算法的用户. 策略模式能让你定义一系列算法, 并将每种算法分别放入独立

  • Java设计模式之java策略模式详解

    目录 为什么使用策略模式? 策略模式包含角色 策略模式的类图 排序案例 策略模式的优点 策略模式的缺点 适用场景 源码分析策略模式的典型应用 Java Comparator 中的策略模式 参考文章 总结 为什么使用策略模式? 实现某一个功能有多条途径,每一条途径对应一种算法,此时我们可以使用一种设计模式来实现灵活地选择解决途径,也能够方便地增加新的解决途径. 策略模式包含角色 Context(环境类):环境类是使用算法的角色,它在解决某个问题(即实现某个方法)时可以采用多种策略.在环境类中维持一

  • java设计模式策略模式图文示例详解

    目录 策略模式 意图 问题 解决方案 真实世界类比 策略模式结构 伪代码 策略模式适合应用场景 实现方式 策略模式优缺点 策略模式优缺点 与其他模式的关系 策略模式 亦称:Strategy 意图 策略模式是一种行为设计模式,它能让你定义一系列算法,并将每种算法分别放入独立的类中,以使算法的对象能够相互替换. 问题 一天,你打算为游客们创建一款导游程序.该程序的核心功能是提供美观的地图,以帮助用户在任何城市中快速定位. 用户期待的程序新功能是自动路线规划:他们希望输入地址后就能在地图上看到前往目的

  • 深入了解Java设计模式之策略模式

    目录 定义 解决的问题 核心要点 类图 溢出效用 代码实现 核心接口 实现类-三个 Context类 Main方法 拓展 JDK源码 Spring源码 定义 定义了算法家族,分别封装起来,让他们之间可以相互替换,此模式让算法的变化,不会影响到使用算法的客户. 解决的问题 在有多种算法相似的情况下,使用 if…else 所带来的复杂和难以维护. 核心要点 把变化的代码从不变的代码中分离出来 针对接口编程而不是具体实现(类) 多用组合/聚合,少用继承 客户端通过组合的方式使用策略 类图 溢出效用 对

  • Java设计模式之策略模式_动力节点Java学院整理

    定义:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换. 类型:行为类模式 类图: 策略模式是对算法的封装,把一系列的算法分别封装到对应的类中,并且这些类实现相同的接口,相互之间可以替换.在前面说过的行为类模式中,有一种模式也是关注对算法的封装--模版方法模式,对照类图可以看到,策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context,它与模版方法模式的区别在于:在模版方法模式中,调用算法的主体在抽象的父类中,而在策略模式中,调用算法的主体则是封装到了封装类Context中

  • Java设计模式之策略模式原理与用法实例详解

    本文实例讲述了Java设计模式之策略模式原理与用法.分享给大家供大家参考,具体如下: 策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换.策略模式让算法独立于使用它的客户而独立变化.其中JDK里面的TreeSet类和TreeMap类就用到了策略模式.这两个类是带排序的集合类,其中排序的规则就相当于策略模式里定义的一系列算法,而集合类就相当于是策略模式里的环境类,供用户使用,用只知道TreeSet和TreeMap是带排序的,至于怎么排序的,是由排序的算法决定的. 策略模式

  • Java设计模式之策略模式定义与用法详解

    本文实例讲述了Java策略模式定义与用法.分享给大家供大家参考,具体如下: 一. 定义: 定义一系列算法,把他们一个一个封装起来,并且使他们可以相互替换. 二. 优点: (1)上下文(Context)和具体策略(ConcreteStrategy)是松耦合关系,因此上下文只需要知道他要使用某一个实现  Strategy接口类的实例,但不需要知道是哪个类. (2)策略模式满足开闭原则,当增加新的具体类时,不需要修改上下文类的代码,上下文即可以引用新的具体策略的实例. 三. 实例: 下面就通过一个问题

  • Java设计模式之策略模式示例详解

    目录 定义 结构 UML类图 UML序列图 深入理解策略模式 策略和上下文的关系 策略模式在JDK中的应用 该策略接口有四个实现类 策略模式的优点 策略模式的缺点 策略模式的本质 在讲策略模式之前,我们先看一个日常生活中的小例子: 现实生活中我们到商场买东西的时候,卖场往往根据不同的客户制定不同的报价策略,比如针对新客户不打折扣,针对老客户打9折,针对VIP客户打8折... 现在我们要做一个报价管理的模块,简要点就是要针对不同的客户,提供不同的折扣报价. 如果是有你来做,你会怎么做? 我们很有可

  • Java设计模式之策略模式深入刨析

    目录 1.基本介绍 2.传统方式 3.采用策略模式 4.策略模式的注意事项和细节 1.基本介绍 1)策略模式(Strategy Pattern)中,定义算法族(策略组),分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户 2)这算法体现了几个设计原则,第一,把变化的代码从不变的代码中分离出来:第二,针对接口编程而不是具体类(定义了策略接口):第三,多用组合/聚合,少用继承(客户通过组合方式使用策略) 例如:针对环境节能,提出了三种节能方式:基带板节能,SPC节能,产品节

  • Java设计模式之策略模式

    在一个收银系统中,如果普通用户.中级会员.高级会员分别对应着不同的优惠策略,常规编程就要使用一系列的判断语句,判断用户类型,这种情况下就可以使用策略模式. 一.概念理解 策略模式的概念很好理解,它将对象和行为分开,将行为定义为 一个行为接口和具体行为的实现,每个if判断都可以理解为一个策略. 如果在收银系统中使用策略模式,要将普通.中级.高级会员分别定义一个具体策略类,并实现各自的方法,定义一个环境类,持有策略类的引用,由引用调用相应的策略类方法,客户端传入相应的具体策略对象就会调用各自的策略方

  • Java设计模式之策略模式详解

    本文实例为大家分享了Java策略模式,供大家参考,具体内容如下 1.策略模式(Strategy Pattern)是一种比较简单的模式,也叫做政策模式(PolicyPattern). 定义如下: Define a family of algorithms,encapsulate each one,and make them interchangeable.    (定义一组算法,将每个算法都封装起来,并且使它们之间可以互换.) 策略模式的通用类图如下所示: 策略模式的三个角色: ● Context

随机推荐