设计模式实际运用 | 状态模式

已于 2023-08-16 05:04:21 修改
阅读量314 收藏 1
点赞数 3
分类专栏： java设计模式实际运用 文章标签： 设计模式 状态模式 java
于 2023-08-15 17:44:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69672118/article/details/132302273
版权

 

文章目录

前言

本专栏主要讲述设计模式在实际开发场景中的运用, 如果对设计模式有一定的基础可以更好的理解, 当然, 我会把整个demo完整的贴出来, 尽量注释清楚, 让没有设计模式基础的也可以稍微改改运用在自己的项目中, 这里对设计模式的具体角色构成不多赘余。

状态模式在处理多状态且复杂的业务, 可以把状态变化与业务解耦, 对繁杂的业务梳理处理更简单清晰不容易出错, 多大数项目中都可以运用, 所以本专栏把状态模式放在第一篇

一、状态模式使用场景及优缺点

定义：对有状态的对象，把复杂的判断逻辑提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为

使用场景：
1. 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式
2. 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时

优点:
1. 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为
2. 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块

缺点:
1. 状态模式的使用必然会增加系统类和对象的个数
2. 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱
3. 状态模式对"开闭原则"的支持并不太好

二、实际开发场景中的运用

1.实体类

这里以订单状态为例:  订单状态有 1待付款  2待派送  3派送中  4已完成  5已取消

具体状态转变代码有注释

package com.practical.behaviorType.state.domain;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;

/**
 * 订单表
 *
 * @TableName orders
 */
@TableName(value = "orders")
@Data
public class Orders implements Serializable {
    /**
     * 主键
     */
    @TableId
    private Long id;
    private String number;
    private Long userId;
    /**
     * 订单状态
     * 1待付款: 可以从 1待付款 -> 5已取消/2待派送
     * 2待派送: 可以从 2待派送 -> 5已取消/3派送中
     * 3派送中: 只能从 3派送中 -> 4已完成
     * 4已完成: 不可操作
     * 5已取消: 不可操作
     */
    private Integer status;
    private Long addressBookId;
    private Date orderTime;
    private Date checkoutTime;
    private Integer payMethod;
    private BigDecimal amount;
    private String remark;
    private String phone;
    private String address;
    private String userName;
    private String consignee;

    @TableField(exist = false)
    private static final long serialVersionUID = 1L;
}

2.定义状态类

1. 抽象状态类 

package com.practical.behaviorType.state.orderStatus;

import com.practical.behaviorType.state.service.OrdersStatusService;

/**
 * 订单状态 抽象父类
 * <p>
 * 1待付款: 可以从 1待付款 -> 5已取消/2待派送
 * 2待派送: 可以从 2待派送 -> 5已取消/3派送中
 * 3派送中: 只能从 3派送中 -> 4已完成
 * 4已完成: 不可操作
 * 5已取消: 不可操作
 */
public abstract class OrdersStatus {

    //修改订单service(状态模式环境类)
    private OrdersStatusService ordersStatusService;
    //订单状态码
    protected Integer code;

    public void setOrdersStatusService(OrdersStatusService ordersStatusService) {
        this.ordersStatusService = ordersStatusService;
    }

    //强制子类指定各自状态码
    public OrdersStatus(Integer code) {
        this.code = code;
    }

    //付款操作   1待付款 -> 2待派送
    public abstract void pay(Long orderId);

    //派送操作   2待派送 -> 3派送中
    public abstract void send(Long orderId);

    //送达操作   3派送中 -> 4已完成
    public abstract void delivery(Long orderId);

    //取消操作   1待付款/2待派送 -> 5已取消
    public abstract void canceled(Long orderId);

    public Integer getCode() {
        return code;
    }
}

2.具体状态类

状态模式最重要的部分: 在各种状态内部既各状态具体实现类中 编写 各自业务 从 当前状态 执行改变状态方法时 的校验, 修改状态等操作, 下面只是一个简单的例子, 大家自行根据业务编写校验逻辑

package com.practical.behaviorType.state.orderStatus;

import com.practical.behaviorType.state.constant.OrdersStatusConstant;
import com.practical.behaviorType.state.domain.Orders;
import com.practical.behaviorType.state.service.OrdersService;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 待支付状态: 1
 *
 * @author zlj
 * @since 2023/8/10
 */
@Component
public class ObligationStatus extends OrdersStatus {

    @Resource
    private OrdersService ordersService;

    //指定状态码
    public ObligationStatus() {
        super(1);
    }

    @Override
    public void pay(Long orderId) {
        //修改数据库状态为待派送
        ordersService.lambdaUpdate()
                .set(Orders::getStatus, OrdersStatusConstant.WAITING_STATUS.code)
                .eq(Orders::getId, orderId)
                .update();
        //模拟
        System.out.println("订单: " + orderId + ", 开始派送");
    }

    @Override
    public void send(Long orderId) {
        throw new RuntimeException("此订单还未支付, 不可派送");
    }

    @Override
    public void delivery(Long orderId) {
        throw new RuntimeException("此订单还未支付, 不可送达");
    }

    @Override
    public void canceled(Long orderId) {
        //修改数据库状态为取消订单
        ordersService.lambdaUpdate()
                .set(Orders::getStatus, OrdersStatusConstant.CANCELED_STATUS.code)
                .eq(Orders::getId, orderId)
                .update();
        //模拟
        System.out.println("订单: " + orderId + ", 已取消");
    }
}
package com.practical.behaviorType.state.orderStatus;

import com.practical.behaviorType.state.constant.OrdersStatusConstant;
import com.practical.behaviorType.state.domain.Orders;
import com.practical.behaviorType.state.service.OrdersService;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 待派送状态 2
 *
 * @author zlj
 * @since 2023/8/10
 */
@Component
public class WaitingStatus extends OrdersStatus {

    @Resource
    private OrdersService ordersService;

    public WaitingStatus() {
        super(2);
    }


    @Override
    public void pay(Long orderId) {
        throw new RuntimeException("此订单已支付, 不可重复支付");
    }

    @Override
    public void send(Long orderId) {
        //修改数据库状态为3派送中
        ordersService.lambdaUpdate()
                .set(Orders::getStatus, OrdersStatusConstant.SENDING_STATUS.code)
                .eq(Orders::getId, orderId)
                .update();
        //模拟
        System.out.println("订单: " + orderId + ", 开始派送");
    }

    @Override
    public void delivery(Long orderId) {
        throw new RuntimeException("此订单还未派送, 不能完成订单");
    }

    @Override
    public void canceled(Long orderId) {
        //修改数据库状态为取消订单
        ordersService.lambdaUpdate()
                .set(Orders::getStatus, OrdersStatusConstant.CANCELED_STATUS.code)
                .eq(Orders::getId, orderId)
                .update();
        //模拟
        System.out.println("订单: " + orderId + ", 已取消");
    }
}

package com.practical.behaviorType.state.orderStatus;

import com.practical.behaviorType.state.constant.OrdersStatusConstant;
import com.practical.behaviorType.state.domain.Orders;
import com.practical.behaviorType.state.service.OrdersService;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 派送中状态 3
 *
 * @author zlj
 * @since 2023/8/10
 */
@Component
public class SendingStatus extends OrdersStatus {
    @Resource
    private OrdersService ordersService;

    public SendingStatus() {
        super(3);
    }

    @Override
    public void pay(Long orderId) {
        throw new RuntimeException("此订单已支付, 不可重复支付");
    }

    @Override
    public void send(Long orderId) {
        throw new RuntimeException("此订单正在派送");
    }

    @Override
    public void delivery(Long orderId) {
        //修改数据库状态为已完成
        ordersService.lambdaUpdate()
                .set(Orders::getStatus, OrdersStatusConstant.FINISH_STATUS.code)
                .eq(Orders::getId, orderId)
                .update();
        //模拟
        System.out.println("订单: " + orderId + ", 已完成");
    }

    @Override
    public void canceled(Long orderId) {
        throw new RuntimeException("此订单正在派送, 不可取消订单");
    }
}

package com.practical.behaviorType.state.orderStatus;

import com.practical.behaviorType.state.service.OrdersService;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 已完成状态 4
 *
 * @author zlj
 * @since 2023/8/10
 */
@Component
public class FinishStatus extends OrdersStatus {
    @Resource
    private OrdersService ordersService;

    public FinishStatus() {
        super(4);
    }

    @Override
    public void pay(Long orderId) {
        throw new RuntimeException("此订单已完成, 不可操作");
    }

    @Override
    public void send(Long orderId) {
        throw new RuntimeException("此订单已完成, 不可操作");
    }

    @Override
    public void delivery(Long orderId) {
        throw new RuntimeException("此订单已完成, 不可操作");
    }

    @Override
    public void canceled(Long orderId) {
        throw new RuntimeException("此订单已完成, 不可操作");
    }


}
package com.practical.behaviorType.state.orderStatus;

import com.practical.behaviorType.state.service.OrdersService;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 已取消状态 5
 *
 * @author zlj
 * @since 2023/8/10
 */
@Component
public class CanceledStatus extends OrdersStatus {
    @Resource
    private OrdersService ordersService;

    public CanceledStatus() {
        super(5);
    }

    @Override
    public void pay(Long orderId) {
        throw new RuntimeException("此订单已取消, 不可操作");
    }

    @Override
    public void send(Long orderId) {
        throw new RuntimeException("此订单已取消, 不可操作");
    }

    @Override
    public void delivery(Long orderId) {
        throw new RuntimeException("此订单已取消, 不可操作");
    }

    @Override
    public void canceled(Long orderId) {
        throw new RuntimeException("此订单已取消, 不可操作");
    }
}

3.定义状态常量

这里用了hutool的工具类SpringUtil.getBean()从springboot中获取bean

package com.practical.behaviorType.state.constant;

import cn.hutool.extra.spring.SpringUtil;
import com.practical.behaviorType.state.orderStatus.*;

/**
 * 状态常量
 *
 * @author zlj
 * @since 2023/8/10
 */
public interface OrdersStatusConstant {

    //1待付款
    ObligationStatus OBLIGATION_STATUS = SpringUtil.getBean(ObligationStatus.class);
    //2待派送
    WaitingStatus WAITING_STATUS = SpringUtil.getBean(WaitingStatus.class);
    //3派送中
    SendingStatus SENDING_STATUS = SpringUtil.getBean(SendingStatus.class);
    //4已完成
    FinishStatus FINISH_STATUS = SpringUtil.getBean(FinishStatus.class);
    //5已取消
    CanceledStatus CANCELED_STATUS = SpringUtil.getBean(CanceledStatus.class);
}

4.定义修改状态Service(状态模式环境类)

package com.practical.behaviorType.state.service;

import com.practical.behaviorType.state.domain.Orders;
import com.practical.behaviorType.state.orderStatus.OrdersStatus;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 状态模式环境类: 修改状态Service
 */
@Service
public class OrdersStatusService {
    //用于存储所有状态, key: 状态值code  value: 具体状态类的bean
    private final static Map<Integer, OrdersStatus> map = new HashMap<>();

    @Resource
    private OrdersService ordersService;//用于操作数据库订单表
    @Resource
    private List<OrdersStatus> ordersStatusList;//注入所有OrdersStatus子类的bean

    //在bean初始化后将所有具体状态放入map
    @PostConstruct
    private void init() {
        for (OrdersStatus ordersStatus : ordersStatusList) {
            map.put(ordersStatus.getCode(), ordersStatus);
        }
    }

    //当前状态
    private OrdersStatus ordersStatus;

    private void setOrdersStatus(Integer status) {
        this.ordersStatus = map.get(status);//设置环境的当前状态
        this.ordersStatus.setOrdersStatusService(this);//指定状态类的环境
    }

    //从数据库查询当前状态
    private Integer getStatus(Long orderId) {
        return ordersService.lambdaQuery().select(Orders::getStatus).eq(Orders::getId, orderId).one().getStatus();
    }

    //付款操作   1待付款 -> 2待派送
    public void pay(Long orderId) {
        this.setOrdersStatus(this.getStatus(orderId));
        ordersStatus.pay(orderId);
    }

    //派送操作   2待派送 -> 3派送中
    public void send(Long orderId) {
        this.setOrdersStatus(this.getStatus(orderId));
        ordersStatus.send(orderId);
    }

    //送达操作   3派送中 -> 4已完成
    public void delivery(Long orderId) {
        this.setOrdersStatus(this.getStatus(orderId));
        ordersStatus.delivery(orderId);
    }

    //取消操作   1待付款/2待派送 -> 5已取消
    public void canceled(Long orderId) {
        this.setOrdersStatus(this.getStatus(orderId));
        ordersStatus.canceled(orderId);
    }
}

5.测试

76af36a0c17548b1a15d8b8b39526f23.png

 完全按照预期执行, 状态模式完成

总结

喜欢的朋友多多收藏点赞，如果对设计模式的实际运用感兴趣的人多, 我会继续更新更多的模式, 大家可以在评论区留言希望下一篇文章更新什么状态模式, 我从中挑取大家留言最多的模式优先码字, 欢迎留言。

 

清汤面不加盐
关注
专栏目录
【设计模式】---状态模式详解及应用实例
于丹丹 no zuo no die no life
08-26 5883
近期在机房合作开发中，对状态模式又有了进一步的理解，下面就以机房收费系统为例子来学习装套模式    1. 状态模式基本概念 状态模式(State Pattern)是设计模式的一种，属于行为模式。 定义(源于Design Pattern)：当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。 状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情
状态模式的应用
岁月沉淀，积累财富
02-03 896
我们在项目开发过程中，经常遇到各种的判断情况，例如根据用户当前登录的的实际判断是上午、下午、或者晚上等。这个相对比较简单，我们可以用if else问题解决；但是若遇到算费功能（例如电费计算、中国移动每月的套餐实际的计算）就比较复杂了。如果我们在一个方法里面写太多的判断语句则针对后续维护都是很头疼的事情。我们应该尽量将这个语句进行拆分，让其更加简便。真正做到每个模块责任分解只做一个动作；不知道怎么弄
观察者模式、状态模式在实际工作中的使用
在路上
06-26 452
带入具体场景,使用设计模式对之前代码进行实际的优化,带你实现真正高内聚,低耦合,高扩展性的代码
设计模式之-状态模式，快速掌握状态模式，通俗易懂的讲解状态模式以及它的使用场景
咖啡程序员
12-25 1418
状态模式适用于当对象的行为取决于其内部状态，并且状态可能在运行时发生变化的情况。它可以帮助我们实现清晰的状态转换逻辑，提高代码的可维护性和扩展性。
快速应用设计模式：状态模式使用
热门推荐
张彦峰的博客
05-12 166万+
状态模式基本介绍与应用分析介绍，同时对于Spring-statemachine状态机框架给出了应用，最后介绍在外卖营销业务中的具体案例分析
什么时候使用状态模式
低调的成长
12-06 1727
前言 最近感觉架构师越来越杂，随随便便面试一个人，简历上都要写上架构相关的内容，好像写上就变成大神一样，但是一细问，却又什么都说不出来，而且问知道哪些设计模式，除了单例，工厂，观察者几个能叫上名，其他的都不是特别了解，最奇葩的是虽然能说出名字和怎么实现的，但是却很少有真正能用上的，感觉莫名其妙，不用你了解他干嘛？ 架构师：实话实说在应用端，真心能称得上架构师的少之又少，首先应用代码量与
iOS App的设计模式开发中对State状态模式的运用
09-02
状态模式是一种设计模式，它允许...通过正确地运用状态模式，开发者可以构建更加灵活、可扩展的系统，同时保持代码的清晰和简洁。在实际项目中，结合其他设计模式，如工厂模式、策略模式等，可以进一步优化系统架构。
设计模式-状态模式.pdf
最新发布
05-16
### 设计模式之状态模式详解 #### 一、概述 状态模式（State Pattern）是一种行为设计模式，它允许对象在其内部状态改变时改变其行为，从而使对象看起来像改变了其类。这种模式的主要目的是将对象的状态作为独立的...
设计模式之状态模式实例
09-07
状态模式是一种行为设计模式，它允许对象在内部状态改变时改变其行为，对象看起来似乎修改了它的类。这种模式常用于处理对象的状态变化，使得...这个例子将帮助我们更好地理解和运用状态模式，提升我们的软件设计能力。
设计模式的状态模式的例子
12-21
设计模式的状态模式的例子，希望对大家有用~~~~~~~~
设计模式大作业.zip
03-31
设计模式是软件工程中的一种最佳实践，用于解决在开发过程中常见的设计问题，提高代码的可重用性、可维护性和可扩展性。本作业涵盖了多种设计模式，包括结构型、行为型和创建型模式，旨在帮助学习者深入理解和应用...
状态模式
cifz的博客
08-11 534
随遇而安–状态模式 定义 当一个对象的内在状态改变时允许改变其行为，这个对象看起来是改变了其类。 使用场景 （1）一个对象的行为取决于它的状态，并且他必须在运行时根据状态改变它的行为。 （2）代码中包含大量与对象状态有关的条件语句，例如，一个操作中含有庞大的多分支语句 （if-else或switch-case）且这些分支依赖于该对象的状态。 状态模...
设计模式---状态模式在web前端中的应用
weixin_34110749的博客
07-26 307
在vue.js之类的mvvm的框架大行其道的当下，开发中最常见的场景就是通过改变数据来展示页面或模块的不同状态，当我们把mvvm玩的不亦乐乎的时候，有时也会停下了想想：在某些项目中不能用vuejs之类的框架时，我们怎么通过改变数据来修改页面或者模块的状态呢。嗯。说到状态，就想到了状态模式 状态模式: 在很多情况下，一个对象的行为取决于一个...
26.设计模式使用场景开发定位
weixin_43719015的博客
03-04 1564
待更新…
什么是状态模式，有哪些应用?
qq_62571013的博客
05-05 762
什么是状态模式，有哪些应用?
状态模式详解附有代码案例分析（包含状态模式与其他相关设计模式的对比）
hyyyya的博客
10-18 657
状态模式一、状态模式的概念以及角色（一）、状态模式的概念（二）、状态模式的角色二、状态模式的应用场景三、状态模式的代码示例四、状态模式相关的设计模式（一）、状态模式与责任链模式（二）、状态模式与策略模式五、状态模式的优缺点（一）、优点（二）、缺点 一、状态模式的概念以及角色 （一）、状态模式的概念 ​ 状态模式也称为状态机模式，是允许对象在内部状态发送改变时改变它的行为，对象看起来好像修改了它的类，属于行为型模式。 ​ 状态模式中类的行为是由状态决定的，不同的状态下有不同的行为。其意图是让一个对象在其内
状态模式（详解版）
黑马程序员广州中心的专栏
02-21 290
在软件开发过程中，应用程序中的有些对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态会发生改变，从而使得其行为也随之发生改变。如人的情绪有高兴的时候和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况...
Java设计模式及应用场景之《状态模式》
晓呆同学的专栏
09-11 1835
一、状态模式定义 二、状态模式的结构和说明 三、状态模式示例 四、状态模式的优缺点 五、状态模式的应用场景及案例
JavaScript设计模式解析：初识状态模式
本书根据JavaScript语言特性，深入浅出地介绍了设计模式的运用。全书分为三个部分： 1. 第一部分聚焦于JavaScript的面向对象和函数式编程基础，阐述这些编程范式如何支持和促进设计模式的实现。这部分帮助读者建立...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值