特色：

和 Eclipse 及 CVS 集成的 UML 工具。可以从字节码逆向工程到类图和序列图。

相关：有免费版；

Poseidon for UML 5.0:

http://www.gentleware.com/

反正在菜单里面
问：
to run
我在菜单的tools中的genernal中把所有的font都改成了宋体，字符集改成了chinese_gb2312,结果生成的文档和文档图里的中文还是"?"
我改的对不对？

to run
ok了,谢谢！太感谢了！！！
关掉rose，再打开后，就ok了：）

其他相关：
soda在从rose中生成文档的时候，对中文的支持非常不好，所以现在仍然建议大家尽量在Rose的模型中使用英文。

那么你们给客户看什么呢？
怎么让客户了解你们的进度呢？
老板总是说，见客户时要给他看点什么，这样才好交流

客户了解进度可以通过很多方式，比如说：项目开发计划、产品原型、用例阐述这些需求方面的工件等等。而实际上当项目进入分析/设计阶段后产生的工件一般是不需要用户进行确认和了解的，用户只要通过项目开发计划和项目计划就可以了解到项目的进度，如果要和用户交流，那就通过产品界面原型等工件与用户进行交流即可。

修改模板：
找到你的ROSE安装目录，下面有SoDAWord->template->rose目录，下面存放的就是SoDA的word模板，你可以根据需要修改；

 rose是最流行的建模工具,一是标准(历史悠久用的人多),二是自始至终贯穿体现了RUP的思想(使用Rational suite)，虽然实际工作中我们因为诸多因素不能够完全按照RUP方法来指导整体开发过程，但相信多数团队还是围绕在rose身边使用了'简化版'的需求分析设计，而多半使用了不怎么地道的'XP'开发:)
      ROSE思想是复杂的，内涵是丰富的，操作是别扭的，文档是简单的，人性是没有的。然而人们对它趋之若鹜的原因恐怕是我们现在的TEAMLEADER,SA受RUP的'毒害'颇深的原因，而这也将影响到徒弟--将来的SA们。
     
一 通过模型生成代码

rose帮助位于 HELP>>CONTENTS>>ROSE JAVA>>HOW TO >>FORWARD ENGINEER FROM  ROSE  TO JAVA SOURCE 


 当你尝试把模型组件转化成代码框架时候，应该考虑到先检查将要生成的类有无语法错误。
 1 打开你要专化的目标diagram
 2 选择你要转化的包或者类
 3.单击  tools>java/j2ee>  Syntax Check 来检查目标代码是否符合规范，比如命名错误。
 4 察看rose log窗口(下方）察看检验结果，如果有错误，即errors那么生成的代码很可能无法通
 过编译
 5 根据需要校正这些组件或者图
 6重复 步骤3直到检验不出错误，然后你就可以进入下一步了   
 假设以上步骤已经搞定了error
 7 选择你要转化的包或者类
 8单击 Tools > Java/J2EE > Generate Code
 一般来说如果你还没有将一个package或者组件映射到一个rose的classpath目录中(就是指定生
 成的东西放哪里)，那么系统不会允许你在接下来的界面里点ok，那么现在就编辑目标路径
 9点classpath entries下的edit按钮，再出现的界面右上角找new(insert)(删除左边那个),然后在列表里新增的行里选择目标路径，你可以选择目标是生成一个zip，jar,还是一个目录，我们选择
 目录。指定目录，ok,那么你选择的路径就新建成功了，选择这个路径，点ok回到界面（层次
 好多阿，界面很丑阿）
 10现在你看到classpath entries里有东西了，选择右侧列表里你要转换的包或者组件，点assign
 ，即分配给目标classpth，理论上你可以把选择好的包组件或者类图分别分配个多个classptah
 对象。点ok开始生成
 11成功后就可以到指定的classpath下看代码了，生成的代码之间拥有如类图所示的关系。
 
 
二 反向功能
rose帮助位于 HELP>>CONTENTS>>ROSE JAVA>>HOW TO >>REVERSE ENGINEER FROM  JAVA SOURCE TO ROSE          
反向工程就是通过java代码生成或者更新一个模型的过程。你可以用ROSE对以下文件进行反向
  A.Java source code (.java files)
  B.Java bytecodes (.class files)
  C.zip, .cab, and .jar files
 1. Open the model you want to create or update.
 打开一个你刚创建或者想更新的模型
 新建一个class diagram（如果你还不会，那么这篇文章就别看了）
 2.单击Tools > Java/J2EE > Reverse Engineer
 那么现在大家可以想象一下rose会怎么做,刚才是选择了图，创建目标路径，生成代码，那么
 现在是否指定路径读文件生成图呢，you can say that again!!
 在出现的界面上选择一个classpath（如果已经存在）当然，你也可以通过edit classpath按钮新
 建一个（新建路径的界面刚才讲过了，不再累赘），然后选择这个classpath，更改下面的filter
 下拉列表，更改目标文件类型(注意不仅仅三行，可以滚动的，对rose的界面真是垃圾这一点
 又深有体会了)，我们这里选择.java，如果这个classptah下存在.java文件，那么就会被列出来
 。
 注意：你可以通过 add添加选中的文件，也可以通过add all添加所有列出来的，更可以通过
 add recursive 递归添加这个路径下所有的文件和子目录下所有文件等等。可以看到rose并不会自动列出甚至显示有没有子目录（无人性)
 从添加好的文件里选择你想反向的文件，点Reverse 开始创建或者更新
 无论成功还是失败都会警告，并有log。有错你就改到没错为止。
 假设你成功了，点击done结束反向，回到rose主界面。           
 注意:rose并不会针对你反向过来的类和组件自动生成图，生成的class已经按照包关系列在你的
        class diagram下面，你需要把他们加到你的图中去(靠,什么玩艺) ,你有两种方法让这个半自动反向工程化上句号。
   1手工把class或者组件拖拉到目的图里
   2在目标图的界面下点击 Query > Add Classes 或者 Query > Add Components ，选择视图方式
   ，一般是logic view,选择要拖拉的类或者组件，>>或者all，点ok完成。生成的类图即反映了代码本身之间的关系。
     ok.教程结束,因为没有抓图软件,懒得拷屏幕，加之文字比较详细，相信拥有写代码能力和
     自学能力的诸位看官理解没问题。作为一个SE,SA,必须掌握的工具，ROSE还有很多功能隐
     藏在稀奇古怪的界面下，如果你不是一个RUP方法的顽固FANS，也没有受到经典学院派的'
     教导',或者干脆就是一个开发人员,那么推荐大家还是快速的投入到together或者Poseidon的怀中吧。




自己的补充：
参考资料：
怎样由rational rose类图生成java代码
http://topic.csdn.net/t/20030410/19/1644982.html

1.安ROSE前先安JDK，       
  不然，要设置一下jdk的路径或者用ROSE找一下JDK的目录：
  Tools-->java/J2EE-->Project Specification-->CLASSPATH-->new

2. 然后，画图的时候，  
  打开J2EE，这个最全啦 ，会自动导入三个包：java、javax、org；  
  否则，复杂的类，可能转的不对；
 
  不过，使用J2EE model需要导入大量的包，会有点慢，只是第一次练习“from  class diagram to java source”的话，打开rose时点cancle不选任何model
  就可以；
3.斜菱形表示public，钥匙表示Protected，锁表示private，T表示default；
4.生成代码之前，在“open standard specification”中的“Attributes”和“Operations”中设置属性的type，方法的返回值等；
5.可以在“关联关系”等的箭头中指定引用的名称；
6.可以设置JAVADOC，   
   还能自动产生MAIN，（未找到相应项）

  可以对类的属性，加READ　WRITE方法，这个还是很好用的，不然，GET
  的，SET的会写好多，设置：
  右键单击要生成代码的类，选open   standard   Specification->Attributes,再右键单
  击要生成setter/getter的属性，选specification->java.....
  然后按“edit   set”  
  将“propertyType”改为“simple”,就可以了；
（read/write的默认值就已经是read/write);

参考： http://topic.csdn.net/t/20020624/11/825787.html

7.一个小技巧：   
   把默认语言设为JAVA： tools-option-notation-default
  因为，你一般不会对使用的语言换来换去的，  
  这样的话，   只要一产生类，就是JAVA类，   
    
  并且，   右击，有一项就相应变为“java/J2EE”;
（如果默认语言时C++，右击的那项是“ANSI C++”）
  双击的项也变了， 不是General的项了   直接是JAVA类属性  ；
 
8.我们要做的第一个步骤就是要先进行语法检查，   
  这一步，是关键；
 有时需要语法检查之后，“java/J2EE”中的“Genarate code”
  这项才从灰色变为可用项；
    
  然后设置好CLASSPATH的输出路径就可以了；

9.导出代码  
  在导出代码的过程中，我们可以看到“OK”按钮和两视图间的“Assign”按钮都是灰色的。这时候，我们要选择两个部分，
一个是在视图中左侧的“CLASSPATH   Entries”要选择一个你要导出代码的路径，点击让它变成蓝色就可以了。  
  这时候，按钮“OK”和“Assign”按钮仍然是灰色的。  
  下面我们还要确定右边哪个包是要导出的，这里很明显就是“scInfoTech”。我们把它和它的组件视图全部选中。这时候，“OK”按钮和“Assign”按钮都变成可用的了。

10. ROSE产生的代码，每个类，每个方法，都会打上一个ROSE号，  
  后期可反转，  
  就是从代码到类图！   
  若想去掉roseid：Tools-->java/J2EE-->Project Specification-->Code Generation；

11.不过，就本身而言，  
   
  产生的代码水平也是不敢^%#%$@%$#**^*&^^&^%#^%#  
   
  好象没有写的好！
 
  不过可以修改代码：java/J2EE-->edit code...;  
    
  但是ROSE的反转厉害的很，  
   
  可以转CLASS的，  
  生成的图，带有关系，  
   
  用来分析别人的代码，  
  VERY爽　！！！  
 
12.把类图、顺序图等图片保存到word中：
     点工具栏中的“fit in window”－>“copy”—>粘贴到word；
     这样得到的图片又清晰又完整又小，通常不到10k；如果图片太小，在word中
     可以以200％的比例阅读：“视图”菜单—>“显示比例”；

13.Rational Rose怎么导入java类库？：
     问：我想用java代码生成rose模型，可是总是有一些类找不到，需要导入jdk
             或者其他的类包,请问怎么操作？
      答：菜单   tools   ->   Java/J2EE   ->   Project   Specification  
              在Classpaths中加入类库路径，比如  
              D:\JBuilder6\jdk1.3.1\src.jar

14.画好了类图、顺序图，并加上了所有的操作，注释，说明等，怎么才能自动
     生成设计文档？（现在还不会，还没装SODA）
参考资料： http://topic.csdn.net/t/20021209/19/1245009.html

  问：我在rose中画了一个类图，所有操作什么的都有了，也都写了注释。  
           但怎么才能自动生成设计文档呢？总不能把注释一个一个的拷出来吧。  

 答：在report菜单总选择SoDA   Report，再选择report   template（比如Detail   of          all   of   attribute   and   operations   by   class   by   package）

 问：怎么没有SoDA选项？是不是要先装soda   for   word

 答：先装soda，还要有word
          http://www.rational.com/    上有不少文档

问：谢谢诸位的回答.我已经装上了,     虽然生成的文档有点儿乱,  
         但可以看出这是一个功能很强大的工具.  

答：其实最好的办法是根据你们文档的要求自己定制soda的模版，定制的过程说
         起来很麻烦，但是其实并不复杂，看看soda的教学文档，半天就可以掌握了

15.画类图的时候，最好把类按“包”组织；并跟java代码实现时的包结构对应；没有包，所有的类堆积在一起将是一盘散沙。



ok！





 
  

本文随便转载，请保留出处：http://blog.csdn.net/dylgsy/

UML的类图关系分为： 关联、聚合/组合、依赖、泛化（继承）。而其中关联又分为双向关联、单向关联、自身关联；下面就让我们一起来看看这些关系究竟是什么，以及它们的区别在哪里。

1、关联


双向关联：
C1-C2：指双方都知道对方的存在，都可以调用对方的公共属性和方法。

在GOF的设计模式书上是这样描述的：虽然在分析阶段这种关系是适用的，但我们觉得它对于描述设计模式内的类关系来说显得太抽象了，因为在设计阶段关联关系必须被映射为对象引用或指针。对象引用本身就是有向的，更适合表达我们所讨论的那种关系。所以这种关系在设计的时候比较少用到，关联一般都是有向的。

使用ROSE 生成的代码是这样的：

class C1 
...{
public:
    C2* theC2;

};

class C2 
...{
public:
    C1* theC1;

};

双向关联在代码的表现为双方都拥有对方的一个指针，当然也可以是引用或者是值。





单向关联:
C3->C4：表示相识关系，指C3知道C4，C3可以调用C4的公共属性和方法。没有生命期的依赖。一般是表示为一种引用。

生成代码如下：

class C3 
...{
public:
    C4* theC4;

};

class C4 
...{

};

单向关联的代码就表现为C3有C4的指针，而C4对C3一无所知。

自身关联（反身关联）：
自己引用自己，带着一个自己的引用。

代码如下：

class C14 
...{
public:
    C14* theC14;

};

就是在自己的内部有着一个自身的引用。

2、聚合/组合

当类之间有整体-部分关系的时候，我们就可以使用组合或者聚合。



聚合：表示C9聚合C10，但是C10可以离开C9而独立存在（独立存在的意思是在某个应用的问题域中这个类的存在有意义。这句话怎么解，请看下面组合里的解释）。

代码如下：

class C9 
...{
public:
    C10 theC10;

};

class C10 
...{

};

组合（也有人称为包容）：一般是实心菱形加实线箭头表示，如上图所示，表示的是C8被C7包容，而且C8不能离开C7而独立存在。但这是视问题域而定的，例如在关心汽车的领域里，轮胎是一定要组合在汽车类中的，因为它离开了汽车就没有意义了。但是在卖轮胎的店铺业务里，就算轮胎离开了汽车，它也是有意义的，这就可以用聚合了。在《敏捷开发》中还说到，A组合B，则A需要知道B的生存周期，即可能A负责生成或者释放B，或者A通过某种途径知道B的生成和释放。

他们的代码如下：

class C7 
...{
public:
    C8 theC8;

};

class C8 
...{
};

可以看到，代码和聚合是一样的。具体如何区别，可能就只能用语义来区分了。

3、依赖



依赖:
指C5可能要用到C6的一些方法，也可以这样说，要完成C5里的所有功能，一定要有C6的方法协助才行。C5依赖于C6的定义，一般是在C5类的头文件中包含了C6的头文件。ROSE对依赖关系不产生属性。

注意，要避免双向依赖。一般来说，不应该存在双向依赖。

ROSE生成的代码如下：

// C5.h
#include "C6.h"

class C5 
...{

};

// C6.h
#include "C5.h"

class C6
...{

};

虽然ROSE不生成属性，但在形式上一般是A中的某个方法把B的对象作为参数使用(假设A依赖于B)。如下：

#include "B.h"
class A
...{
          void Func(B &b);
}

那依赖和聚合\组合、关联等有什么不同呢？

关联是类之间的一种关系，例如老师教学生，老公和老婆，水壶装水等就是一种关系。这种关系是非常明显的，在问题领域中通过分析直接就能得出。

依赖是一种弱关联，只要一个类用到另一个类，但是和另一个类的关系不是太明显的时候（可以说是“uses”了那个类），就可以把这种关系看成是依赖，依赖也可说是一种偶然的关系，而不是必然的关系，就是“我在某个方法中偶然用到了它，但在现实中我和它并没多大关系”。例如我和锤子，我和锤子本来是没关系的，但在有一次要钉钉子的时候，我用到了它，这就是一种依赖，依赖锤子完成钉钉子这件事情。

组合是一种整体-部分的关系，在问题域中这种关系很明显，直接分析就可以得出的。例如轮胎是车的一部分，树叶是树的一部分，手脚是身体的一部分这种的关系，非常明显的整体-部分关系。

上述的几种关系（关联、聚合/组合、依赖）在代码中可能以指针、引用、值等的方式在另一个类中出现，不拘于形式，但在逻辑上他们就有以上的区别。

这里还要说明一下，所谓的这些关系只是在某个问题域才有效，离开了这个问题域，可能这些关系就不成立了，例如可能在某个问题域中，我是一个木匠，需要拿着锤子去干活，可能整个问题的描述就是我拿着锤子怎么钉桌子，钉椅子，钉柜子；既然整个问题就是描述这个，我和锤子就不仅是偶然的依赖关系了，我和锤子的关系变得非常的紧密，可能就上升为组合关系（让我突然想起武侠小说的剑不离身，剑亡人亡...）。这个例子可能有点荒谬，但也是为了说明一个道理，就是关系和类一样，它们都是在一个问题领域中才成立的，离开了这个问题域，他们可能就不复存在了。


4、泛化（继承）



泛化关系：如果两个类存在泛化的关系时就使用，例如父和子，动物和老虎，植物和花等。
ROSE生成的代码很简单，如下：

#include "C11.h"

class C12 : public C11
...{
};

5、这里顺便提一下模板



上面的图对应的代码如下：

template<int>
class C13 
...{
};

这里再说一下重复度，其实看完了上面的描述之后，我们应该清楚了各个关系间的关系以及具体对应到代码是怎么样的，所谓的重复度，也只不过是上面的扩展，例如A和B有着“1对多”的重复度，那在A中就有一个列表，保存着B对象的N个引用，就是这样而已。

好了，到这里，已经把上面的类图关系说完了，希望你能有所收获了，我也费了不少工夫啊（画图、生成代码、截图、写到BLOG上，唉，一头大汗）。不过如果能让你彻底理解UML类图的这些关系，也值得了。:)

UML图与应用代码例子:
1.泛化(Generalization)
[泛化]
表示类与类之间的继承关系，接口与接口之间的继承关系，或类对接口的实现关系。一般化的关系是从子类指向父类的，与继承或实现的方法相反。
[具体表现]
父类 父类实例＝new 子类()
[UML图](图1.1)

图1.1Animal类与Tiger类,Dog类的依赖关系

[代码表现]

2.依赖(Dependency)
[依赖]
对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系。
[具体表现]
依赖关系表现在局部变量，方法的参数，以及对静态方法的调用
[现实例子]
比如说你要去拧螺丝，你是不是要借助(也就是依赖)螺丝刀(Screwdriver)来帮助你完成拧螺丝(screw)的工作
[UML表现](图1.2)

图1.2 Person类与Screwdriver类的依赖关系

[代码表现]

1. public class Person{   
2.     /** 拧螺丝 */  
3.     public void screw(Screwdriver screwdriver){   
4.         screwdriver.screw();   
5.     }   
6. }  

3.关联(Association)
[关联]
对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。
[具体表现]
关联关系是使用实例变量来实现
[现实例子]
比如客户和订单，每个订单对应特定的客户，每个客户对应一些特定的订单；再例如公司和员工，每个公司对应一些特定的员工，每个员工对应一特定的公司
[UML图] (图1.3)

图1.3 公司和员工的关联关系

[代码表现]

1. public class Company{   
2.     private Employee employee;   
3.     public Employee getEmployee(){   
4.         return employee;   
5.     }   
6.     public void setEmployee(Employee employee){   
7.         this.employee=employee;   
8.     }   
9.     //公司运作   
10.     public void run(){   
11.         employee.startWorking();   
12.     }   
13. }  

(4)聚合（Aggregation）
[聚合]
当对象A被加入到对象B中，成为对象B的组成部分时，对象B和对象A之间为聚集关系。聚合是关联关系的一种，是较强的关联关系，强调的是整体与部分之间的关系。
[具体表现]
与关联关系一样，聚合关系也是通过实例变量来实现这样关系的。关联关系和聚合关系来语法上是没办法区分的，从语义上才能更好的区分两者的区别。
[关联与聚合的区别]
(1)关联关系所涉及的两个对象是处在同一个层次上的。比如人和自行车就是一种关联关系，而不是聚合关系，因为人不是由自行车组成的。
聚合关系涉及的两个对象处于不平等的层次上，一个代表整体，一个代表部分。比如电脑和它的显示器、键盘、主板以及内存就是聚集关系，因为主板是电脑的组成部分。
(2)对于具有聚集关系（尤其是强聚集关系）的两个对象，整体对象会制约它的组成对象的生命周期。部分类的对象不能单独存在，它的生命周期依赖于整体类的对象的生命周期，当整体消失，部分也就随之消失。比如张三的电脑被偷了，那么电脑的所有组件也不存在了，除非张三事先把一些电脑的组件（比如硬盘和内存）拆了下来。
[UML图](图1.4)

图1.3 电脑和组件的聚合关系

[代码表现]

1. public class Computer{   
2.     private CPU cpu;   
3.     public CPU getCPU(){   
4.         return cpu;   
5.     }   
6.     public void setCPU(CPU cpu){   
7.         this.cpu=cpu;   
8.     }   
9.     //开启电脑   
10.     public void start(){   
11.         //cpu运作   
12.         cpu.run();   
13.     }   
14. }  

[参考资料]
1.《Java与模式》(阎宏 编著) 第2章 统一建模语言UML简介

参考资料：
《UML参考手册》：第四章 4.3关系 36页 05年8月出版；
《UML用户指南》：
97页中说：
“泛化、关联，甚至包括实现其实都是某种依赖，只不过它们本身有足够重要的语义。如果你先对泛化、关联和实现建模，然后把所有其他关系都看作是依赖，你就不会犯错误。”

101页（高级关系一章）中说：
“Aggregation/Composition 聚合/组合 只是 Association 关联 的一种修饰，一种高级用法，用于细节建模（组合表示一种强拥有的聚合，整体与部分的生命周期一致）。”

（参考：http://www.umlchina.com/best/g24/u1127470.htm）

2.给上述文章补充一个实现的例子：

（不过，应该给接口和实现都加上getEmail，getTel之类的方法，这样才更好的体现接口的含义；图和java代码有待自己完善。）

3.补充组合的例子和uml图（实心）：
组合关系的uml图：
先画聚合关系，－》“open specification”－》“by value”；
这时聚合关系的图形就变成实心的了；