【设计模式】策略模式在Java工程中应用

简介: 【设计模式】策略模式在Java工程中应用

在之前的文章中,曾经给大家介绍过策略模式:【设计模式】策略模式,在该篇文章中,我们曾很清楚的说到,策略模式主要解决的问题是:在有多种算法相似的情况下,解决使用 if...else 所带来的复杂和难以维护。策略模式使我们的实现更加符合开闭原则:面向扩展开发,面向修改关闭。在后来的学习和工作的多次应用中,有了更加深刻的认识。再次总结此篇文章赘述下。


此篇文章,将以创建订单为例,创建不同类型的订单,不同类型的订单不同的处理逻辑


类图:



image.png


代码:

  1. 抽象策略(Strategy)角色:抽象策略角色由抽象类或接口来承担,它给出具体策略角色需要实现的接口;
package strategyTest;
import strategyTest.dto.BaseRequestDTO;
/**
 * 类 名 称:CreateStrategy
 * 类 描 述:策略抽象类
 * 创建时间:2023/2/20 3:46 下午
 * 创 建 人:admin
 */
public abstract class AbstractOrderStrategy {
    public abstract Boolean isPracticable(BaseRequestDTO dto);
    // 业务执行总流程
    public ResponseResult process(BaseRequestDTO dto) {
        ResponseResult paramsValidate = validateParams(dto);
        if (!paramsValidate.isSuccess()) {
            return paramsValidate;
        }
        ResponseResult ruleValidate = validateRules(dto);
        if (!ruleValidate.isSuccess()) {
            return ruleValidate;
        }
        ResponseResult processResult = doProcess(dto);
        if(processResult.isSuccess()){
            postProcessAction(dto);
        }
        return processResult;
    }
    // 参数校验
    protected abstract ResponseResult validateParams(BaseRequestDTO dto);
    // 业务规则校验
    protected abstract ResponseResult validateRules(BaseRequestDTO dto);
    // 核心实现
    protected abstract ResponseResult doProcess(BaseRequestDTO dto);
    // 后置处理(异步操作等)
    protected abstract void postProcessAction(BaseRequestDTO dto);
}


2.具体策略(ConcreteStrategy)角色:实现封装了具体的算法或行为;

顺风车类型处理:

1. package strategyTest.impl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import strategyTest.AbstractOrderStrategy;
import strategyTest.ResponseResult;
import strategyTest.dto.BaseRequestDTO;
import strategyTest.dto.SfcRequestDTO;
/**
 * 类 名 称:SfcImpl
 * 类 描 述:TODO
 * 创建时间:2023/2/20 3:58 下午
 * 创 建 人:admin
 */
@Service
public class SfcImpl extends AbstractOrderStrategy {
    private Logger logger = LoggerFactory.getLogger(SfcImpl.class);
    @Override
    public Boolean isPracticable(BaseRequestDTO dto) {
        if(dto.getType() == 1){
            return true;
        }
        return false;
    }
    @Override
    protected ResponseResult validateParams(BaseRequestDTO dto) {
        SfcRequestDTO sfcRequestDTO = (SfcRequestDTO) dto;
        if (sfcRequestDTO.getIsShare() == null || sfcRequestDTO.getIsShare() == 0) return ResponseResult.ERROR;
        logger.info("sfc validateParams success");
        return ResponseResult.SUCCESS;
    }
    @Override
    protected ResponseResult validateRules(BaseRequestDTO dto) {
        // 无校验
        return ResponseResult.SUCCESS;
    }
    @Override
    protected ResponseResult doProcess(BaseRequestDTO dto) {
        logger.info("sfc doProcess success");
        return ResponseResult.SUCCESS;
    }
    @Override
    protected void postProcessAction(BaseRequestDTO dto) {
        logger.info("sfc 异步执行...");
    }
}


巴士订单处理:

package strategyTest.impl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import strategyTest.AbstractOrderStrategy;
import strategyTest.ResponseResult;
import strategyTest.dto.BaseRequestDTO;
import strategyTest.dto.BusRequestDTO;
/**
 * 类 名 称:BusImpl
 * 类 描 述:TODO
 * 创建时间:2023/2/20 3:58 下午
 * 创 建 人:admin
 */
@Service
public class BusImpl extends AbstractOrderStrategy {
    private Logger logger = LoggerFactory.getLogger(BusImpl.class);
    @Override
    public Boolean isPracticable(BaseRequestDTO dto) {
        if (dto.getType() == 2) {
            return true;
        }
        return false;
    }
    @Override
    protected ResponseResult validateParams(BaseRequestDTO dto) {
        BusRequestDTO busRequestDTO = (BusRequestDTO) dto;
        if (busRequestDTO.getRouteId() == null || busRequestDTO.getRouteId() == 0) return ResponseResult.ERROR;
        logger.info("bus validateParams success");
        return ResponseResult.SUCCESS;
    }
    @Override
    protected ResponseResult validateRules(BaseRequestDTO dto) {
        BusRequestDTO busRequestDTO = (BusRequestDTO) dto;
        if (busRequestDTO.getSeats() != null && busRequestDTO.getSeats() > 30) return ResponseResult.ERROR;
        logger.info("bus validateRules success");
        return ResponseResult.SUCCESS;
    }
    @Override
    protected ResponseResult doProcess(BaseRequestDTO dto) {
        logger.info("bus doProcess success");
        return ResponseResult.SUCCESS;
    }
    @Override
    protected void postProcessAction(BaseRequestDTO dto) {
        logger.info("bus 异步执行...");
    }
}



3.上下文(Context)角色:持有抽象策略类的引用。(引用,执行策略)

package strategyTest;
import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
import strategyTest.dto.BaseRequestDTO;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
 * 类 名 称:StrategyContext
 * 类 描 述:策略执行上下文
 * 创建时间:2023/2/20 3:47 下午
 * 创 建 人:admin
 */
@Component
public class StrategyContext{
    // 策略管理类
    @Autowired
    private List<AbstractOrderStrategy> strategies = new ArrayList<>();
    // 获取策略类
    public AbstractOrderStrategy getStrategy(BaseRequestDTO dto) {
        for (AbstractOrderStrategy strategy : strategies) {
            if (strategy.isPracticable(dto)) {
                return strategy;
            }
        }
        return null;
    }
}




调用方client:

可以在一个controller,也可以写在多个controller

package strategyTest.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import strategyTest.AbstractOrderStrategy;
import strategyTest.ResponseResult;
import strategyTest.StrategyContext;
import strategyTest.dto.BaseRequestDTO;
import strategyTest.dto.BusRequestDTO;
import strategyTest.dto.SfcRequestDTO;
/**
 * 类 名 称:客户端请:可以充当controller或者业务调用上游
 * 类 描 述:TODO
 * 创建时间:2023/2/20 3:58 下午
 * 创 建 人:admin
 */
@RestController
public class ClientTest {
    @Autowired
    private StrategyContext strategyContext;
    @RequestMapping("/createSfc")
    public ResponseResult createSfc(SfcRequestDTO sfcRequestDTO){
        if(sfcRequestDTO == null){
            return ResponseResult.ERROR;
        }
        return this.createOrder(sfcRequestDTO);
    }
    @RequestMapping("/createBus")
    public ResponseResult createBus(BusRequestDTO busRequestDTO){
        if(busRequestDTO == null){
            return ResponseResult.ERROR;
        }
        return this.createOrder(busRequestDTO);
    }
    private ResponseResult createOrder(BaseRequestDTO baseRequestDTO) {
        AbstractOrderStrategy strategy = strategyContext.getStrategy(baseRequestDTO);
        if(strategy == null){
            return ResponseResult.ERROR;
        }
        return strategy.process(baseRequestDTO);
    }
}


我们看下运行结果:

sfc运行结果:


885a4a34877e04fdb4a825e914bfe5a1.png

bus运行结果:


e25202176067c83800f023bf9dda4d0c.png

是不是非常简洁明了!!!


e839a47e643d5973603e66cfa9feba25.png

我们看完代码,再结合类图看下,此时如果我们想新增一种类型的创建订单流程,比如创建一笔代驾订单,需要如何做? 我们只需要做两步:


1、新增一个代驾的实现类DjImpl,继承StrategyContext类;


2、在Controller中,新增一个方法(如果不同类型的订单有不在同一个controller,可将createOrder方法抽象到父类controller,此时新增一个子类controller继承父类和父类的方法即可);


其他地方无需改动。。。其他类型的创建订单流程完全无改动,无影响。下单流程解耦,测试范围极大的降低。


想想我们在项目中,相似的场景写过多少if else。每次添加新的实现,是否影响到原有功能。结合这篇文章,希望能对读者朋友有所帮助。


总结:


策略模式帮助我们把相似的算法抽象,使用上下文管理抽象类的具体实现,每次新增算法时,只需新增具体实现。使我们的代码轻松解耦,符合开闭原则,极大的缩小了影响范围。是成为一名优秀工程师的必修课!

相关文章
|
14天前
|
设计模式 算法 开发者
「全网最细 + 实战源码案例」设计模式——策略模式
策略模式(Strategy Pattern)是一种行为型设计模式,用于定义一系列可替换的算法或行为,并将它们封装成独立的类。通过上下文持有策略对象,在运行时动态切换算法,提高代码的可维护性和扩展性。适用于需要动态切换算法、避免条件语句、经常扩展算法或保持算法独立性的场景。优点包括符合开闭原则、运行时切换算法、解耦上下文与策略实现、减少条件判断;缺点是增加类数量和策略切换成本。示例中通过定义抽象策略接口和具体策略类,结合上下文类实现动态算法选择。
50 8
「全网最细 + 实战源码案例」设计模式——策略模式
|
30天前
|
Java 编译器 开发者
Java中的this关键字详解:深入理解与应用
本文深入解析了Java中`this`关键字的多种用法
127 9
|
30天前
|
Java 应用服务中间件 API
【潜意识Java】javaee中的SpringBoot在Java 开发中的应用与详细分析
本文介绍了 Spring Boot 的核心概念和使用场景,并通过一个实战项目演示了如何构建一个简单的 RESTful API。
41 5
|
30天前
|
人工智能 自然语言处理 搜索推荐
【潜意识Java】了解并详细分析Java与AIGC的结合应用和使用方式
本文介绍了如何将Java与AIGC(人工智能生成内容)技术结合,实现智能文本生成。
61 5
|
30天前
|
SQL Java 数据库连接
【潜意识Java】深入理解MyBatis,从基础到高级的深度细节应用
本文详细介绍了MyBatis,一个轻量级的Java持久化框架。内容涵盖MyBatis的基本概念、配置与环境搭建、基础操作(如创建实体类、Mapper接口及映射文件)以及CRUD操作的实现。此外,还深入探讨了高级特性,包括动态SQL和缓存机制。通过代码示例,帮助开发者更好地掌握MyBatis的使用技巧,提升数据库操作效率。总结部分强调了MyBatis的优势及其在实际开发中的应用价值。
32 1
|
2月前
|
设计模式 存储 缓存
前端必须掌握的设计模式——策略模式
策略模式(Strategy Pattern)是一种行为型设计模式,旨在将多分支复杂逻辑解耦。每个分支类只关心自身实现,无需处理策略切换。它避免了大量if-else或switch-case代码,符合开闭原则。常见应用场景包括表单验证、风格切换和缓存调度等。通过定义接口和上下文类,策略模式实现了灵活的逻辑分离与扩展。例如,在国际化需求中,可根据语言切换不同的词条包,使代码更加简洁优雅。总结来说,策略模式简化了多条件判断,提升了代码的可维护性和扩展性。
|
2月前
|
安全 算法 Java
Java CAS原理和应用场景大揭秘:你掌握了吗?
CAS(Compare and Swap)是一种乐观锁机制,通过硬件指令实现原子操作,确保多线程环境下对共享变量的安全访问。它避免了传统互斥锁的性能开销和线程阻塞问题。CAS操作包含三个步骤:获取期望值、比较当前值与期望值是否相等、若相等则更新为新值。CAS广泛应用于高并发场景,如数据库事务、分布式锁、无锁数据结构等,但需注意ABA问题。Java中常用`java.util.concurrent.atomic`包下的类支持CAS操作。
84 2
|
2月前
|
监控 Java 数据库连接
Java线程管理:守护线程与用户线程的区分与应用
在Java多线程编程中,线程可以分为守护线程(Daemon Thread)和用户线程(User Thread)。这两种线程在行为和用途上有着明显的区别,了解它们的差异对于编写高效、稳定的并发程序至关重要。
64 2
|
3月前
|
设计模式 消息中间件 搜索推荐
Java 设计模式——观察者模式:从优衣库不使用新疆棉事件看系统的动态响应
【11月更文挑战第17天】观察者模式是一种行为设计模式,定义了一对多的依赖关系,使多个观察者对象能直接监听并响应某一主题对象的状态变化。本文介绍了观察者模式的基本概念、商业系统中的应用实例,如优衣库事件中各相关方的动态响应,以及模式的优势和实际系统设计中的应用建议,包括事件驱动架构和消息队列的使用。
|
3月前
|
缓存 Java 开发者
Java多线程并发编程:同步机制与实践应用
本文深入探讨Java多线程中的同步机制,分析了多线程并发带来的数据不一致等问题,详细介绍了`synchronized`关键字、`ReentrantLock`显式锁及`ReentrantReadWriteLock`读写锁的应用,结合代码示例展示了如何有效解决竞态条件,提升程序性能与稳定性。
368 6