springboot+状态机

最新推荐文章于 2024-05-10 11:22:43 发布
最新推荐文章于 2024-05-10 11:22:43 发布
阅读量2.9k 收藏 19
点赞数 22
文章标签： spring boot 后端 java springcloud 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38564282/article/details/130594575
版权

最近好多业务都是流程状态的传递，借此机会写词文章，记录一下，什么样的场景设计需要我们的状态机：

目前市场流行的状态机：
 1.Spring Statemachine 

  2.阿里COLA4.4

状态机框架

  • Spring Statemachine （重量级选手）1.2k+ star.
  • squirrel-foundation（松鼠）1.8k+ star.
  • cola-statemachine （可乐）6.6k+ star.

springboot合cola-statemachine 4.4.0

cola-statemachine（阿里出品）

相比Spring statemachine状态机等的复杂，功能多；我们实际业务员需要常用的功能，简单使用，所以这类就显得不简洁；再看cola-statemachine相比就是小巧、无状态、简单、轻量、性能极高的状态机DSL实现，解决业务中的状态流转问题。
github:
https://github.com/alibaba/COLA/tree/master/cola-components/cola-component-statemachine

学习这玩意什么用：

状态机优势

1、状态机建立的控制中心是跟外界低耦合的，通过event通信；
2、控制中心所有的状态都是预设好的，不会超预料；
3、状态的跳转都是有设定控制条件的，会按照预设的转移路径运动；
4、状态机还非常容易的扩展和变更，支持因业务的发展而变更或扩展复杂业务流程。

Spring Boot StateMachine实现 

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

Spring Boot cola实现 

         <dependency>
                <groupId>com.alibaba.cola</groupId>
                <artifactId>cola-component-statemachine</artifactId>
                <version>4.4.0-SNAPSHOT</version>
            </dependency>

状态机实现步骤：

         第一步生成一个状态机

        第二步：设置一个外部状态转移类型的builder 
        第三步：设置状态机的id和ready
        第四步：触发状态机

概念：
State：状态

Event：事件，状态由事件触发，引起变化

Transition：流转，表示从一个状态到另一个状态

External Transition：外部流转，两个不同状态之间的流转

Internal Transition：内部流转，同一个状态之间的流转

Condition：条件，表示是否允许到达某个状态

Action：动作，到达某个状态之后，可以做什么

StateMachine：状态机

完成状态机配置：状态机的初始状态和所有状态机的转移规则

整个状态的调度逻辑主要依靠配置方式的定义，而所有的业务逻辑操作都被定义在了状态监听器中，其实状态监听器可以实现的功能远不止上面我们所述的内容，它还有更多的事件捕获

都是技术人员介绍那么多都是废话，直接上代码它不香

好多代码都是demo根本没有实际试用起来。今天给大家上点干活。

无脑选择spring自带的状态机：

场景一：电商的订单，和发货，退货的状态

企业无商城，你玩什么。因此我们的实际场景就是我们经常看到的订单状态的流转

状态机定义三件事：

1.定义枚举状态

2.定义枚举事件

3.定义事件流转的触发条件

有人就说了，为什么定义枚举呢？

答：你想定义啥，定义啥，你有本事，可以直接定义字典，定义接口，定义静态字段。

1.先给我们的业务订单定义状态

public enum OrderState implements IEnum<String> {
    CREATED(0, ""),//新创建订单
    PENDING(10, "Pending"),//支付待确认
    WAIT_SHIP(20, "Preparing"),//待发货
    REFUND_CHOICE(30, ""),//订单退款逻辑选择器,伪状态，数据库中不存在

    DELIVERING(40, "Shipped"),//已发货[运输中],所有的子单都发货，订单变更为已发货状态
    DELIVERED(50, "Shipped"),//已妥投[运输中],所有的子单都妥投，订单变更为妥投状态

    RECEIVED(60, "Received"),//已签收,所有的子单都签收(刨除逆向订单)，订单变更为已签收
    COMPLETED(70, "Completed"),//完成,所有的子单都完成(刨除逆向订单)，订单变更为已完成
    CANCELED(80, "Canceled"),//已取消,未支付订单、取消订单

    REFUND_AUDIT(90, "Reviewing"),//退货审核，所有子单都处于该状态
    REFUND_AUDIT_CHOICE(95, ""),//订单退款审核逻辑选择器,伪状态，数据库中不存在
    REFUNDING(100, "Refunding"),//退款中，所有子单都处于该状态
    REFUNDED(110, "Refunded");//已退款，所有子单都处于该状态

    /**
     * 此值为了解决父订单的状态取值而设，越大说明业务流程越深，时间离现在越近，订单的状态取此值最小的子单的状态
     */
    @Getter
    private final int logicDepth;

    @Getter
    @Setter
    private String customerDesc;

    OrderState(int depth, String desc) {
        this.logicDepth = depth;
        this.customerDesc = desc;
    }

    @Override
    public String getValue() {
        return name();
    }
}

2.定义事件

public enum OrderEvent implements IEnum<String> {
    COD_CHECKOUT,//创建订单后选择COD支付
    COD_CONFIRM,//支付确认
    COD_CANCEL,//支付取消
    COD_TIMEOUT,//支付确认超时

    PAY_SUCCESS,//PPD支付成功
    PAY_TIMEOUT,//支付超时
    PAY_CANCEL,//取消支付

    USER_CANCEL,//支付后/支付确认后用户取消
    PLATFORM_CANCEL,//支付后平台取消
    TIMEOUT_CANCEL,//订单匹配超时取消

    DO_SHIP,//发货
    ORDER_ARRIVE,//妥投
    CONFIRM_RECEIVE,//用户签收
    ORDER_REVIEW,//订单评价

    REJECT_ORDER,//用户拒签
    APPLY_RETURN,//申请退货退款

    RETURN_AGGREE,//退货退款审核通过
    RETURN_REJECT,//退货退款审核拒绝

    GOODS_RETURNED,//平台收到退回货物
    DO_REFUND,//收到货后，平台操作发起退款

    PPD_REFUND_SUCCESS,;//退款成功回调
    COD_REFUND_SUCCESS,//退款成功回调

    @Override
    public String getValue() {
        return name();
    }
}

3.定义状态机配置

@Configuration
public class OrderStateMachineConfig {

    final static String MACHINEID = "orderItemStateMachine";

    @Bean
    public StateMachinePersister<OrderState, OrderEvent, OrderStateAware> orderItemPersister(
            StateMachinePersist<OrderState, OrderEvent, OrderStateAware> orderItemStateMachinePersist) {
        return new DefaultStateMachinePersister<>(orderItemStateMachinePersist);
    }

    @Bean
    public StateMachine<OrderState, OrderEvent> orderItemStateMachine() throws Exception {
        // @formatter:off
        StateMachineBuilder.Builder<OrderState, OrderEvent> builder = StateMachineBuilder.builder();

        builder.configureConfiguration()
                .withConfiguration()
                .machineId(MACHINEID)
                .beanFactory(beanFactory);

        builder.configureStates()
                .withStates()
                .initial(OrderState.CREATED)
                .choice(OrderState.REFUND_CHOICE)
                .choice(OrderState.REFUND_AUDIT_CHOICE)
                .end(OrderState.COMPLETED)
                .end(OrderState.CANCELED)
                .end(OrderState.REFUNDED)
                .states(EnumSet.allOf(OrderState.class));

        builder.configureTransitions()
                //CREATED 状态流转
                .withExternal()
                .source(OrderState.CREATED).target(OrderState.WAIT_SHIP).event(OrderEvent.PAY_SUCCESS)
                .and().withExternal()
                .source(OrderState.CREATED).target(OrderState.CANCELED).event(OrderEvent.PAY_CANCEL)
                .and().withExternal()
                .source(OrderState.CREATED).target(OrderState.CANCELED).event(OrderEvent.PAY_TIMEOUT)
                .and().withExternal()
                .source(OrderState.CREATED).target(OrderState.PENDING).event(OrderEvent.COD_CHECKOUT)

                //PENDING 状态流转
                .and().withExternal()
                .source(OrderState.PENDING).target(OrderState.WAIT_SHIP).event(OrderEvent.COD_CONFIRM)
                .and().withExternal()
                .source(OrderState.PENDING).target(OrderState.CANCELED).event(OrderEvent.COD_CANCEL)
                .and().withExternal()
                .source(OrderState.PENDING).target(OrderState.CANCELED).event(OrderEvent.COD_TIMEOUT)

                //WAIT_SHIP 状态流转
                .and().withExternal()
                .source(OrderState.WAIT_SHIP).target(OrderState.DELIVERING).event(OrderEvent.DO_SHIP)
                .and().withExternal()
                .source(OrderState.WAIT_SHIP).target(OrderState.REFUND_CHOICE).event(OrderEvent.USER_CANCEL)
                .and().withExternal()
                .source(OrderState.WAIT_SHIP).target(OrderState.REFUND_CHOICE).event(OrderEvent.PLATFORM_CANCEL)
                .and().withExternal()
                .source(OrderState.WAIT_SHIP).target(OrderState.REFUND_CHOICE).event(OrderEvent.TIMEOUT_CANCEL)

                //退货退款/仅退款/cancel choice流转
                .and().withChoice()
                .source(OrderState.REFUND_CHOICE)
                //如果为COD支付[wait_ship,delivered],状态变为Canceled，事物提交后返还库存、退还限购，发送异步消息通知A端
                //COD received状态 不允许退款
                .first(OrderState.CANCELED, codRefundChoiceGuard,codRefundChoiceAction)
                //否则 !cod & wait_ship & 实付=0，状态变为Refunded，事物提交后返还库存、退还限购，退还cash，发送异步消息通知A端
                .then(OrderState.REFUNDED,cashRefundChoiceGuard,cashRefundChoiceAction)
                //否则 !cod & wait_ship & 实付>0, 状态变为Refunding,事物提交后返还库存、退还限购，退还cash，调用三方支付退款api，发送异步消息通知A端
                .then(OrderState.REFUNDING, ppdRefundOnlyChoiceGuard,ppdRefundOnlyChoiceAction)
                //否则 (!cod & received)(可能包含cash支付，此时也需要审核)
                .then(OrderState.REFUND_AUDIT, ppdRefundChoiceGuard,ppdRefundChoiceAction)

                //DELIVERING 状态流转
                .and().withExternal()
                .source(OrderState.DELIVERING).target(OrderState.DELIVERED).event(OrderEvent.ORDER_ARRIVE)

                //DELEVERED 状态流转
                .and().withExternal()
                .source(OrderState.DELIVERED).target(OrderState.RECEIVED).event(OrderEvent.CONFIRM_RECEIVE)
                .and().withExternal()
                .source(OrderState.DELIVERED).target(OrderState.REFUND_CHOICE).event(OrderEvent.REJECT_ORDER)

                //RECEIVED 状态流转
                .and().withExternal()
                .source(OrderState.RECEIVED).target(OrderState.COMPLETED).event(OrderEvent.ORDER_REVIEW)
                .and().withExternal()
                .source(OrderState.RECEIVED).target(OrderState.REFUND_CHOICE).event(OrderEvent.APPLY_RETURN)

                //RETURN_AUDIT 状态流转
                .and().withExternal()
                .source(OrderState.REFUND_AUDIT).target(OrderState.COMPLETED).event(OrderEvent.RETURN_REJECT)
                .and().withExternal()
                .source(OrderState.REFUND_AUDIT).target(OrderState.REFUND_AUDIT_CHOICE).event(OrderEvent.RETURN_AGGREE)

                //审核通过后
                .and().withChoice()
                .source(OrderState.REFUND_AUDIT_CHOICE)
                //实付=0
                .first(OrderState.REFUNDED,refundAuditChoiceGuard)
                //实付>0
                .last(OrderState.REFUNDING)

                //REFUNDING 状态流转
                .and().withExternal()
                .source(OrderState.REFUNDING).target(OrderState.REFUNDED).event(OrderEvent.PPD_REFUND_SUCCESS)
//                .and().withExternal()
//                .source(OrderState.REFUNDING).target(OrderState.REFUNDED).event(OrderEvent.COD_REFUND_SUCCESS)
        ;
        // @formatter:on
        return builder.build();
    }


    @Bean
    public StateMachinePersist<OrderState, OrderEvent, OrderStateAware> orderItemStateMachinePersist() {
        return new StateMachinePersist<OrderState, OrderEvent, OrderStateAware>() {
            @Override
            public void write(StateMachineContext<OrderState, OrderEvent> context, OrderStateAware contextObj) {
            }

            @Override
            public StateMachineContext<OrderState, OrderEvent> read(OrderStateAware contextObj) {
                return new DefaultStateMachineContext<>(
                        contextObj.getState(),
                        null, null, null, null, MACHINEID);
            }
        };
    }
}

 4.定义状态机

public interface OrderEventFirer extends OrderStateAware {

    default void fireEvent(StateMachineRestorer restorer, OrderEvent event) {
        StateMachine<OrderState, OrderEvent> stateMachine = restorer.restore(this);
        stateMachine.sendEvent(event);
        OrderState newState = stateMachine.getState().getId();
        changeState(newState,event);
    }

    default void fireEvent(StateMachineRestorer restorer, OrderEvent event, Map<String,Object> headers) {
        StateMachine<OrderState, OrderEvent> stateMachine = restorer.restore(this);

        MessageBuilder<OrderEvent> builder = MessageBuilder.withPayload(event);
        for (Map.Entry<String, Object> entry : headers.entrySet()) {
            builder.setHeader(entry.getKey(), entry.getValue());
        }
        Message<OrderEvent> message = builder.build();
        stateMachine.sendEvent(message);
        OrderState newState = stateMachine.getState().getId();
        changeState(newState,event);
    }

    default void changeState(OrderState newState, OrderEvent event){
        OrderState currentState = this.getState();
        Assert.state(currentState != newState,"Undefined state transition.state=" + currentState + ",event=" + event);
        this.setBackState(currentState);
        this.setState(newState);
        this.setLatestAction(event);
    }

    void setState(OrderState state);

    void setBackState(OrderState state);

    void setLatestAction(OrderEvent event);
}

5.业务代码使用

 @Override
    public void doDelivered(String orderItemUuid, TrackDetailsDto tracking) {
        OrderItem orderItem = baseMapper.findByUuid(orderItemUuid);
        orderItem.setDeliverAt(tracking.getDeliverDate());
        orderItem.fireEvent(stateMachineRestorer, OrderEvent.ORDER_ARRIVE);
        if(null == orderItem.getPaymentAt()) {
            orderItem.setPaymentAt(orderItem.getDeliverAt());
        }
        baseMapper.updateById(orderItem);

        Order order = orderDao.findByUuid(orderItem.getOrderUuid());
        if (null == order.getDeliveredCount()) {
            order.setDeliveredCount(0);
        }
        order.setDeliveredCount(order.getDeliveredCount() + 1 );

        List<OrderState> subStates = baseMapper.findByOrderUuid(order.getUuid()).stream().map(OrderItem::getState).collect(Collectors.toList());
        if (order.stateModified(subStates)) {
            smsSender.sendSms(
                    SmsBizType.ORDER_SINGED,
                    order.getLanguage(),
                    order.getShippingAddressMobile());
        }
        orderDao.updateById(order);
    }

写完收工：

好多网友看了，欲哭无泪，看了这么久不能运行。白扯半天。😄 里面缺几个实现类，缺数据库表设计。这是实际代码，能贴出来嘛。根据思路去实现才是王道，比一些demo强太多了。

你们需要这套源码，欢迎加我微信

 

各种功能业务实现。需要大牛出手帮助写的，欢迎咨询，地道的架构师，地道的经理，地道的业务终结者，只要你提，没有完成不了的。看准文章标签来吧。

杭州架构师
关注
  • 22
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
SpringBoot + SpringSecurity 短信验证码登录功能实现
08-27
SpringBoot + SpringSecurity 短信验证码登录功能实现 本文主要介绍了 SpringBoot + SpringSecurity 短信验证码登录功能实现的详细过程，该功能可以使用户通过手机短信验证码登录系统，而不是传统的用户名密码登录...
SpringBoot项目基于springboot+vue的游戏交易系统.zip
04-14
SpringBoot项目基于Spring Boot Vue的游戏交易系统是一个为游戏玩家设计的在线游戏道具交易平台。它结合了Spring Boot的后端快速开发特性和Vue.js在前端的高效渲染能力，整合了用户账户管理、商品上架、订单处理、...
springboot状态机模式
qq_41604890的博客
02-03 2358
状态机模式 框架 实现 状态扭转
项目终于用上了Spring状态机，非常优雅！
m0_71777195的博客
05-16 1382
先来解释什么是“状态”（ State ）。现实事物是有不同状态的，例如一个自动门，就有 open 和 closed 两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed。状态机，也就是 State Machine ，不是指一台实际机器，而是指一个数学模型。说白了，一般就是指一张状态转换图。例如，根据自动门的运行规则，我们可以抽象出下面这么一个图。
Spring状态机的实现原理和业务场景
最新发布
finally_vince的博客
05-10 1242
Spring Statemachine 是 Spring Framework 的一部分，它提供了一种实现状态机的方式，允许开发者定义状态机的状态、事件、行为和转换。状态机是一种计算模型，它可以根据一系列规则从一个状态转移到另一个状态。以下 V 哥将从Spring状态机的基本概念、实现原理、案例来介绍状态机的应用，再结合状态设计模式的原理，让你知其然知其所以然，开干！
Springboot使用mechineState状态机
青春不散场的专栏
08-23 373
参考:https://docs.spring.io/spring-statemachine/docs/1.0.0.M3/reference/htmlsingle/#sm-statecontext。
【SpringBoot技术专题】「StateMachine」StateMachine状态机设计及实现开发学习指南
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
01-15 7818
本文主要介绍一下状态机以及相关的一些概念。结合一个简单的订单状态流程，示例怎样在Springboot中集成。
spring-boot 扩展 statemachine 状态机（文末有彩蛋）
qq_37220802的博客
03-01 515
状态机全称有限状态机，因为一般的状态机的状态都是离散而且可枚举的，这就是有限的原因。状态机表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。通俗的描述状态机就是定义了一套状态変更的流程：状态机包含一个状态集合，定义当状态机处于某一个状态的时候它所能接收的事件以及可执行的行为，执行完成后，状态机所处的状态变化可以被感知。状态事件 状态机的状态变更肯定是通过触发一个事件引起的行为 触发了之后执行的业务逻辑。比如说订单未支付状态到支付状态的变更需要走的业务，写流水、修改账户余额等。
基于SpringBoot+Vue+Mysql的二手手机管理系统（源码+论文）
03-26
二手交易网站可以实现远程购物，远程选择喜欢的商品和随时追踪订单的状态。二手交易网站给人们带来前所未有的体验，满足了新时代人们的购物需求，所以网上二手交易模式得到大力发展。 本系统为基于Springboot的...
毕设之在线疫苗预约小程序(源码+部署说明+SpringBoot+微信小程序+vue).zip
04-10
预约记录查询：用户可以查看自己的预约记录，了解预约状态和接种进度。 取消预约：用户在预约未完成前可以取消预约，重新选择其他时间和地点。 通知提醒：用户在预约成功或需要接种时，会收到系统发送的通知提醒。...
阿里状态机引擎实现
qq_33816292的博客
01-13 697
状态机引擎设计
在Spring中理解状态机：解锁业务流程的无限可能
todoitbo的博客
10-16 1323
Spring中的状态机
Spring Boot使用Spring StateMachine框架实现状态机
实践求真知
11-04 7497
一 点睛 Spring StateMachine框架可能对于大部分使用Spring的开发者来说还比较生僻，它的主要功能是帮助开发者简化状态机的开发过程，让状态机结构更加层次化。它的第三个Release版本1.2.0，其中增加了对Spring Boot的自动化配置。 我们通过一个简单的示例来对Spring StateMachine有一个初步的认识。 假设我们需要实现一个订单的相关流程，其中包括...
探索状态驱动开发的奇妙世界——Cola-StateMachine的介绍与使用
沉迷写代码的程序猿的博客
09-19 2510
前面接受了Spring实现的状态机，这个状态机的优点在于功能很完备，缺点也是功能十分完备。完备到什么程度了，提供了状态机的高级玩法，比如状态的嵌套、状态的并行、子状态机等等。但是在开发中我们并不需要这些。除此之外，就是性能差的问题，包括但不仅限于在内的所有开源状态机都是有状态的，也就意味着状态机记住先前的状态和输入，以便在进行状态转换时使用这些信息作出决策。这就导致了这些有状态的状态机出现了线程安全的问题。而我们的系统往往是分布式多线程的，所以为了解决线程安全问题，我们不得不每次都要build一个实例。
【Spring Boot】创建一个简单的Spring Boot的 Demo
渐若窥宏大的博客
03-06 2945
走进Spring Boot 文章目录走进Spring Boot环境搭建新建Spring Boot项目开始创建项目配置JDK版本 和 Initializr Service URL配置Project Metadata信息配置Spring Boot版本及默认引入组件配置项目名称和项目位置项目工程介绍1、Java类文件2、资源文件3、测试类文件4、pom文件运行项目小结 简单记录 - Spring Bo...
COLA-statemachine事务失效踩坑
qq_34438435的博客
05-17 1160
cola-statemachine是阿里开源项目COLA中的轻量级状态机组件。在实际使用的过程中我曾发现状态机内事务不生效的问题，经过排查得到解决，以此记录一下。
Spring Statemachine使用入门
通往神秘的道路的专栏
11-21 1541
1、编程式 下面以官网的示例稍加改造举例来体会一下Spring Statemachine使用。 添加下面maven坐标到pom中。 <dependencies> <dependency> <groupId>org.springframework.statemachine</groupId> <ar...
StateMachine使用及源码解读，我的阿里手淘面试经历分享
2401_84104439的博客
04-04 585
最后，如果大伙有什么好的学习方法或建议欢迎大家在评论中积极留言哈，希望大家能够共同学习、共同努力、共同进步。
springboot+jwt+shiro+redis例子
07-17
可以的，我可以为您提供一个基于Spring Boot、JWT、Shiro和Redis的例子。这个例子将演示如何使用这些技术实现用户认证和授权，并且将用户的状态存储在Redis中。 首先，您需要创建一个Spring Boot项目并添加所需的依赖。 在pom.xml文件中添加以下依赖： ``` <dependencies> <!-- Spring Boot --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Shiro --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring-boot-web-starter</artifactId> <version>1.7.1</version> </dependency> <!-- JWT --> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> </dependency> <!-- Redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> </dependencies> ``` 接下来，创建一个名为`JwtUtils`的JWT工具类，用于生成和验证JWT令牌。您可以参考以下代码： ```java import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import java.util.Date; @Component public class JwtUtils { @Value("${jwt.secret}") private String secret; @Value("${jwt.expiration}") private int expiration; @PostConstruct public void init() { secret = Base64.getEncoder().encodeToString(secret.getBytes()); } public String generateToken(String username) { Date now = new Date(); Date expiryDate = new Date(now.getTime() + expiration * 1000); return Jwts.builder() .setSubject(username) .setIssuedAt(now) .setExpiration(expiryDate) .signWith(SignatureAlgorithm.HS512, secret) .compact(); } public String getUsernameFromToken(String token) { Claims claims = Jwts.parser() .setSigningKey(secret) .parseClaimsJws(token) .getBody(); return claims.getSubject(); } public boolean validateToken(String token) { try { Jwts.parser().setSigningKey(secret).parseClaimsJws(token); return true; } catch (Exception e) { return false; } } } ``` 然后，创建一个名为`RedisUtils`的Redis工具类，用于操作Redis。您可以参考以下代码： ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Component; import java.util.concurrent.TimeUnit; @Component public class RedisUtils { @Autowired private RedisTemplate<String, Object> redisTemplate; public void set(String key, Object value, long expiration) { redisTemplate.opsForValue().set(key, value, expiration, TimeUnit.SECONDS); } public Object get(String key) { return redisTemplate.opsForValue().get(key); } public void delete(String key) { redisTemplate.delete(key); } public boolean hasKey(String key) { return redisTemplate.hasKey(key); } } ``` 接下来，创建一个名为`JwtRealm`的Shiro Realm，用于验证JWT令牌和授权。您可以参考以下代码： ```java import org.apache.shiro.authc.AuthenticationException; import org.apache.shiro.authc.AuthenticationToken; import org.apache.shiro.authc.SimpleAuthenticationInfo; import org.apache.shiro.authc.UsernamePasswordToken; import org.apache.shiro.realm.AuthorizingRealm; import org.apache.shiro.subject.PrincipalCollection; public class JwtRealm extends AuthorizingRealm { @Autowired private JwtUtils jwtUtils; @Autowired private RedisUtils redisUtils; @Override public boolean supports(AuthenticationToken token) { return token instanceof JwtToken; } @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { // TODO: 实现授权逻辑 } @Override protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException { JwtToken jwtToken = (JwtToken) token; String username = jwtUtils.getUsernameFromToken(jwtToken.getToken()); if (username == null || !jwtUtils.validateToken(jwtToken.getToken())) { throw new AuthenticationException("无效的令牌"); } // TODO: 查询用户信息并返回认证信息 return new SimpleAuthenticationInfo(username, jwtToken.getToken(), getName()); } } ``` 最后，创建一个名为`JwtToken`的Shiro Token，用于封装JWT令牌。您可以参考以下代码： ```java import org.apache.shiro.authc.AuthenticationToken; public class JwtToken implements AuthenticationToken { private String token; public JwtToken(String token) { this.token = token; } @Override public Object getPrincipal() { return token; } @Override public Object getCredentials() { return token; } } ``` 以上是一个基于Spring Boot、JWT、Shiro和Redis的例子。您可以根据您的需求进行修改和扩展。希望对您有帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杭州架构师

你的鼓励你创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值