Subsystems are generally said to have a certain function of the system, and the commonly said "module" concept is similar
For example, for a monitoring system, we can say that there is a "data acquisition subsystem", then this subsystem is to complete the data acquisition task of a relatively complete function of the combination.
In the process of analyzing the problem, in order to avoid a large number of things intersect, so we need to consider a large number of relative relationships, we usually divided a complex system into several separate subsystems, so that we can independently consider the relationship between these subsystems, Sub-Systems and then independent of each subsystem within the relationship between the things.
A subsystem is a model element that has the semantics of a package (which can contain other model elements) and a class (its behavior). The behavior of a subsystem is provided by the classes or other subsystems it contains. Sub-Systems Subsystems implement one or more interfaces that define the behavior that a subsystem can perform.
Subsystems can be used in a number of complementary ways, Sub-Systems dividing the system into several units:
Can be scheduled, configured, or delivered independently
can be developed independently (as long as the interface remains unchanged)
Can be deployed independently on a set of distributed compute nodes
Can be independently changed without destroying the rest of the system
In addition, subsystems can:
Dividing the system into several units to provide limited security for critical resources
Represents an existing product or external system in a design
Determining subsystems from class collaboration
If the classes in a collaboration are simply interacting with each other and can generate a well-defined set of results, the collaboration and its classes should be encapsulated in a subsystem.
This rule also applies to a subset of collaborations. Sub-Systems Any part or all of the collaboration can be encapsulated and simplified, which makes the design easier to understand.
Note Optional if a specific collaboration (or child collaboration) represents an optional behavior, it should be encapsulated in a subsystem. If you can remove, upgrade, or replace certain features with other features, you should consider these features independent. Note the user interface of the system. If the user interface is relatively independent of the entity classes in the system (that is, both can and will be changed independently), Sub-Systems you should create a horizontal integrated subsystem: The associated user interface boundary class is grouped into a subsystem, and the related entity classes are grouped into another subsystem. If the user interface is tightly coupled with the entity classes it displays (that is, a change on one side triggers a change on the other), you should create a vertically integrated subsystem: Load the associated boundary classes and entity classes into a common subsystem. Note that the protagonist separates the features used by two different protagonists, as each lead may independently change their own requirements for the system. Find classes that are coupled to and within a class, or that have higher cohesion, to collaborate with each other to provide a set of services. The classes with higher coupling are organized into subsystems, separating the classes along the weakly coupled boundaries. In some cases, classes can be divided into smaller classes that have higher cohesion responsibilities, thus completely eliminating weak coupling. Note Replacement If you specify several service levels for a particular feature (for example, High, medium, and low availability), each service level is represented as a separate subsystem, and each subsystem implements the same set of interfaces. In this way, subsystems can be replaced with each other. Sub-Systems Attention distribution Although a particular subsystem may have multiple instances, each instance is executed on a different node, it is not possible to split a single instance of the subsystem between the nodes. If subsystem behavior must be split between nodes, the subsystem needs to be partitioned into smaller subsystems to have more restrictive functionality. Determine the functionality that must exist on each node and create a new subsystem to "own" the function, and then distribute the responsibilities and related elements within the subsystem accordingly.
Once the class is organized into a subsystem, the use case implementation should be updated accordingly.
Once you have created a subsystem: a name and a short description.
If the tool supports the package but does not support the subsystem, Sub-Systems the package can be used to record the subsystem; Represents a subsystem.
The responsibility for the original analysis class should be transferred to the newly created subsystem, and the description of the subsystem is used to record the responsibilities.