生命周期元件架構：生命周期描述語言——關系與讀寫鎖執行過程示例

@StateMachine
    static interface InformativeStateMachine {

        @StateSet
        static interface States {

            @Initial
            @Functions({ @Function(transition = Transitions.LogicalDelete.class, value = Recycled.class),
                    @Function(transition = Transitions.Confirm.class, value = Confirmed.class) })
            static interface Draft {}
            @Function(transition = Transitions.Finish.class, value = Finished.class)
            static interface Confirmed {}
            @End
            static interface Finished {}
            @Functions({ @Function(transition = Transitions.PutBack.class, value = Draft.class),
                    @Function(transition = Transitions.PhysicalDelete.class, value = Vanished.class) })
            static interface Recycled {}
            @End
            static interface Vanished {}
        }
        @TransitionSet
        static interface Transitions {

            static interface Confirm {}
            static interface LogicalDelete {}
            static interface PutBack {}
            static interface PhysicalDelete {}
            static interface File {}
            static interface Finish {}
        }
    }
    @StateMachine
    static interface CustomerStateMachine extends InformativeStateMachine {

        @StateSet
        static interface States extends InformativeStateMachine.States {

            @CompositeState
            @LifecycleOverride
            static interface Confirmed extends InformativeStateMachine.States.Confirmed {

                @StateSet
                static interface ConfirmedStates {

                    @Initial
                    @Functions({ @Function(transition = Transitions.Suspend.class, value = ServiceSuspended.class),
                            @Function(transition = Transitions.TerminateService.class, value = ServiceExpired.class),
                            @Function(transition = Transitions.Cancel.class, value = Canceled.class) })
                    static interface InService {}
                    @Function(transition = Transitions.Resume.class, value = InService.class)
                    static interface ServiceSuspended {}
                    @Functions({ @Function(transition = Transitions.Renew.class, value = InService.class),
                            @Function(transition = Transitions.Disconnect.class, value = Disconnected.class),
                            @Function(transition = Transitions.Abandon.class, value = Abandoned.class) })
                    static interface ServiceExpired {}
                    @Functions({ @Function(transition = Transitions.Abandon.class, value = Abandoned.class),
                            @Function(transition = Transitions.Disconnect.class, value = Disconnected.class) })
                    static interface Canceled {}
                    @End
                    @ShortCut(InformativeStateMachine.States.Finished.class)
                    static interface Disconnected {}
                    @End
                    @ShortCut(InformativeStateMachine.States.Recycled.class)
                    static interface Abandoned {}
                }
                @TransitionSet
                static interface Transitions {

                    static interface Abandon {}
                    static interface Suspend {}
                    static interface Resume {}
                    static interface Renew {}
                    static interface Cancel {}
                    static interface TerminateService {}
                    static interface Disconnect {}
                }
            }
        }
    }
    @StateMachine
    static interface ContractStateMachine extends InformativeStateMachine {

        @StateSet
        static interface States extends InformativeStateMachine.States {

            @CompositeState
            @LifecycleOverride
            static interface Confirmed extends InformativeStateMachine.States.Confirmed {

                @StateSet
                static interface ConfirmedStates {

                    @Initial
                    @Functions({ @Function(transition = Transitions.StartService.class, value = ServiceStarted.class),
                            @Function(transition = Transitions.TerminateService.class, value = Terminated.class) })
                    @InboundWhile(on = { InformativeStateMachine.States.Draft.class, CustomerStateMachine.States.Confirmed.ConfirmedStates.InService.class },
                            relation = Relations.Customer.class)
                    @ValidWhile(on = { CustomerStateMachine.States.Confirmed.ConfirmedStates.InService.class }, relation = Relations.Customer.class)
                    static interface Effective {}
                    @Function(transition = Transitions.AbortService.class, value = ServiceAborted.class)
                    @ValidWhile(on = { CustomerStateMachine.States.Confirmed.ConfirmedStates.InService.class }, relation = Relations.Customer.class)
                    @InboundWhile(on = { CustomerStateMachine.States.Confirmed.ConfirmedStates.InService.class }, relation = Relations.Customer.class)
                    static interface ServiceStarted {}
                    @Function(transition = Transitions.Invalidate.class, value = Uneffective.class)
                    @InboundWhile(on = { CustomerStateMachine.States.Confirmed.ConfirmedStates.InService.class }, relation = Relations.Customer.class)
                    static interface ServiceAborted {}
                    @End
                    @ShortCut(InformativeStateMachine.States.Finished.class)
                    static interface Terminated {}
                    @End
                    @ShortCut(InformativeStateMachine.States.Draft.class)
                    static interface Uneffective {}
                }
                @TransitionSet
                static interface Transitions {

                    static interface Invalidate {}
                    static interface StartService {}
                    static interface AbortService {}
                    static interface TerminateService {}
                }
                @RelationSet
                static interface Relations {

                    @Parent
                    @RelateTo(CustomerStateMachine.class)
                    static interface Customer {}
                }
            }
        }
    }
    @StateMachine
    static interface OrderStateMachine extends InformativeStateMachine {

        @StateSet
        static interface States extends InformativeStateMachine.States {

            @CompositeState
            @LifecycleOverride
            static interface Confirmed extends InformativeStateMachine.States.Confirmed {

                @StateSet
                static interface ConfirmedStates {

                    @Initial
                    @InboundWhile(on = { ContractStateMachine.States.Confirmed.ConfirmedStates.ServiceStarted.class }, relation = Relations.Contract.class)
                    @ValidWhile(on = { ContractStateMachine.States.Confirmed.ConfirmedStates.ServiceStarted.class }, relation = Relations.Contract.class)
                    @Functions({ @Function(transition = Transitions.StartProduce.class, value = Manufactoring.class),
                            @Function(transition = Transitions.Dequeue.class, value = Dequeued.class) })
                    static interface Queued {}
                    @InboundWhiles({
                            @InboundWhile(on = { ContractStateMachine.States.Confirmed.ConfirmedStates.ServiceStarted.class },
                                    relation = Relations.Contract.class),
                            @InboundWhile(on = { ResourceStateMachine.States.OfficialRunning.RunningStates.Idle.class }, relation = Relations.Resource.class) })
                    @ValidWhiles({ @ValidWhile(on = { ContractStateMachine.States.Confirmed.ConfirmedStates.ServiceStarted.class },
                            relation = Relations.Contract.class) })
                    @Function(transition = Transitions.StartPackage.class, value = Packaging.class)
                    static interface Manufactoring {}
                    @InboundWhile(on = { ContractStateMachine.States.Confirmed.ConfirmedStates.ServiceStarted.class }, relation = Relations.Contract.class)
                    @ValidWhile(on = { ContractStateMachine.States.Confirmed.ConfirmedStates.ServiceStarted.class }, relation = Relations.Contract.class)
                    @Function(transition = Transitions.Deliver.class, value = { Delivering.class })
                    static interface Packaging {}
                    @InboundWhile(on = { ContractStateMachine.States.Confirmed.ConfirmedStates.ServiceStarted.class }, relation = Relations.Contract.class)
                    @ValidWhile(on = { ContractStateMachine.States.Confirmed.ConfirmedStates.ServiceStarted.class }, relation = Relations.Contract.class)
                    @Function(transition = Transitions.Complete.class, value = Completed.class)
                    static interface Delivering {}
                    @End
                    @ShortCut(InformativeStateMachine.States.Finished.class)
                    static interface Completed {}
                    @End
                    @ShortCut(InformativeStateMachine.States.Draft.class)
                    static interface Dequeued {}
                }
                @TransitionSet
                static interface Transitions {

                    static interface Deliver {}
                    static interface Dequeue {}
                    static interface StartProduce {}
                    static interface StartPackage {}
                    static interface Complete {}
                }
                @RelationSet
                static interface Relations {

                    @Parent
                    @RelateTo(ContractStateMachine.class)
                    static interface Contract {}
                    @RelateTo(ResourceStateMachine.class)
                    static interface Resource {}
                }
            }
        }
    }
    @StateMachine
    static interface ResourceStateMachine {

        @StateSet
        static interface States {

            @Initial
            @Function(transition = Transitions.Test.class, value = TestRunning.class)
            static interface New {}
            @Functions({ @Function(transition = Transitions.GoLive.class, value = OfficialRunning.class),
                    @Function(transition = Transitions.ConfirmMalfunction.class, value = Malfunctioning.class) })
            static interface TestRunning {}
            @Functions({ @Function(transition = Transitions.Repair.class, value = Repairing.class),
                    @Function(transition = Transitions.Deprecate.class, value = Deprecated.class) })
            static interface Malfunctioning {}
            @Function(transition = Transitions.ConfirmMalfunction.class, value = Malfunctioning.class)
            @CompositeState
            static interface OfficialRunning {

                @StateSet
                static interface RunningStates {

                    @Initial
                    @Function(transition = RunningTransitions.Acquire.class, value = Busy.class)
                    static interface Idle {}
                    @Functions({ @Function(transition = RunningTransitions.Fail.class, value = Failing.class),
                            @Function(transition = RunningTransitions.Release.class, value = Idle.class) })
                    static interface Busy {}
                    @End
                    @ShortCut(Malfunctioning.class)
                    static interface Failing {}
                }
                @TransitionSet
                static interface RunningTransitions {

                    static interface Acquire {}
                    static interface Release {}
                    static interface Fail {}
                }
            }
            @Function(transition = Transitions.Test.class, value = TestRunning.class)
            static interface Repairing {}
            @End
            static interface Deprecated {}
        }
        @TransitionSet
        static interface Transitions {

            static interface Test {}
            static interface ConfirmMalfunction {}
            static interface Repair {}
            static interface GoLive {}
            static interface Deprecate {}
        }
    }
    @LifecycleMeta(InformativeStateMachine.class)
    @LifecycleLock(SimpleLock.class)
    static class InformativeObject extends ReactiveObject {

        public InformativeObject() {
            initialState(InformativeStateMachine.States.Draft.class.getSimpleName());
        }

        @Transition
        public void confirm() {}

        @Transition
        public void logicalDelete() {}

        @Transition
        public void putBack() {}

        @Transition
        public void physicalDelete() {}

        @Transition
        public void file() {}

        @Transition
        public void finish() {}
    }
    @LifecycleMeta(CustomerStateMachine.class)
    @LifecycleLock(SimpleLock.class)
    static class CustomerObject extends InformativeObject {

        @Transition
        public void abandon() {}

        @Transition
        public void suspend() {}

        @Transition
        public void resume() {}

        @Transition
        public void renew() {}

        @Transition
        public void cancel() {}

        @Transition
        public void terminateService() {}

        @Transition
        public void disconnect() {}
    }
    @LifecycleMeta(ContractStateMachine.class)
    @LifecycleLock(SimpleLock.class)
    static class ContractObject extends InformativeObject {

        @Relation(ContractStateMachine.States.Confirmed.Relations.Customer.class)
        private CustomerObject customer;

        public ContractObject(final CustomerObject customer) {
            super();
            this.customer = customer;
        }

        @Transition
        public void invalidate() {}

        @Transition
        public void startService() {}

        @Transition
        public void abortService() {}

        @Transition
        public void terminateService() {}
    }
    @LifecycleMeta(OrderStateMachine.class)
    @LifecycleLock(SimpleLock.class)
    static class OrderObject extends InformativeObject {

        @Relation
        private ContractObject contract;

        public OrderObject(ContractObject contract) {
            this.contract = contract;
        }

        @Transition
        public void deliver() {}

        @Transition
        public void dequeue() {}

        @Transition
        public void startProduce(@Relation(OrderStateMachine.States.Confirmed.Relations.Resource.class) ResourceObject resource) {}

        @Transition
        public void startPackage() {}

        @Transition
        public void complete() {}
    }
    @LifecycleMeta(ResourceStateMachine.class)
    @LifecycleLock(SimpleLock.class)
    static class ResourceObject extends ReactiveObject {

        public ResourceObject() {
            initialState(ResourceStateMachine.States.New.class.getName());
        }

        @Transition
        public void test() {}

        @Transition
        public void confirmMalfunction() {}

        @Transition
        public void repair() {}

        @Transition
        public void goLive() {}

        @Transition
        public void deprecate() {}

        @Transition
        public void acquire() {}

        @Transition
        public void release() {}

        @Transition
        public void fail() {}
    }
           

@Test
    public void test_relational_locking() {
        final CustomerObject customer = new CustomerObject();
        final ContractObject contract = new ContractObject(customer);
        final OrderObject order = new OrderObject(contract);
        final ResourceObject resource = new ResourceObject();
        customer.confirm();
        contract.confirm();
        contract.startService();
        order.confirm();
        resource.test();
        resource.goLive();
        order.startProduce(resource);
        order.startPackage();
        order.deliver();
        order.complete();
        assertState(OrderStateMachine.States.Finished.class, order);
    }
           

帶有關系限制的狀态機引擎執行過程中讀寫鎖的使用日志

前文：生命周期元件架構：關系型狀态機服務