How important are diagrams for the JEE calculation

UML (Unified Modeling Language) is a standard of the OMG (http://www.omg.org/uml) and is not a method, but defines a notation and semantics for the visualization, construction and documentation of models for business process modeling and for the object-oriented Software development.

MDA (Model Driven Architecture) is also an OMG standard (http://www.omg.org/mda) and defines a procedure for the software development process using UML. MDA differentiates between PIM (Platform Independent Model), PSM (Platform Specific Model) and code and provides a basis for automatic code generation.

Sequence diagrams are the most important interaction diagrams and show the timing of a series of messages (method calls) between certain objects in a time-limited situation. The creation and removal of objects can also be included.

Sequence diagrams focus on the temporal flow of messages, while other diagrams (e.g. communication diagram) illustrate how the objects work together.

Sometimes used abbreviations: 'ref' = reference to already defined sequence, 'alt' = selection among alternatives, 'opt' = optional execution, 'par' = parallel execution, 'loop' = iterative loop, '{...}' = Constraint.

"interface"no attributes
only abstract operations
cannot be instantiated
Interface classes are abstract classes for defining functional interfaces. They facilitate software development based on the division of labor ("Design by Contract"). Interface classes can inherit from other interface classes («extend») and be implemented in specific classes (realization relationship, «realize»).«Type»mostly attributes
mostly abstract operations
Associations with other types
Types are abstract specifications (similar to interfaces) of structural interfaces."Entity"many attributes
many primitive operations (getter / setter)
few complex operations
Entity classes represent technical facts or real world objects (contract, customer, address).«Control»few attributes
transient, short life
complex operations
Control classes are used for process, control and calculation processes, mostly across classes.«Boundary»no operations of their own
delegate operation calls
no technical logic
almost only derived or derivable attributes
no persistence, no states
often singletons
Interface objects form a compilation of properties of other objects, for example for decoupling in the sense of facades."primitive"elementary classes and standard classes
few attributes
simple operations
Primitive classes are used in declarations of attributes. They are not shown as a class in the class diagram.«Enumeration»similar to primitive classes
almost only in declarations for attributes
Enumerations are enumerable sets of values. Can represent values ​​for selection lists.«Structure»attribute definitions only
no operations
Data structures are normally only used to exchange data with other systems.«Utility»Class attributes
Class operations
Collections of global variables and functions.
"Stereotype"
Package-name :: class-name
{Property values}
± Attribute name: Attribute type = initial value {assurance}
± method name (parameter: type) {property}

Circle example
radius {radius> 0}
center: Point = (20.30)
setRadius (rad)
setPosition (pos: Point)
Class notation

Three categories:

1.) Class name (possibly with additions)

2.) Attributes (properties / data)

3.) Operations (methods)

The attribute or method names can be preceded by visibility symbols: + for public, - for private and # for protected. Class attributes and methods are underlined. Derived attributes (automatically calculated) are marked by a preceding slash: / DerivedAttr. Abstract methods are either written in italics or supplemented with the property value {abstract}. Stereotypes can be specified in front of the method names (e.g. «constructor»).

The notation for objects is similar to the class notation. Instead of the class name, the underlined object name is used, possibly followed by a colon and the name of the instantiated class ("objectName: class name").



Instance relationship

The arrow is open and dashed and points from the object to the class (object "depends on" class, «instance of»).

The object name is underlined.



Inheritance

The arrow is closed and solid and points from the derived subclass (= subclass) to the upper class (= base class = superclass).

The upper class is a generalization of the subclass and vice versa the subclass is a specialization of the upper class ("generic term" relationship = "is-a" relationship).

Abstract class
{abstract}


Abstract class

Abstract classes are identified by the property value {abstract} or by a italic set class name is highlighted. The appearance of the inheritance arrow does not change.

Abstract classes can contain abstract methods, i.e. methods whose function has not yet been defined.

Abstract classes cannot be instantiated; they can only serve as inheritance templates.

directed association



ordered association



Addiction

Association, Aggregation and Composition

Associations represent relationships between classes. In programming languages, they are usually implemented through corresponding reference attributes in the classes involved, with a higher multiplicity with a collection object.

Most associations are shown in more detail than in the images shown.

At both ends of the connecting line, the multiplicity is usually noted, which indicates the number of objects with which this relationship can come about. Examples: '1', '0..1', '0 .. *', '5..8', '5.8'. A distinction is made between cardinality (number of elements) and multiplicity (range of permitted cardinalities).

The role names relevant for the relationship can also be entered at the ends of the connection line.

In the middle of the connecting line can be added: «Stereotype», relationship name, reading direction in the form of a triangular arrow () and property values ​​in square brackets ([]).

Realization / refinement


--O InterfaceXy

InterfaceXy
O--

Refinement relationships (“refine”, “bind”) exist, for example, in the creation (macro-like text replacement) of parameterized concrete classes (parameterized class, bound element) from template-like parameterizable classes (template).

Realization relationships (“realize”) exist, for example, with interfaces (“interface”). Often the interface class is simply represented by the "lollipop" symbol (circle with stem) and the interface name as a shorthand way of writing.

Has

(Aggregation)

Has

(Composition)

Aggregations and compositions are special associations that represent "part / whole" relationships and "has-a" relationships. With the aggregation, the "parts" of the "whole" can also exist individually, with the composition only if the "whole" also exists (e.g. invoice items on an invoice). The connecting line is given a diamond on the "whole" side, which is unfilled during aggregation and filled during composition. With automatic code generation, however, aggregations and compositions are not treated differently than normal associations in some tools.

Qualified Assoc.
—————

The qualified association divides the referenced objects into partitions using qualifying attributes. The qualifier can be compared to a key for dictionaries, associative fields or database look-up tables. The qualifier could be a personnel number, for example.

methodXy (parm)


Message exchange, method call

The exchange of messages between objects is accomplished by method calls, the names and parameters of which are shown together with an arrow.

MDA (Model Driven Architecture) is a standard of the OMG (http://www.omg.org/mda) and defines a procedure for the software development process using UML. MDA differentiates between PIM (Platform Independent Model), PSM (Platform Specific Model) and code and provides a basis for automatic code generation.

Terms

  • MDA:
    MDA (Model Driven Architecture) defines a procedure for the software development process (http://www.omg.org/mda).
  • UML 2.0:
    MDA is based on UML in version 2.0 (Unified Modeling Language) (techdocs / uml.htm, http://www.omg.org/uml).
  • MOF, XMI:
    The UML metadata of the OO models are stored in MOF repositories (Meta Object Facility) and can be exchanged with other UML or MDA tools via XMI (XML Metadata Interchange) (http://www.omg.org/ technology / documents / formal / mof.htm, ... / xmi.htm).
  • PIM, PSM:
    The modeling of the technical business processes (PIM, Platform Independent Model) is separated from the modeling of the technical implementation (PSM, Platform Specific Model).
  • Interchangeable technical platform:
    It is possible to choose the technical platform used (e.g. Java EE, .NET) at a later date.
  • Patterns and reuse:
    Proven design patterns, best practices and reusable components are supported.
  • Procedure models:
    MDA is compatible with established development processes and procedural models (e.g. RUP, Agile Modeling, XP).
  • Automation:
    Both the transformation of the PIM into the PSM (e.g. with Java EE Patterns) and the subsequent generation of source code (e.g. Java) can possibly (at least largely) be automated (e.g. for web applications).

Possible requirements for UML / MDA tools for automatic code generation

  • "Real" MDA or just an MDD variant?
    Division into PIM (Platform Independent Model), PSM (Platform Specific Model) and Code?
  • OCL (Object Constraint Language)? Or alternative?
  • Code-relevant starting point only UML class diagrams or also other UML diagram types?
  • Which automatically generated result UML diagram types?
  • Which design patterns? GoF and Sun? Can patterns be changed or own patterns used? Only at an additional cost?
  • Forward, reverse, round-trip?
  • If there is no round-trip: Is it possible to embed your own code (e.g. in "protected areas") that is retained after a rebuild?
  • Compliant with XMI (XML Metadata Interchange), MOF (Meta-Object Facility) and JMI (Java Metadata Interface)?
  • With which other UML / MDA / RAD tools is which data exchange possible (e.g. Rational Rose XDE, Borland Together)?
  • Target programming languages ​​/ platforms (e.g. Java standalone, JSP + Tomcat, EJB + JBoss, .NET)?
  • GUI builder?
  • Can stand-alone applications be developed?
    With Swing and SWT (Standard Widget Toolkit)?
  • Can web applications be developed? With Struts? With JSF (JavaServer Faces)?
    Convenient creation of the GUI for web application (including tree views and horizontal menu bars with pull-down menus)?
    For the web browsers Microsoft Internet Explorer, Netscape, Mozilla, Opera and Konqueror?
    Also for mobile devices (WAP / WML / MIDP)?
  • Deployment at the click of a mouse?
    Automatic deployment for Tomcat, JBoss, WebLogic and WebSphere?
    Deployment for which other platforms / frameworks?
  • Can portlets be created? For which portal server? Also according to "JSR 168 Portlet Specification"? Also according to WSRP standard (Web Services for Remote Portlets)?
  • Creation of your own and connection to a third-party SOAP web service at the click of a mouse?
  • Automatic generation of a GUI for external web services based on the WSDL file with a click of the mouse?
  • At the click of a mouse: JMS, CORBA, EAI (e.g. with SAP R / 3® BAPI)?
  • Support for single sign-on, LDAP and SSL?
  • Connection to which SQL databases (MySQL, PostgreSQL, MaxDB, Oracle, IBM DB2, MS SQL Server)?
  • Convenient debugging? Remote too?
  • Test software at the click of a mouse? JUnit?
  • Which phases of the complete development cycle are covered?
    Which tools are recommended for the missing phases?
    Comfortable integration in CVS and Subversion?
    Is it possible to embed it in process models such as RUP?


Links to further information

  • Websites
  • UML at OMG: http://www.omg.org/uml
  • UML at Jeckle: http://www.jeckle.de/unified.htm, http://www.jeckle.de/files/telelogic2003.pdf, http://www.jeckle.de/uml-glasklar/AgilityDays2003. pdf
  • UML at Gulp: http://www.gulp.de/kb/it/projekt/projekterffekt1.html
  • UML tutorial, University of Magdeburg: http://www-ivs.cs.uni-magdeburg.de/~dumke/UML
  • UML, University of Oldenburg: http://elvis.offis.uni-oldenburg.de/Zwischenbericht-A/node24.html
  • UML at Rätzmann: http://www.dfpug.de/konf/konf_1999/gruppe02_oop/d_uml/d_uml.htm
  • Sun Java Center, J2EE Patterns: http://java.sun.com/developer/technicalArticles/J2EE/patterns
  • Architecture and Architecture Modeling Techniques (UML, MDA, EUP): http://www.agiledata.org/essays/enterpriseArchitectureTechniques.html
  • MDA, Code Generation Network: http://www.codegeneration.net/tiki-index.php?page=MDA
  • openMDA: http://www.openmda.de/aboutmda.htm
  • MDA from a Developer's Perspective, TheServerSide.com: http://www.theserverside.com/resources/article.jsp?l=MDA
  • Model Driven Architecture, software-kompetenz.de: http://www.software-kompetenz.de/?5348
  • Model Driven Architecture, Szallies: http://www.wohnklo.de/szallies/mda
  • Magazine articles
  • Model Driven Architecture, Basic Concepts and Classification of the Model Driven Architecture (MDA), Roßbach / Stahl / Neuhaus, Java magazine 2003.09, page 22
  • Books
  • Jeckle / Rupp / Hahn / Zengler / Queins, UML 2 crystal clear, 2003-11, 3446225757: Amazon.de
  • Chonoles / Schardt, UML 2 for Dummies, 2003-12, 3826630912: Amazon.de
  • Austria, object-oriented software development (with UML 2), 2004, 3486272667: http://www.oose.de/publikationen.htm, Java magazine, Amazon.de
  • Born / Holz / Kath, software development with UML 2, 2003-12, 3827320860: Amazon.de
  • Rumbaugh / Jacobson / Booch, The Unified Modeling Language Reference Manual, 1998, 020130998X: Amazon.co.uk
  • Andresen, component-based software development with MDA, UML and XML, 2003, 3446222820: Amazon.de
  • Warmer / Kleppe / Bast, MDA Explained, 2003, 032119442X: Amazon.de; (takes into account OptimalJ)
  • Frankel, Model Driven Architecture, 2003, 0471319201: Amazon.de
  • Hubert, Convergent Architecture, Building Model-Driven J2EE Systems with UML, 2001, 0471105600: convergentarchitecture.com, Amazon.de; (takes ArcStyler into account)
  • UML tools
  • See also Java magazine 2003.03, page 44, "An overview of the UML products available on the market"
  • UML tools lists: http://www.oose.de/service/uml-werkzeuge.html, http://www.objectsbydesign.com/tools/umltools_byCompany.html
  • Overview of UML-MDA tools: http://www.ecotronics.ch/kleiner/umltools.htm
  • yEd, yWorks: http://www.yworks.com/en/products_yed_about.html
  • astah (formerly JUDE), Change Vision: http://astah.change-vision.com/en/product/astah-community.html
  • ArgoUML, Tigris.org: http://argouml.tigris.org
  • Poseidon, Gentleware: http://www.gentleware.com
  • UML plug-in for Eclipse: http://eclipseuml.com
  • Enterprise Architect, Sparx Systems: http://www.sparxsystems.com.au/ea.htm
  • UML development environments
  • Rational Rose XDE Developer, IBM: http://www.rational.com/products/xde
  • Rational Rapid Developer (RRD), IBM: http://www.rational.com/products/rapiddeveloper
  • Together, Borland: http://www.borland.de/together, http://www.borland.de/together/solo, http://www.togethersoft.com/products
  • MDA development environments
  • Ameos, Aonix, Karlsruhe / Munich / Korschenbroich: http://www.aonix.de
  • AndroMDA: http://www.andromda.org, http://sourceforge.net/projects/andromda, http://genome.tugraz.at/Theses/Truskaller2003.pdf
  • ArcStyler, Interactive Objects Software, Freiburg: http://www.arcstyler.com, http://www.arcstyler.com/products/arcstyler_overview.jsp, http://www.io-software.com/news/pr_mai_200503_d. jsp
  • iQgen, innoQ, Ratingen: http://www.innoq.com/iqgen
  • MDE, Metanology: http://www.metanology.com
  • OptimalJ, Compuware: http://www.compuware.de/products/optimalj, http://www.compuware.no/optimalJ/ButlerGroupReport.pdf
  • smartGENERATOR, BITPlan, Meerbusch: http://www.bitplan.de/xmlweb/index.php?topic=products/smartgenerator
  • Software through Pictures (StP), Aonix: http://www.aonix.de/stp_acd.html, http://www.jfs2003.de/abstracts.html#A4 / PDF
  • XCoder: http://sourceforge.net/projects/xcoder, http://www.liantis.com/Leistungen



Further topics: other TechDocs | Procedural models
© 2001-2007 Torsten Horn, Aachen