cola架构：有限状态机（FSM）源码分析

news2024/12/26 21:49:37

目录

0. cola状态机简述

1.cola状态机使用实例

2.cola状态机源码解析

2.1 语义模型源码

2.1.1 Condition和Action接口

2.1.2 State

2.1.3 Transition接口

2.1.4 StateMachine接口

2.2 Builder模式

2.2.1 StateMachine Builder模式

2.2.2 ExternalTransitionBuilder---转移构造Builder模式

2.2.2.1 链式调用顺序保障

2.2.2.2 链式调用具体实现

0. cola状态机简述

cola状态机采用无状态设计，不存储中间状态，重点关注状态之间的转移，这样的设计使得cola更加的简单、轻量、易于上手，在高并发多线程场景下应用单例模式可以实现更高的性能；

cola状态机框架根据实际使用场景进行抽象领域建模，抽象出如下的语义模型：

  • State：状态
  • Event：事件，状态由事件触发，引起变化
  • Transition：流转，表示从一个状态到另一个状态
  • External Transition：外部流转，两个不同状态之间的流转
  • Internal Transition：内部流转，同一个状态之间的流转
  • Condition：条件，表示是否允许到达某个状态
  • Action：动作，到达某个状态之后，可以做什么
  • StateMachine：状态机

上述语义模型之间的实体关系模型如下：

  •  一个状态机实例（StateMachine）可以包含多个状态（State）
  • 每个状态可以包含多个状态转移（Transition）
  • 每个状态转移（Transition）包含初始状态、目标状态、驱动事件（Event），以及状态转移条件（Condition）和命中转移条件之后的动作（Action）

理清上述语义模型的概念后，下面通过源码分析来探究cola状态机的内部实现； 

1.cola状态机使用实例

在深入源码解析之前，首先通过一个具体的状态机实例了解状态机的使用方法，后面再逐步探究其执行过程：

public class StateMachineTest {

    static String MACHINE_ID = "TestStateMachine";

    static enum States {
        STATE1,
        STATE2,
        STATE3,
        STATE4
    }

    static enum Events {
        EVENT1,
        EVENT2,
        EVENT3,
        EVENT4,
        INTERNAL_EVENT
    }

    static class Context {
        String operator = "frank";
        String entityId = "123465";
    }

    @Test
    public void testExternalNormal() {
        StateMachineBuilder<States, Events, Context> builder = StateMachineBuilderFactory.create();
        builder.externalTransition()
            .from(States.STATE1)
            .to(States.STATE2)
            .on(Events.EVENT1)
            .when(checkCondition())
            .perform(doAction());

        StateMachine<States, Events, Context> stateMachine = builder.build(MACHINE_ID);
        States target = stateMachine.fireEvent(States.STATE1, Events.EVENT1, new Context());
        Assert.assertEquals(States.STATE2, target);
    }

    private Condition<Context> checkCondition() {
        return new Condition<Context>() {
            @Override
            public boolean isSatisfied(Context context) {
                System.out.println("Check condition : " + context);
                return true;
            }
        };
    }

    private Action<States, Events, Context> doAction() {
        return (from, to, event, ctx) -> {
            System.out.println(
                ctx.operator + " is operating " + ctx.entityId + " from:" + from + " to:" + to + " on:" + event);
        };
    }
}

 上面首先通过Builder模式创建StateMachine实例，其中定义了STATE1到STATE2的转移，然后通过fireEvent触发状态转移，在满足Condition时，执行了具体的动作Action；

2.cola状态机源码解析

cola状态机的核心逻辑都是围绕着上述的语义模型展开的，下面首先看下语义模型的源码；

2.1 语义模型源码

2.1.1 Condition和Action接口

 Condition接口：

/**
 * Condition
 *
 * @author Frank Zhang
 * @date 2020-02-07 2:50 PM
 */
public interface Condition<C> {

    /**
     * @param context context object
     * @return whether the context satisfied current condition
     */
    boolean isSatisfied(C context);

    default String name(){
        return this.getClass().getSimpleName();
    }
}

Action接口： 

/**
 * Generic strategy interface used by a state machine to respond
 * events by executing an {@code Action} with a {@link StateContext}.
 *
 * @author Frank Zhang
 * @date 2020-02-07 2:51 PM
 */
public interface Action<S, E, C> {

//    /**
//     * Execute action with a {@link StateContext}.
//     *
//     * @param context the state context
//     */
//    void execute(StateContext<S, E> context);

    public void execute(S from, S to, E event, C context);

}

Condition接口定义了isSatisfied方法评估是否命中条件；

Action接口通过方法execute执行具体的动作；

2.1.2 State

State接口定义如下：

/**
 * State
 *
 * @param <S> the type of state
 * @param <E> the type of event
 *
 * @author Frank Zhang
 * @date 2020-02-07 2:12 PM
 */
public interface State<S,E,C> extends Visitable{

    /**
     * Gets the state identifier.
     *
     * @return the state identifiers
     */
    S getId();

    /**
     * Add transition to the state
     * @param event the event of the Transition
     * @param target the target of the transition
     * @return
     */
    Transition<S,E,C> addTransition(E event, State<S, E, C> target, TransitionType transitionType);

    List<Transition<S,E,C>> getEventTransitions(E event);

    Collection<Transition<S,E,C>> getAllTransitions();

}

State接口实现：

/**
 * StateImpl
 *
 * @author Frank Zhang
 * @date 2020-02-07 11:19 PM
 */
public class StateImpl<S,E,C> implements State<S,E,C> {
    protected final S stateId;
    private EventTransitions eventTransitions = new EventTransitions();

    StateImpl(S stateId){
        this.stateId = stateId;
    }

    @Override
    public Transition<S, E, C> addTransition(E event, State<S,E,C> target, TransitionType transitionType) {
        Transition<S, E, C> newTransition = new TransitionImpl<>();
        newTransition.setSource(this);
        newTransition.setTarget(target);
        newTransition.setEvent(event);
        newTransition.setType(transitionType);

        Debugger.debug("Begin to add new transition: "+ newTransition);

        eventTransitions.put(event, newTransition);
        return newTransition;
    }

    @Override
    public List<Transition<S, E, C>> getEventTransitions(E event) {
        return eventTransitions.get(event);
    }

    @Override
    public Collection<Transition<S, E, C>> getAllTransitions() {
        return eventTransitions.allTransitions();
    }

    @Override
    public S getId() {
        return stateId;
    }

    @Override
    public String accept(Visitor visitor) {
        String entry = visitor.visitOnEntry(this);
        String exit = visitor.visitOnExit(this);
        return entry + exit;
    }

    @Override
    public boolean equals(Object anObject){
        if(anObject instanceof State){
            State other = (State)anObject;
            if(this.stateId.equals(other.getId()))
                return true;
        }
        return false;
    }

    @Override
    public String toString(){
        return stateId.toString();
    }
}

可以看出State聚合了多个状态转移（Transition） ，

状态转移是通过EventTransitions类来进行封装管理的，源码如下：

/**
 * EventTransitions
 *
 * 同一个Event可以触发多个Transitions，https://github.com/alibaba/COLA/pull/158
 *
 * @author Frank Zhang
 * @date 2021-05-28 5:17 PM
 */
public class EventTransitions<S,E,C> {
    private HashMap<E, List<Transition<S,E,C>>> eventTransitions;

    public EventTransitions(){
        eventTransitions = new HashMap<>();
    }

    public void put(E event, Transition<S, E, C> transition){
        if(eventTransitions.get(event) == null){
            List<Transition<S,E,C>> transitions = new ArrayList<>();
            transitions.add(transition);
            eventTransitions.put(event, transitions);
        }
        else{
            List existingTransitions = eventTransitions.get(event);
            verify(existingTransitions, transition);
            existingTransitions.add(transition);
        }
    }

    /**
     * Per one source and target state, there is only one transition is allowed
     * @param existingTransitions
     * @param newTransition
     */
    private void verify(List<Transition<S,E,C>> existingTransitions, Transition<S,E,C> newTransition) {
        for (Transition transition : existingTransitions) {
            if (transition.equals(newTransition)) {
                throw new StateMachineException(transition + " already Exist, you can not add another one");
            }
        }
    }

    public List<Transition<S,E,C>> get(E event){
        return eventTransitions.get(event);
    }

    public List<Transition<S,E,C>> allTransitions(){
        List<Transition<S,E,C>> allTransitions = new ArrayList<>();
        for(List<Transition<S,E,C>> transitions : eventTransitions.values()){
            allTransitions.addAll(transitions);
        }
        return allTransitions;
    }
}

2.1.3 Transition接口

接口定义如下：

/**
 * {@code Transition} is something what a state machine associates with a state
 * changes.
 *
 * @author Frank Zhang
 *
 * @param <S> the type of state
 * @param <E> the type of event
 * @param <C> the type of user defined context, which is used to hold application data
 *
 * @date 2020-02-07 2:20 PM
 */
public interface Transition<S, E, C>{
    /**
     * Gets the source state of this transition.
     *
     * @return the source state
     */
    State<S,E,C> getSource();

    void setSource(State<S, E, C> state);

    E getEvent();

    void setEvent(E event);

    void setType(TransitionType type);
    /**
     * Gets the target state of this transition.
     *
     * @return the target state
     */
    State<S,E,C> getTarget();

    void setTarget(State<S, E, C> state);

    /**
     * Gets the guard of this transition.
     *
     * @return the guard
     */
    Condition<C> getCondition();

    void setCondition(Condition<C> condition);

    Action<S,E,C> getAction();

    void setAction(Action<S, E, C> action);

    /**
     * Do transition from source state to target state.
     *
     * @return the target state
     */

    State<S, E, C> transit(C ctx, boolean checkCondition);
    /**
     * Verify transition correctness
     */
    void verify();
}

具体实现如下：

/**
 * TransitionImpl。
 *
 * This should be designed to be immutable, so that there is no thread-safe risk
 *
 * @author Frank Zhang
 * @date 2020-02-07 10:32 PM
 */
public class TransitionImpl<S,E,C> implements Transition<S,E,C> {

    private State<S, E, C> source;

    private State<S, E, C> target;

    private E event;

    private Condition<C> condition;

    private Action<S,E,C> action;

    private TransitionType type = TransitionType.EXTERNAL;

    @Override
    public State<S, E, C> getSource() {
        return source;
    }

    @Override
    public void setSource(State<S, E, C> state) {
        this.source = state;
    }

    @Override
    public E getEvent() {
        return this.event;
    }

    @Override
    public void setEvent(E event) {
        this.event = event;
    }

    @Override
    public void setType(TransitionType type) {
        this.type = type;
    }

    @Override
    public State<S, E, C> getTarget() {
        return this.target;
    }

    @Override
    public void setTarget(State<S, E, C> target) {
        this.target = target;
    }

    @Override
    public Condition<C> getCondition() {
        return this.condition;
    }

    @Override
    public void setCondition(Condition<C> condition) {
        this.condition = condition;
    }

    @Override
    public Action<S, E, C> getAction() {
        return this.action;
    }

    @Override
    public void setAction(Action<S, E, C> action) {
        this.action = action;
    }

    @Override
    public State<S, E, C> transit(C ctx, boolean checkCondition) {
        Debugger.debug("Do transition: "+this);
        this.verify();
        if (!checkCondition || condition == null || condition.isSatisfied(ctx)) {
            if(action != null){
                action.execute(source.getId(), target.getId(), event, ctx);
            }
            return target;
        }

        Debugger.debug("Condition is not satisfied, stay at the "+source+" state ");
        return source;
    }

    @Override
    public final String toString() {
        return source + "-[" + event.toString() +", "+type+"]->" + target;
    }

    @Override
    public boolean equals(Object anObject){
        if(anObject instanceof Transition){
            Transition other = (Transition)anObject;
            if(this.event.equals(other.getEvent())
                    && this.source.equals(other.getSource())
                    && this.target.equals(other.getTarget())){
                return true;
            }
        }
        return false;
    }

    @Override
    public void verify() {
        if(type== TransitionType.INTERNAL && source != target) {
            throw new StateMachineException(String.format("Internal transition source state '%s' " +
                    "and target state '%s' must be same.", source, target));
        }
    }
}

可以看出，Transition聚合了源State、目标State、Event、Condition、Action；

在上述方法transit中，Transition在满足条件Condition的条件下，执行了具体动作Action，并且返回目标State；

2.1.4 StateMachine接口

/**
 * StateMachine
 *
 * @author Frank Zhang
 *
 * @param <S> the type of state
 * @param <E> the type of event
 * @param <C> the user defined context
 * @date 2020-02-07 2:13 PM
 */
public interface StateMachine<S, E, C> extends Visitable{

    /**
     * Verify if an event {@code E} can be fired from current state {@code S}
     * @param sourceStateId
     * @param event
     * @return
     */
    boolean verify(S sourceStateId,E event);

    /**
     * Send an event {@code E} to the state machine.
     *
     * @param sourceState the source state
     * @param event the event to send
     * @param ctx the user defined context
     * @return the target state
     */
     S fireEvent(S sourceState, E event, C ctx);

    /**
     * MachineId is the identifier for a State Machine
     * @return
     */
    String getMachineId();

    /**
     * Use visitor pattern to display the structure of the state machine
     */
    void showStateMachine();

    String generatePlantUML();
}

状态机具体实现：

/**
 * For performance consideration,
 * The state machine is made "stateless" on purpose.
 * Once it's built, it can be shared by multi-thread
 * <p>
 * One side effect is since the state machine is stateless, we can not get current state from State Machine.
 *
 * @author Frank Zhang
 * @date 2020-02-07 5:40 PM
 */
public class StateMachineImpl<S, E, C> implements StateMachine<S, E, C> {

    private String machineId;

    private final Map<S, State<S, E, C>> stateMap;

    private boolean ready;

    private FailCallback<S, E, C> failCallback;

    public StateMachineImpl(Map<S, State<S, E, C>> stateMap) {
        this.stateMap = stateMap;
    }

    @Override
    public boolean verify(S sourceStateId, E event) {
        isReady();

        State sourceState = getState(sourceStateId);

        List<Transition<S, E, C>> transitions = sourceState.getEventTransitions(event);

        return transitions != null && transitions.size() != 0;
    }

    @Override
    public S fireEvent(S sourceStateId, E event, C ctx) {
        isReady();
        Transition<S, E, C> transition = routeTransition(sourceStateId, event, ctx);

        if (transition == null) {
            Debugger.debug("There is no Transition for " + event);
            failCallback.onFail(sourceStateId, event, ctx);
            return sourceStateId;
        }

        return transition.transit(ctx, false).getId();
    }

    private Transition<S, E, C> routeTransition(S sourceStateId, E event, C ctx) {
        State sourceState = getState(sourceStateId);

        List<Transition<S, E, C>> transitions = sourceState.getEventTransitions(event);

        if (transitions == null || transitions.size() == 0) {
            return null;
        }

        Transition<S, E, C> transit = null;
        for (Transition<S, E, C> transition : transitions) {
            if (transition.getCondition() == null) {
                transit = transition;
            } else if (transition.getCondition().isSatisfied(ctx)) {
                transit = transition;
                break;
            }
        }

        return transit;
    }

    private State getState(S currentStateId) {
        State state = StateHelper.getState(stateMap, currentStateId);
        if (state == null) {
            showStateMachine();
            throw new StateMachineException(currentStateId + " is not found, please check state machine");
        }
        return state;
    }

    private void isReady() {
        if (!ready) {
            throw new StateMachineException("State machine is not built yet, can not work");
        }
    }

    @Override
    public String accept(Visitor visitor) {
        StringBuilder sb = new StringBuilder();
        sb.append(visitor.visitOnEntry(this));
        for (State state : stateMap.values()) {
            sb.append(state.accept(visitor));
        }
        sb.append(visitor.visitOnExit(this));
        return sb.toString();
    }

    @Override
    public void showStateMachine() {
        SysOutVisitor sysOutVisitor = new SysOutVisitor();
        accept(sysOutVisitor);
    }

    @Override
    public String generatePlantUML() {
        PlantUMLVisitor plantUMLVisitor = new PlantUMLVisitor();
        return accept(plantUMLVisitor);
    }

    @Override
    public String getMachineId() {
        return machineId;
    }

    public void setMachineId(String machineId) {
        this.machineId = machineId;
    }

    public void setReady(boolean ready) {
        this.ready = ready;
    }

    public void setFailCallback(FailCallback<S, E, C> failCallback) {
        this.failCallback = failCallback;
    }
}

状态机方法fireEvent的执行逻辑如下：

  1. 通过routeTransition方法，获取目标转移Transition（只会返回一个）

  2. 执行目标转移Transition的转移方法transit，并返回目标State

在方法routeTransition中：

  1. 首先根据源State和Event获取关联的转移列表
  2. 遍历转移列表，返回命中转移条件Condition的转移

2.2 Builder模式

上述cola状态机语义模型的源码就解析完成了，在实际使用时，需要将语义模型进行组合构造编排，这里是通过Builder模式来完成的，下面进行展开说明；

2.2.1 StateMachine Builder模式

StateMachineBuilder顶层接口定义如下：

/**
 * StateMachineBuilder
 *
 * @author Frank Zhang
 * @date 2020-02-07 5:32 PM
 */
public interface StateMachineBuilder<S, E, C> {
    /**
     * Builder for one transition
     *
     * @return External transition builder
     */
    ExternalTransitionBuilder<S, E, C> externalTransition();

    /**
     * Builder for multiple transitions
     *
     * @return External transition builder
     */
    ExternalTransitionsBuilder<S, E, C> externalTransitions();

    /**
     * Start to build internal transition
     *
     * @return Internal transition builder
     */
    InternalTransitionBuilder<S, E, C> internalTransition();

    /**
     * set up fail callback, default do nothing {@code NumbFailCallbackImpl}
     *
     * @param callback
     */
    void setFailCallback(FailCallback<S, E, C> callback);

    StateMachine<S, E, C> build(String machineId);

}

具体实现如下：

/**
 * StateMachineBuilderImpl
 *
 * @author Frank Zhang
 * @date 2020-02-07 9:40 PM
 */
public class StateMachineBuilderImpl<S, E, C> implements StateMachineBuilder<S, E, C> {

    /**
     * StateMap is the same with stateMachine, as the core of state machine is holding reference to states.
     */
    private final Map<S, State<S, E, C>> stateMap = new ConcurrentHashMap<>();
    private final StateMachineImpl<S, E, C> stateMachine = new StateMachineImpl<>(stateMap);
    private FailCallback<S, E, C> failCallback = new NumbFailCallback<>();

    @Override
    public ExternalTransitionBuilder<S, E, C> externalTransition() {
        return new TransitionBuilderImpl<>(stateMap, TransitionType.EXTERNAL);
    }

    @Override
    public ExternalTransitionsBuilder<S, E, C> externalTransitions() {
        return new TransitionsBuilderImpl<>(stateMap, TransitionType.EXTERNAL);
    }

    @Override
    public InternalTransitionBuilder<S, E, C> internalTransition() {
        return new TransitionBuilderImpl<>(stateMap, TransitionType.INTERNAL);
    }

    @Override
    public void setFailCallback(FailCallback<S, E, C> callback) {
        this.failCallback = callback;
    }

    @Override
    public StateMachine<S, E, C> build(String machineId) {
        stateMachine.setMachineId(machineId);
        stateMachine.setReady(true);
        stateMachine.setFailCallback(failCallback);
        StateMachineFactory.register(stateMachine);
        return stateMachine;
    }

}

StateMachineBuilder定义中：

  • 通过build方法完成状态机实例的创建 
  • 通过externalTransition方法完成外部转移的构造
  • 通过internalTransition方法完成内部转移的构造

在build方法中，构造StateMachine实例，并注册到StateMachineFactory中 ，然后返回StateMachine实例，完成构建；

对于转移Transition的构造，下面以externalTransition返回的ExternalTransitionBuilder为例进行具体分析，内部转移同理不再展开；

2.2.2 ExternalTransitionBuilder---转移构造Builder模式

2.2.2.1 链式调用顺序保障

在上述状态机使用实例中，是通过链式编程来完成外部转移构造的，如下：

这里通过接口约束，限制了：

  1. externalTransition方法之后只能调用from方法
  2. from方法之后只能调用to方法等调用顺序
  3. ......依次类推

内部原理是：

  1. externalTransition方法返回了ExternalTransitionBuilder接口，而ExternalTransitionBuilder接口只定义了from方法，并且返回From接口
  2. From接口中又只定义了to方法，并且返回To接口
  3. ......依次类推

相关接口定义说明如下：

/**
 * ExternalTransitionBuilder
 *
 * @author Frank Zhang
 * @date 2020-02-07 6:11 PM
 */
public interface ExternalTransitionBuilder<S, E, C> {
    /**
     * Build transition source state.
     * @param stateId id of state
     * @return from clause builder
     */
    From<S, E, C> from(S stateId);

}
/**
 * From
 *
 * @author Frank Zhang
 * @date 2020-02-07 6:13 PM
 */
public interface From<S, E, C> {
    /**
     * Build transition target state and return to clause builder
     * @param stateId id of state
     * @return To clause builder
     */
    To<S, E, C> to(S stateId);

}
/**
 * To
 *
 * @author Frank Zhang
 * @date 2020-02-07 6:14 PM
 */
public interface To<S, E, C> {
    /**
     * Build transition event
     * @param event transition event
     * @return On clause builder
     */
    On<S, E, C> on(E event);
}
public interface On<S, E, C> extends When<S, E, C>{
    /**
     * Add condition for the transition
     * @param condition transition condition
     * @return When clause builder
     */
    When<S, E, C> when(Condition<C> condition);
}
public interface When<S, E, C>{
    /**
     * Define action to be performed during transition
     *
     * @param action performed action
     */
    void perform(Action<S, E, C> action);
}

 通过上述严格的顺序调用，保证了Transition构造的正确性和易读性；

2.2.2.2 链式调用具体实现

下面看一下上述链式调用相关接口的具体实现逻辑：

ExternalTransitionBuilder的具体实现类如下：

/**
 * TransitionBuilderImpl
 *
 * @author Frank Zhang
 * @date 2020-02-07 10:20 PM
 */
class TransitionBuilderImpl<S,E,C> extends AbstractTransitionBuilder<S,E,C> implements ExternalTransitionBuilder<S,E,C>, InternalTransitionBuilder<S,E,C> {


    private State<S, E, C> source;
    private Transition<S, E, C> transition;

    public TransitionBuilderImpl(Map<S, State<S, E, C>> stateMap, TransitionType transitionType) {
        super(stateMap, transitionType);
    }

    @Override
    public From<S, E, C> from(S stateId) {
        source = StateHelper.getState(stateMap, stateId);
        return this;
    }

    @Override
    public To<S, E, C> within(S stateId) {
        source = target = StateHelper.getState(stateMap, stateId);
        return this;
    }

    @Override
    public When<S, E, C> when(Condition<C> condition) {
        transition.setCondition(condition);
        return this;
    }

    @Override
    public On<S, E, C> on(E event) {
        transition = source.addTransition(event, target, transitionType);
        return this;
    }

    @Override
    public void perform(Action<S, E, C> action) {
        transition.setAction(action);
    }


}

其中AbstractTransitionBuilder抽象类具体实现如下，实现了接口From、To、On：

 abstract class AbstractTransitionBuilder<S,E,C> implements  From<S,E,C>,On<S,E,C>,To<S,E,C>{

    final Map<S, State<S, E, C>> stateMap;

    protected State<S, E, C> target;

    final TransitionType transitionType;

    public AbstractTransitionBuilder(Map<S, State<S, E, C>> stateMap, TransitionType transitionType) {
        this.stateMap = stateMap;
        this.transitionType = transitionType;
    }
    @Override
    public To<S, E, C> to(S stateId) {
        target = StateHelper.getState(stateMap, stateId);
        return this;
    }
}

 上述用到的StateHelper帮助类说明如下：

public class StateHelper {
    public static <S, E, C> State<S, E, C> getState(Map<S, State<S, E, C>> stateMap, S stateId){
        State<S, E, C> state = stateMap.get(stateId);
        if (state == null) {
            state = new StateImpl<>(stateId);
            stateMap.put(stateId, state);
        }
        return state;
    }
}

下面对链式调用执行过程具体说明如下： 

  1. from方法实现中，通过StateHelper帮助类完成源State的创建；
  2.  to方法实现中，同样通过StateHelper帮助类完成目标State的创建；
  3. on方法实现中，在源State中添加新的转移；
  4. when方法实现中，对构造的转移添加转移条件Condition；
  5. perform方法实现中，对构造的转移添加具体动作Action；

最后通过状态机build方法，完成状态机的构造并注入所有State列表；

至此，状态机实例、状态机包含的状态、状态关联的所有转移都构造完毕，后续就可以通过状态机的触发方法fireEvent完成状态转移了。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1136137.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

重生奇迹MU上武器加13有加成吗？

重生奇迹MU上武器加13有加成吗？

重生奇迹一身加13的额外属性在哪看 装备页面。在角色扮演类游戏《重生奇迹mu》中&#xff0c;玩家可以在装备页面查看一身加13的额外属性&#xff0c;该道具能为玩家提供攻击力加成&#xff0c;输出更多的伤害。 重生奇迹13绝望之仗需要多少力量 16力量。重生奇迹mu加13绝望…
阅读更多...
掌动智能APP自动化测试工具的主要功能

掌动智能APP自动化测试工具的主要功能

掌动智能APP自动化测试工具是一类用于自动执行测试脚本和验证移动应用程序的工具。它们模拟用户与应用程序的交互&#xff0c;以便检查应用程序的功能、性能和稳定性。这些工具可以用于各种移动平台&#xff0c;包括iOS和Android。本文将介绍APP自动化测试工具的主要功能有哪些…
阅读更多...
大数据-Storm流式框架（四）---storm容错机制

大数据-Storm流式框架（四）---storm容错机制

1、集群节点宕机 Nimbus服务器 硬件 单点故障&#xff1f;可以搭建HA jStorm搭建 nimbus的HA nimbus的信息存储到zookeeper中&#xff0c;只要下游没问题&#xff08;进程退出&#xff09;nimbus退出就不会有问题&#xff0c; 如果在nimbus宕机&#xff0c;也不能提交…
阅读更多...
DC-9 靶机

DC-9 靶机

DC_9 信息搜集 存活检测 详细扫描 后台网页扫描 漏洞利用 漏洞发现 在 search 页面的输入框尝试 sql 注入 1 or 11#返回大量数据 sqlmap 爆破数据库 sqlmap -u http://10.4.7.154/search.php --dbs --batch 爆破失败&#xff0c;显示未找到参数 抓包查看 爆破数据库 …
阅读更多...
iPhone手机屏幕分辨率

iPhone手机屏幕分辨率

ios app测试时&#xff0c;需要测试应用在不同型号的苹果手机上的表现形式&#xff0c;可以自己在浏览器上配置。 代数设备逻辑像素尺寸缩放发布时间第一代iPhone 2G320 x 480480 x 3203.5寸1x2007年6月29日第二代iPhone 3320 x 480480 x 3203.5寸1x2008年7月11日第三代iPhone …
阅读更多...
ThinkPHP8学习笔记

ThinkPHP8学习笔记

ThinkPHP8官方文档地址&#xff1a;ThinkPHP官方手册 一、composer换源 1、查看 composer 配置的命令composer config -g -l 2、禁用默认源镜像命令composer config -g secure-http false 3、修改为阿里云镜像源composer config -g repo.packagist composer https://mirror…
阅读更多...
JoySSL-新兴国产品牌数字证书

JoySSL-新兴国产品牌数字证书

随着我国对数据安全重视程度的不断提升&#xff0c;国产SSL证书越来越受到广大政府机关和企业的青睐&#xff0c;成为提升网站数据安全能力的重要技术手段。那么什么是国产SSL证书&#xff1f;国产SSL证书和普通SSL证书又有什么区别呢&#xff1f; 什么是国产SSL证书&#xff…
阅读更多...
封神工具：腾讯云服务器价格计算器_好工具分享

封神工具：腾讯云服务器价格计算器_好工具分享

腾讯云价格计算器&#xff1a;可以计算腾讯云服务器不同CVM实例规格、CPU内存、公网带宽和系统盘费用明细表&#xff0c;可以一键计算出精准报价明细表&#xff0c;腾讯云服务器网txyfwq.com分享大家腾讯云服务器价格计算器入口链接、使用方法及限制说明&#xff1a; 腾讯云服…
阅读更多...
优思学院：六西格玛培训中的“绿带”和“黑带”

优思学院：六西格玛培训中的“绿带”和“黑带”

在当今竞争激烈的商业世界中&#xff0c;提高效率、减少浪费是每个组织都追求的目标。为了达到这一目标&#xff0c;六西格玛管理方法为组织提供了一个卓越的工具。在六西格玛培训中&#xff0c;我们经常会听到“绿带”和“黑带”这两个术语。那么&#xff0c;究竟什么是绿带和…
阅读更多...
现代挖掘机vr在线互动展示厅是实现业务增长的加速度

现代挖掘机vr在线互动展示厅是实现业务增长的加速度

VR数字博物馆全景展示充分应用5G、VR全景、web3d开发和三维动画等技术&#xff0c;将实体博物馆整体还原到3D数字空间&#xff0c;让游客360全景漫游式参观&#xff0c;无论大小、贵重、破损的典藏展品都能通过3D建模技术&#xff0c;逼真重现到三维虚拟场景中&#xff0c;让参…
阅读更多...
VSCode汉化设置

VSCode汉化设置

扩展中搜索并安装 Chinese… 快捷键 commandshiftp&#xff0c;输入框中输入config&#xff0c;选择Config Display Language 选择zh-cn&#xff0c;重启vscode
阅读更多...
红米电脑硬盘剪切

红米电脑硬盘剪切

Redmi R14 2023版固态硬盘剪切 工具准备操作结尾语 首先要说明&#xff0c;本文所说的操作不一定适合你的电脑&#xff0c;因为电子产品更新换代过快&#xff0c;你的硬盘不一定能剪切&#xff0c;在操作前一定要仔细观察硬盘的型号&#xff0c;是否为同款&#xff0c;我上了图…
阅读更多...
HarmonyOS鸿蒙原生应用开发设计- 流转图标

HarmonyOS鸿蒙原生应用开发设计- 流转图标

HarmonyOS设计文档中&#xff0c;为大家提供了独特的流转图标&#xff0c;开发者可以根据需要直接引用。 开发者直接使用官方提供的流转图标内容&#xff0c;既可以符合HarmonyOS原生应用的开发上架运营规范&#xff0c;又可以防止使用别人的图标侵权意外情况等&#xff0c;减…
阅读更多...
TikTok文化探索：热议时事与社会话题

TikTok文化探索：热议时事与社会话题

在当今数字时代&#xff0c;社交媒体平台如TikTok已经成为了我们日常生活中不可或缺的一部分。它不仅仅是一个娱乐应用&#xff0c;也是一扇窥视世界、探讨时事和社会话题的窗户。本文将深入探讨TikTok如何成为文化探索的平台&#xff0c;热议时事和社会话题&#xff0c;以及它…
阅读更多...
LLVM学习笔记（50）

LLVM学习笔记（50）

4.1.4. DAG合并与合法化 来自SelectionDAGBuilder的SelectionDAG输出还不能进行指令选择&#xff0c;必须通过额外的转换——显示在上图。在指令选择前应用的遍序列如下&#xff1a; 匹配一组节点&#xff0c;在有利时使用更简单的构造来替换它们&#xff0c;DAG合并遍优化Se…
阅读更多...
基于NB-iot技术实现财物跟踪的EA01-SG定位模块方案

基于NB-iot技术实现财物跟踪的EA01-SG定位模块方案

NB-iot无线数传模块可做财物防盗窃器&#xff0c;让你的财物可定位跟踪&#xff01; 随着社会的发展&#xff0c;公共资源及共享资源的蓬勃发展&#xff0c;对资产管理和资产追踪有了新的需求&#xff0c;如&#xff1a;某儿童玩具车在商场外面提供车辆乘坐游玩服务&#xff0…
阅读更多...
一、python基础语法

一、python基础语法

文章目录 1.Python介绍1&#xff09;发明者龟叔2&#xff09;python特点3&#xff09;python缺点4&#xff09;Python版本 2.Python解释器1&#xff09;编译型和解释型2&#xff09;常见的python解释器3&#xff09;下载Python解释器4&#xff09;安装Python解释器5&#xff09…
阅读更多...
​软件测试知多少：Postman​接口自动化测试

​软件测试知多少：Postman​接口自动化测试

Postman除了前面介绍的一些功能&#xff0c;还有其他一些小功能在日常接口测试或许用得上。今天&#xff0c;我们就来盘点一下&#xff0c;如下所示&#xff1a; 一、数据驱动 想要批量执行接口用例&#xff0c;我们一般会将对应的接口用例放在同一个Collection中&#xff0c…
阅读更多...
11.初始JavaScript[初步了解何为js]

11.初始JavaScript[初步了解何为js]

文章目录 1.初识 JavaScript1.1JavaScript 是什么1.2发展历史1.3JavaScript 和 HTML 和 CSS 之间的关系1.4JavaScript 运行过程1.5JavaScript 的组成 2.前置知识2.1第一个程序2.2JavaScript 的书写形式2.2.1行内式2.2.2内嵌式2.2.3外部式 2.3注释2.4输入输出2.4.1输入: prompt2…
阅读更多...
WSL重装Anaconda

WSL重装Anaconda

第一次安装使用的是官网下载的文件&#xff0c;存放在Windows中进行安装的&#xff0c;结果安装后有一些小错误&#xff0c;现在想重新安装过。 一、卸载原Anaconda 首先要知道Anaconda的安装地址&#xff0c;默认地址为&#xff1a;C:\Users\用户名\AppData\Local\Packages\…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023