文档章节

策略模式(Strategy)

gavin_jin
 gavin_jin
发布于 2019/02/23 00:49
字数 2971
阅读 2
收藏 0

3 月,跳不动了?>>>

 

设计模式,无论是coder们业余聊天,还是面试时面试官喜欢出的问题中,都会看到它的影子。设计模式,是基于面向对象之上的,应用好设计模式,我们在平时开发,还是架构设计,在系统的架构性,可拓展,可维护性方面的考虑都会有质的提升。当我们会一些基础语法,逻辑控制之后,就需要考虑我现在写的代码,在以后的拓展,维护会有那些瓶颈,如何改善,这些问题考虑清楚后在进行编码,开发就会事半功倍。范围说小一点,基于Java , 无论是JDK源码,还是我们每天都在接触的各种框架,都使用了各种设计模式。

设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

策略模式的定义和使用场景
定义:策略模式定义了一系列的算法,并将每一个算法封装起来,而且使他们可以相互替换,让算法独立于使用它的客户而独立变化。

分析下定义,策略模式定义和封装了一系列的算法,它们是可以相互替换的,也就是说它们具有共性,而它们的共性就体现在策略接口的行为上,另外为了达到最后一句话的目的,也就是说让算法独立于使用它的客户而独立变化,我们需要让客户端依赖于策略接口。

使用场景:

1.针对同一类型问题的多种处理方式,仅仅是具体行为有差别时; 
2.需要安全地封装多种同一类型的操作时; 
3.出现同一抽象类有多个子类,而又需要使用 if-else 或者 switch-case 来选择具体子类时。

UML类图

在策略模式中,一个行为可以在系统运行时动态修改。这种类型设计模式是行为型设计模式,策略模式中,会有代表各种策略的对象和执行策略的context上下文对象。策略对象改变context执行的算法。

举例:

  1. 出门旅行,拥有很多出行策略,比如飞机,汽车,火车等;
  2. JDK AWT中的LayoutManager;
  3. 支付系统中,有很多支付策略,比如支付宝,微信,银联。在支付时需要选择其中一种支付策略进行支付业务。

简要介绍

  1. 用途:定义一系列策略,他们实现自己的算法,使用策略模式实现在运行时动态替换各个策略。
  2. 解决难点:在有很多类似算法的实现中,使用 if … else 会造成难以维护和拓展。
  3. 使用场景:在一个系统中有很多类,它们之间唯一的区别只在与行为的不同,而且需要系统需要动态选择这些行为中的一种,如果不使用适当的设计模式,就会产生多重条件选择语句。

优、缺点

  1.  优点:
        1、可以动态的改变对象的行为
     缺点:
        1、客户端必须知道所有的策略类,并自行决定使用哪一个策略类
        2、策略模式将造成产生很多策略类

 

三个角色:

环境(Context)角色:持有一个Strategy的引用。

抽象策略(Strategy)角色:这是一个抽象角色,通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

具体策略(ConcreteStrategy)角色:包装了相关的算法或行为。

策略模式的典型代码如下:
 

抽象策略类

public interface Strategy {
    /**
     * 策略方法
     */
    public void strategyInterface();
}

 具体策略类

public class ConcreteStrategyA implements Strategy {

    @Override
    public void strategyInterface() {
        //相关的业务
    }

}
public class ConcreteStrategyB implements Strategy {

    @Override
    public void strategyInterface() {
        //相关的业务
    }

}

环境角色类

public class Context {
    //持有一个具体策略的对象
    private Strategy strategy;
    /**
     * 构造函数,传入一个具体策略对象
     * @param strategy    具体策略对象
     */
    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    /**
     * 策略方法
     */
    public void contextInterface(){

        strategy.strategyInterface();
    }

}

策略模式例子


假设鹅厂推出了3种会员,分别为会员,超级会员以及金牌会员,还有就是普通玩家,针对不同类别的玩家,购买《王者农药》皮肤有不同的打折方式,并且一个顾客每消费10000就增加一个级别,那么我们就可以使用策略模式,因为策略模式描述的就是算法的不同,这里我们举例就采用最简单的,以上四种玩家分别采用原价(普通玩家),九折,八折和七价的收钱方式。

那么我们首先要有一个计算价格的策略接口

public interface CalPrice {
    //根据原价返回一个最终的价格
    Double calPrice(Double orgnicPrice);
}

下面是4种玩家的计算方式的实现

public class Orgnic implements CalPrice {

    @Override
    public Double calPrice(Double orgnicPrice) {
        return orgnicPrice;
    }
}
public class Vip implements CalPrice {
    @Override
    public Double calPrice(Double orgnicPrice) {
        return orgnicPrice * 0.9;
    }
}
public class SuperVip implements CalPrice {
    @Override
    public Double calPrice(Double orgnicPrice) {
        return orgnicPrice * 0.8;
    }
}
public class GoldVip implements CalPrice {
    @Override
    public Double calPrice(Double orgnicPrice) {
        return orgnicPrice * 0.7;
    }
}

我们看客户类,我们需要客户类帮我们完成玩家升级的功能。

public class Player {
    private Double totalAmount = 0D;//客户在鹅厂消费的总额
    private Double amount = 0D;//客户单次消费金额
    private CalPrice calPrice = new Orgnic();//每个客户都有一个计算价格的策略,初始都是普通计算,即原价

    //客户购买皮肤,就会增加它的总额
    public void buy(Double amount) {
        this.amount = amount;
        totalAmount += amount;
        if (totalAmount > 30000) {//30000则改为金牌会员计算方式
            calPrice = new GoldVip();
        } else if (totalAmount > 20000) {//类似
            calPrice = new SuperVip();
        } else if (totalAmount > 10000) {//类似
            calPrice = new Vip();
        }
    }

    //计算客户最终要付的钱
    public Double calLastAmount() {
        return calPrice.calPrice(amount);
    }
}

接下来是客户端调用,系统会帮我们自动调整收费策略。

public class Client {
    public static void main(String[] args) {
        Player player = new Player();
        player.buy(5000D);
        System.out.println("玩家需要付钱:" + player.calLastAmount());
        player.buy(12000D);
        System.out.println("玩家需要付钱:" + player.calLastAmount());
        player.buy(12000D);
        System.out.println("玩家需要付钱:" + player.calLastAmount());
        player.buy(12000D);
        System.out.println("玩家需要付钱:" + player.calLastAmount());
    }
}

运行以后会发现,第一次是原价,第二次是九折,第三次是八折,最后一次则是七价。这样设计的好处是,客户不再依赖于具体的收费策略,依赖于抽象永远是正确的。

在上面的基础上,我们可以使用简单工厂来稍微进行优化

public class CalPriceFactory {
    private CalPriceFactory(){}
    //根据客户的总金额产生相应的策略
    public static CalPrice createCalPrice(Player customer){
        if (customer.getTotalAmount() > 30000) {//3000则改为金牌会员计算方式
            return new GoldVip();
        }else if (customer.getTotalAmount() > 20000) {//类似
            return new SuperVip();
        }else if (customer.getTotalAmount() > 10000) {//类似
            return new Vip();
        }else {
            return new Orgnic();
        }
    }
}

这样就将制定策略的功能从客户类分离了出来,我们的客户类可以变成这样。

public class Player {
    private Double totalAmount = 0D;//客户在鹅厂消费的总额
    private Double amount = 0D;//客户单次消费金额
    private CalPrice calPrice = new Orgnic();//每个客户都有一个计算价格的策略,初始都是普通计算,即原价

    //客户购买皮肤,就会增加它的总额
    public void buy(Double amount) {
        this.amount = amount;
        totalAmount += amount;
        /* 变化点,我们将策略的制定转移给了策略工厂,将这部分责任分离出去 */
        calPrice = CalPriceFactory.createCalPrice(this);
    }

    //计算客户最终要付的钱
    public Double calLastAmount() {
        return calPrice.calPrice(amount);
    }

    public Double getTotalAmount() {
        return totalAmount;
    }
}

虽然结合简单工厂模式,我们的策略模式灵活了一些,但不免发现在工厂中多了if-else判断,也就是如果增加一个会员类别,我又得增加一个else-if语句,这是简单工厂的缺点,对修改开放。这就是说简单工厂模式不符合开闭原则。

那有什么方法,可以较好的解决这个问题呢?那就是使用注解, 所以我们需要给注解加入属性上限和下限,用来表示策略生效的区间,用来解决总金额判断的问题。

1.首先我们做一个注解,这个注解是用来给策略添加的,当中可以设置它的上下限
 

package com.gavin.patttern.strategy;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
//import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//这是有效价格区间注解,可以给策略添加有效区间的设置
@Target(ElementType.TYPE)//表示只能给类添加该注解
@Retention(RetentionPolicy.RUNTIME)//这个必须要将注解保留在运行时
public @interface PriceRegion {
    int max() default Integer.MAX_VALUE;
    int min() default Integer.MIN_VALUE;
}

可以看到,我们只是使用这个注解来声明每一个策略的生效区间,于是对策略进行修改

@PriceRegion(max = 10000)
public class Orgnic implements CalPrice {

    @Override
    public Double calPrice(Double orgnicPrice) {
        return orgnicPrice;
    }
}
@PriceRegion(max=20000)
public class Vip implements CalPrice {
    @Override
    public Double calPrice(Double orgnicPrice) {
        return orgnicPrice * 0.9;
    }
}
@PriceRegion(min=20000,max=30000)
public class SuperVip implements CalPrice {
    @Override
    public Double calPrice(Double orgnicPrice) {
        return orgnicPrice * 0.8;
    }
}
@PriceRegion(min=3000)
public class GoldVip implements CalPrice {
    @Override
    public Double calPrice(Double orgnicPrice) {
        return orgnicPrice * 0.7;
    }
}

接下来就是在策略工厂中去处理注解

package com.gavin.patttern.strategy;

import java.io.File;
import java.io.FileFilter;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;
/**
 * 这里是关键
 * @author gavin
 *
 */
public class CalPriceFactory {
	// 
	private static final String CAL_PRICE_PACKAGE = "com.gavin.patttern.strategy";//这里是一个常量,表示我们扫描策略的包
	private ClassLoader classLoader = getClass().getClassLoader();

    private List<Class<? extends CalPrice>> calPriceList;//策略列表

    //根据玩家的总金额产生相应的策略
    public CalPrice createCalPrice(Player player) {
        //在策略列表查找策略
        for (Class<? extends CalPrice> clazz : calPriceList) {
            PriceRegion validRegion = handleAnnotation(clazz);//获取该策略的注解
            //判断金额是否在注解的区间
            if (player.getTotalAmount() > validRegion.min() && player.getTotalAmount() < validRegion.max()) {
                try {
                    //是的话我们返回一个当前策略的实例
                    return clazz.newInstance();
                } catch (Exception e) {
                    throw new RuntimeException("策略获得失败");
                }
            }
        }
        throw new RuntimeException("策略获得失败");
    }

    //处理注解,我们传入一个策略类,返回它的注解
    private PriceRegion handleAnnotation(Class<? extends CalPrice> clazz) {
        Annotation[] annotations = clazz.getDeclaredAnnotations();
        if (annotations == null || annotations.length == 0) {
            return null;
        }
        for (int i = 0; i < annotations.length; i++) {
            if (annotations[i] instanceof PriceRegion) {
                return (PriceRegion) annotations[i];
            }
        }
        return null;
    }
    

    //单例
    private CalPriceFactory() {
        init();
    }

    //在工厂初始化时要初始化策略列表
    private void init() {
        calPriceList = new ArrayList<Class<? extends CalPrice>>();
        File[] resources = getResources();//获取到包下所有的class文件
        Class<CalPrice> calPriceClazz = null;
        try {
            calPriceClazz = (Class<CalPrice>) classLoader.loadClass(CalPrice.class.getName());//使用相同的加载器加载策略接口
        } catch (ClassNotFoundException e1) {
            throw new RuntimeException("未找到策略接口");
        }
        for (int i = 0; i < resources.length; i++) {
            try {
                //载入包下的类
                Class<?> clazz = classLoader.loadClass(CAL_PRICE_PACKAGE + "." + resources[i].getName().replace(".class", ""));
                // gavin 这里是关键
                //判断是否是CalPrice的实现类并且不是CalPrice它本身,满足的话加入到策略列表
                if (CalPrice.class.isAssignableFrom(clazz) && clazz != calPriceClazz) {
                    calPriceList.add((Class<? extends CalPrice>) clazz);
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    //获取扫描的包下面所有的class文件
    private File[] getResources() {
        try {
            File file = new File(classLoader.getResource(CAL_PRICE_PACKAGE.replace(".", "/")).toURI());
            return file.listFiles(new FileFilter() {
                public boolean accept(File pathname) {
                    if (pathname.getName().endsWith(".class")) {//我们只扫描class文件
                        return true;
                    }
                    return false;
                }
            });
        } catch (Exception e) {
            throw new RuntimeException("未找到策略资源");
        }
    }

    public static CalPriceFactory getInstance() {
        return CalPriceFactoryInstance.instance;
    }

    private static class CalPriceFactoryInstance {

        private static CalPriceFactory instance = new CalPriceFactory();
    }
}

虽然工厂里的逻辑增加了,但是解耦的效果达到了,现在我们随便加入一个策略,并设置好它的生效区间,策略工厂就可以帮我们自动找到适应的策略。

Android源码中的策略模式

Android的源码中,策略模式最典型的就是属性动画中的应用. 

 

 

参考

https://blog.csdn.net/u012124438/article/details/70039943/ 等

 

© 著作权归作者所有

上一篇: 泛型编程
下一篇: RecycleBin机制
gavin_jin
粉丝 28
博文 127
码字总数 143102
作品 0
海淀
技术主管
私信 提问
加载中

评论(0)

策略模式-javascript

一个基于策略模式的程序至少由两部分组成。 第一个部分是一组策略类,策略类封装了具体的算法,并负责具体的计算过程。第二个部分是环境类Context,Context接受客户的请求,随后把请求委托给...

wee911
2019/09/29
0
0
Javascript策略模式理解以及应用

最近一直在看Javascript设计模式,想通过写文章来增加自己对策略模式的理解,同时记录自己学习的经历。希望大家看完之后觉得有收获可以帮忙点个赞表示支持。 策略模式的定义 策略模式的定义是...

arzh
2018/12/18
0
0
设计模式-Strategy Pattern

一、 策略(Strategy)模式 策略模式的用意是针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化...

Start-up
2012/05/17
67
0
23种设计模式(12):策略模式

定义:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换。 类型:行为类模式 类图: 策略模式是对算法的封装,把一系列的算法分别封装到对应的类中,并且这些类实现相同的接口,...

LCZ777
2014/07/09
62
0
JavaScript 的一些设计模式

设计模式的定义:在面向对象软件设计过程中针对特定问题的简洁而优雅的解决方案 设计模式是前人解决某个特定场景下对而总结出来的一些解决方案。可能刚开始接触编程还没有什么经验的时候,会...

格西南
2019/08/20
0
0

没有更多内容

加载失败,请刷新页面

加载更多

每年营收翻倍的 AfterShip 是如何体系化做新员工培训(下)

AfterShip 自 2012 年成立以来,每年业务都可实现 100% 的复合增长。对于这家公司来说,组建团队是一件更重要的事情,并且尤为重视工程师团队文化的建设,他们推崇团队文化多元化及相互包容性...

爱客科技
31分钟前
26
0
如何在企业内部实现云信私有化

在信息安全愈发重要的今天,企业越来越重视和业务有关的数据,视其为企业的生命线,云信针对这一特点专门构建了一整套私有化方案,并且在多家行业龙头企业内部稳定运行,成为企业内部发展的助...

真正稳定的网易云信
32分钟前
13
0
动态代理的实际应用

原文链接 前言 最近在用 Python 的 SQLAlchemy 库时(一个类似于 Hibernate 的 ORM 框架),发现它的 Events 事件还挺好用。 简单说就是当某张表的数据发生变化(曾、删、改)时会有一个事件...

crossoverJie
36分钟前
10
0
视频直播技术之如何搭建流媒体服务器?

实时视频直播是这两年非常火的技术形态,已经渗透到教育、在线互娱等各种业务场景中。但要搭建一套实时视频直播系统,并非易事,下面针对直播系统的的搭建做一下说明: 1.1 通常的直播系统的...

图玩智能科技
37分钟前
30
0
SpringTask任务调度详解+SpringBoot整合

1 定时任务的框架 Quartz:整合了Spring SpringTask:轻量 SpringBoot整合SpringTask:两行代码即可搞定 1.1.说说定时任务的应用场景 1. 月底扣话费2. 会员到期3. 生日祝福4. qq好友生日祝...

漫路h
37分钟前
17
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部