JAVA设计模式-行为型模式-状态模式学习DEMO

背景：按照支付到发货的场景展示，支付到发货到收货的状态转变。用状态模式来编写

 依赖

<!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>

        <!-- Junit 5 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

1-定义抽象接口

/**
 * <简述>支付状态抽象接口
 * <详细描述>
 * @author syf
 * @date 2023/8/11 9:22
 * @return null
 */
public interface OrderStatus {

    //支付
    public void pay(Order order);

    //发送
    public void send(Order order);;

    //收货
    public void receive(Order order);
}

2-创建状态接口的实现类

支付类

public class PayStatus implements OrderStatus {

    @Override
    public void pay(Order order) {
        System.out.println("订单已经支付，不能再次支付。。。。。");
    }

    @Override
    public void send(Order order) {
        System.out.println("订单已经发货。。。。。");
        order.setOrderStatus(new SendStatus());
    }

    @Override
    public void receive(Order order) {
        System.out.println("订单尚未发货，不能收货。。。。。");
    }
}

发货类 

public class SendStatus implements OrderStatus {

    @Override
    public void pay(Order order) {
        System.out.println("订单已经发货，不能再次支付。。。。。");
    }

    @Override
    public void send(Order order) {
        System.out.println("订单已经发货，不能再次发货。。。。。");
    }

    @Override
    public void receive(Order order) {
        System.out.println("订单收货。。。。。");
        //业务操作 改变状态
        order.setOrderStatus(new ReceiveStatus());
    }
}

收货类

public class ReceiveStatus implements OrderStatus {

    @Override
    public void pay(Order order) {
        System.out.println("订单已经收货，不能再次支付。。。。。");
    }

    @Override
    public void send(Order order) {
        System.out.println("订单已经收货，不能再次发货。。。。。");
    }

    @Override
    public void receive(Order order) {
        System.out.println("订单已经收货，不能再次收货。。。。。");
    }

}

   3-创建订单主题对象

无参构造，默认已经已经支付

/**
 * <简述>抽象接口的实现类
 * <详细描述>
 * @author syf
 * @date 2023/8/11 9:23
 * @return null
 */
public class Order {
    private  OrderStatus orderStatus;

    //无参构造，默认订单已经支付
    public Order(){
        orderStatus = new PayStatus();
    }


    //生成get set方法
    public OrderStatus getOrderStatus() {
        return orderStatus;
    }

    public void setOrderStatus(OrderStatus orderStatus) {
        this.orderStatus = orderStatus;
    }

    //定义代理方法，调用订单的支付行为
    public void pay(){
        orderStatus.pay(this);
    }

    //定义代理方法，调用发货的行为
    public void send(){
        orderStatus.send(this);
    }

    //定义代理方法，调用订单的收货行为
    public void receive(){
        orderStatus.receive(this);
    }
}

4-测试以及代码展示

   @org.junit.jupiter.api.Test
    public void payStatus() throws  Exception{
        com.ratelimiter.state.service.Order  order = new com.ratelimiter.state.service.Order ();

        //order.getOrderStatus().pay(order);

        //上面写法过于冗长，所以在order类中加了代理
        order.pay();
        order.send();
        order.receive();
 
    }

结果展示

订单已经支付，不能再次支付。。。。。
订单已经发货。。。。。
订单收货。。。。。

   @org.junit.jupiter.api.Test
    public void payStatus() throws  Exception{
        com.ratelimiter.state.service.Order  order = new com.ratelimiter.state.service.Order ();

        //order.getOrderStatus().pay(order);

         order.pay();
        order.send();
        order.receive();
        //再次发货
        order.send();
 
    }

订单已经支付，不能再次支付。。。。。
订单已经发货。。。。。
订单收货。。。。。
订单已经收货，不能再次发货。。。。。