BlogJava-semovy-文章分类-设计模式

UML 类图关系

semovy — Tue, 22 Apr 2008 09:35:00 GMT

UML类图关系全面剖析

2008-04-10 作者:一雨田的专栏来源:CSDN

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

1、关联

1000){this.resized=true;this.style.width=1000;}">

双向关联：

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

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

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

1000){this.resized=true;this.style.width=1000;}" align=top>class C1
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>public:
1000){this.resized=true;this.style.width=1000;}" align=top> C2* theC2;
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>class C2
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>public:
1000){this.resized=true;this.style.width=1000;}" align=top> C1* theC1;
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};

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

1000){this.resized=true;this.style.width=1000;}">

单向关联:

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

生成代码如下：

1000){this.resized=true;this.style.width=1000;}" align=top>class C3
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>public:
1000){this.resized=true;this.style.width=1000;}" align=top> C4* theC4;
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>class C4
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};

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

1000){this.resized=true;this.style.width=1000;}">

自身关联（反身关联）：

自己引用自己，带着一个自己的引用。

代码如下：

1000){this.resized=true;this.style.width=1000;}" align=top>class C14
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>public:
1000){this.resized=true;this.style.width=1000;}" align=top> C14* theC14;
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};

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

2、聚合/组合

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

1000){this.resized=true;this.style.width=1000;}">

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

代码如下：

1000){this.resized=true;this.style.width=1000;}" align=top>class C9
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>public:
1000){this.resized=true;this.style.width=1000;}" align=top> C10 theC10;
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>class C10
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};
1000){this.resized=true;this.style.width=1000;}" align=top>

1000){this.resized=true;this.style.width=1000;}">

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

他们的代码如下：

1000){this.resized=true;this.style.width=1000;}" align=top>class C7
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>public:
1000){this.resized=true;this.style.width=1000;}" align=top> C8 theC8;
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>class C8
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>};

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

3、依赖

1000){this.resized=true;this.style.width=1000;}">

依赖:

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

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

ROSE生成的代码如下：

1000){this.resized=true;this.style.width=1000;}" align=top>// C5.h
1000){this.resized=true;this.style.width=1000;}" align=top>＃i nclude "C6.h"
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>class C5
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>// C6.h
1000){this.resized=true;this.style.width=1000;}" align=top>＃i nclude "C5.h"
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>class C6
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>};
1000){this.resized=true;this.style.width=1000;}" align=top>

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

1000){this.resized=true;this.style.width=1000;}" align=top>＃i nclude "B.h"
1000){this.resized=true;this.style.width=1000;}" align=top>class A
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top> void Func(B &b);
1000){this.resized=true;this.style.width=1000;}" align=top>}

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

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

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

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

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

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

4、泛化（继承）

1000){this.resized=true;this.style.width=1000;}">

泛化关系：如果两个类存在泛化的关系时就使用，例如父和子，动物和老虎，植物和花等。

ROSE生成的代码很简单，如下：

1000){this.resized=true;this.style.width=1000;}" align=top>＃i nclude "C11.h"
1000){this.resized=true;this.style.width=1000;}" align=top>
1000){this.resized=true;this.style.width=1000;}" align=top>class C12 : public C11
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>};

5、这里顺便提一下模板

1000){this.resized=true;this.style.width=1000;}">

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

1000){this.resized=true;this.style.width=1000;}" align=top>template
1000){this.resized=true;this.style.width=1000;}" align=top>class C13
1000){this.resized=true;this.style.width=1000;}" align=top>1000){this.resized=true;this.style.width=1000;}" align=top>...{
1000){this.resized=true;this.style.width=1000;}" align=top>};
1000){this.resized=true;this.style.width=1000;}" align=top>

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

semovy 2008-04-22 17:35 发表评论

利用java的动态代理写日志

semovy — Mon, 04 Feb 2008 19:12:00 GMT

1.测试的实体Bean Person类

Person.java

package com.semovy.bean;

public class Person {

private String id;

private String name;

private String note;

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getNote() {
return note;
}

public void setNote(String note) {
this.note = note;
}

public Person(String id, String name, String note) {
  super();
  this.id = id;
  this.name = name;
  this.note = note;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return "id: " + id + " name: " + name + " note: " + note;
}

}
2.操作Person实体类的接口PersonService

PersonService.java

package com.semovy.service;

import java.util.ArrayList;
import java.util.List;

import com.semovy.bean.Person;

public interface PersonService {

public List persons = new ArrayList();

public abstract void addPerson(Person person);

public abstract Person getPersonById(String id);

public abstract void deletePersonById(String id);

//public abstract void updatePerson(Person person);

public abstract void displayPersonById(String id);

public abstract void displayAllPersons();
}
3.实现PersonService接口的PersonServiceImpl

PersonServiceImpl.java

package com.semovy.service.impl;

import java.util.Iterator;

import com.semovy.bean.Person;
import com.semovy.service.PersonService;

public class PersonServiceImpl implements PersonService {

public void addPerson(Person person) {
persons.add(person);
}

public void deletePersonById(String id) {
  Iterator it = persons.iterator();
  while(it.hasNext())
  {
   Person person = (Person)it.next();
   if(person.getId().equals(id))
   {
    it.remove();
    break;
   }
  }
}

public void displayAllPersons() {

  Iterator it = persons.iterator();
  while(it.hasNext())
  {
   Person person = (Person)it.next();
   System.out.println(person.toString());
  }
}

public void displayPersonById(String id) {

  Iterator it = persons.iterator();
  while(it.hasNext())
  {
   Person person = (Person)it.next();
   if(person.getId().equals(id))
   {
    System.out.println(person.toString());
    break;
   }
  }

}

public Person getPersonById(String id) {
  Iterator it = persons.iterator();
  while(it.hasNext())
  {
   Person person = (Person)it.next();
   if(person.getId().equals(id))
   {
    return person;
   }
  }
  return null;
}

/*public void updatePerson(Strin) {
  Iterator it = persons.iterator();
  while(it.hasNext())
  {
   Person person = (Person)it.next();
   if(person == aperson)
   {
    persons.set(arg0, arg1)
   }
  }
}*/

}

4.写日志的代理类LogProxy 它实现了InvocationHandler接口

LogProxy.java

package com.semovy.bean;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

public class LogProxy implements InvocationHandler {

Logger logger = Logger.getLogger(this.getClass().getName());
private Object delegate = null;

public Object getDelegate() {
return delegate;
}

public void setDelegate(Object delegate) {
this.delegate = delegate;
}

public Object bind(Object delegate) {
  this.delegate = delegate;
  return Proxy.newProxyInstance(delegate.getClass().getClassLoader(),
    delegate.getClass().getInterfaces(),this);
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  Object result = null;
  try
  {
   logger.log(Level.INFO,method.getName() + " 开始处理...");
   result = method.invoke(this.delegate, args);
   logger.log(Level.INFO,method.getName() + " 结束处理...");
  }catch(Exception e)
  {
   logger.log(Level.ERROR,e.getLocalizedMessage());
  }

  return result;
}
}

5.在eclipse中添加log4j.properties

log4j.properties

log4j.rootLogger=DEBUG,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%F:%L) - %m%n

5.写测试类Test.java

Test.java

package com.semovy.test;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.List;

import com.semovy.bean.LogProxy;
import com.semovy.bean.Person;
import com.semovy.service.PersonService;
import com.semovy.service.impl.PersonServiceImpl;

public class Test {

/**
* @param args
*/
public static void main(String[] args) {

  LogProxy logProxy = new LogProxy();
  PersonService personService = (PersonService)logProxy.bind(new PersonServiceImpl());
  personService.addPerson(new Person("1","name1","note1"));
  personService.addPerson(new Person("2","name2","note2"));
  personService.addPerson(new Person("3","name3","note3"));
  personService.addPerson(new Person("4","name4","note4"));
  personService.displayPersonById("3");
  personService.displayAllPersons();
  Person person = personService.getPersonById("2");
  person.setName("名称2");
  person.setNote("注脚2");
  personService.displayAllPersons();
  personService.deletePersonById("2");
  personService.displayAllPersons();
  //saveToFile(persons,"c:/persons.txt");
}

public static void saveToFile(List list,String path)
{
  System.out.println("开始写入文件...");
  try
  {
   PrintWriter out = new PrintWriter(new File(path));
   Iterator it = list.iterator();
   while(it.hasNext())
   {
    Person person = (Person)it.next();
    out.println(person.toString());
   }
   out.flush();
   out.close();
   System.out.println("结束写入文件...");
  }catch(IOException e)
  {
   System.out.println(e.getLocalizedMessage());
  }

}
}

6.运行测试结果:

2008-02-05 02:55:28,926 INFO (LogProxy.java:34) - addPerson 开始处理...
2008-02-05 02:55:28,926 INFO (LogProxy.java:36) - addPerson 结束处理...
2008-02-05 02:55:28,926 INFO (LogProxy.java:34) - addPerson 开始处理...
2008-02-05 02:55:28,926 INFO (LogProxy.java:36) - addPerson 结束处理...
2008-02-05 02:55:28,926 INFO (LogProxy.java:34) - addPerson 开始处理...
2008-02-05 02:55:28,936 INFO (LogProxy.java:36) - addPerson 结束处理...
2008-02-05 02:55:28,936 INFO (LogProxy.java:34) - addPerson 开始处理...
2008-02-05 02:55:29,036 INFO (LogProxy.java:36) - addPerson 结束处理...
2008-02-05 02:55:29,036 INFO (LogProxy.java:34) - displayPersonById 开始处理...
id: 3 name: name3 note: note3
2008-02-05 02:55:29,036 INFO (LogProxy.java:36) - displayPersonById 结束处理...
2008-02-05 02:55:29,036 INFO (LogProxy.java:34) - displayAllPersons 开始处理...
id: 1 name: name1 note: note1
id: 2 name: name2 note: note2
id: 3 name: name3 note: note3
id: 4 name: name4 note: note4
2008-02-05 02:55:29,046 INFO (LogProxy.java:36) - displayAllPersons 结束处理...
2008-02-05 02:55:29,046 INFO (LogProxy.java:34) - getPersonById 开始处理...
2008-02-05 02:55:29,046 INFO (LogProxy.java:36) - getPersonById 结束处理...
2008-02-05 02:55:29,046 INFO (LogProxy.java:34) - displayAllPersons 开始处理...
id: 1 name: name1 note: note1
id: 2 name: 名称2 note: 注脚2
id: 3 name: name3 note: note3
id: 4 name: name4 note: note4
2008-02-05 02:55:29,046 INFO (LogProxy.java:36) - displayAllPersons 结束处理...
2008-02-05 02:55:29,046 INFO (LogProxy.java:34) - deletePersonById 开始处理...
2008-02-05 02:55:29,046 INFO (LogProxy.java:36) - deletePersonById 结束处理...
2008-02-05 02:55:29,046 INFO (LogProxy.java:34) - displayAllPersons 开始处理...
id: 1 name: name1 note: note1
id: 3 name: name3 note: note3
id: 4 name: name4 note: note4
2008-02-05 02:55:29,046 INFO (LogProxy.java:36) - displayAllPersons 结束处理...

semovy 2008-02-05 03:12 发表评论

关于项目框架设计的一点学习

semovy — Sun, 16 Sep 2007 13:10:00 GMT

关于项目框架设计的一点学习

这两天又在接触一个新项目，对于如何设计一个项目的框架有了点概念，关于web项目（对于oa系统来说）的主体感觉比较需要设计的几部分为：

1．页面模板定义：关于view层展示，无论对于top（顶层菜单）+left（左边树状菜单）+right（主体内容）结构还是left+right结构，都需要首先定制一些模板，如struts中可使用tiles定义。

2．分页标签：自定义一个比较通用的分页标签或者使用一些框架中自带的（如struts-menu或者JSF中的t:dataScroller），不过比较好的做法是基于其源码编写自己的分页标签。

3． DB 设计：可使用Power Deisign等设计数据库表结构，产生相关的表。

4．代码自动生成：编写代码生成脚本如build.xml文件的编写（根据DB生成代码，也可以忽略3，先建model，再从model生成代码和数据库schema），生成Struts、Spring、Hibernate相关文件。

关于代码的整体架构如下：

action 层：处理从view层传递过来的数据。

service 层：封装业务逻辑，一般同时在spring中声明事务代理。

dao 层：进行事务中的原子操作，同时在spring中注入相应的sessionFactory。

Spring + Struts 取得spring的bean的两种常用方法：

1. DelegatingActionProxy ：将所有action标签中type属性设为org.springframework.web.struts.DelegatingActionProxy　也就是将action委托给了spring，同时在 action-servlets.xml 中配置一个于action标签path属性对应的bean(也就是bean的name值等于action的path值)，如：

struts-config.xml 中，以struts的plugin的方式,让spring接管struts的action：

< action name = "portalForm" parameter = "method" path = "/portalAction" type = "org.springframework.web.struts.DelegatingActionProxy" scope = "request" >

< forward name = "portalEdit" path = " pages/portalEdit.jsp" />

< forward name = "portalList" path = " pages/portalList.jsp " />

action >

< plug-in className = "org.springframework.web.struts.ContextLoaderPlugIn" >

< set-property property = "contextConfigLocation"

value = "/WEB-INF/action-servlets.xml" />

plug-in >

action-servlets.xml （配置文件格式和spring配置一样）中：

< beans >

< bean name = "/portalAction"

class = "com.cn.lively.action.PortalMainAction" >

< property name = "portalService" >

< ref bean = "portalService" />

property >

bean >

beans >

2. WebApplicationContextUtils.getRequiredWebApplicationContext ：在action中获得spring的bean，

public Object getService (String name) {

ApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servlet.getServletContext());

return wac .getBean(name);

}

这种方式没有在struts里边加入spring的plugin，实际上是使用了依赖查找来获得对象，并且在servlet代码中硬编码了应用对象的bean名字。

附：

感觉一个国内小型项目（周期半年左右）的开发，完美的团队大概四个人左右就够了，

A ：前期框架设计 + 开发过程中不断改进完美整个框架，角色——架构师

B ：前期需求调研 + 开发过程中负责技术难度比较大的模块开发，角色——程序员

C ：前期需求调研负责人 + 开发过程中负责业务逻辑复杂的模块开发，角色——项目负责人

D ：前期需求调研 + 开发过程中负责模块开发，角色——程序员

同时B、C负责共同解决开发中出现的技术和业务问题，C负责控制项目进度，

项目后期，B、C、D进行交叉测试，A负责review代码。

如果公司已经比较成熟的框架（即基本系统管理模块 + 代码自动生成），那么角色A可以省略，只需要B、C、D三个人即可进行项目开发，其中角色B在开发中担当一部分A的角色。

甚至可以只由B、C两个人进行开发，把角色D的工作分担到B、C身上，B侧重技术，C侧重业务逻辑。

semovy 2007-09-16 21:10 发表评论

UML类目及关系

semovy — Fri, 10 Aug 2007 06:38:00 GMT

UML类目及关系

类与类之间的关系对于理解面向对象具有很重要的作用，以前在面试的时候也经常被问到这个问题，在这里我就介绍一下。
类与类之间存在以下关系:
(1)泛化(Generalization)
(2)关联(Association)
(3)依赖(Dependency)
(4)聚合(Aggregation)

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

图1.1Animal类与Tiger类,Dog类的泛化关系

[代码表现]

class Animal{}
class Tiger extends Animal{}
public class Test
{
public void test()
{
Animal a= new Tiger();
}
}

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

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

[代码表现]

public class Person{
/** 拧螺丝 */
public void screw(Screwdriver screwdriver){
screwdriver.screw();
}
}

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

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

[代码表现]

public class Company{
private Employee employee;
public Employee getEmployee(){
return employee;
}
public void setEmployee(Employee employee){
this.employee=employee;
}
//公司运作
public void run(){
employee.startWorking();
}
}

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

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

[代码表现]

public class Computer{
private CPU cpu;
public CPU getCPU(){
return cpu;
}
public void setCPU(CPU cpu){
this.cpu=cpu;
}
//开启电脑
public void start(){
//cpu运作
cpu.run();
}
}

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

最终的判别可以以内存结构为区分，比如关联与依赖比较难分别，那么，你可以判断，某个对象是在当前类里被实例的还是，只传了引用！如果是引用，则关联，否则就是依赖！比如
public class Test {
private B b;
private A a;
public void exec() {
A a = new A();
b.exec();
}

//a , b 的getter,setter省略
}
其中A类对象a就是依赖，因为a对象的内存空间被创建在Test 这个类里
而B类的b对象则是引用！

semovy 2007-08-10 14:38 发表评论

统一建模语言UML

semovy — Wed, 30 May 2007 12:46:00 GMT

统一建模语言UML

软件工程领域在1995年至1997年取得了前所未有的进展,其成果超过软件工程领域过去15年来的成就总和。其中最重要的、具有划时代重大意义的成果之一就是统一建模语言(UML:Unified Modeling Language)的出现。

在世界范围内,至少在近10年内,UML将是面向对象技术领域内占主导地位的标准建模语言。采用UML作为我国统一的建模语言是完全必要的:首先,过去数十种面向对象的建模语言都是相互独立的,而UML可以消除一些潜在的不必要的差异,以免用户混淆;其次,通过统一语义和符号表示,能够稳定我国的面向对象技术市场,使项目根植于一个成熟的标准建模语言,从而可以大大拓宽所研制与开发的软件系统的适用范围,并大大提高其灵活程度。

统一建模语言（UML）是用来对软件密集系统进行描述、构造、视化和文档编制的一种语言。

首先，也是最重要的一点，统一建模语言融合了Booch、OMT和OOSE方法中的概念，它是可以被上述及其他方法的使用者广泛采用的一门简单、一致、通用的建模语言。

其次，统一建模语言扩展了现有方法的应用范围。特别值得一提的是，UML的开发者们把并行分布式系统的建模作为UML的设计目标，也就是说，UML具有处理这类问题的能力。

第三，统一建模语言是标准的建模语言，而不是一个标准的开发流程。虽然UML的应用必然以系统的开发流程为背景，但根据我们的经验，不同的组织，不同的应用领域需要不同的开发过程。举个例子来说，开发错综复杂的软件是非常有趣的工作，但开发这种软件与构造严格实时的航空电子系统是大不一样的，后者是性命攸关的大事。因此我们首先把精力集中在设计通用的元模型上（统一不同方法的语义），其次是建立通用的表示法（提供对这些语义的形象化的表达）。虽然UML的开发者们将继续倡导从用例驱动到体系结构为中心最后反复改进、不断添加的软件开发过程，但实际上设计标准的开发流程并不是非常必要的。

UML是一种定义良好、易于表达、功能强大且普遍适用的建模语言。它溶入了软件工程领域的新思想、新方法和新技术。它的作用域不限于支持面向对象的分析与设计,还支持从需求分析开始的软件开发的全过程。

面向对象技术和UML的发展过程可用上图来表示,标准建模语言的出现是其重要成果。在美国,截止1996年10月,UML获得了工业界、科技界和应用界的广泛支持,已有700多个公司表示支持采用UML作为建模语言。1996年底,UML已稳占面向对象技术市场的85%,成为可视化建模语言事实上的工业标准。1997年11月17日,OMG采纳UML 1.1作为基于面向对象技术的标准建模语言。UML代表了面向对象方法的软件开发技术的发展方向,具有巨大的市场前景,也具有重大的经济价值和国防价值。

标准建模语言UML的内容

首先,UML融合了Booch、OMT和OOSE方法中的基本概念,而且这些基本概念与其他面向对象技术中的基本概念大多相同,因而,UML必然成为这些方法以及其他方法的使用者乐于采用的一种简单一致的建模语言;其次,UML不仅仅是上述方法的简单汇合,而是在这些方法的基础上广泛征求意见,集众家之长,几经修改而完成的,UML扩展了现有方法的应用范围;第三,UML是标准的建模语言,而不是标准的开发过程。尽管UML的应用必然以系统的开发过程为背景,但由于不同的组织和不同的应用领域,需要采取不同的开发过程。

作为一种建模语言,UML的定义包括UML语义和UML表示法两个部分。

(1) UML语义描述基于UML的精确元模型定义。元模型为UML的所有元素在语法和语义上提供了简单、一致、通用的定义性说明,使开发者能在语义上取得一致,消除了因人而异的最佳表达方法所造成的影响。此外UML还支持对元模型的扩展定义。

(2) UML表示法定义UML符号的表示法,为开发者或开发工具使用这些图形符号和文本语法为系统建模提供了标准。这些图形符号和文字所表达的是应用级的模型,在语义上它是UML元模型的实例。

标准建模语言UML的重要内容可以由下列五类图(共9种图形)来定义:

·第一类是用例图,从用户角度描述系统功能,并指出各功能的操作者。

·第二类是静态图(Static diagram),包括类图、对象图和包图。其中类图描述系统中类的静态结构。不仅定义系统中的类,表示类之间的联系如关联、依赖、聚合等,也包括类的内部结构(类的属性和操作)。类图描述的是一种静态关系,在系统的整个生命周期都是有效的。对象图是类图的实例,几乎使用与类图完全相同的标识。他们的不同点在于对象图显示类的多个对象实例,而不是实际的类。一个对象图是类图的一个实例。由于对象存在生命周期,因此对象图只能在系统某一时间段存在。包由包或类组成,表示包与包之间的关系。包图用于描述系统的分层结构。

·第三类是行为图(Behavior diagram),描述系统的动态模型和组成对象间的交互关系。其中状态图描述类的对象所有可能的状态以及事件发生时状态的转移条件。通常,状态图是对类图的补充。在实用上并不需要为所有的类画状态图,仅为那些有多个状态其行为受外界环境的影响并且发生改变的类画状态图。而活动图描述满足用例要求所要进行的活动以及活动间的约束关系,有利于识别并行活动。

·第四类是交互图(Interactive diagram),描述对象间的交互关系。其中顺序图显示对象之间的动态合作关系,它强调对象之间消息发送的顺序,同时显示对象之间的交互;合作图描述对象间的协作关系,合作图跟顺序图相似,显示对象间的动态合作关系。除显示信息交换外,合作图还显示对象以及它们之间的关系。如果强调时间和顺序,则使用顺序图;如果强调上下级关系,则选择合作图。这两种图合称为交互图。

·第五类是实现图( Implementation diagram )。其中构件图描述代码部件的物理结构及各部件之间的依赖关系。一个部件可能是一个资源代码部件、一个二进制部件或一个可执行部件。它包含逻辑类或实现类的有关信息。部件图有助于分析和理解部件之间的相互影响程度。

配置图定义系统中软硬件的物理体系结构。它可以显示实际的计算机和设备(用节点表示)以及它们之间的连接关系,也可显示连接的类型及部件之间的依赖性。在节点内部,放置可执行部件和对象以显示节点跟可执行软件单元的对应关系。

从应用的角度看,当采用面向对象技术设计系统时,首先是描述需求;其次根据需求建立系统的静态模型,以构造系统的结构;第三步是描述系统的行为。其中在第一步与第二步中所建立的模型都是静态的,包括用例图、类图(包含包)、对象图、组件图和配置图等五个图形,是标准建模语言UML的静态建模机制。其中第三步中所建立的模型或者可以执行,或者表示执行时的时序状态或交互关系。它包括状态图、活动图、顺序图和合作图等四个图形,是标准建模语言UML的动态建模机制。因此,标准建模语言UML的主要内容也可以归纳为静态建模机制和动态建模机制两大类。

semovy 2007-05-30 20:46 发表评论

UML基础知识

semovy — Wed, 16 May 2007 09:50:00 GMT

UML基础知识

1. 软件工程的5个阶段：需求分析(Requirements Capture)，系统分析与设计(System Analysis and Design)，实现(Implement)，测试(Test)，维护(Maintenance)。

2. UML的定义包括UML语义和UML表示法两个部分。UML语义描述基于UML的精确元模型定义。元模型为UML的所有元素在语法和语义上提供了简单、一致和通用的定义性说明。UML表示法，为开发者或开发工具使用图形工具和文本语法为系统建模提供了标准。

3. UML(Unified Modeling Language)由视图(View)，图(Diagram)，模型元素(Model Element)，通用机制(General Mechanism)等组成，还提供了扩展机制(Extension Mechanism)，使得UML语言能够适应一个特殊的方法或者扩充到一个组织或用户。

a) 视图是表达系统的某一方面特征的UML建模元素的子集，由多个图构成，是在某一个抽象层上，对系统的抽象表示。

b) 图是模型元素集的图形表示，通常由弧(关系)和顶点(其他模型元素)相互连接构成。

c) 模型元素代表面向对象中的类、对象、消息和关系等概念，是构成图的基本概念。

d) 通用机制用于表示其他信息，比如注释、模型元素的语义等。

4. UML用模型来描述系统的结构或静态特征，以及行为或动态特征，从不同的视角为系统架构建模，形成不同视角：

a) 用例视图(Use Case View)，强调从用户角度看到的或需要的系统功能，是被称为参与者的外部用户所能观察到的系统功能的模型图。

b) 逻辑视图(Logical View)，展现系统的静态或结构组成及特征，也被称为结构模型视图(Structural Model View)或者静态视图(Static View)。

c) 并发视图(Concurrent View)，体现了系统的动态或者行为特征，也称为行为模型视图(Behavioral Model View)或动态视图(Dynamic View)。

d) 组件视图(Component View)，体现了系统实现的结构和行为特征，也称为实现模型视图(Implementation Model View)。

e) 配置视图(Deployment View)，体现了系统实现环境的结构和行为特征，也被称为环境模型视图(Environment Model View)或者物理视图(Physical View)。

5. 视图由图构成，UML提供了9种不同的图：

a) 用例图(Use Case Diagram)，描述系统功能；

b) 类图(Class Diagram)，描述系统的静态结构；

c) 对象图(Object Diagram)，描述系统在某个时刻的静态结构；

d) 时序图(Sequence Diagram)，按时间顺序描述系统元素间的交互；

e) 协作图(Collaboration Diagram)，按照时间和空间顺序描述系统元素间的交互和他们之间的关系；

f) 状态图(State Diagram)，描述了系统元素的状态条件和响应；

g) 活动图(Activity Diagram)，描述了系统元素的活动；

h) 组件图(Component Diagram)，描述了实现系统的元素的组织；

i) 配置图(Deployment Diagram)，描述了环境元素的配置，并把实现系统的元素映射到配置上。

6. 图和视图之间的对应关系：
用户模型视图：用例图
结构模型视图：类图和对象图
行为模型视图：时序图、协作图、状态图和活动图
实现模型视图：组件图
环境模型视图：配置图

7. UML的两套建模机制，静态建模机制和动态建模机制。静态建模机制包括用例图、类图、对象图、包、组件图和配置图；动态建模机制包括消息、状态图、时序图、协作图、活动图。

semovy 2007-05-16 17:50 发表评论

UML概述

semovy — Mon, 07 May 2007 07:46:00 GMT

1.背景知识

1997年，OMG组织（Object Management Group对象管理组织）发布了统一建模语言（Unified Modeling Language，UML）。UML的主要创始人是Jim Rumbaugh、Ivar Jacobson和Grady Booch ,UML的目标之一就是为开发团队提供标准通用的设计语言来开发和构建计算机应用。UML提出了一套IT专业人员期待多年的统一的标准建模符号。通过使用UML，这些人员能够阅读和交流系统架构和设计规划, UML符号集只是一种语言而不是一种方法学. 2003年，UML已经获得了业界的认同.

2.简述

UML捕捉了软件系统有关决策和理解,用来理解、设计、浏览、配置、维护以及控制系统得信息.UML包括语义概念、标记符号和指南,据有静态、动态、环境上和组织性的部分.

I． UML捕捉静态结构和动态行为的信息。系统建模成独立对象的集合以及它们交互和实现。静态结构定义各种对象和实现已经它们的关系，动态行为定义了对象间的通讯。可以从不同视角进行建模，以不同视角理解系统。

II． UML可以用包来组织模型结构

3．目标

UML不是完整的开发方法，它不包括逐步的开发流程。但UML包括了所有必要的概念来解决现代迭代过程中解决用例驱动的需求。

4．UML概念范围

I．静态结构

II．动态行为

III．实现构造

IV．模型组织

V．扩展机制

5. UML视图

UML视图可以分为三个领域：结构型分类、动态行为和模型管理

I．结构性分类包括静态视图、用例视图和实现视图。它描述了系统中事物和事物之间的关系，包括类、用例、构件和节点，为构建动态行为提供了基础。

II．动态行为包括状态机视图、活动图和交互图。它描述了系统时间上的行为

III．模型管理，用包来组织模型，特殊的包包括模型和子系统，模型视图和其它视图交迭，为团队工作和配置控制把它们组织起来。

IV．扩展，包括约束、版型和标签值。

semovy 2007-05-07 15:46 发表评论

UML必懂！

semovy — Sun, 25 Mar 2007 07:17:00 GMT

1、活动图、类图用在详细设计。（详细设计和概要设计有些时候不是分的那么细）
2、顺序图、类图、构件图用在概要设计。
3、用例图、状态图是给客户看的。
4、顺序图是根据类图来画的，顺序图中的对象是类图中的类的实例，顺序图中一个对象
指向另一个对象的方法是这个对象的方法。

5、三层结构(1)界面类我做好了一些按钮、文本框、标签等，分给一个初级程序员就可以，
把界面规划好就行，对里面的业务不必关心。
(2)业务类这就要给一个高级程序员来做，主要是哪些类实现哪些方法就行。
(3)实体类用业务来调用实体，实体就是实实在在的东西。
注意:在界面类和业务类之间，有这样一个，用中间的接口人，
可以是高级程序员,他要用struts把界面和业务联系起来。
UML的课程总结

UML是干什么的,是用来表达我们思想的,我们的面向对象的思想.
想一想:我们来到这个班,是为了锻炼我们怎么去独立思考,怎么去工作的,
在设计的时候,要有一个设计的理念,和设计的思想,
只有你自己真的动脑去想了,那才是你自己的,老师告诉你,
那是老师的,不是你的.
说一下九个图:

一、需求阶段:1、用例图 (1)你画完了，主要是用户能否看懂。
(2)你画的用例图里是不是覆盖了用户需求的每一个功能和要求。
　　 2、状态图 (1)在这个状态很重要的情况下，要把它画出来。
(2)很强调状态时需要画它。
二、设计阶段包括（概要设计和详细设计分公司而言）
　　　　　　 1、概要设计(1)构件图 @强调软件之间的和部署图形成对比。
(2)时序图 @宽广的时候用在概要设计。
(3)类图 @
(4)协作图 @
　　 2、详细设计(1)类图 @在这里面一定要写详细了，让编码人员看完，伪代码就能出来（伪代码是指一般用代码的格式表示程序执行过程和算法，但不能在编译器上通过编译的代码，目的是为了展示程序的执行过程。）
@每个类的方法，属性都要写出来。
(2)活动图 @逻辑复杂的时候要用到它，如果想练习的话，可以用随机抽题这个来练。
(3)时序图 @主要强调顺序，就是必须按这个顺序来的。
(4)部署图 @是强调硬件之间的和上面的构件图形成对比。
重点：1、用例图
2、类图
3、时序图
4、活动图 ·是给一个编码人员就可以做出来的东西，每一句一句的翻译过来。不需要知道太多。

还有一个要说的是：计划进度表。
(1)需求从多长时间到多长时间。
(2)设计从多长时间到多长时间。
(3)编码从多长时间到多长时间。

摘自 chenkaituo 的BLOG

semovy 2007-03-25 15:17 发表评论