Eclipse UML插件介绍、安装及使用

Eclipse UML插件

Green

官网：https://www.360docs.net/doc/7117787985.html,/

安装方法：

解压后，把plugins文件夹拷贝到Eclipse的根目录了下，即把plugins文件夹里的文件拷贝到Eclipse的plugins目录下。

注意：最新版本只支持Eclipse 3.5 (Galileo)

Green Builds

Release Date Installation Release Notes Version GEF Version Eclipse Version October 22,2009 N/A Notes 3.5.0 3.4 3.5 (Galileo)

October 30,2009 N/A Notes 3.4.0 3.4 3.4 (Ganymede) December 14, 2008 N/A N/A 3.1.0 3.4 3.4 (Ganymede)

November 5, 2008 N/A N/A 3.1.0 RC2 3.4 3.4 (Ganymede)

October 3, 2008 N/A N/A 3.1.0 RC1 3.4 3.4 (Ganymede) September 15, 2008 N/A N/A 3.0.1 3.4 3.4 (Ganymede) October 19, 2007 Procedures Notes 3.0.0 3.3 3.3 (Europa) July 17, 2007 Procedures Notes 2.5.1 3.2 3.3 (Europa)

June 5, 2007 Procedures Notes 2.5.0 3.2 3.2 September 12, 2006 Procedures Notes 2.5.0 RC3 3.2 3.2

March 1, 2006 Procedures N/A 2.5.0 RC2 3.1.1 3.2 December 13, 2005 N/A N/A 2.5.0 RC1 3.1.1 3.2

October 12, 2005 N/A N/A 2.4.0 3.1.1 3.1

操作说明：

安装成功后，在Eclipse的Window -> Preferences，能看到Green的菜单项：如图

右键点击某个类或接口，可以把该类或接口添加到一个类图中(不支持拖拽)：

点击右下角的案件[Toggle Explwration Icons]，可以去掉[All ->…]

可以通过点击右键，把类图导出为.gif, .jpg, .png等格式的图片

Using the Green UML Plugin for Eclipse

The open-source Green UML plug-in, from the Computer Science and Engineering Department at the University at Buffalo (State Univ. of New York), enables the developer to generate Java code by directly creating and manipulating a UML diagram. Likewise, a UML diagram can be created from existing code ("round-trip engineering"). Changes in the diagram are immediately reflected in the code and changes in the code are reflected in the diagram right away as well. This frees the developer to focus on the design and architecture of their system without worrying about the syntactical details of the programming language.

Home page of Green UML.

On-line Documentation

Off-line Documentation: In Eclipse, in the main top menu, go to Help/Help Contents and click on the Green Users Guide.

To install the Green UML plug-in, please go to the Eclipse installation page.

If you are new to UML class diagrams, it is highly recommended that you review the basics of UML first.

Green UML Screen Shot

Quick Start

Note: Sometimes a change made directly in the Java code does not immediately show up in the diagram. It is recommended that after making changes directly to the code, when

switching back to the diagram, right-click in any clear area of the diagram and select

"Refresh Editor". This will insure that the diagram is properly synchronized with the code.

Create a New Diagram

Important Note: Green UML will not work with classes in the default package! In

practice, this is not really a restriction because you should always put all of your classes

in packages and never have code in the default package.

Create a New Blank Diagram

In the Package Explorer, right-click anywhere in the desired project and select "New/Other/Green UML Class Diagram"

Create a New Diagram from an Existing Class or Interface -- creates a new class

diagram with

New class diagram with only one class/interface in it:Right-click the class or

interface in the Package Explorer and select "Green UML/Add to New Class

Diagram"

New class diagram with the specified class/interface and its immediate

superclass: Right-click the class or interface in the Package Explorer and select

"Green UML/Incrementally Explore in New Class Diagram"

Green UML will create an XXX.grn file in the root of the src folder (the default

package location). To rename a class diagram, highlight it's *.grn file and go to the Eclipse main menu and select File/Rename or hit the F2 function key.

Adding Classes and Interfaces to Diagrams

Create a New Class or Interface in the Diagram

1.On the right side of the diagram, in the Palette, highlight either "Class" or

"Interface".

2.Move the mouse over to the desired location for the class on the diagram and

left-click to deposit a class or interface icon at that location.

3.Fill out all the desired information in the pop-up dialog that appears.

Green UML will automatically generate the appropriate Java file for your new

class or interface and will also auto-generate the code stubs for the class or

interface.

Add an Existing Class or Interface to a Diagram

To add an existing class or interface to a diagram, be sure that the desired diagram

is open and visible.

Right-click the desired Java file in the Package Explorer and select Green UML/Add to Last Viewed Class Diagram

Modify a Class or Interface on a Diagram

Double-clicking on a class or interface will open its Java code file for editing.

o Changing the visibility (public, private, protected, etc) of a class must be done via the code editor.

Adding a method or field:

1.Right-click the name of class or interface in the diagram to select the entire

class/interface

2.Then select Add and then click Add Field or Add Method.

3.Fill out the pop-dialog box with the appropriate specifications for the new field or

method.

Green UML will automatically generate a stub (signature but no code body) for any

methods and fields that are made.

Editing an existing method

Right-click the method and select "Refactor/Change Method

Signature". This will bring up the dialog window to edit the signature of the

method.

Adding Relationship Lines to a UML Class Diagram

Adding Inheritance Lines

Generalization Lines (solid lines with closed arrowheads) indicate that a

subclass extends superclass or an sub-interface extends a

super-interface. The arrow will point from the subclass (sub-interface) to the

superclass (super-interface).

1.In the Palette, highlight the "Generalization" option.

2.Left-click on the desired subclass (sub-interface). A line will now be

attached from that class/interface to the mouse pointer.

3.Move the mouse to the desired superclass (super-interface) and left-click. A

generalization line will be created and the associated Java code will be

auto-generated. Green UML will not let you create a line that would result

in invalid Java code.

Realization Lines (dotted lines with closed arrowheads) indicate that a

class implements an interface. The arrow will point from the class to the

interface.

1.In the Palette, highlight the "Realization" option.

2.Left-click on the desired class. A line will now be attached from that

class/interface to the mouse pointer.

3.Move the mouse to the desired interface and left-click. A realization line

will be created and the associated Java code will be auto-generated. Green

UML will not let you create a line that would result in invalid Java code.

Adding Association and Composition Lines

Association line s (tailless solid lines with open arrowheads) indicate that one

class holds a static reference to another class or instance of an interface, i.e. it has

a field of the referenced type. The association line points from the class with the

reference to the referenced class. Green UML has the erroneous notion

unfortunately, that all such fields are initialized via constructor input parameters,

so it auto-generates both the field and adds constructor code to initialize it via a

constructor input parameter. Unfortunately, this constructor code will need to be

deleted if one initializes the field in a different manner, such as by using a factory

object.

1.In the Palette, highlight the "Association" option.

2.Left-click on the class you want to have the reference to the other class. A

line will now be attached from that class to the mouse pointer.

3.Move the mouse to the desired interface and left-click. An association line

will be created and the associated Java code (field & constructor) will be

auto-generated. Green UML will not let you create a line that would result

in invalid Java code.

Composition lines (solid lines with no arrowheads and a diamond-shaped tail)

indicate that one class holds a static reference to another class or instance of an

interface, i.e. it has a field of the referenced type, but also explicitly constructs the

objects being referenced. Colloquially, we say that one object "owns"

another. The composition line points from the "owner" to the referenced

class. Green UML has the erroneous notion unfortunately, that all such fields

are initialized via constructor input parameters, so it auto-generates both the field

and adds constructor code to initialize it with the referenced class's

constructor.. Unfortunately, this constructor code will need to be deleted if one

initializes the field in a different manner, such as by using a factory

object. Green UML is currently unable to handle an composition with an abstract

class or interface, which is rather common.

1.In the Palette, highlight the "Composition" option.

2.Left-click on the class you want to have the reference to the other class. A

line will now be attached from that class to the mouse pointer.

3.Move the mouse to the desired interface and left-click. An association line

will be created and the associated Java code (field & constructor) will be

auto-generated. Green UML will not let you create a line that would result

in invalid Java code.

Adding Dependency Lines (not shown on screen shot above)

Dependency lines (tailless dotted lines with open arrowheads) are used to indicate a

variety of usually dynamic relationships between classes and interfaces, such as taking

another class as an input or returning it from a method, or instantiating it for use as a

local variable or value. If class "A" uses class "B", the dependency arrow will point

from class "A" to class "B".

Green UML supports the two dependency scenarios. In the Palette, you may see

either the "Instantiaton Dependency" or "Local Assignment

Dependency" option. Clicking the small triangle next to the visible choice will

show you the other choice. A "push-pin" icon lets you show both options at once.

Instantiation Dependency is when a method in one class instantiates another class for

use as a value in a method.

1.Highlight the "Instantiaton Dependency" option and drawing a line from

the class doing the instantiation to the one being instantiated. Green UML will

want you to only use concrete, classes that can be instantiated.

2.A dialog box will appear asking you what method to put the code stub. The

"cardinality" is simply how many instances you wish created.

3.Green UML will generate the constructor call in the desired method.

Local Assignment Dependency is when a method in one class creates a local variable of the type of the target class of the dependency.

1.Highlight the "Local Assignment Dependency" option and drawing a line

from the class doing the instantiation to the one being instantiated. The target

may be an abstract class or an interface, but if it is, Green UML will ask you

which concrete sub-class/implementation to actually instantiate.

2.A dialog box will appear asking you what method to put the code stub. The

"cardinality" is simply how many instances you wish created.

3.Green UML will generate the constructor call and local variable assignment in the

desired method. The variable type will be the target of the dependency but the

constructor call will be to the selected concrete sub-type if the target is

abstract. Green UML is not capable of auto-generating code for instantiating a

concrete subclass of a concrete superclass local variable.

Adding Notes (not shown on screen shot above)

Notes are just boxes of text placed on the diagram to help the reader understand it

better.

1.Highlight the "Note" option in the Palette.

2.Left-click wherever you want the note to appear in the diagram.

3.Fill out the text of the note box.

Tips and Traps

Exporation Icons

Green UML has a feature where it can automatically add the superclass or implemented

interface of a selected class onto the diagram. This is referred to as "incremental

exploring". If your diagram looks like the following, where an "ALL......" is

displayed under the class name, the exploration feature is activated.

Clicking on the "ALL" will display the superclass or interface. You can choose what

to show by right-clicking the class and selecting "Incrementally Explore".

Clicking the "Toggle Exploration Icons" option in the Paletter will turn the

incremental exploration feature on and off.

Technical Errors

Green UML incorrectly uses an empty diamond symbol to denote a composition--the

UML standard is to use a filled diamond. Empty diamonds are generally used for

"aggregations" which closely resembles Green UML's "associations", which is really the

generic term encompassing both aggregations and compositions. See, for

instance, https://www.360docs.net/doc/7117787985.html,/content/m11658/latest/ and https://www.360docs.net/doc/7117787985.html,/wiki/Class_d

iagram.

BUG in Green 3.5.0 when branching in SVN: In this version (and presumably,

earlier versions as well) of Green UML, the .GRN diagram file holds hard-coded

references to the Eclipse project folder. These references are NOT updated when the

source code is branched and subsequently copied to another project folder. Thus, in

the branched code, the diagrams will appear blank because Green UML cannot find the

source files because it is looking in the wrong place. Work around:The .GRN

diagram files are just ASCII text files in an XML-like format. Use any text editor, e.g.

Notepad, to open the file and globally search and replace all occurances of the old

project folder name with the new project folder name.

AmaterasUML

官网：http://amateras.sourceforge.jp/cgi-bin/fswiki_en/wiki.cgi?page=AmaterasUML

安装方法：

解压后，把.jar文件(3个)拷贝到Eclipse的plugins目录下。

注意：最新版本只支持Eclipse 3.3 ~ 3.5 (Galileo) ，3.6安装失败。

操作说明：

安装成功后，在Eclipse的Window -> Preferences，能看到AmaterasUML的菜单项：如图

通过勾选[Show simple name of Class or Interface]，可以只显示类名或接口名(不包括包名)；

通过New -> Others…，新建一个类图，然后可以通过拖拽的方式把一个类或接口添加到当前的类图中：

可以通过点击右键，把类图导出为.jpg格式的图片

AmaterasUML

AmaterasUML is an Eclipse plug-in for drawing UML class-diagram, and UML sequence-diagram.

Class diagram

Sequence diagram

License

Eclipse Public License 1.0

Download

AmaterasUML

AmaterasUML works with Eclipse 3.3 or later(not support Eclipse 3.2), and AmaterasUML also requires GEF.

1.Please download AmaterasUML_x.x.x.zip from here.

2.Unzip that and put all jar files into ECLIPSE_HOME/plugins.

How to Use

Class diagram editor

Please select "File"->"New"->"Other"->"AmaterasUML"->"Class diagram". Then class diagram file (*.cld) was created.

Opened Class diagam editor, and you can edit diagram using pallete. Then fields/methods can add from a context menu.

Some properties (ex class name) are edit directry in diagram. but some property(is abstract class or concrete class) are edit only property view.

If you want import/export Java, choose "Java" from a context menu.

Edit directry

AmaterasUML automaticaly parse field/methods when edit directry.

edit directy

parse your input

Sequence diagram editor

Please select "File"->"New"->"Other"->"AmaterasUML"->"Class diagram". Then class diagram file (*.sqd) was created.

Opened Sequence diagram editor, and you can edit diagram using pallete.

If you want add a Message, choose "Message". Then select source "Lifeline" or "Activation"

and target "Lifeline" or "Activation"

If you want add a Creation message, choose "Message". Then select source "Lifeline" or "Activation" and target "Instance" (Target instance must be none of imcoming/outgoing

message)

If you want add a Self-call message, choose "Message". Then select source "Activation" and same "Activation" by target.

You can select a class of Instance. Select the instance and choose "Import and Assign Class model" from a context menu. Then you can code assist on diagram or property view. Please hit CTRL + SPACE(limitation: can't use mouse when select the proposal, and if you escape the edit on diagram, hit esc key 2 times...)

Add Creation message

Please connect Lifeline/Activation to Instance.

Add Self-call message

Please connect same Activation.

Message completion

Please hit CTRL+SPACE on message.

Sequence API example

Please select "Window"->"Show View"->"Other"->"AmaterasUML"->"Stack Trace Sample".Then paste Java stack trace to opened view, and execute action. New stacktrace.sqd file is created on selected project/folder.

paste stack trace.

generated stack trace sequence diagram.

If you use Sequence API, you can create such plugin easily. This is a sample code, how to use Sequence API.

Sample code

//Add net.java.amateras.umleditor plugin in your plugin dependency.

//instanciate builder.

SequenceModelBuilder builder = new SequenceModelBuilder();

// create instances

InstanceModel start = builder.createInstance("Start");

InstanceModel next = builder.createInstance("Next");

InstanceModel last = builder.createInstance("Last");

InstanceModel instanciated = builder.createInstance("NewObject");

// ready to create message

builder.init(start);

// create message from Start to Next

MessageModel msg = builder.createMessage("Message to Next", next);

// create message from Next to Last

builder.createCreationMessage("Message to Last", last);

// create message from Last to Start

builder.createMessage("Return to Start", start);

// create self-call message on Start

builder.createSelfCallMessage("Self-Call");

// back to pointer

builder.back(msg);

// create message from Start to Last on next to first message.

builder.createMessage("Message to Last", last);

// add creation message.

builder.createCreationMessage("create", instanciated);

// convert to xml

System.out.println(builder.toXML());

generated sequence diagram

Usecase diagram editor

Please select "File"->"New"->"Other"->"AmaterasUML"->"Usecase diagram". Then class diagram file (*.ucd) was created.

Opened Usecase diagram editor, and you can edit diagram using pallete.

You can change the Actor image using property.

You can also attach any file to Usecase using property.

If you double click the Usecase, attached file will open in Eclipse.

Activity diagram editor

Please select "File"->"New"->"Other"->"AmaterasUML"->"Activity diagram". Then class diagram file (*.acd) was created.

Opened Usecase diagram editor, and you can edit diagram using pallete.

Common

You can swtich the hide/show grid by using "AmaterasUML" file menu History

2009/04/19 - Version 1.3.2

New appearance settings of class diagram / sequence diagram

Auto diagram reloading when the file is updated such as SVN update

See details here about new features.

2008/02/14 - Version 1.3.1

Auto layout in the class diagram editor.

Java model importing supports aggregation.

See details here about new features.

2007/10/07 - Version 1.3.0

Eclipse 3.3 Support (This version can't work with Eclipse 3.2.x)

Copy & Pase in the class diagram, the usecase diagram and the activity diagram.

Brand new visual theme for diagrams.

See details here about new features.

2007/04/22 - Version 1.2.2

Activity diagram is available.

Connection routers which exclude BendpoinConnectionRouter are not supported.

Bendpoint moves according to the entity dragging.

Note: This version hasn't compatibility with old versions.

See details here about new features.

2006/8/31 - Version 1.2.1

Class Diagram

o Enable to drag two or more classes at a time.

o Enable auto connect to Generalization/Realization connection.