状态管理艺术——借助Spring StateMachine驭服复杂应用逻辑

2023-09-15 20:42:25

文章目录

1. 什么是状态

在开发中，无时无刻离不开状态的一个概念，任何一条数据都有属于它的状态。

比如一个电商平台，一个订单会有很多状态，比如待付款、待发货、待收货、完成订单。而这其中每一个状态的改变都随着一个个事件的发生。比如将商品下单但未付款，那么订单就是待付款状态，当触发支付事件，那么订单就能从待付款状态转变未待发货状态，以此类推随之对应的事件就是发货、收货。

其二，状态的流动是固定了的。也就是说，待付款状态的下一个状态只能是待发货状态，不能直接转化为待收货状态。这种由待付款直接转变未待收货的状态是非法的，是程序不允许的。

对于这样的一种情况，最简单的解决方案无疑就是if-lese，比如编写一个支付接口，首先根据订单ID从数据库中查询出来订单信息，然后判断一下订单状态是不是待付款状态，如果是待付款状态，则可以继续下面的流程，否则抛出异常告知用户是非法操作。

image-20230910124440071

这种使用硬编码的if-else实现的效果固然没啥问题，但是如果中间状态出现了改变，比如待付款状态出现一个待拼单，那么代码改动幅度未免太大，难以维护。

这时候，学过设计模式的同学，很容易就想到了状态模式。

状态模式将状态改变抽象成了三个角色：

  1. 环境角色(Context)：也称上下文，定义了客户端需要的接口，维护一个当前状态，并将状态的相关操作委托给当前状态对象处理。
  2. 抽象状态角色(State)：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
  3. 具体状态（Concrete State）角色：实现抽象状态所对应的行为。

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

但是状态模式也存在缺点：

  1. 如果一个实物存在过多状态，会出现类爆炸问题。
  2. 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
  3. 状态模式对开闭原则的支持并不太好，对于可以切换状态的状态模式增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态，而且修改某个状态类的行为也需修改对应类的源代码。

对比两种方案，状态模式是更好的解决方案，而对应到实践，也就是状态机。

2. 有限状态机概述

有限状态机（Finite-state machine,FSM），又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。

而要实现状态之间的流转，必须具备以下几个要素。

image-20230910130409427

1. 当前状态：状态流转的起始状态，如上图中的新建状态

2. 触发事件：引发状态与状态之间流转的事件，如上图中的创建订单这个动作

3. 响应函数：触发事件到下一个状态之间的规则

4. 目标状态：状态流转的终止状态，如上图中的待付款状态

简单来说，只有满足当订单是新建状态并且触发创建订单事件，才会执行触发函数，使得状态由新建转化为待付款。

这就是一个状态机的基本要素，但是要实现一个状态机并不简单，好在Spring为我们提供了Spring StateMachine框架。

3. Spring StateMachine

Spring Statemachine是应用程序开发人员在Spring应用程序中使用状态机概念的框架
Spring Statemachine旨在提供以下功能：

  1. 易于使用的扁平单级状态机，用于简单的使用案例。
  2. 分层状态机结构，以简化复杂的状态配置。
  3. 状态机区域提供更复杂的状态配置。
  4. 使用触发器，转换，警卫和操作。
  5. 键入安全配置适配器。
  6. 生成器模式，用于在Spring Application上下文之外使用的简单实例化通常用例的食谱
  7. 基于Zookeeper的分布式状态机
  8. 状态机事件监听器。
  9. UML Eclipse Papyrus建模。
  10. 将计算机配置存储在永久存储中。
  11. Spring IOC集成将bean与状态机关联起来。

官网：spring.io/projects/sp…

源码：github.com/spring-proj…

API：docs.spring.io/spring-stat…

状态机是一种用于控制应用程序状态转换的机制。它包含了一组预定义的状态和状态之间的转换规则。在应用程序运行时，通过不同的事件或计时器触发，状态机能够根据事先定义好的规则自动地改变应用程序的状态。这种设计思想使得开发人员能够更加方便地追踪和调试应用程序的行为，因为状态转换的规则是在启动时确定的，而不需要动态地修改或推断。

4. Spring StateMachine 入门小案例

首先，引入Spring StateMachine 的依赖。

<dependency>
    <groupId>org.springframework.statemachine</groupId>
    <artifactId>spring-statemachine-core</artifactId>
    <version>2.1.3.RELEASE</version>
</dependency>

定义订单状态的枚举与触发订单状态改变的事件枚举

/**
 * @description: 订单状态
 * @author：lrk
 * @date: 2023/9/6
 */
@AllArgsConstructor
@Getter
public enum OrderState {

    WAIT_PAYMENT(1, "待支付"),
    WAIT_DELIVER(2, "待发货"),
    WAIT_RECEIVE(3, "待收货"),
    FINISH(4, "已完成");
    private Integer value;
    private String desc;
}

/**
 * @description: 事件枚举类
 * @author：lrk
 * @date: 2023/9/6
 */
public enum OrderStatusChangeEvent {
    /**
     * 支付
     */
    PAYED,

    /**
     * 发货
     */
    DELIVERY,

    /**
     *  确认收货
     */
    RECEIVED
}

创建一个订单表，这里只是简单演示，所有只有id、用户名称和订单状态

CREATE TABLE `t_order`  (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT 'id',
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '下单用户名称',
  `status` tinyint NULL DEFAULT NULL COMMENT '订单状态（1：待支付，2：待发货，3：待收货，4：已完成）',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

接着，编写状态机的配置类。

  1. 绑定初始状态与解决状态，以及所有的订单状态
  2. 绑定从一个状态流向下一个状态需要触发的事件
/**
 * @description: 状态机配置类
 * @author：lrk
 * @date: 2023/9/6
 */
@Configuration
@EnableStateMachine(name = "orderStateMachine")
@Slf4j
public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderState, OrderStatusChangeEvent> {

    /**
     * 配置初始状态
     */
    @Override
    public void configure(StateMachineStateConfigurer<OrderState, OrderStatusChangeEvent> states) throws Exception {
        states.withStates()
                // 指定初始化状态
                .initial(OrderState.WAIT_PAYMENT)
            	// 指定解决状态
                .end(OrderState.FINISH)
                .states(EnumSet.allOf(OrderState.class));
    }



    /**
     * 配置状态转换事件关系
     *
     * @param transitions
     * @throws Exception
     */
    @Override
    public void configure(StateMachineTransitionConfigurer<OrderState, OrderStatusChangeEvent> transitions) throws Exception {
        transitions
                //支付事件:待支付-》待发货
                .withExternal().source(OrderState.WAIT_PAYMENT).target(OrderState.WAIT_DELIVER)
                .event(OrderStatusChangeEvent.PAYED)
                .and()
                //发货事件:待发货-》待收货
                .withExternal().source(OrderState.WAIT_DELIVER).target(OrderState.WAIT_RECEIVE)
                .event(OrderStatusChangeEvent.DELIVERY)
                .and()
                //收货事件:待收货-》已完成
                .withExternal().source(OrderState.WAIT_RECEIVE).target(OrderState.FINISH).event(OrderStatusChangeEvent.RECEIVED);
    }
}

接着，编写状态机监听器。

状态机监听器种指定了状态从某个状态到某个状态的时候会触发哪个方法，执行方法的逻辑。

比如订单状态一开始是WAIT_PAYMENT，需要转化为WAIT_DELIVER

那么就会执行payTransition方法的逻辑，在这个方法中可以编写相应的业务逻辑。

/**
 * @description: 状态机监听器
 * @author：lrk
 * @date: 2023/9/6
 */
@WithStateMachine(name = "orderStateMachine")
@Slf4j
@Component("orderStateListener")
public class OrderListener {

    @Resource
    private OrderService orderService;


    @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
    public boolean payTransition(Message<OrderStatusChangeEvent> message) {
        Order order = (Order) message.getHeaders().get("order");
        order.setStatus(OrderState.WAIT_DELIVER.getValue());
        log.info("支付，状态机反馈信息：" + message.getHeaders().toString());
        return orderService.updateById(order);
    }

    @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE")
    public boolean deliverTransition(Message<OrderStatusChangeEvent> message) {
        Order order = (Order) message.getHeaders().get("order");
        order.setStatus(OrderState.WAIT_RECEIVE.getValue());
        log.info("发货，状态机反馈信息：" + message.getHeaders().toString());
        return orderService.updateById(order);
    }

    @OnTransition(source = "WAIT_RECEIVE", target = "FINISH")
    public boolean receiveTransition(Message<OrderStatusChangeEvent> message) {
        Order order = (Order) message.getHeaders().get("order");
        order.setStatus(OrderState.FINISH.getValue());
        log.info("收货，状态机反馈信息：" + message.getHeaders().toString());
        return orderService.updateById(order);
    }
}

接着编写接口

/**
 * @description: 订单接口
 * @author：lrk
 * @date: 2023/9/6
 */
@RestController
@RequestMapping("order")
public class OrderController {

    @Resource
    private OrderService orderService;

    @GetMapping("create")
    public BaseResponse<Order> create() {
        return ResultUtils.success(orderService.create());
    }

    @GetMapping("pay")
    public BaseResponse<Order> pay(@RequestParam Integer id) {
        return ResultUtils.success(orderService.pay(id));
    }

    @GetMapping("deliver")
    public BaseResponse<Order> deliver(@RequestParam Integer id) {
        return ResultUtils.success(orderService.deliver(id));
    }

    @GetMapping("receive")
    public BaseResponse<Order> receive(@RequestParam Integer id) {
        return ResultUtils.success(orderService.receive(id));
    }


    @GetMapping("getOrders")
    public BaseResponse<List<Order>> getOrders() {
        return ResultUtils.success(orderService.getOrders());
    }
}

/**
 * @author lrk
 * @description 针对表【t_order】的数据库操作Service实现
 * @createDate 2023-09-06 22:42:22
 */
@Service
@Slf4j
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order>
        implements OrderService {

    @Resource
    private StateMachine<OrderState, OrderStatusChangeEvent> orderStateMachine;

    @Resource
    private StateMachinePersister<OrderState, OrderStatusChangeEvent, Order> persister;


    @Override
    public Order create() {
        Order order = new Order();
        order.setName("小明" + UUID.randomUUID());
        order.setStatus(OrderState.WAIT_PAYMENT.getValue());
        this.save(order);
        return order;
    }

    @Override
    public Order pay(int id) {
        Order order = this.getById(id);
        log.info("支付：order订单信息：{}", order);
        if (!sendEvent(OrderStatusChangeEvent.PAYED, order)) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "状态转换异常");
        }
        return this.getById(id);
    }

    @Override
    public Order deliver(int id) {
        Order order = this.getById(id);
        log.info("发货：order订单信息：{}", order);
        if (!sendEvent(OrderStatusChangeEvent.DELIVERY, order)) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "状态转换异常");
        }
        return this.getById(id);
    }

    @Override
    public Order receive(int id) {
        Order order = this.getById(id);
        log.info("收货：order订单信息：{}", order);
        if (!sendEvent(OrderStatusChangeEvent.RECEIVED, order)) {
            throw new BusinessException(ErrorCode.OPERATION_ERROR, "状态转换异常");
        }
        return this.getById(id);
    }

    @Override
    public List<Order> getOrders() {
        return this.list();
    }


    /**
     * 发送订单状态转换事件
     * synchronized修饰保证这个方法是线程安全的
     *
     * @param changeEvent
     * @param order
     * @return
     */
    private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) {
        boolean result = false;
        try {
            //启动状态机
            orderStateMachine.start();
            //尝试恢复状态机状态
            persister.restore(orderStateMachine, order);
            Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build();
            result = orderStateMachine.sendEvent(message);
            //持久化状态机状态
            persister.persist(orderStateMachine, order);
        } catch (Exception e) {
            log.error("订单操作失败:{}", e);
        } finally {
            orderStateMachine.stop();
        }
        return result;

    }
}

其实到这，还需要思考一个问题，在业务层通过状态机发送的只是订单转变事件只是订单状态改变的事件OrderStatusChangeEvent，那么状态机怎么知道初始状态是什么？因为需要靠初始状态判断是否达到体检可以转变状态。

这就需要配置状态机持久化配置了

/**
 * 持久化配置
 * 实际使用中，可以配合redis等，进行持久化操作
 *
 * @return
 */
@Bean
public DefaultStateMachinePersister persister() {
    return new DefaultStateMachinePersister<>(new StateMachinePersist<Object, Object, Order>() {
        //这个内存中的示例仅用于演示目的。对于真正的应用程序，你应该使用真正的持久存储实现。
        private Map<Long, StateMachineContext<Object, Object>> map = new HashMap();

        @Override
        public void write(StateMachineContext<Object, Object> context, Order order) throws Exception {
            map.put(order.getId(), context);
        }

        @Override
        public StateMachineContext<Object, Object> read(Order order) throws Exception {
            return map.get(order.getId());
        }
    });
}

首先状态机会触发read(Order order)方法，在持久化存储中读取相应的状态机上下文。

这样状态机就能获取到的初始状态了。

而write(StateMachineContext<Object, Object> context, Order order)方法，则是将订单ID对应的上下文放到map集合中去。

根据订单的初始状态和触发事件对应的目标状态，执行相对应的状态机监听器事件。

然后将状态机修改后的订单状态的上下文通过write方法，写进map中，以便下一次订单状态流转的时候可以用到。

4.1 接口测试

一开始，创建一个订单，订单状态为1，也就是待付款。

image-20230910140018214

接着调用支付接口，触发支付事件，订单状态流转为2，也就是待发货

image-20230910140113795

如果这时候，不调用发货接口，直接调用收货接口，订单状态会不会改变呢？

image-20230910140200977

很明显不会，状态机会识别到状态流转异常，在sendEvent会返回false表示失败，接着业务层抛出异常。

继续调用发货接口，订单触发发货事件，订单状态转变为3，也就是待收货状态。

image-20230910140344843

最后，收货，整个订单状态流转过程就完美完成了！

image-20230910140412868

5. 总结

Spring StateMachine是Spring旗下的一个状态机框架。所以生态非常丰富，与Spring整合度非常高，非常适合结合Spring框架去使用。

但是，Spring StateMachine定制性难度困难，因为Spring StateMachine是一个复杂的框架，各方面来说难以定制化。

所以如果是直接使用状态机的组件库，可以考虑使用Spring的状态机。

参考

  1. Squirrel状态机-从原理探究到最佳实践 - 掘金 (juejin.cn)
  2. 状态机的介绍和使用 | 京东物流技术团队 - 掘金 (juejin.cn)
  3. Spring之状态机讲解_spring状态机_爱吃牛肉的大老虎的博客-CSDN博客
  4. Spring StateMachine 文档 | 中文文档 (gitcode.host)
  5. 【设计模式】软件设计原则以及23种设计模式总结_起名方面没有灵感的博客-CSDN博客
  6. 使用Spring StateMachine框架实现状态机 (taodudu.cc)
更多推荐

Redis主从复制(Redis6.2.5版本)

1、Redis单击服务问题？Redis的单机服务在实际的应用中会有很多的问题，所以在实际的使用中如果使用了redis服务，往往都不是单机服务，都会配置主从复制或者哨兵机制及redis的集群服务等。Redis的单机服务，当主机发生机器故障的时候，我们就需要做数据迁移，同时也会大概率出现数据大量都是的情况，并且短时间内，系

ChatGPT：解释Java中 ‘HttpResponse‘ 使用 ‘try-with-resources‘ 的警告和处理 ‘Throwable‘ 打印警告

ChatGPT：解释Java中‘HttpResponse’使用‘try-with-resources’的警告和处理‘Throwable’打印警告我在IDEA中对一个函数的警告点击了ignore，怎么撤回这个呢ChatGPT：要撤回在IDEA中对一个函数的警告的忽略，您可以按照以下步骤进行操作：打开您的项目，并在编辑器中

SkyWalking快速上手（三）——架构剖析2

文章目录介绍UI组件什么是UI组件？UI组件的配置配置UI组件示例使用SkyWalkingUIStorage组件什么是Storage组件？Storage组件的配置配置Storage组件示例结语介绍接上篇文章：SkyWalking快速上手（二）——架构剖析1SkyWalking是一个开源的分布式系统追踪、监控和诊断工具，

Python爬虫:通过js逆向获取某视频平台上的视频的m3u8链接

Python爬虫:通过js逆向获取某视频平台上的视频的m3u8链接1.前言2.js逆向分析3.参考代码和运行结果1.前言现在我们在网页端看的视频，其前端实现原理就小编目前知道的而言，总的有两点:其一，直接就是一个mp4(或其他类似的)视频链接，如果我们能得到这个视频链接，直接用这个链接就能下载到这个视频；其二，和第一点

毕业设计|基于stm32单片机的app视频遥控抽水灭火小车设计

基于stm32单片机的app视频遥控抽水灭火水泵小车设计1、项目简介1.1系统构成1.2系统功能2、部分电路设计2.1L298N电机驱动电路设计2.2继电器控制电路设计3、部分代码展示3.1小车控制代码3.1水泵控制代码4演示视频及代码资料获取1、项目简介视频简介中包含资料https://www.bilibili.co

自定义协议、序列化与反序列化

在编写TCP和UDP程序的时候，我们很自然的就使用了读取的函数对数据进行获取，对于UDP来说提供的是无连接的以数据报的形式进行传输，对于TCP来说是面向数据流的，在之前的程序中我们只是进行了读取的操作，但是并没有对读取的内容进行分析。那如果我们要传输一些结构化的数据的话，那么就需要引入"协议"这个概念。网络版计算器在本

前后端分离毕设项目之产业园区智慧公寓管理系统设计与实现（内含源码+文档+教程）

博主介绍：✌全网粉丝10W+,前互联网大厂软件研发、集结硕博英豪成立工作室。专注于计算机相关专业毕业设计项目实战6年之久，选择我们就是选择放心、选择安心毕业✌🍅由于篇幅限制，想要获取完整文章或者源码，或者代做，拉到文章底部即可看到个人VX。🍅2023年-2024年最新计算机毕业设计本科选题大全汇总感兴趣的可以先收藏

如何选择适合你的隧道爬虫ip？

隧道爬虫IP在保护你的网络隐私和提供安全的数据传输方面起着关键作用。然而，在众多的商家中选择适合自己的并非易事。本文将分享一些关键的考虑因素，帮助你选择适合你的隧道爬虫IP商家。无论你是个人用户还是企业客户，相信这些指南都能帮助你做出明智的选择，确保你的网络连接安全可靠。一、明确你的需求1、安全性需求：确定你对数据隐私

webpack 基础配置

常见配置文件打包的出口和入口webpack如何开启一台服务webpack如何打包图片，静态资源等。webpack配置loader配置plugin配置sourceMap配置babel语法降级等接下来，我们先从webpack的基本配置开始吧！在准备配置之前,搭建一个webpack工程，你可以在自己的工程下npminit或者

spring怎么去引用/注入集合/数组类型和 怎么通过 util 名称空间创建 list以及 怎么去通过级联属性赋值

😀前言本章是spring基于XML配置bean系类中第3篇讲解了spring怎么去引用/注入集合/数组类型和怎么通过util名称空间创建list以及怎么去通过级联属性赋值🏠个人主页：尘觉主页🧑个人简介：大家好，我是尘觉，希望我的文章可以帮助到大家，您的满意是我的动力😉😉在csdn获奖荣誉:🏆csdn城市之星

VMware 三种网络连接模式

VMware虚拟机的三种网络连接模式：桥接，NAT，仅主机。网卡vmnet0,vmnet1,vmnet8区别。在VMware中，虚拟机的网络连接主要是由VMware创建的虚拟交换机负责实现的，VMware可以根据需要创建多个虚拟网络。VMware的虚拟网络都是以“VMet+数字”的形式来命名的，例如VMnet0,VMn

热文推荐
  1. 互联网摸鱼日报(2023-09-18)

    互联网摸鱼日报(2023-09-18)36氪新闻最前线|号外电摩12.68万元起订，配16.9度一体压铸电池包本周双碳大事：CCER交易管理办法获生态环境部原则通过；明阳斥资100亿元加码光伏项目；“全路程”获2亿元D轮融资200亿，贝佐斯投出全球最大天使轮12种自由职业者管理时间的高效方法开彩票站，还是一门好生意吗：

  2. 阿曼市场最全开发攻略，看这一篇就够了

    中东是一个充满外贸机遇的市场，已经成为很多外贸人重点开发的市场。阿曼的海岸南方和东方临阿拉伯海，东北方则抵阿曼湾。阿曼因为扼守着世界上最重要的石油输出通道——波斯湾和阿曼湾之间的霍尔木兹海峡，所以地理位置非常重要，商机也是很多的。作为外贸人，如何开发阿联酋市场客户呢？今天就来谈谈这个问题。文章略长，大家点赞收藏+关注，

  3. 【深度学习】 Python 和 NumPy 系列教程（十九）：Matplotlib详解：2、3d绘图类型（5）3D等高线图（3D Contour Plot）

    目录一、前言二、实验环境三、Matplotlib详解1、2d绘图类型2、3d绘图类型0.设置中文字体1.3D线框图（3DLinePlot）2.3D散点图（3DScatterPlot）3.3D条形图（3DBarPlot）4.3D曲面图（3DSurfacePlot）5.3D等高线图（3DContourPlot）一、前言Py

  4. 设计模式：简单工厂模式

    目录代码实现总结简单工厂模式（SimpleFactoryPattern）是一种创建型设计模式，它提供了一种创建对象的最简单方式，通过一个工厂类根据传入的参数来决定创建哪种产品类的实例。在简单工厂模式中，有三个主要角色：产品（Product）：定义了工厂创建的对象的接口。具体产品（ConcreteProduct）：实现了

  5. ElasticSearch（ES）简单介绍

    ES简介Elasticsearch（通常简称为ES）是一个开源的分布式搜索和分析引擎，旨在处理各种类型的数据，包括结构化、半结构化和非结构化数据。它最初是为全文搜索而设计的，但随着时间的推移，它已经演变成一个功能强大的数据分析工具，用于实时搜索、日志和事件数据分析、业务智能等各种用途。以下是关于Elasticsearc

  6. 正则表达式基础

    正则表达式是一种用来匹配字符串的技术，它可以通过特定的模式来搜索、替换或提取字符串中的内容。正则表达式的语法有很多不同的标记和修饰符，以下是一些常见的基础语法代码：\d：匹配任意一个数字。\w：匹配任意一个字母或数字。\s：匹配任意一个空白字符。.：匹配除换行符以外的任意一个字符。[abc]：匹配字符集合中的任意一个字

  7. RocketMQ概论

    目录前言：1.概述2.下载安装、集群搭建3.消息模型4.如何保证吞吐量4.1.消息存储4.1.1顺序读写4.1.2.异步刷盘4.1.3.零拷贝4.2.网络传输前言：RocketMQ的代码示例在安装目录下有全套详细demo，所以本文不侧重于讲API这种死的东西，而是侧重于讲解RocketMQ的特性。消息中间件无非需要关注

  8. OJ练习第173题——单词接龙 II

    单词接龙II力扣链接：126.单词接龙II题目描述按字典wordList完成从单词beginWord到单词endWord转化，一个表示此过程的转换序列是形式上像beginWord->s1->s2->…->sk这样的单词序列，并满足：每对相邻的单词之间仅有单个字母不同。转换过程中的每个单词si（1<=i<=k）必须是字典

  9. 算法通关村 | 透彻理解动态规划

    1.斐波那契数列1，1，2，3，5，8，13，.....f(n)=f(n-1)+f(n-2)代码实现publicstaticintcount_2=0;publicintfibonacci(intn){if(n<=2){count_2++;returnn;}intf1=1;intf2=2;intsum=0;for(int