import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
public StateMachine<States, Events> buildMachine() throws Exception {
	StateMachineBuilder.Builder<States, Events> builder = StateMachineBuilder.builder();

	builder.configureStates()
			.withStates()
			.initial(States.STATE1)
			.states(EnumSet.allOf(States.class));

	builder.configureTransitions()
			.withExternal()
			.source(States.STATE1).target(States.STATE2)
			.event(Events.EVENT1)
			.and()
			.withExternal()
			.source(States.STATE2).target(States.STATE1)
			.event(Events.EVENT2);

	return builder.build();
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
public StateMachine<States, Events> buildMachineNoTransition() throws Exception {
    StateMachineBuilder.Builder<States, Events> builder = StateMachineBuilder.builder();

    builder.configureConfiguration()
           .withConfiguration()
           .taskExecutor(new SyncTaskExecutor())
    ;

    builder.configureStates()
           .withStates()
           .initial(States.SI)
           .state(States.S1)
           .states(EnumSet.allOf(States.class))
    ;


    return builder.build();
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
public StateMachine<States, Events> buildMachineOnlyNormalStates() throws Exception {
    StateMachineBuilder.Builder<States, Events> builder = StateMachineBuilder.builder();

    builder.configureConfiguration()
           .withConfiguration()
           .taskExecutor(new SyncTaskExecutor())
    ;

    builder.configureStates()
           .withStates()
           .states(EnumSet.allOf(States.class))
    ;


    return builder.build();
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
@Test
public void testFactory() {
	StateMachineFactory<SkipperStates, SkipperEvents> factory = context.getBean(StateMachineFactory.class);
	assertThat(factory).isNotNull();
	StateMachine<SkipperStates, SkipperEvents> stateMachine = factory.getStateMachine("testFactory");
	assertThat(stateMachine).isNotNull();
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
@Test
public void testSimpleInstallShouldNotError() throws Exception {
	Mockito.when(packageService.downloadPackage(any()))
			.thenReturn(new org.springframework.cloud.skipper.domain.Package());
	Mockito.when(releaseService.install(any(), any())).thenReturn(new Release());

	Message<SkipperEvents> message = MessageBuilder
		.withPayload(SkipperEvents.INSTALL)
		.setHeader(SkipperEventHeaders.PACKAGE_METADATA, new PackageMetadata())
		.setHeader(SkipperEventHeaders.INSTALL_PROPERTIES, new InstallProperties())
		.setHeader(SkipperEventHeaders.VERSION, 1)
		.build();

	StateMachineFactory<SkipperStates, SkipperEvents> factory = context.getBean(StateMachineFactory.class);
	StateMachine<SkipperStates, SkipperEvents> stateMachine = factory.getStateMachine("testInstall");

	StateMachineTestPlan<SkipperStates, SkipperEvents> plan =
			StateMachineTestPlanBuilder.<SkipperStates, SkipperEvents>builder()
				.defaultAwaitTime(10)
				.stateMachine(stateMachine)
				.step()
					.expectStateMachineStarted(1)
					.expectStates(SkipperStates.INITIAL)
					.and()
				.step()
					.sendEvent(message)
					.expectStates(SkipperStates.INITIAL)
					.expectStateChanged(3)
					.expectStateEntered(SkipperStates.INSTALL,
							SkipperStates.INSTALL_INSTALL,
							SkipperStates.INITIAL)
					.and()
				.build();
	plan.test();

	Mockito.verify(errorAction, never()).execute(any());
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
@Test
public void testSimpleUpgradeShouldNotError() throws Exception {
	Mockito.when(releaseReportService.createReport(any())).thenReturn(new ReleaseAnalysisReport(new ArrayList<>(),
			new ReleaseDifference(), new Release(), new Release()));
	Mockito.when(upgradeStrategy.checkStatus(any()))
			.thenReturn(true);

	UpgradeRequest upgradeRequest = new UpgradeRequest();

	Message<SkipperEvents> message1 = MessageBuilder
			.withPayload(SkipperEvents.UPGRADE)
			.setHeader(SkipperEventHeaders.UPGRADE_REQUEST, upgradeRequest)
			.build();

	StateMachineFactory<SkipperStates, SkipperEvents> factory = context.getBean(StateMachineFactory.class);
	StateMachine<SkipperStates, SkipperEvents> stateMachine = factory.getStateMachine("testSimpleUpgradeShouldNotError");

	StateMachineTestPlan<SkipperStates, SkipperEvents> plan =
			StateMachineTestPlanBuilder.<SkipperStates, SkipperEvents>builder()
				.defaultAwaitTime(10)
				.stateMachine(stateMachine)
				.step()
					.expectStateMachineStarted(1)
					.expectStates(SkipperStates.INITIAL)
					.and()
				.step()
					.sendEvent(message1)
					.expectStates(SkipperStates.INITIAL)
					.expectStateChanged(9)
					.and()
				.build();
	plan.test();
	Mockito.verify(upgradeCancelAction, never()).execute(any());
	Mockito.verify(errorAction, never()).execute(any());
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
private void processSubMachine(Element aXml, StateMachine<S, E> aStateMachine) {
    Collection<State<S, E>> lStates = aStateMachine.getStates();
    if (aStateMachine.getInitialState() != null) {
        aXml.setAttribute("initial", aStateMachine.getInitialState().getId().toString());
    }

    processStates(aXml, lStates);
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
private void processMachine(IMdtUml2Model.IMUStateMachine aSM, StateMachine<S, E> aStateMachine, State<S, E> aSsmParent) {
    IMdtUml2Model.IMURegionState lRootRegion = aSM.addRegion(
            new UuidId(aStateMachine.getUuid()),
            aSsmParent == null ? "root" : aSsmParent.getId() + "r0"
    );
    processRegion(lRootRegion, aStateMachine, aStateMachine.getInitialState());
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
public SsmDumper(StateMachine<S, E> aStateMachine) {
    this(aStateMachine, new ChainedNamingStrategy(new INamingStrategy[]{
                 new GetFromMethodNamingStrategy("getName"),
                 new SimpleClassNameNamingStrategy(),
                 new GuessFromEnclosingMethodNamingStrategy(),
                 new ToStringNamingStrategy()
         }),
         new ChainedNamingStrategy(new INamingStrategy[]{
                 new GetFromMethodNamingStrategy("getName"),
                 new SimpleClassNameNamingStrategy(),
                 new GuessFromEnclosingMethodNamingStrategy(),
                 new ToStringNamingStrategy()
         })
    );
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
public StateMachine<States, Events> buildMachine() throws Exception {
    StateMachineBuilder.Builder<States, Events> builder = StateMachineBuilder.builder();

    builder.configureConfiguration()
           .withConfiguration()
           .taskExecutor(new SyncTaskExecutor())
    ;

    builder.configureStates()
           .withStates()
           .initial(States.SI)
           .state(States.S1, new Action<States, Events>() {
               @Override
               public void execute(StateContext<States, Events> context) {
                   System.out.print("test");
               }
           }, null)
           .states(EnumSet.allOf(States.class))
    ;

    builder.configureTransitions()
           .withExternal()
           .source(States.SI).target(States.S1)
           .event(Events.E1)
           .and()
           .withLocal()
           .source(States.S2).target(States.S3)
           .event(Events.E1)
           .and()
           .withExternal()
           .source(States.S2).target(States.SE)
           .event(Events.E2)
           .and()
           .withExternal()
           .source(States.S1).target(States.SE)
           .event(Events.E2);

    return builder.build();
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
public StateMachine<String, String> buildUmlMachine(String aPath) throws Exception {
    StateMachineBuilder.Builder<String, String> builder = StateMachineBuilder.builder();

    builder.configureModel().withModel().factory(new UmlStateMachineModelFactory(
            aPath
    ));
    builder.configureConfiguration()
           .withConfiguration()
           .taskExecutor(new SyncTaskExecutor())
    ;
    return builder.build();
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
static <S extends Enum<S>, E extends Enum<E>> StateMachine<S, E> build(EnumStateMachineConfigurerAdapter<S, E> aClass) throws Exception {
    StateMachineBuilder.Builder<S, E> builder = StateMachineBuilder.builder();
    aClass.configure(builder.configureConfiguration());
    aClass.configure(builder.configureModel());
    aClass.configure(builder.configureStates());
    aClass.configure(builder.configureTransitions());
    return builder.build();
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
@Test
public void dumpAll() throws Exception {

    StateMachine<AllStates.States, AllStates.Events> lSM = (new AllStates()).buildMachine();
    SsmMdtUml2Dumper<AllStates.States, AllStates.Events> sut = new SsmMdtUml2Dumper<>(
            lSM
    );

    sut.dump();
    System.out.println(sut.asString());
    sut.save(new File(getBuildPath() + "/test_model_all"));
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
@Test
public void dumpChoice() throws Exception {
    StateMachine<ChoiceJunctionSSM.ConfigChoice.States, ChoiceJunctionSSM.ConfigChoice.Events> lSM = build(
            new ChoiceJunctionSSM.ConfigChoice());
    SsmMdtUml2Dumper<ChoiceJunctionSSM.ConfigChoice.States, ChoiceJunctionSSM.ConfigChoice.Events> sut = new SsmMdtUml2Dumper<>(
            lSM);

    sut.dump();
    System.out.println(sut.asString());
    sut.save(new File(getBuildPath() + "/test_model_choice"));
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
@Test
public void dumpForkJoin() throws Exception {
    StateMachine<JoinSM.Config14.States2, JoinSM.Config14.Events>     lSM = build(new JoinSM.Config14());
    SsmMdtUml2Dumper<JoinSM.Config14.States2, JoinSM.Config14.Events> sut = new SsmMdtUml2Dumper<>(lSM);

    sut.dump();
    System.out.println(sut.asString());
    sut.save(new File(getBuildPath() + "/test_model_forkjoin"));
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
@Test
public void dumpJoin() throws Exception {
    StateMachine<JoinSM.Config15.States2, JoinSM.Config15.Events>     lSM = build(new JoinSM.Config15());
    SsmMdtUml2Dumper<JoinSM.Config15.States2, JoinSM.Config15.Events> sut = new SsmMdtUml2Dumper<>(lSM);

    sut.dump();
    System.out.println(sut.asString());
    sut.save(new File(getBuildPath() + "/test_model_join"));
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
@Test
public void dumpJunction() throws Exception {
    StateMachine<ChoiceJunctionSSM.ConfigJunction.States, ChoiceJunctionSSM.ConfigJunction.Events> lSM = build(
            new ChoiceJunctionSSM.ConfigJunction());
    SsmMdtUml2Dumper<ChoiceJunctionSSM.ConfigJunction.States, ChoiceJunctionSSM.ConfigJunction.Events> sut = new SsmMdtUml2Dumper<>(
            lSM);

    sut.dump();
    System.out.println(sut.asString());
    sut.save(new File(getBuildPath() + "/test_model_junction"));
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
@Override
public void stateMachineStopped(StateMachine<S, E> stateMachine) {
    if (!stateMachine.isComplete()) {
        State<S, E> currentState = stateMachine.getState();
        Long currentTime = System.currentTimeMillis();
        String fromId = currentState != null ? currentState.getId().toString() : "unknown";
        FlowDetails flowDetails = new FlowDetails("", flowType, "", flowId, fromId, "unknown", "FLOW_CANCEL",
                lastStateChange == -1L ? -1L : currentTime - lastStateChange);
        StructuredEvent structuredEvent = structuredFlowEventFactory.createStucturedFlowEvent(stackId, flowDetails, true);
        structuredEventClient.sendStructuredEvent(structuredEvent);
        lastStateChange = currentTime;
    }
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
public FlowAdapter(String flowId, StateMachine<S, E> flowMachine, MessageFactory<E> messageFactory, StateConverter<S> stateConverter,
        EventConverter<E> eventConverter, Class<? extends FlowConfiguration> flowConfigClass, FlowStructuredEventHandler flowStructuredEventHandler) {
    this.flowId = flowId;
    this.flowMachine = flowMachine;
    this.messageFactory = messageFactory;
    this.stateConverter = stateConverter;
    this.eventConverter = eventConverter;
    this.flowConfigClass = flowConfigClass;
    this.flowStructuredEventHandler = flowStructuredEventHandler;
}
 

import org.springframework.statemachine.StateMachine; //导入依赖的package包/类
private void generate() throws Exception {
    StringBuilder builder = new StringBuilder("digraph {\n");
    inject(flowConfiguration, "applicationContext", APP_CONTEXT);
    Flow flow = initializeFlow();
    StateMachine<FlowState, FlowEvent> stateMachine = getStateMachine(flow);
    FlowState init = stateMachine.getInitialState().getId();
    builder.append(generateStartPoint(init, flowConfiguration.getClass().getSimpleName())).append('\n');
    List<Transition<FlowState, FlowEvent>> transitions = (List<Transition<FlowState, FlowEvent>>) stateMachine.getTransitions();
    Map<String, FlowState> transitionsAlreadyDefined = new HashMap<>();
    transitionsAlreadyDefined.put(init.toString(), init);
    while (!transitions.isEmpty()) {
        for (Transition<FlowState, FlowEvent> transition : new ArrayList<>(transitions)) {
            FlowState source = transition.getSource().getId();
            FlowState target = transition.getTarget().getId();
            if (transitionsAlreadyDefined.values().contains(source)) {
                String id = generateTransitionId(source, target, transition.getTrigger().getEvent());
                if (!transitionsAlreadyDefined.keySet().contains(id)) {
                    if (target.action() != null && !transitionsAlreadyDefined.values().contains(target)) {
                        builder.append(generateState(target, target.action().getSimpleName())).append('\n');
                    }
                    builder.append(generateTransition(source, target, transition.getTrigger().getEvent())).append('\n');
                    transitionsAlreadyDefined.put(id, target);
                }
                transitions.remove(transition);
            }
        }
    }
    saveToFile(builder.append('}').toString());
}