网硕互联帮助中心Builder
如何使用
import com.google.common.base.Preconditions;
import org.apache.commons.lang.StringUtils;
public class User {
private String name; // 必填字段
private String telephone; // 必填字段
private String sex; // 必填字段
private int age; // 可选字段
private String address; // 可选字段
private User(UserBuilder builder) {
this.name = builder.name;
this.telephone = builder.telephone;
this.sex = builder.sex;
this.age = builder.age;
this.address = builder.address;
}
@Override
public String toString() {
return "{\\"name\\":" + name + ",\\"telephone\\":\\"" + telephone
+ "\\",\\"sex\\":\\"" + sex + "\\",\\"age\\":\\""
+ age + "\\",\\"address\\":" + address + "}";
}
public static class UserBuilder {
private String name;
private String telephone;
private String sex;
private int age;
private String address;
public UserBuilder setName(String name) {
this.name = name;
return this;
}
public UserBuilder setTelephone(String telephone) {
this.telephone = telephone;
return this;
}
public UserBuilder setSex(String sex) {
this.sex = sex;
return this;
}
public UserBuilder setAge(int age) {
this.age = age;
return this;
}
public UserBuilder setAddress(String address) {
this.address = address;
return this;
}
public User build() {
// 必填字段校验
Preconditions.checkArgument(StringUtils.isNotBlank(name), "name can not be empty");
Preconditions.checkArgument(StringUtils.isNotBlank(telephone), "name can not be empty");
Preconditions.checkArgument(StringUtils.isNotBlank(telephone), "name can not be empty");
// 传入builder对象以构建user对象
User user = new User(this);
System.out.println("通过Builder模式成功构建User对象");
return user;
}
}
}
public static void main(String[] args) {
User user = new User.UserBuilder()
.setName("张三")
.setTelephone("18812546788")
.setSex("男")
.setAge(31)
.build();
System.out.println("通过Builder模式构建的User对象: " + user);
}
状态机
什么是状态机？
状态机（State Machine）是一种数学模型，用于描述系统在不同状态间的转换。它由以下部分组成：
状态（State）：系统可能处于的各个状态。
事件（Event）：触发状态转换的动作或条件。
转换（Transition）：事件触发后，系统从一个状态转移到另一个状态的过程。
动作（Action）：状态转换时执行的操作。
状态机分为有限状态机（FSM）和无限状态机，Spring Boot 中常用的是有限状态机。
状态机在订单管理中的应用
在商城系统中，订单状态通常包括：待支付、已支付、已发货、已收货、已完成、已取消等。状态机可以清晰地管理这些状态及其转换。
状态机基本结构与使用
StateMachine和State关系是双向的，这是因为状态机需要持有状态对象来表示当前状态，以及通过当前的状态对象中的方法进行状态的流转，而流转的结果需要重新set到状态机中，又要求State必须持有状态机对象。
当然，这里State对StateMachine的关系也可以通过依赖来表示。
定义状态机状态枚举
import lombok.Getter;
@Getter
public enum OrderStateEnum {
WAIT_PAYMENT(1, "待支付"),
WAIT_DELIVER(2, "待发货"),
WAIT_RECEIVE(3, "待收货"),
RECEIVED(4, "已收货"),
CANCEL(5, "已取消");
private final int state;
private final String desc;
OrderStateEnum(int state, String desc) {
this.state = state;
this.desc = desc;
}
public int getState() {
return state;
}
public String getDesc() {
return desc;
}
}
事件接口定义
public interface OrderState {
OrderStateEnum orderStateType();
default void pay(OrderStateMachine stateMachine) {
System.out.println("|–当前订单状态不支持支付，已忽略");
}
default void cancel(OrderStateMachine stateMachine) {
System.out.println("|–当前订单状态不支持取消，已忽略");
}
default void deliver(OrderStateMachine stateMachine) {
System.out.println("|–当前订单状态不支持发货，已忽略");
}
default void receive(OrderStateMachine stateMachine) {
System.out.println("|–当前订单状态不支持收货，已忽略");
}
}
default的作用是不需要类再重写这个方法，接口可以实现不能跳转状态的逻辑
如果当前状态能触发对应事件则重写对应方法并添加相关执行逻辑
例如：待支付状态可以有两个事件：支付或者取消
public class WaitPaymentState implements OrderState {
@Override
public OrderStateEnum orderStateType() {
return OrderStateEnum.WAIT_PAYMENT;
}
@Override
public void pay(OrderStateMachine stateMachine) {
stateMachine.setCurrentState(new WaitDeliverState());
}
@Override
public void cancel(OrderStateMachine stateMachine) {
stateMachine.setCurrentState(new CancelState());
}
}
状态机定义
缓存所有的状态映射，由当前状态对象来触发相关事件
public class OrderStateMachine {
public static final Map<OrderStateEnum, OrderState> ORDER_STATE_MAP = new HashMap<>();
static {
ORDER_STATE_MAP.put(OrderStateEnum.WAIT_PAYMENT, new WaitPaymentState());
ORDER_STATE_MAP.put(OrderStateEnum.WAIT_DELIVER, new WaitDeliverState());
ORDER_STATE_MAP.put(OrderStateEnum.WAIT_RECEIVE, new WaitReceiveState());
ORDER_STATE_MAP.put(OrderStateEnum.RECEIVED, new ReceivedState());
ORDER_STATE_MAP.put(OrderStateEnum.CANCEL, new CancelState());
}
private OrderState currentState;
public OrderStateMachine(OrderStateEnum orderStateEnum) {
this.currentState = ORDER_STATE_MAP.get(orderStateEnum);
}
public OrderState getCurrentState() {
return currentState;
}
public void setCurrentState(OrderState currentState) {
this.currentState = currentState;
}
void pay() {
currentState.pay(this);
}
void deliver() {
currentState.deliver(this);
}
void receive() {
currentState.receive(this);
}
void cancel() {
currentState.cancel(this);
}
}
测试
public class OrderService {
public static void main(String[] args) {
OrderStateMachine stateMachine = new OrderStateMachine(OrderStateEnum.WAIT_DELIVER);
invoke(stateMachine::pay, "用户支付", stateMachine);
invoke(stateMachine::deliver, "商家发货", stateMachine);
invoke(stateMachine::receive, "用户收货", stateMachine);
invoke(stateMachine::cancel, "取消支付", stateMachine);
}
public static void invoke(Runnable runnable, String desc, OrderStateMachine stateMachine) {
System.out.println(desc + "前订单状态: " + stateMachine.getCurrentState().orderStateType().getDesc());
runnable.run();
System.out.println(desc + "后订单状态: " + stateMachine.getCurrentState().orderStateType().getDesc());
System.out.println("——————");
}
}
springboot使用状态机
定义状态和事件
public enum OrderStates {
PENDING_PAYMENT, PAID, SHIPPED, RECEIVED, COMPLETED, CANCELLED
}
public enum OrderEvents {
PAY, SHIP, RECEIVE, COMPLETE, CANCEL
}
配置状态机-状态以及触发事件之间的关系
@Configuration
@EnableStateMachine
public class StateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderStates, OrderEvents> {
@Override
public void configure(StateMachineStateConfigurer<OrderStates, OrderEvents> states) throws Exception {
states
.withStates()
.initial(OrderStates.PENDING_PAYMENT)
.states(EnumSet.allOf(OrderStates.class));
}
@Override
public void configure(StateMachineTransitionConfigurer<OrderStates, OrderEvents> transitions) throws Exception {
transitions
.withExternal()
.source(OrderStates.PENDING_PAYMENT).target(OrderStates.PAID).event(OrderEvents.PAY)
.and()
.withExternal()
.source(OrderStates.PAID).target(OrderStates.SHIPPED).event(OrderEvents.SHIP)
.and()
.withExternal()
.source(OrderStates.SHIPPED).target(OrderStates.RECEIVED).event(OrderEvents.RECEIVE)
.and()
.withExternal()
.source(OrderStates.RECEIVED).target(OrderStates.COMPLETED).event(OrderEvents.COMPLETE)
.and()
.withExternal()
.source(OrderStates.PENDING_PAYMENT).target(OrderStates.CANCELLED).event(OrderEvents.CANCEL)
.and()
.withExternal()
.source(OrderStates.PAID).target(OrderStates.CANCELLED).event(OrderEvents.CANCEL);
}
}
使用状态机
@Service
public class OrderService {
@Autowired
private StateMachine<OrderStates, OrderEvents> stateMachine;
public void payOrder() {
stateMachine.sendEvent(OrderEvents.PAY);
}
public void shipOrder() {
stateMachine.sendEvent(OrderEvents.SHIP);
}
public void receiveOrder() {
stateMachine.sendEvent(OrderEvents.RECEIVE);
}
public void completeOrder() {
stateMachine.sendEvent(OrderEvents.COMPLETE);
}
public void cancelOrder() {
stateMachine.sendEvent(OrderEvents.CANCEL);
}
}
评论前必须登录！
注册