策略设计模式

已于 2022-01-27 21:00:13 修改
阅读量534 收藏 1
点赞数
分类专栏： Design Patterns 文章标签： 策略模式 设计模式
于 2022-01-27 20:57:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45337431/article/details/122723553
版权

策略模式

一、概述

策略模式，英文全称是 Strategy Design Pattern。在 GoF 的《设计模式》一书中，它是这样定义的：定义一族算法类，将每个算法分别封装起来，让它们可以互相替换。

工厂模式是解耦对象的创建和使用，观察者模式是解耦观察者和被观察者。策略模式是将定义、创建、使用这三部分进行解耦。

二、定义、创建、使用

2.1 定义

/**
 * 策略接口
 */
public interface Strategy {
    void executeStrategy();
}

/**
 * 策略枚举
 */
@Getter
public enum StrategyEnum {
    A("A", "A策略模式"),
    B("B", "B策略模式");
    private String type;
    private String desc;
    StrategyEnum(String type, String desc) {
        this.type = type;
        this.desc = desc;
    }
}

/**
 * A策略模式
 */
@Slf4j
public class StrategyA implements Strategy {
    @Override
    public void executeStrategy() {
        log.info("执行策略A！");
    }
}

/**
 * B策略模式
 */
@Slf4j
public class StrategyB implements Strategy {
    @Override
    public void executeStrategy() {
        log.info("执行策略B！");
    }
}

2.2 创建

/**
 * 策略工厂
 */
public class StrategyFactory {

    /**
     * 管理所有策略的Map
     */
    private static final Map<StrategyEnum, Strategy> STRATEGY_MAP = new HashMap<>(2);

    /**
     * 静态代码块，启动的时候将所有策略的实现加载进去
     */
    static {
        STRATEGY_MAP.put(StrategyEnum.A, new StrategyA());
        STRATEGY_MAP.put(StrategyEnum.B, new StrategyB());
    }

    /**
     * 对外只提供获取策略的方法
     */
    public Strategy getStrategy(StrategyEnum strategyEnum) {
        if (null == strategyEnum) {
            throw new IllegalArgumentException("This strategyEnum is not exist!");
        }
        return STRATEGY_MAP.get(strategyEnum);
    }
}

2.3 使用

/**
 * 策略使用
 */
@RunWith(JUnit4.class)
public class StrategyTest {

    /**
     * 测试策略的使用
     */
    @Test
    public void testGetStrategy() {
        StrategyFactory.getStrategy(StrategyEnum.A);
        strategy.executeStrategy();
    }
}

这种属于【有状态】的策略模式，当然还有无状态的策略模式。

三、Spring策略模式的应用

使用spring的时候，我们可以使用@PostConstruct注解，在spring加载完毕对象后，进行后置处理的时候，将实现类放入map中。定义部分相同，其他有所改动。

3.1 创建

/**
 * spring的策略管理
 */
@Component
public class StrategySpringFactory {

    /**
     * 管理所有策略的Map
     */
    private Map<StrategyEnum, Strategy> strategyMap = new HashMap<>(2);

    /**
     * 将策略注入
     */
    @Resource
    private Strategy strategyA;
    @Resource
    private Strategy strategyB;

    /**
     * 初始化：后置处理器
     */
    @PostConstruct
    public void init() {
        strategyMap.put(StrategyEnum.A, strategyA);
        strategyMap.put(StrategyEnum.B, strategyB);
    }

    /**
     * 对外只提供获取策略的方法
     */
    public Strategy getStrategy(StrategyEnum strategyEnum) {
        if (null == strategyEnum) {
            throw new IllegalArgumentException("This strategyEnum is not exist!");
        }
        return strategyMap.get(strategyEnum);
    }
}

3.2 使用

/**
 * 策略使用
 */
@SpringBootTest(classes = AppStart.class)
@RunWith(SpringRunner.class)
public class StrategyTest {

    /**
     * 注入工厂
     */
    @Resource
    private StrategySpringFactory strategySpringFactory;

    /**
     * 策略模式使用
     */
    @Test
    public void testGetStrategySpring() {
        Strategy strategy = strategySpringFactory.getStrategy(StrategyEnum.B);
        strategy.executeStrategy();
    }
}

四、策略模式+反射的实际案例

场景描述 ：有一个活动（这里设置为招收活动），会有很多的规则，任何人都可以报名，但是必须满足条件，为了方便未来增加新的活动，代码好维护，我们需要使用枚举作为策略，同时使用反射统一化代码。

案例代码如下(省略set.get)：

/*
* Person类，父类，任何人，具备基础属性
*/
public class Person {
    /*姓名*/
    private String name;

    /*年龄*/
    private Integer age;

    /*失信率*/
    private Double breakRate;
}

/*
* teacher类,后面可以根据需求继续增加属性或者职业
*/
public class Teacher extends Person {
    /*职级*/
    private Integer level;
}

/*
* student类,后面可以根据需求继续增加属性或者职业
*/
public class Student extends Person {
    /*分数*/
    private Double score;
}

/*
* 活动类，具备规则属性，即招收要求，根据枚举去找对应的比较方式
*/
public class EmployRule {
    /*规则名称*/
    private String ruleName;

    /*规则标识*/
    private String ruleProperty;

    /*规则值*/
    private String ruleValue;
}

/*
* 规则枚举，其中还有枚举，分别是比较类型，以及值类型
*/
public enum  EmployRuleEnum {
    MIN_AGE("最小年龄", "age", RuleTypeEnum.GREATER_EQUAL, DataTypeEnum.INT),
    MIN_LEVEL("最小职级", "level", RuleTypeEnum.GREATER_EQUAL, DataTypeEnum.INT),
    MIN_SCORE("最低分数", "score", RuleTypeEnum.GREATER_EQUAL, DataTypeEnum.DOUBLE),
    MAX_BREAK_RATE("最高失信率", "breakRate", RuleTypeEnum.LESS_EQUAL, DataTypeEnum.DOUBLE);

    /*规则名称*/
    private String ruleName;

    /*规则标识*/
    private String ruleProperty;

    /*规则类型（大于，小于，等于）*/
    private RuleTypeEnum ruleType;

    /*值类型(整数、浮点)*/
    private DataTypeEnum dataType;

    /**
     * 根据property获取枚举类
     * @param property
     * @return
     */
    public static EmployRuleEnum getByProperty(String property){
        if(StringUtils.isEmpty(property)){
            return null;
        }
        for(EmployRuleEnum ruleEnum : EmployRuleEnum.values()){
            if(property.equals(ruleEnum.getRuleProperty())){
                return ruleEnum;
            }
        }
        return null;
    }

    EmployRuleEnum(String ruleName, String ruleProperty, RuleTypeEnum ruleType, DataTypeEnum dataType) {
        this.ruleName = ruleName;
        this.ruleProperty = ruleProperty;
        this.ruleType = ruleType;
        this.dataType = dataType;
    }
}

/*
* 比较类型
*/
public enum RuleTypeEnum {
	/*大于等于*/
    GREATER_EQUAL(1, "大于等于"),
    /*小于等于*/
    LESS_EQUAL(2, "小于等于")
    ;
    /*类型*/
    private int type;
    /*描述*/
    private String desc;

    /**
     * 根据type获取枚举
     * @param type
     * @return
     */
    public static RuleTypeEnum getByType(Integer type){
        if(type == null){
            return null;
        }
        for(RuleTypeEnum typeEnum : RuleTypeEnum.values()){
            if(typeEnum.type == type){
                return typeEnum;
            }
        }
        return null;
    }

    RuleTypeEnum(int type, String desc) {
        this.type = type;
        this.desc = desc;
    }
}

/*
* 值类型
*/
public enum DataTypeEnum {
    INT(1, "整数") {
        @Override
        public int compare(String value, Object o) throws Exception {
            if (!(o instanceof Integer)) {
                throw new Exception();
            }
            Integer obj = (Integer) o;
            return Integer.valueOf(value).compareTo(obj); //规则中获取的值-用户传来的数据值
        }
    },
    LONG(2, "长整型") {
        @Override
        public int compare(String value, Object o) throws Exception {
            if (!(o instanceof Long)) {
                throw new Exception();
            }
            Long obj = (Long) o;
            return Long.valueOf(value).compareTo(obj);
        }
    },
    FLOAT(3, "浮点型") {
        @Override
        public int compare(String value, Object o) throws Exception {
            if (!(o instanceof Float)) {
                throw new Exception();
            }
            Float obj = (Float) o;
            return Float.valueOf(value).compareTo(obj);
        }
    },
    DOUBLE(4, "长浮点型") {
        @Override
        public int compare(String value, Object o) throws Exception {
            if (!(o instanceof Double)) {
                throw new Exception();
            }
            Double obj = (Double) o;
            return Double.valueOf(value).compareTo(obj);
        }
    };

    /**
     * 类型标识
     */
    private Integer type;

    /**
     * 描述
     */
    private String desc;

    /**
     * 根据type查询枚举类
     * @param type
     * @return
     */
    public static DataTypeEnum getByDataType(Integer type){
        if(type == null){
            return null;
        }
        for(DataTypeEnum dataTypeEnum : DataTypeEnum.values()){
            if(dataTypeEnum.getType().equals(type)){
                return dataTypeEnum;
            }
        }
        return null;
    }

    /**
     * 比较方法，用于枚举方法重写
     * @param value
     * @param o
     * @return
     * @throws Exception
     */
    public abstract int compare(String value, Object o)throws Exception;
    DataTypeEnum(Integer type, String desc) {
        this.type = type;
        this.desc = desc;
    }
}

/**
* service方法实现
*/
public class VerifyServiceImpl implements VerifyService {

    /*json*/
    private static final ObjectMapper objectMaper = new ObjectMapper();

    /*日志*/
    private static Logger logger = Logger.getLogger(VerifyServiceImpl.class.getName());

    @Override
    public void doVerify(Person person, EmployRule rule) throws Exception {
        logger.info(String.format("VerifyServiceImpl.doVerify 入参：person = %s, rule = %s", objectMaper.writeValueAsString(person), objectMaper.writeValueAsString(rule)));
        //校验参数
        String ruleName = rule.getRuleName();//规则名称
        String ruleProperty = rule.getRuleProperty();//规则标识
        String ruleValue = rule.getRuleValue();//规则值
        if (null == person || StringUtils.isEmpty(ruleProperty)
                || StringUtils.isEmpty(ruleValue) || StringUtils.isEmpty(ruleName)) {
            throw new Exception("入参有空值");
        }

        //获取值类型的枚举类
        EmployRuleEnum property = EmployRuleEnum.getByProperty(ruleProperty);
        if (null == property) {
            throw new Exception("数据类型不存在");
        }
        DataTypeEnum dataType = property.getDataType();

        //获取规则类型:大于，小于，等于
        RuleTypeEnum ruleTypeEnum = property.getRuleType();
        if (null != ruleTypeEnum) {
            switch (ruleTypeEnum) {

                //小于等于
                case LESS_EQUAL:
                    if (this.compare(person, ruleProperty, dataType, ruleValue) <= 0) {
                        throw new Exception(String.format("%s 不符合要求", ruleName));
                    }
                    return;

                //大于等于
                case GREATER_EQUAL:
                    if (this.compare(person, ruleProperty, dataType, ruleValue) >= 0) {
                        throw new Exception(String.format("%s 不符合要求", ruleName));
                    }
                    return;

                default:
                    throw new Exception("未知规则类型");
            }
        }
    }

    /**
     * 比较的共用方法，反射实现
     * @param person 传入的的获取，可以获取对应属性的值
     * @param ruleProperty 规则属性标识
     * @param valueType 值类型（int, long, float, double）的枚举
     * @param ruleValue 规则的值
     * @return 比较结果
     * @throws Exception
     */
    private int compare(Person person, String ruleProperty, DataTypeEnum valueType, String ruleValue) throws Exception {

        /*反射处理*/
        Class<? extends Person> clazz = person.getClass();

        try {
            //根据名称获取某个变量的值(私有)
            Field field = null;

            /*Person是父类，传入的可能是其子类，这里分开处理*/
            //子类中获取(私有)
            try {
                field = clazz.getDeclaredField(ruleProperty);
            } catch (Exception e) {
            }

            //父类中获取(私有)
            if (null == field) {
                try {
                    field = clazz.getSuperclass().getDeclaredField(ruleProperty);
                } catch (Exception e) {
                }
            }

            //设置私有变量访问权限
            if (null == field) {
                throw new Exception("获取到的规则值为空");
            }
            field.setAccessible(true);

            //返回指定对象上该field字段对应的值
            Object o = field.get(person);
            if (null == o) {
                throw new Exception("获取不到对象中实际的值");
            }

            //调用数据类型枚举的比较方法进行比较(规则值-对象值)
            return valueType.compare(ruleValue, o);
        } catch (Exception e) {
            logger.info(String.format("compare 比较方法反射获取不到属性, ruleProperty = %s, exceptionMessage = %s",ruleProperty , e.toString()));
            throw new Exception("反射方法异常，获取不到值！");
        }
    }
}

也可以使用java8的函数式接口Comparator接口

public enum DataTypeEnum {

    INT(1, "整型"){
        @Override
        public int compare(String ruleValue, Object o) {
            Integer value = (Integer)o;
            Comparator<Integer> comparator = Integer::compareTo;
            return comparator.compare(Integer.valueOf(ruleValue), value);
        }
    },
    DOUBLE(2, "浮点") {
        @Override
        public int compare(String ruleValue, Object o) {
            Double value = (Double)o;
            Comparator<Double> comparator = Double::compareTo;
            return comparator.compare(Double.valueOf(ruleValue), value);
        }
    }
    ;
    public abstract int compare(String ruleValue, Object o);
    
    private Integer type;
    private String desc;

    DataTypeEnum(Integer type, String desc) {
        this.type = type;
        this.desc = desc;
    }

    public Integer getType() {
        return type;
    }

    public String getDesc() {
        return desc;
    }

    public static DataTypeEnum getDataTypeEnumByType(Integer type){
        if (null == type) {
            return null;
        }
        for (DataTypeEnum bean : DataTypeEnum.values()) {
            if (type.equals(bean.getType())) {
                return bean;
            }
        }
        return null;
    }
}

@Test
public void testIDoNotKnowWhatYouWantToTest() {
    Integer dataType = 2;
    DataTypeEnum dataTypeEnum = DataTypeEnum.getDataTypeEnumByType(dataType);
    int compare;
    switch (dataTypeEnum) {
        case INT:
            compare = dataTypeEnum.compare("20", 50);
            System.out.println(compare);
            break;
        case DOUBLE:
            compare = dataTypeEnum.compare("7.5",7.5);
            System.out.println(compare);
        default:
            break;
    }
}
松鼠MaSaKi
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常用设计模式--策略模式
xiongxianze的博客
10-26 1268
从上图可以看到，我们将操作封装到类中，他们实现了同一个接口，然后在 Context 中调用。 这里我们举一个计算器的例子： 此例中，为加法和减法分别创建了一个类。 其实策略不一定要命名为 Strategy，Context 不一定要叫 Context，可以根据实际情况自己命名，在计算器的例子中，你如果非要命名为 Strategy 和 Context，反而让人产生疑惑。 实际代码也很简...
设计模式之策略模式（STRATEGY）
zhaominyong的专栏
06-12 1136
1 策略模式简介 名称 Strategy 结构 图2如下： 参与者 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。 环境（Context）类：持有一个策略类的引用，最终给客户端调用。 意图 定义一系列
java设计模式之策略模式
J_Newbie的博客
08-26 240
java设计模式 策略模式
设计模式之策略模式
wang0907的博客
01-27 7747
java程序的设计原则 6大原则： 单一职责：一个类和方法只做一件事。 开闭：对修改关闭，对扩展开发。 里氏替换：子类可扩展新方法，但不可修改父类已有方法（父类已提供了具体实现的方法）。 依赖倒置：依赖于抽象，而非具体实现，即面向接口编程（如方法参数，类属性使用接口声明，这样可接收任何子类）。 接口隔离：使用多个隔离的接口定义抽象，降低耦合。 最少知道/迪米特：降低类之间的依赖，聚合，组合等。 1：策略设计模式 策略设计模式一般使用的场景是，多种可互相替代的同类行为，在具体运行过程中根据不同情况，选择其中
设计模式详解之策略模式
阿里技术
06-01 4809
策略模式是一种应用广泛的行为型模式，核心思想是对算法进行封装，委派给不同对象来管理，本文将着眼于策略模式进行分享。
策略设计模式简单代码实现
11-28
设计模式之一：策略模式。代码来源于Head First设计模式。
详解设计模式：策略模式
栗筝i的博客
12-02 1833
策略模式（Strategy Pattern）也被称为政策模式（Policy Pattern），是在 GoF 23 种设计模式中定义了的行为型模式。 策略模式 是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，使得它们可以互换，被封装起来的算法具有独立性外部不可改变其特性。 本片文章内容包括：关于策略模式、策略模式 Demo（伪代码）、策略模式的应用（Comparator 中的策略模式）
策略模式（策略设计模式）详解
傅红雪的专栏
03-18 3667
在现实生活中常常遇到实现某种目标存在多种策略可供选择的情况，例如，出行旅游可以乘坐飞机、乘坐火车、骑自行车或自己开私家车等，超市促销可以釆用打折、送商品、送积分等方法。 在软件开发中也常常遇到类似的情况，当实现某一个功能存在多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能，如数据排序策略有冒泡排序、选择排序、插入排序、二叉树排序等。 如果使用多重条件转移语句实...
java中的策略模式-接口
weixin_46672808的博客
01-11 272
package Test; /* 策略模式：定义一系列算法，将每一个算法封装起来，相互替换使用 */ public class JieKou { public static void main(String[] args) { BaseService user=new UserService(); user.setiSave(new FileSave()); user.add("user"); } } interface ISave
设计模式之策略模式（面向接口编程）
马一凡的博客
01-06 1430
面向实现编程的弊端 举一个简单的动物界的例子，我们需要写一段代码，包含以下要素：鸭子类，鸭子的若干子类，实现一些方法。 惯用的编程思路： 1、写一个鸭子类Duck，写几个方法，比如鸭子飞行的方法fly()，鸭子叫的方法quack()。 2、写鸭子的子类，比如绿头鸭MallardDuck，继承Duck类。 3、在子类中重写以上两个方法。 这种编程思路的弊端： 1、代码冗杂： 在代码量少且代码稳定不变...
6.Java设计模式-----策略模式（Strategy Pattern）
扛麻袋的少年的博客
06-12 1556
什么是策略模式 策略模式作为一种软件设计模式，指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法。比如每个人都要“交个人所得税”，但是“在美国交个人所得税”和“在中国交个人所得税”就有不同的算税方法。 ----来自：百度百科 策略模式，有两个不变：起点和终点不变，中途具体实现方式可以随机，只要从起点到了终点即可。 即：过程不同，结果相同...
策略模式详解
CHZKAL的博客
06-22 799
出于对设计模式的学习复习，才决定写的这一系列文章，一方面是帮助自己更快的复习记忆，另一方面是帮助有需要的人快速入门，分享自己的学习内容吧。 图片来源网络 概念和目的 设计模式是众多经验丰富的工程师经过大量的实验花费了很多很多时间才总结出来的，可以说是众多经验的结晶了。在所有的中、大型项目中，设计模式随处可见。使用设计模式，是为了提高代码的可重用性、可读性以及可靠性。适当的使用设...
设计模式初探-策略模式
Java Dynamic的专栏
02-15 1544
策略模式(STRATEGY)，别名政策(Policy)，通过将一系列的算法封装成一个个的策略对象，使算法可以相互替换，并能独立于使用它们的客户而变化，属于对象行为型模式。软件开发过程中，通常要设计相应的算法，比如电子网站中经常有折扣活动，并且用户等级不同，享受的折扣也不一样。通过使用策略模式将折扣算法封装起来，不仅可以用于网商平台，还可以用于手持设备中折扣活动的实现。封装的特性确保了扩展算法和增加
JAVA设计模式之策略模式
DAIHUINKZX的博客
02-01 463
策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。 策略模式的主要优点如下。 多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句，如 if...else 语句、switch...case 语句。 策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，
【设计模式】策略模式+工厂模式动态绑定类名的几种方式
weixin_42246822的博客
06-24 292
策略模式说明 在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。 在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。 这样，在后续调整渠道时只需要新增/删除一个类，而不会影响整体的逻辑。 改造优化 在类中购物渠道分为拼多多、淘系、京东和当当这4个渠道。以前的做法是根据不同的渠道，if/else判断取调用不同的代码。 还有种情况是这几个渠道消费相
六种常见的设计模式----策略模式
weixin_43862793的博客
10-09 338
策略模式
java策略设计模式
最新发布
10-05
在Java中，策略设计模式（Strategy Pattern）是一种行为型设计模式，它允许在运行时更改一个类的行为或算法。该模式通过定义一组可以互相替换的算法，并将每个算法封装在独立的策略类中，使得算法可以独立于客户端而...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值