uml - Differences of Component Diagrams and Deployment Diagrams? - Stack Overflow
About the Series This series of articles is designed to present the set of core UML diagrams in a way that emphasizes the important relationships between the. Deployment diagrams show the relationships between the software and hardware components in the system and the physical distribution of the processing. UML Component and Deployment Diagrams - Brief Overview. Elements of Deployment diagram Association Component and nodes;
If a composite is deleted, all of its parts are normally deleted with it. Aggregation A kind of association that has one of its end marked shared as kind of aggregation, meaning that it has a shared aggregation. Constraint A condition or restriction expressed in natural language text or in a machine readable language for the purpose of declaring some of the semantics of an element. Dependency A dependency is a relationship that signifies that a single or a set of model elements requires other model elements for their specification or implementation.
This means that the complete semantics of the depending elements is either semantically or structurally dependent on the definition of the supplier element s. A generalization is a taxonomic relationship between a more general classifier and a more specific classifier. Each instance of the specific classifier is also an indirect instance of the general classifier.
Thus, the specific classifier inherits the features of the more general classifier. Modeling Source Code Either by forward or reverse engineering, identify the set of source code files of interest and model them as components stereotyped as files.
For larger systems, use packages to show groups of source code files. Consider exposing a tagged value indicating such information as the version number of the source code file, its author, and the date it was last changed. Use tools to manage the value of this tag.
Model the compilation dependencies among these files using dependencies. Again, use tools to help generate and manage these dependencies. Typically, this will involve some or all the components that live on one node, or the distribution of these sets of components across all the nodes in the system.
Consider the stereotype of each component in this set. For most systems, you'll find a small number of different kinds of components such as executables, libraries, tables, files, and documents. You can use the UML's extensibility mechanisms to provide visual cues clues for these stereotypes.
For each component in this set, consider its relationship to its neighbors. Most often, this will involve interfaces that are exported realized by certain components and then imported used by others. If you want to expose the seams in your system, model these interfaces explicitly. If you want your model at a higher level of abstraction, elide these relationships by showing only dependencies among the components.
Relationships in deployment diagrams
Modeling a Physical Database Identify the classes in your model that represent your logical database schema. Select a strategy for mapping these classes to tables. You will also want to consider the physical distribution of your databases.
Your mapping strategy will be affected by the location in which you want your data to live on your deployed system. To visualize, specify, construct, and document your mapping, create a component diagram that contains components stereotyped as tables. The Controllers component is dependent on both the CustomerBusinessObjects and the BankingBusinessObjects components through their respective interfaces.
The Controllers component is dependent on or at least some of its contained classes are dependent on the CustomerForms component, because the controller classes launch those forms.
Relationships in deployment diagrams
Similarly the Controllers component is dependent on or at least some of its contained classes are dependent on the BankingForms component As hinted in the previous paragraph, components will contain object classes.
It is usual for UML modeling tools to provide a mechanism for mapping classes onto the components, like this: The other classes will be mapped to different components for deployment. The worked example presented in this article represents only one way to skin the component-design cat for our running case study.
As you will see when we consider the UML Deployment Diagram below, it might turn out to be better from an architectural standpoint to map subsets of the controller classes onto two separate controller components: Alternatively, these controllers might be mapped to the CustomerForms and BankingForms components on which they depend.
You might also think about incremental delivery whereby some software components may be usefully deployed before other are ready — for example the customer management components before the banking components — and in this respect the original packaging of use cases may help to drive the packaging of components.
While the software analyst has probably done all that needs to be done, and maybe even too much at the high level, the technical architect would need to do some lower-level work in defining the couplings between the implementation classes and their facades.
The UML Component Diagram in general and this component diagram in particular leads logically to the UML Deployment Diagram which demonstrates how the various components may be actually deployed to nodes representing the client and server computers.
Here is an example: