Spring中实现策略模式的几种方式小结

最新推荐文章于 2024-09-22 11:41:17 发布
最新推荐文章于 2024-09-22 11:41:17 发布
阅读量132 收藏 5
点赞数 5
文章标签： 策略模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ineing/article/details/138375274
版权

一.背景

在写业务代码的时候，难免会遇到很多if-else，这个时候如果if-else不是很多可以用if-else。如果此时场景过多，太多的if-else会导致代码比较臃肿，所以这个时候就需要抽象化，将每个场景独立开来，定义一个顶层接口，不同场景有不同实现，这个时候策略模式就出现了。本文主要阐述工作中常用的实现策略模式的几种方式。

二.实现一

2.1 定义接口

package com.ljm.service;
 
import com.ljm.constant.StrategyEnum;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:09
 * @Version: v1.0.0
 * @Description: TODO
 **/
public interface IHandler {
 
    void handler();
    StrategyEnum getHandleStrategy();
}

2.2 定义枚举

package com.ljm.constant;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:10
 * @Version: v1.0.0
 * @Description: TODO
 **/
public enum StrategyEnum {
    FIRST, SECOND, THIRD, FOUR
}

2.3 定义实现类

import com.ljm.constant.StrategyEnum;
import com.ljm.service.IHandler;
import org.springframework.stereotype.Service;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:12
 * @Version: v1.0.0
 * @Description: TODO
 **/
@Service
public class FirstHandler implements IHandler {
 
    @Override
    public void handler() {
        System.out.println("Execute First Handler");
    }
 
    @Override
    public StrategyEnum getHandleStrategy() {
        return StrategyEnum.FIRST;
    }
}
package com.ljm.service.impl;
 
import com.ljm.constant.StrategyEnum;
import com.ljm.service.IHandler;
import org.springframework.stereotype.Service;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:12
 * @Version: v1.0.0
 * @Description: TODO
 **/
@Service
public class SecondHandler implements IHandler {
    @Override
    public void handler() {
        System.out.println("Execute Second Handler");
    }
 
    @Override
    public StrategyEnum getHandleStrategy() {
        return StrategyEnum.SECOND;
    }
}
package com.ljm.service.impl;
 
import com.ljm.constant.StrategyEnum;
import com.ljm.service.IHandler;
import org.springframework.stereotype.Service;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:12
 * @Version: v1.0.0
 * @Description: TODO
 **/
@Service
public class ThirdHandler implements IHandler {
    @Override
    public void handler() {
        System.out.println("Execute Third Handler");
    }
 
    @Override
    public StrategyEnum getHandleStrategy() {
        return StrategyEnum.THIRD;
    }
}
package com.ljm.service.impl;
 
import com.ljm.constant.StrategyEnum;
import com.ljm.service.IHandler;
import org.springframework.stereotype.Service;
 
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:12
 * @Version: v1.0.0
 * @Description: TODO
 **/
@Service
public class FourHandler implements IHandler {
    @Override
    public void handler() {
        System.out.println("Execute Four Handler");
    }
 
    @Override
    public StrategyEnum getHandleStrategy() {
        return StrategyEnum.FOUR;
    }
}

2.4 定义策略工厂类

package com.ljm.service;
 
import com.ljm.constant.StrategyEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:16
 * @Version: v1.0.0
 * @Description: TODO
 **/
@Service
public class HandlerStrategyFactory {
 
    public final ConcurrentHashMap<StrategyEnum,IHandler> handlerStrategyMap = new ConcurrentHashMap<>();
 
    @Autowired
    public HandlerStrategyFactory(List<IHandler> iHandlers){
        iHandlers.forEach(x -> handlerStrategyMap.put(x.getHandleStrategy(),x));
    }
 
    public IHandler  getHandleStrategy(StrategyEnum strategyEnum){
       return handlerStrategyMap.get(strategyEnum);
    }
}

2.5 测试

package com.ljm;
 
import com.MyApplication;
import com.ljm.constant.StrategyEnum;
import com.ljm.service.HandlerStrategyFactory;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
 * @Author: ljm
 * @Date: 2024/2/26 10:58
 * @Version: v1.0.0
 * @Description: TODO
 **/
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = MyApplication.class)
public class MyTest {
 
    @Autowired
    private HandlerStrategyFactory handlerStrategyFactory;
 
    @Test
    public void testStrategy() {
        handlerStrategyFactory.getHandleStrategy(StrategyEnum.FIRST).handler();
        handlerStrategyFactory.getHandleStrategy(StrategyEnum.SECOND).handler();
        handlerStrategyFactory.getHandleStrategy(StrategyEnum.THIRD).handler();
        handlerStrategyFactory.getHandleStrategy(StrategyEnum.FOUR).handler();
 
       /* 测试结果
        Execute First Handler
        Execute Second Handler
        Execute Third Handler
        Execute Four Handler*/
    }
 
}

实现一主要是为IHandler接口新增一个用于区分使用何种策略的方法，再构建一个策略工厂类，利用构造器注入的方式，将Spring中的实现类与相应的枚举类绑定，在使用的时候只需要传入StrategyEnum相应的值就可以调用想调用的策略.

三.实现二

3.1 定义抽象类

package com.ljm.service;
 
import com.ljm.constant.StrategyEnum;
import org.springframework.beans.factory.InitializingBean;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:09
 * @Version: v1.0.0
 **/
public abstract class AbstractHandler implements InitializingBean {
 
    public  abstract void handler();
    public  abstract StrategyEnum getHandleStrategy();
 
    @Override
    public void afterPropertiesSet() throws Exception {
        HandlerStrategyFactory.registerHandlerStrategy(this);
    }
}

3.2 定义枚举

package com.ljm.constant;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:10
 * @Version: v1.0.0
 * @Description: TODO
 **/
public enum StrategyEnum {
    FIRST, SECOND, THIRD, FOUR
}

3.3 定义实现类

package com.ljm.service.impl;
 
import com.ljm.constant.StrategyEnum;
import com.ljm.service.AbstractHandler;
import org.springframework.stereotype.Service;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:12
 * @Version: v1.0.0
 * @Description: TODO
 **/
@Service
public class FirstHandler extends AbstractHandler {
 
    @Override
    public void handler() {
        System.out.println("Execute First Handler");
    }
 
    @Override
    public StrategyEnum getHandleStrategy() {
        return StrategyEnum.FIRST;
    }
}
package com.ljm.service.impl;
 
import com.ljm.constant.StrategyEnum;
import com.ljm.service.AbstractHandler;
import org.springframework.stereotype.Service;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:12
 * @Version: v1.0.0
 * @Description: TODO
 **/
@Service
public class SecondHandler extends AbstractHandler {
    @Override
    public void handler() {
        System.out.println("Execute Second Handler");
    }
 
    @Override
    public StrategyEnum getHandleStrategy() {
        return StrategyEnum.SECOND;
    }
}
package com.ljm.service.impl;
 
import com.ljm.constant.StrategyEnum;
import com.ljm.service.AbstractHandler;
import org.springframework.stereotype.Service;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:12
 * @Version: v1.0.0
 * @Description: TODO
 **/
@Service
public class ThirdHandler extends AbstractHandler {
    @Override
    public void handler() {
        System.out.println("Execute Third Handler");
    }
 
    @Override
    public StrategyEnum getHandleStrategy() {
        return StrategyEnum.THIRD;
    }
}
package com.ljm.service.impl;
 
import com.ljm.constant.StrategyEnum;
import com.ljm.service.AbstractHandler;
import org.springframework.stereotype.Service;
 
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:12
 * @Version: v1.0.0
 * @Description: TODO
 **/
@Service
public class FourHandler extends AbstractHandler {
    @Override
    public void handler() {
        System.out.println("Execute Four Handler");
    }
 
    @Override
    public StrategyEnum getHandleStrategy() {
        return StrategyEnum.FOUR;
    }
}

3.4 定义策略工厂类

package com.ljm.service;
 
import com.ljm.constant.StrategyEnum;
 
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * @Author: ljm
 * @Date: 2024/4/29 15:16
 * @Version: v1.0.0
 * @Description: TODO
 **/
public class HandlerStrategyFactory {
 
    public static final ConcurrentHashMap<StrategyEnum, AbstractHandler> handlerStrategyMap = new ConcurrentHashMap<>();
 
    public static void registerHandlerStrategy(AbstractHandler handler) {
        handlerStrategyMap.put(handler.getHandleStrategy(), handler);
    }
 
    public static AbstractHandler getHandleStrategy(StrategyEnum strategyEnum) {
        return handlerStrategyMap.get(strategyEnum);
    }
}

3.5 测试

package com.ljm;
 
import com.MyApplication;
import com.ljm.constant.StrategyEnum;
import com.ljm.service.HandlerStrategyFactory;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
 * @Author: ljm
 * @Date: 2024/2/26 10:58
 * @Version: v1.0.0
 * @Description: TODO
 **/
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = MyApplication.class)
public class MyTest {
 
 
    @Test
    public void testStrategy() {
        HandlerStrategyFactory.getHandleStrategy(StrategyEnum.FIRST).handler();
        HandlerStrategyFactory.getHandleStrategy(StrategyEnum.SECOND).handler();
        HandlerStrategyFactory.getHandleStrategy(StrategyEnum.THIRD).handler();
        HandlerStrategyFactory.getHandleStrategy(StrategyEnum.FOUR).handler();
 
       /* 测试结果
        Execute First Handler
        Execute Second Handler
        Execute Third Handler
        Execute Four Handler*/
    }
 
}

实现二主要是为AbstractHandler抽象类实现InitializingBean接口,再对象初始化的时候将其注册到我们自己构建的策略工厂类中，此时的对象由Spring生成并与相应的枚举类绑定，在使用的时候只需要传入StrategyEnum相应的值就可以调用想调用的策略.

ineing
关注
原来使用 Spring 实现策略模式可以这么简单！
武培轩
02-01 7886
策略模式作为一种软件设计模式，指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法，可以替代代码中大量的 if-else。比如我们生活中的场景：买东西结账可以使用微信支付、支付宝...
基于Spring实现策略模式
wadfdhsajd的博客
06-17 918
　　看多很多策略模式，总结下来实现原理大体都差不多，在这里主要是讲解下自己基于Spring更优雅的实现方案；这个方案主要是看了一些开源rpc和Spring相关源码后的一些思路，所以在此进行总结1.3.1 一个接口，两个方法 public interface IFileStrategy { //属于哪种文件解析类型 FileTypeResolveEnum gainFileType(); //封装的公用算法（具体的解析方法） void resolve(Object objectparam);} 1.3.2
Spring中实现策略模式的几种方式
qq_45136592的博客
04-29 1252
在写业务代码的时候，难免会遇到很多if-else，这个时候如果if-else不是很多可以用if-else。如果此时场景过多，太多的if-else会导致代码比较臃肿，所以这个时候就需要抽象化，将每个场景独立开来，定义一个顶层接口，不同场景有不同实现，这个时候策略模式就出现了。本文主要阐述工作中常用的实现策略模式的几种方式。 2.2 定义枚举 2.3 定义实现类 2.4 定义策略工厂类 2.5 测试 实现一主要是为IHandler接口新增一个用于区分使用何种策略的方法，再构建一个策略工厂类，利用构
【springboot策略模式就该这么写】
最新发布
shengfq的技术博客专栏
09-22 259
验证密码的合规性,需要根据可选的密码验证策略,如:最小长度,最大长度,数字个数,大写字母,小写字母…,而且还是需要链式调用验证器来对密码进行合规性验证.这个场景的实现就联想到策略模式和责任链模式的代码设计思路来实现.
Spring下使用策略模式
06-08
NULL 博文链接：https://zl4.iteye.com/blog/2333003
Spring实现策略模式
oldfish_的博客
05-03 1554
什么是策略模式 指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法 在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护 如我最近写的爬虫小说，行为是爬取小说内容，但是针对不同的网站，实现都不一样 本文收获 1.java8的lambda 2.spring的aware接口 3.策略模式 实现方式 方式一： 1.定义接口和实现类，给每个不同的实现类指定key /** * 定义接口 */ public interface TestProxy { public String
利用spring实现策略模式
qq_36800514的博客
03-22 196
利用spring实现策略模式代码 代码 public abstract class BaseHandler<T> { @Transactional(rollbackFor = Exception.class) public abstract void handle(String payload); /** * 对应类型的处理方式 * @return */ public abstract String type(); /**
Spring学习总结——Spring实现IoC的多种方式
m0_68850571的博客
04-19 3260
一、Spring框架概述 1.1、资源 1.2、Spring历史 1.3、框架特征与功能 1.4、Spring组成 1.5、Spring Boot与Spring Cloud 二、IoC基础 三、使用XML配置的方式实现IOC 3.1、使用无参构造方法创建对象 3.2、使用有参构造方法创建对象 3.3、通过属性赋值 3.4、对象引用 3.5、对象作用域 3.6、延迟初始化bean 四、使用Spring注解配置IOC 4.1、修改BookDAO 4.2
Java中定时任务的6种实现方式，你知道几种？
m0_65634190的博客
12-21 1041
几乎在所有的项目中，定时任务的使用都是不可或缺的，如果使用不当甚至会造成资损。还记得多年前在做金融系统时，出款业务是通过定时任务对外打款，当时由于银行接口处理能力有限，外加定时任务使用不当，导致发出大量重复出款请求。还好在后面环节将交易卡在了系统内部，未发生资损。 所以，系统的学习一下定时任务，是非常有必要的。这篇文章就带大家整体梳理学习一下Java领域中常见的几种定时任务实现。 ##线程等待实现 先从最原始最简单的方式来讲解。可以先创建一个thread，然后让它在while循环里一直运行着，通过sleep
Spring中实现策略模式示例
极道Jdon的技术博客
02-24 1523
如果 Spring 的代码或我们的类名在未通知的情况下发生变化，这种对 Spring 内部 Bean 名称的依赖可能会导致问题。此功能允许我们在接口的默认方法中使用 @Autowired，这样我们就可以在向导接口中注册每个 CurseStrategy，而无需在每个策略实现中实现注册方法。Spring 提供了一个神奇的功能，允许我们以 List 的形式注入一个接口的多个实现，这样我们就可以用它来注入策略并在它们之间切换。它简化了代码并提高了效率。我们可以在向导中注入我们的诅咒（策略），并筛选出所需的诅咒。
Spring项目中策略模式实现方案
ZBH的博客
07-09 2085
在基于 Spring 的项目中通过SpringBean很方便地实现策略模式方案的介绍说明设计模式系列中分类为行为型模式的一种，通过把不同处理逻辑封装为策略对象，然后在代码逻辑中通过context 上下文对象来选择合适的策略对象处理事物 策略模式常用来替代代码中的 if-else 分支逻辑，不过并非代码中有多重 if-else 就需要用策略模式进行重构，只有当这些分支逻辑会经常需要扩展新的分支逻辑场景时才适合使用策略模式，策略模式下只需增加新的策略对象而不需要修改原来的if-else分支处理逻辑，即符合开闭原
Spring中的策略模式
JSUITDLWXL的博客
07-04 1275
总结起来，策略模式在Spring中的应用使得我们可以灵活地切换和组合不同的行为，而不需要修改使用这些行为的类。在使用策略的类中，通过调用注入的策略类的方法，来实现具体的算法逻辑。这样，在运行时可以动态地替换策略类，从而实现不同的行为。在Spring的配置文件中，使用依赖注入（DI）的方式将策略类注入到需要使用策略的类中。方法来进行支付操作。当需要替换策略时，可以通过配置文件中的DI来注入不同的策略类。创建多个实现策略接口的类，每个类实现了策略接口中的方法，以提供不同的实现。在使用策略的地方，通过调用。
spring实现策略模式（最终版）
yy550956983的博客
05-11 1128
这个话题网上已经有很多解答，这里要做的仅仅是稍微归纳下。如果想略过推理的部分，请直接看向文章末尾。 当我们针对不同的情况，需要使用不同的逻辑时，就需要使用到策略模式。其本质是一种模式匹配：将模式映射到逻辑。伪代码如下所示： interface Strategy { void doWork() } class A implements Strategy {..} class B implements Strategy {..} // 默认策略 class C implements Strategy {
设计模式--spring源码中使用策略模式（Strategy Pattern）
weixin_33770878的博客
09-23 308
转载http://liuxi1024.iteye.com/blog/583145      策略模式（Strategy Pattern）中体现了两个非常基本的面向对象设计的基本原则：封装变化的概念；编程中使用接口，而不是对接口实现。策略模式的定义如下：定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使这些算法在客户端调用它们的时候能够互不影响地变化。策略模式使开发人员能够开发出...
spring项目中使用策略模式
Prf_Nie的博客
02-15 1296
spring项目中使用策略模式，讲解简单，易懂，易学
结合spring特性实现的策略模式
zquwei的博客
09-14 268
结合spring特性实现的策略模式 背景 工作中常常需要用到设计模式，集合spring实现的设计模式使用起来比较方便，下面就简单举例使用下。如我这里想根据不同的场景类型更新不同的表。 使用 1、策略接口类 public interface UpdateTableStrategy { void UpdateTableByAnswer(); } 2、不同的策略实现类： @Component public class updateTable1 implements UpdateTableSt
设计模式（三）策略模式——在Spring中使用策略模式
lishuzhen5678的博客
06-01 2658
前言 在 设计模式（一）策略模式 —— 策略模式结构 和 ...
Spring中如何优雅的使用策略模式
weixin_46425661的博客
08-05 1349
策略模式是什么，在Spring中如何优雅的使用
Spring框架中工厂模式实现程序解耦的实践
在Spring中，可以通过定义接口并让多个类实现该接口，然后将接口注入到需要的地方，实现运行时的多态行为。这样，即使更换了接口的实现，也不会影响调用者。 6. 总结 结合Spring框架的Bean工厂和工厂模式，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值