关系生命周期
@StateMachine
static interface ContractLifecycle {
@StateSet
static interface States {
@Initial
@Functions({ @Function(transition = ContractLifecycle.Transitions.Activate.class, value = Active.class),
@Function(transition = ContractLifecycle.Transitions.Cancel.class, value = Canceled.class) })
static interface Draft {}
@Functions({ @Function(transition = ContractLifecycle.Transitions.Expire.class, value = Expired.class),
@Function(transition = ContractLifecycle.Transitions.Cancel.class, value = Canceled.class) })
static interface Active {}
@End
static interface Expired {}
@End
static interface Canceled {}
}
@TransitionSet
static interface Transitions {
static interface Activate {}
static interface Expire {}
static interface Cancel {}
}
}
@LifecycleMeta(ContractLifecycle.class)
public static class Contract extends ReactiveObject {
public Contract() {
initialState(ContractLifecycle.States.Draft.class.getSimpleName());
}
@Transition
public void activate() {}
@Transition
public void expire() {}
@Transition
public void cancel() {}
}
// ///////////////////////////////////////////////////////////////////////////////
// Relational Case 1.
// ///////////////////////////////////////////////////////////////////////////////
@StateMachine
static interface RelationalOrderLifecycleSharingValidWhile {
@StateSet
static interface States {
@Initial
@Function(transition = Transitions.Start.class, value = Started.class)
@ValidWhile(on = { ContractLifecycle.States.Active.class }, relation = Relations.Contract.class)
static interface Created {}
@CompositeState
@Function(transition = Transitions.Cancel.class, value = Canceled.class)
static interface Started {
@StateSet
static interface SubStates {
@Initial
@Function(transition = RelationalOrderLifecycleSharingValidWhile.States.Started.SubTransitions.DoProduce.class, value = Producing.class)
@ValidWhile(on = { ContractLifecycle.States.Active.class }, relation = RelationalOrderLifecycleSharingValidWhile.Relations.Contract.class)
static interface OrderCreated {}
@Function(transition = RelationalOrderLifecycleSharingValidWhile.States.Started.SubTransitions.DoDeliver.class, value = Delivering.class)
@ValidWhile(on = { ContractLifecycle.States.Active.class }, relation = RelationalOrderLifecycleSharingValidWhile.Relations.Contract.class)
static interface Producing {}
@Function(transition = RelationalOrderLifecycleSharingValidWhile.States.Started.SubTransitions.ConfirmComplete.class, value = Done.class)
@ValidWhile(on = { ContractLifecycle.States.Active.class }, relation = RelationalOrderLifecycleSharingValidWhile.Relations.Contract.class)
static interface Delivering {}
@End
@ShortCut(RelationalOrderLifecycleSharingValidWhile.States.Finished.class)
// Ignoring : @ValidWhile(on = {
// ContractLifecycle.States.Active.class }, relation =
// Relations.Contract.class)
static interface Done {}
}
@TransitionSet
static interface SubTransitions {
static interface DoProduce {}
static interface DoDeliver {}
static interface ConfirmComplete {}
}
}
@End
static interface Finished {}
@End
static interface Canceled {}
}
@TransitionSet
static interface Transitions {
static interface Start {}
static interface Cancel {}
}
@RelationSet
static interface Relations {
@RelateTo(ContractLifecycle.class)
static interface Contract {}
}
}
@LifecycleMeta(RelationalOrderLifecycleSharingValidWhile.class)
public static class ProductOrderSharingValidWhile extends ProductBase {
private Contract contract;
public ProductOrderSharingValidWhile(Contract contract) {
this.contract = contract;
initialState(RelationalOrderLifecycleSharingValidWhile.States.Created.class.getSimpleName());
}
@Relation(RelationalOrderLifecycleSharingValidWhile.Relations.Contract.class)
public Contract getContract() {
return this.contract;
}
@Transition
public void start() {}
@Transition
public void cancel() {}
@Transition
public void doProduce() {}
@Transition
public void doDeliver() {}
@Transition
public void confirmComplete() {}
}
@Test
public void test_relational_composite_state_machine_sharing_with_composite_state() {
final Contract contract = new Contract();
// Outer Initial State
assertState(ContractLifecycle.States.Draft.class, contract);
contract.activate();
assertState(ContractLifecycle.States.Active.class, contract);
final ProductOrderSharingValidWhile product = new ProductOrderSharingValidWhile(contract);
// Outer State + Outer Transition => Composite State => Composite
// Initial State
{
// Outer Initial State
assertState(RelationalOrderLifecycleSharingValidWhile.States.Created.class, product);
// Outer Transition
product.start();
assertState(RelationalOrderLifecycleSharingValidWhile.States.Started.SubStates.OrderCreated.class, product);
}
{
// Composite State + Composite Transition => Composite State
product.doProduce();
assertState(RelationalOrderLifecycleSharingValidWhile.States.Started.SubStates.Producing.class, product);
product.doDeliver();
assertState(RelationalOrderLifecycleSharingValidWhile.States.Started.SubStates.Delivering.class, product);
}
{
// Composite State + Composite Transition => Composite Final State
// => Outer State
product.confirmComplete();
assertState(RelationalOrderLifecycleSharingValidWhile.States.Finished.class, product);
}
}
@Test(expected = LifecycleException.class)
public void test_relational_standalone_composite_invalid_state_sharing_from_owning_valid_while() {
final Contract contract = new Contract();
assertState(ContractLifecycle.States.Draft.class, contract);
final ProductOrderSharingValidWhile order = new ProductOrderSharingValidWhile(contract);
try {
order.start();
} catch (LifecycleException e) {
assertInvalidStateErrorByValidWhile(e, contract, order, ContractLifecycle.States.Active.class);
}
contract.activate();
assertState(ContractLifecycle.States.Active.class, contract);
order.start();
assertState(RelationalOrderLifecycleSharingValidWhile.States.Started.SubStates.OrderCreated.class, order);
contract.cancel();
assertState(ContractLifecycle.States.Canceled.class, contract);
try {
order.doProduce();
} catch (LifecycleException e) {
assertInvalidStateErrorByValidWhile(e, contract, order, ContractLifecycle.States.Active.class);
throw e;
}
}
相关推荐
标题中的“生命周期组件框架——关系型状态机服务”暗示了我们即将探讨的是一个与软件开发相关的框架，特别关注的是对象或组件在其存在期间的行为管理。生命周期管理是编程中一个重要的概念，它涉及到对象从创建、...
在IT领域，有限状态机（Finite State Machine, FSM）是一种重要的设计模式，它在软件工程、计算机科学以及许多其他领域都有广泛的应用。本主题“一个有趣的有限状态机的JAVA实现”将带你探索如何利用Java语言构建一...
5. **状态图（State Diagrams）**：状态图用于表示一个对象在其生命周期内可能经历的各种状态以及引起状态转移的事件。 6. **活动图（Activity Diagrams）**：活动图类似于流程图，用于表示系统中的业务流程或算法...
《软件开发生命周期与统一建模语言UML》是一门深度探讨软件开发过程及建模技术的课程，主要聚焦在如何有效地管理和设计复杂的软件项目。软件开发生命周期（Software Development Life Cycle, SDLC）是软件工程中的...
4. **状态图（State Diagrams）**：状态图描述了对象在其生命周期内可能经历的各种状态以及状态之间的转换。通过js uml2，可以直观地描绘出对象的行为模式。 5. **活动图（Activity Diagrams）**：活动图类似于流程...
《软件开发生命周期与统一建模语言UML》是一份重要的教育资源，主要涵盖了软件工程中的核心概念和技术。软件开发生命周期（SDLC）是指导软件项目从概念化到最终产品交付的一系列阶段，包括需求分析、设计、实现、...
《软件开发生命周期与统一建模语言UML》是一门深入探讨软件工程核心概念的课程，由专家曹静主讲。这门课程的核心是理解软件开发的完整过程以及如何使用UML（统一建模语言）进行有效的系统设计和沟通。 软件开发生命...
状态图（State Diagram）描述对象在其生命周期内的行为变化；活动图（Activity Diagram）用于展现流程和决策；组件图（Component Diagram）和部署图（Deployment Diagram）则关注系统的物理结构。 3. **UML符号和...
### UML类图关系详解 #### 一、引言 UML（Unified Modeling Language，统一建模语言）是一种广泛应用于软件工程领域的图形化语言，它帮助开发者理解和设计系统。其中，UML类图是最常用的一种图示方式，用于描述系统...
状态图是UML中的一种图形化表示方法，用于描述一个系统或对象在其生命周期中的动态行为，特别是状态变化的过程。状态图主要关注的是系统的状态及其如何响应外部事件来改变自身状态。 - **状态图元素**：状态图主要...
标题中的"state_seg.rar_CD machine_状态机 源码"表明这是一个关于状态机设计的项目，源码可能与CD（Compact Disc）机器的操作或控制有关。在嵌入式系统和数字逻辑设计中，状态机是一种常用的设计模式，用于处理序列...
UML 自动售货机的设计_状态图描述 UML（Unified Modeling Language）是一种软件设计语言，用于描述软件系统的结构、行为和架构。自动售货机的设计就是使用UML来描述自动售货机的原理和状态转换。 状态图是UML中一...
- **定时图/状态机**：展示订单状态或用户会话状态的变迁过程。 通过这两个实例，我们可以学习到如何使用UML进行需求分析、系统设计和沟通交流。UML建模不仅可以提高软件开发的效率，还可以降低出错率，增强系统的...
状态图是 UML 中的一种重要建模工具，用于描述对象在生命周期中的状态变化和转换过程。本教程主要介绍状态图的基本概念、建模方法和应用场景。 事件（Event） 事件是指对一个在时间和空间上占据一定位置的有意义的...
状态图用于捕获对象、子系统和系统的生命周期。状态图可以告知一个对象可以拥有的状态，并且事件（如小溪的接收、时间的流逝、错误、条件变为真等）会怎么随着时间的推移来影响这些状态。 6. 顺序图（Sequence ...
- **行为建模**：讲解了如何使用UML的行为图（如活动图、状态机图）来描述系统的动态行为。 - **架构建模**：探讨了如何使用UML的架构视图来描述系统的结构和组件关系。 - **子系统设计**：指导如何设计和组织子系统...
《软件开发生命周期与统一建模语言UML详解》 软件开发生命周期（Software Development Life Cycle，SDLC）是软件工程领域中一个重要的概念，它为软件项目的规划、设计、实施、测试和维护等阶段提供了指导框架。SDLC...
- **状态机图(State Machine Diagram)**：也称为状态图或状态转换图，展示了对象在其生命周期内的各种状态及这些状态之间的转移。 - **活动图(Activity Diagram)**：用于展示工作流中的活动步骤及控制流，常用于业务...
12. **日志工具**：如Logcat的增强版，帮助开发者调试和记录应用行为。 在"ChaoJar-Demo"这个子文件中，你可能找到这些组件的示例代码，包括如何集成、配置和使用。通过研究这些示例，你可以更深入地理解每个组件的...