[设计模式]springboot优雅实现策略器模式(加入注册器实现)

最新推荐文章于 2024-06-03 19:33:38 发布
最新推荐文章于 2024-06-03 19:33:38 发布
阅读量872 收藏
点赞数
文章标签： 设计模式 spring boot 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiqiefucong/article/details/132916263
版权

优雅实现策略器模式

场景

登陆场景使用（登陆之后返回用户信息和token所做操作基本一致，杜绝多个判断）

  1. 用户名密码登陆，
  2. 指纹登录
  3. 手机号登陆
    楼主之前写过一次通过注解实现的，那个看起来没有注册器实现优雅。
    策略器可以使用的场景很多，主要为了杜绝多if判断，把if判断需实现的信息放在自己的实现类中，提升代码可阅读性，提高执行效率，降低出错概率。
    八股文：可扩展性高，灵活性高，代码复用性高，单一职责原则，可替换性高。

废话少说，源码地址。

代码地址 
git clone https://github.com/gwy572294624/strategy-demo-new

讲解

chatGpt关于策略模式的八股文
策略模式（Strategy Pattern）是一种行为型设计模式，用于将不同的算法封装成独立的策略类，并使这些策略类可以相互替换，以实现在运行时动态地选择不同的算法。

在策略模式中，有三个主要的角色：

  1. 环境（Context）：环境类是策略模式的核心，其内部持有一个策略对象的引用。环境类将具体的任务委派给策略对象进行处理，而不直接实现具体的算法逻辑。

  2. 策略（Strategy）：策略类是一个接口或抽象类，它定义了具体算法的方法。不同的策略类实现了不同的算法逻辑。策略类之间可以相互替换，提供了算法的灵活配置。

  3. 具体策略（Concrete Strategies）：具体策略类是策略模式的实现类，实现了策略接口或抽象类中定义的具体算法逻辑。

策略模式的工作流程如下：

  1. 客户端创建一个环境对象，并通过构造函数或设置方法将具体的策略对象传递给环境对象。

  2. 客户端根据需求选择合适的策略对象。

  3. 环境对象在执行任务时，会将具体的算法委派给当前持有的策略对象进行处理。

  4. 当需要切换算法时，客户端可以动态地替换环境对象的策略对象，实现不同的算法逻辑。

策略模式的优点包括灵活性、可替换性、可扩展性和代码复用性。它可以避免使用大量的条件语句或开关语句，将不同的算法逻辑封装在独立的策略类中，使系统更加灵活、易于扩展和维护。

关于本文

策略模式组成是通过环境，策略，具体实现三部分组成，本文将环境（context）通过注册器实现，实现自动化注入容器中，维护起来更方便。主要用于优化系统中多if判断场景，大一点的系统应该都能碰到，所以希望可以帮助到大家。

创建登陆策略


public interface LoginStrategy {

    /**
     * 检查参数
     * @return
     */
    default Result checkParam(LoginPatamDTO loginPatamDTO){
        return Result.err();
    }

    /**
     * 登陆
     * @param loginPatamDTO
     * @return
     */
    default Result<LoginUserInfoVO> login(LoginPatamDTO loginPatamDTO){
        return Result.err();
    }
}

创建环境（注册器）

将bean对象放在指定的map容器中。


@Component
public class LoginCommonStrategyRegistry {

    @Autowired
    private BeanFactory beanFactory;


    private Map<LoginTypeEnum, LoginStrategy> loginrCommonStrategyMap = new ConcurrentHashMap<>();

    public Map<LoginTypeEnum, LoginStrategy> mapGet() {
        return this.loginrCommonStrategyMap;
    }

    /**
     * 初始化策略
     */
    public void registry(LoginTypeEnum loginTypeEnum, Class glass) {
        LoginStrategy funderCommonStrategy = (LoginStrategy)beanFactory.getBean(glass);
        this.loginrCommonStrategyMap.put(loginTypeEnum, funderCommonStrategy);
    }
}

简化代码 创建父类对象，也方便后期扩展

@PostConstruct 是 Java 中的一个注解，用于标记一个方法，在对象创建之后（通过构造函数创建并注入依赖后），在依赖注入完成之后立即执行。它的作用是在对象初始化阶段执行一些必要的操作，例如初始化资源、建立连接、加载数据等。


@Service
public abstract class AbstractLoginService implements LoginStrategy {

    private final LoginCommonStrategyRegistry loginCommonStrategyRegistry;
    public AbstractLoginService(LoginCommonStrategyRegistry loginCommonStrategyRegistry){
        this.loginCommonStrategyRegistry = loginCommonStrategyRegistry;
    }

    /**
     * 注册当前类到策略map中
     */
    @PostConstruct
    protected abstract void initRegistry();
}

具体策略实现类

用户名密码登陆


@Service
@Slf4j
public class UserNameLoginService extends AbstractLoginService {


    public UserNameLoginService(LoginCommonStrategyRegistry loginCommonStrategyRegistry) {
        super(loginCommonStrategyRegistry);
    }

    @Override
    protected void initRegistry() {
        super.loginCommonStrategyRegistry.registry(LoginTypeEnum.USERNAME_TYPE, this.getClass());
    }

    @Override
    public Result checkParam(LoginPatamDTO loginPatamDTO) {
        if (ObjectUtils.isEmpty(loginPatamDTO.getUserName())) {
            return Result.err("用户名不能为空");
        }
        if (ObjectUtils.isEmpty(loginPatamDTO.getPassword())) {
            return Result.err("密码不能为空");
        }
        return Result.suc();
    }

    @Override
    public Result<LoginUserInfoVO> login(LoginPatamDTO loginPatamDTO) {
        log.info("这里是用户名和密码登陆");
        if (loginPatamDTO.getUserName().equals("admin") && loginPatamDTO.getPassword().equals("admin")) {
            // 创建默认对象 模拟登陆返回
            LoginUserInfoVO loginUserInfoVO = LoginUserInfoVO.loginUserInfoVOCreate(loginPatamDTO.getLoginTypeEnum());
            return Result.suc(loginUserInfoVO);
        } else {
            return Result.err("用户名或者密码不正确");
        }
    }
}

手机号登陆


@Service
@Slf4j
public class PhoneLoginService extends AbstractLoginService {


    public PhoneLoginService(LoginCommonStrategyRegistry loginCommonStrategyRegistry) {
        super(loginCommonStrategyRegistry);
    }

    @Override
    protected void initRegistry() {
        super.loginCommonStrategyRegistry.registry(LoginTypeEnum.PHONE_TYPE, this.getClass());
    }

    @Override
    public Result checkParam(LoginPatamDTO loginPatamDTO) {
        if (ObjectUtils.isEmpty(loginPatamDTO.getPhone())) {
            return Result.err("手机号不能为空");
        }
        if (ObjectUtils.isEmpty(loginPatamDTO.getSmsCode())) {
            return Result.err("验证码不能为空");
        }
        return Result.suc();
    }

    @Override
    public Result<LoginUserInfoVO> login(LoginPatamDTO loginPatamDTO) {
        log.info("这里是手机号登陆");
        if (loginPatamDTO.getPhone().equals("17777777777") && loginPatamDTO.getSmsCode().equals("7777")) {
            // 创建默认对象 模拟登陆返回
            LoginUserInfoVO loginUserInfoVO = LoginUserInfoVO.loginUserInfoVOCreate(loginPatamDTO.getLoginTypeEnum());
            return Result.suc(loginUserInfoVO);
        } else {
            return Result.err("验证码不正确");
        }
    }
}

触发点

如果没有写策略模式 那代码应该是这样

if(type.equals("用户名登陆")){
	// 用户名密码登陆验证
}else if(type.equals("手机号登陆")){
	// 手机号登陆
}else if(.......){
 ....
}

使用策略模式触发点确实简化了不少代码，让代码优雅起来了。后续扩展啥的都很方便。

@RestController
public class LoginController {
    /**
     * 模拟redis
     */
    public static Map<String, String> userInforedis = new ConcurrentHashMap<>();

    private final LoginCommonStrategyRegistry loginCommonStrategyRegistry;

    public LoginController(LoginCommonStrategyRegistry loginCommonStrategyRegistry) {
        this.loginCommonStrategyRegistry = loginCommonStrategyRegistry;
    }


    @RequestMapping(value = "/a/login")
    public Result<LoginUserInfoVO> login(LoginPatamDTO loginPatamDTO) {
        if (ObjectUtils.isEmpty(loginPatamDTO.getLoginTypeEnum())) {
            return Result.err("无效的登陆方式");
        }
        LoginStrategy loginStrategy = loginCommonStrategyRegistry.mapGet().get(
                loginPatamDTO.getLoginTypeEnum());
        if (loginStrategy == null) {
            return Result.err("无效的登陆方式");
        }
        Result result = loginStrategy.checkParam(loginPatamDTO);
        if (result.getCode() == 0) {
            return result;
        }
        Result<LoginUserInfoVO> login = loginStrategy.login(loginPatamDTO);
        if (login.getCode() == 1) {
            userInforedis.put(login.getDate().getToken(), JSON.toJSONString(login.getDate()));
        }
        return login;
    }

}

调试



http://127.0.0.1:8080/a/login?loginTypeEnum=USERNAME_TYPE&userName=admin&password=admin

{"code":1,"msg":"成功","date":{"token":"57a44abe-e731-40f1-a9f6-1069710ac6fa","userInfoBO":{"userId":"这个是id","userRealName":"这个是名字","userSex":"这个是性别","userDeptIds":"这个是部门","loginTypeEnum":"USERNAME_TYPE"}}}

简言

在接入策略模式前一定要想好调用交互逻辑，如果系统有现成的最好使用现成的。当然也要避免循环依赖注入。

希望本文可以帮到大家。

Gy-1-__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java策略模式设计(简易收银台SpringBoot)
逍遥云恋
04-08 1433
1.准备工作,创建一个SpringBoot项目 2.用于判定使用哪个策略的类 public class CashContext { private CashSupercs acceptCash; /** * 使用构造方法来进行选择具体的收费策略 * * @param cashSuper */ public CashContext(...
Springboot配置过滤器实现过程解析
08-18
Springboot配置过滤器实现过程解析 本文主要介绍了Springboot配置过滤器的实现过程解析，通过示例代码详细介绍了过滤器的实现细节，对大家的学习或者工作具有一定的参考学习价值。 Springboot配置过滤器的基础概念...
基于Spring自动注入快速实现策略模式+工厂模式优化过多的if..else
m0_74444744的博客
12-21 1951
基于Spring自动注入快速实现策略模式+工厂模式优化过多的if..else
JAVA设计模式-策略模式及在Springboot2.X中写法
最新发布
菊头蝙蝠的博客
06-03 678
策略模式是一种行为型设计模式,定义了一系列算法,并将每个算法封装起来,使它们可以互相替换。
java（Springboot）实现策略模式
zhoupan2008的专栏
11-16 402
springboot实现策略模式
java spring 实现策略,策略模式-springboot使用Demo
weixin_30341445的博客
03-10 317
1.生命一个注解 用于标记策略类import java.lang.annotation.*;@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Inheritedpublic @interface HandlerReportSubjectType {/*** 策略类型* @return*/int value...
设计模式：注册器模式（php实现）
weixin_36020178的博客
08-15 292
1、注册器模式 1.1、简介 注册器模式是一种基础常见的设计模式，它的主要意思是把多个类的实例注册到一个注册器类中去。然后需要哪个类，由这个注册器类统一调取。 2、实现 步骤1 创建注册器 Register.php class Register { protected static $objects; public static function set($alias, $object) { self::$objects[$alias] = $object; } public static f
php设计模式-注册器模式
木易慕翊
12-28 249
简介： 注册器模式，用于解决全局共享和交换对象。已经创建好的对象，挂在到某个全局可以使用的数组上，在需要使用的时候，直接从该数组上获取即可。将对象注册到全局的树上，任何地方都直接去访问。 实例： <?php //注册器模式 class Register { //保存映射到注册器上的对象 protected static $object; //将对象映射到注册器上 public static function set
Springboot之策略模式
songdancer的博客
01-20 728
策略模式在Springboot中的应用
springboot @WebFilter注解过滤器的实现
08-24
SpringBoot @WebFilter注解过滤器的实现 SpringBoot 框架提供了多种方式来实现过滤器，例如使用 Servlet Filter API 或者使用 Spring 的 HandlerInterceptor机制，但是 SpringBoot 2.x 版本中引入了新的 @WebFilter...
策略模式Demo
12-03
http://blog.csdn.net/xingjiarong/article/details/50166481
Java SpringBoot实现的过滤器（和拦截器）控制登录页面跳转
04-13
通常，你需要配置过滤器或拦截器的注册，然后在代码中实现具体的逻辑。此外，可能还需要设置路由规则，以便在用户尝试访问受保护的URL时触发过滤器或拦截器。 7. **filterdemo**： 这个压缩包可能包含了一个示例...
SpringBoot实现简单的登录注册（超级详细）
04-12
SpringBoot实现简单的登录注册（超级详细），配合博客讲解，快速打通前后端。博客地址：https://blog.csdn.net/qq_35207086/article/details/117165939
使用SpringBoot实现策略模式
qq_51081700的博客
11-04 318
本篇文章主要会描述SpringBoot与策略模式的结合使用，因为不涉及到理论部分，所以在阅读本篇之前，需要对策略模式的理论已经有了一个基本的了解。
java spring 实现策略,SpringBoot中使用策略模式
weixin_39835117的博客
03-10 246
策略模式：定义一组算法，将每个算法都封装起来，相互之间可以互换。策略模式需要一个抽象算法接口，一组算法，一个容器类(Context)假设我们有一个场景：根据传值type的不同，调用不同的接口(加减乘除)抽象算法接口：public interface IZStrategy {/*** 计算* @param a* @param b* @return*/BigDecimal doCalculate(Bi...
设计模式-注册模式
技术人集结地
12-26 1356
注册模式是一种设计模式，也称为注册树或注册器模式。这种模式将类的实例化和创建分离开来，避免在应用程序启动时实例化对象，以避免造成资源的浪费。注册模式的核心思想是将类的创建和管理的代码封装到一个工厂类中，用户代码无需显式地通过“new”关键字实例化对象。相反，用户可以将类对象注册到全局的注册树上，这些对象就可以被应用程序中的任何地方访问。使用注册模式的优势在于，它提供了一种集中管理对象的方式，避免了在每个需要使用对象的地方重复创建和销毁对象。
【设计模式】SpringBoot优雅使用策略模式
积木成林，聚沙成塔
06-21 6649
本篇文章主要会描述SpringBoot与策略模式的结合使用，因为不涉及到理论部分，所以在阅读本篇之前，需要对策略模式的理论已经有了一个基本的了解。通过Spring获取接口的实现，并解析实现类上的注解的方式，可以在程序启动时动态的将策略注入到一个Map中，作为策略的容器。使用时传入标识符就可以获取到对应的策略执行了。
springboot 实现一种通用策略模式框架
z086961063的博客
05-04 206
策略模式
springboot实现策略模式
06-08
好的，下面我给你讲一下如何在Spring Boot中实现策略模式。 首先，我们需要定义一个接口或者抽象类，用于定义策略模式中的抽象行为。以一个简单的计算器为例，我们可以定义一个`Calculator`接口，其中包含一个`calculate`方法： ```java public interface Calculator { int calculate(int a, int b); } ``` 然后，我们需要定义具体的策略类，实现`Calculator`接口。假设我们有两种计算方式：加法和乘法，我们可以分别定义两个实现类： ```java @Component public class AddCalculator implements Calculator { @Override public int calculate(int a, int b) { return a + b; } } @Component public class MultiplyCalculator implements Calculator { @Override public int calculate(int a, int b) { return a * b; } } ``` 在上面的代码中，我们使用了`@Component`注解将这两个类注册为Spring Bean，以便在其他地方可以自动注入它们。 接下来，我们需要一个Context类，用于选择具体的策略类。在Spring Boot中，我们可以使用`@Autowired`注解自动注入所有实现了`Calculator`接口的Bean，并使用`@Qualifier`注解来指定具体的实现类。例如： ```java @Service public class CalculatorService { @Autowired private List<Calculator> calculators; public int calculate(String operator, int a, int b) { for (Calculator calculator : calculators) { if (calculator.getClass().getSimpleName().equalsIgnoreCase(operator)) { return calculator.calculate(a, b); } } throw new IllegalArgumentException("Invalid operator: " + operator); } } ``` 在上面的代码中，我们使用了一个`List<Calculator>`来注入所有实现了`Calculator`接口的Bean。然后，我们在`calculate`方法中根据传入的运算符选择具体的策略类，并调用它的`calculate`方法进行计算。 最后，我们可以在Controller中使用`CalculatorService`类来实现具体的业务逻辑。例如： ```java @RestController public class CalculatorController { @Autowired private CalculatorService calculatorService; @GetMapping("/calculate") public int calculate(@RequestParam String operator, @RequestParam int a, @RequestParam int b) { return calculatorService.calculate(operator, a, b); } } ``` 在上面的代码中，我们使用了`@RequestParam`注解来接收请求参数，然后调用`CalculatorService`的`calculate`方法进行计算，并返回结果。 这就是在Spring Boot中实现策略模式的方法。希望对你有帮助！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值