Java StateMachine类代码示例

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"));
}