一、定义
     代理模式（Proxy Pattern）, 为其他对象提供一种代理以控制对这个对象的访问。在某些情况下 ，一个客户不 想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

     代理模式一般涉及到的角色有：

          抽象角色 ：声明真实对象和代理对象的共同接口；

          代理角色 ： 代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可 以在执行真实对象操作时，附加其他                       的操作，相当于对真实对象进行封装。

          真实角色 ：代理角色所代表的真实对象，是我们最终要引用的对象。

二、为什么要使用Proxy模式
1.授权机制 不同级别的用户对同一对象拥有不同的访问权利,如Jive论坛系统中,就使用Proxy进行授权机制控制,访问论坛有两种人:注册用户和游客(未注册用 户),Jive中就通过类似ForumProxy这样的代理来控制这两种用户   对论坛的访问权限.

2.某个客户端不能直接操作到某个对象,但又必须和那个对象有所互动.
  举例两个具体情况:
      (1)如果那个对象是一个是很大的图片,需要花费很长时间才能显示出来,那么当这个图片包含在文档中时,使用编辑器或浏览器打开这个文档,打开文档必须很 迅速,不能等待大图片处理完成,这时需要做个图片Proxy来代          替真正的图片.
      (2)如果那个对象在Internet的某个远端服务器上,直接操作这个对象因为网络速度原因可能比较慢,那我们可以先用Proxy来代替那个对象.

  总之原则是,对于开销很大的对象,只有在使用它时才创建,这个原则可以为我们节省很多宝贵的Java内存。Proxy应用范围很广,现在流行的分布计算方式RMI和Corba等都是Proxy模式的应用。

三、 如何使用

以下以《Java与模式》中的示例为例：

抽象角色：

abstract public class Subject{

    abstract public void request();

}

真实角色： 实现了Subject的request()方法。

public class RealSubject extends Subject{

       public RealSubject(){

       }

       public void request(){

              System.out.println("From real subject.");

       }

}

代理角色：

public class ProxySubject extends Subject{

    private RealSubject realSubject;  //以真实角色作为代理角色的属性

       public ProxySubject(){

       }

       //该方法封装了真实对象的request方法

       public void request()  {

            preRequest(); 

            if( realSubject == null ){

                 realSubject = new RealSubject();

            }

            realSubject.request();  //此处执行真实对象的request方法

            postRequest();

       }

    private void preRequest(){

        //something you want to do before requesting

    }

    private void postRequest() {

        //something you want to do after requesting

    }

}

客户端调用：

Subject sub=new ProxySubject();

Sub.request();

     由 以上代码可以看出，客户实际需要调用的是RealSubject类的request()方法，现在用ProxySubject来代理 RealSubject类，同样达到目的，同时还封装了其他方法(preRequest(),postRequest())，可以处理一些其他问题。

     另外，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个 代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。

四、动态代理类

       Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object [] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：

Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。

Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

Static Object newProxyInstance (ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

     所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

    在使用动态代理类时，我们必须实现InvocationHandler接口，以第一节中的示例为例：

抽象角色(之前是抽象类，此处应改为接口)：

public interface Subject{

    abstract public void request();

}

具体角色RealSubject：同上；

代理角色：

import java.lang.reflect.Method;

import java.lang.reflect.InvocationHandler;

public class DynamicSubject implements InvocationHandler {

  private Object sub;

  public DynamicSubject() {

  }

  public DynamicSubject(Object obj) {

    sub = obj;

  }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    System.out.println("before calling " + method);

    method.invoke(sub,args);

    System.out.println("after calling " + method);

    return null;

  }

}

     该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；此外，在该类还实现了invoke方法，该方法中的method.invoke(sub,args);其实就是调用被代理对象的将要被 执行的方法，方法参数sub是实际的被代理对象，args为执行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些相关操 作。

客户端：

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

public class Client{

    static public void main(String[] args) throws Throwable{

      RealSubject rs = new RealSubject();  //在这里指定被代理类

      InvocationHandler ds = new DynamicSubject(rs);  //初始化代理类

         Class cls = rs.getClass();

      //以下是分解步骤

      /*

      Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces()) ;

      Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});

      Subject subject =(Subject) ct.newInstance(new Object[]{ds});

     */

     //以下是一次性生成

      Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );

      subject.request();

}

     通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实现了非常灵活的动态代理关系。

五、代理模式的应用
一般来说分为几种：
1、远程（Remote）代理：也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实。
2、虚拟（Virtual）代理：根据需要将一个资源消耗很大或者比较复杂的对象延迟的真正需要时才创建。
    比如说你打开一个很大的HTML网页时，里面可能有很多的文字和图片，但你还是可以很快的打开它，此时你所看到的是所有的文字，但图片却是一张张的下载后才能看到。那些未打开的图片框，就是通过虚拟代理来代替了真实的图片，此时代理存储了真实图片的路径和尺寸。
3、保护（Protect or Access）代理：控制对一个对象的访问权限。一般用于对象有 不同权限的时候。
4、智能引用（Smart Reference）代理：当调用真实对象时，代理出来另外一些事，提供比对目标对象额外的服务。
    如：计算真实对象的引用次数，这样当该对象没有引用时，可以自动释放它；或当第一次引用一个持久对象时，将它装入内存；或在访问一个实际对象前，检查是否已经锁定它，以确保其它对象不能改变它。它们都是通过代理在访问一个对象时附加一些内务处理。

• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

一、适配器模式定义
     Adapter，将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

二、详细说明
     通常，客户类（clients of class）通过类的接口访问它提供的服务。有时，现有的类（existing class）可以提供客户类的功能 需要，但是它所提供的接口不一定是客户类所期望的。这是由于现有的接口太详细或者缺乏详细或接口的名称与客户类所查找的不同等诸多不同原因导致的。

　 　在这种情况下，现有的接口需要转化（convert）为客户类期望的接口，这样保证了对现有类的重用。如果不进行这样的转化，客户类就不能利用现有类所 提供的功能。适配器模式（Adapter Pattern）可以完成这样的转化。适配器模式建议定义一个包装类，包装有不兼容接口的对象。这个包装类指的 就是适配器（Adapter），它包装的对象就是适配者(Adaptee)。适配器提供客户类需要的接口，适配器接口的实现是把客户类的请求转化为对适配 者的相应接口的调用。换句话说：当客户类调用适配器的方法时，在适配器类的内部调用适配者类的方法，这个过程对客户类是透明的，客户类并不直接访问适配者 类。因此，适配器可以使由于借口不兼容而不能交互的类可以一起工作（work together）。

三、Adapter的分类

适配器总体上可以分为两类，类适配器（Class Adapter）和对象适配器(Object Adapter)

类适配器：

　　类适配器是通过继承类适配者类（Adaptee Class）实现的，另外类适配器实现客户类所需要的接口。当客户对象调用适配器类方法的时候，适配器内部调用它所继承的适配者的方法。

对象适配器：

　　对象适配器包含一个适配器者的引用（reference），与类适配器相同，对象适配器也实现了客户类需要的接口。当客户对象调用对象适配器的方法的时候，对象适配器调它所包含的适配器者实例的适当方法。

　　下表是类适配器（Class Adapter）和对象适配器(Object Adapter)的详细不同：

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

public class Singleton {
private Singleton(){}
　　    //在自己内部定义自己一个实例，是不是很奇怪？
　　    //注意这是private 只供内部调用
　　    private static Singleton instance = new Singleton();
　　    //这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　    public static Singleton getInstance() {
　　　　    return instance; 　　
　　    }
} 

public class Singleton {
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　    //这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　    //使用时生成实例，提高了效率！
　　    if (instance==null)
　　　　    instance＝new Singleton();
        return instance; 　　

    }
} 

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

一、原型模式定义
     用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.

     Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节。

     工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

二、如何使用
     因为Java中的提供clone()方法来实现对象的克隆,所以Prototype模式实现一下子变得很简单.

三、实例

public abstract class AbstractSpoon implements Cloneable{
　　String spoonName;

　　public void setSpoonName(String spoonName) {
            this.spoonName = spoonName;
      }
　　public String getSpoonName() {return this.spoonName;}

　　public Object clone(){
　　　　Object object = null;
　　　　try {
　　　　　　object = super.clone();
　　　　} catch (CloneNotSupportedException exception) {
　　　　　　System.err.println("AbstractSpoon is not Cloneable");
　　　　}
　　　　return object;
　　}
}

 有个具体实现(ConcretePrototype):

public class SoupSpoon extends AbstractSpoon{
　　public SoupSpoon(){
　　　　setSpoonName("Soup Spoon");
　　}
}

调用Prototype模式很简单:

AbstractSpoon spoon = new SoupSpoon();
AbstractSpoon spoon2 = spoon.clone();

当然也可以结合工厂模式来创建AbstractSpoon实例。

在Java中Prototype模式变成clone()方法的使用，此方法执行的是该对象的“浅表复制”，而不“深层复制”操作。

四、说明：
克隆必须满足的条件：
a.对任何的对象x,都有：x.clone() != x,即克隆对象与原对象不是同一个对象。
b.对任何的对象x,都有：x.clone().getClass() == x.get getClass()，即克隆对象与原对象的类型是一样的。 c.如果对象x的equals()方法定义恰当的话，那么x.clone().equals(x)应当是成立的。
在java中实现clone()应该满足这三个条件。

浅复制：复制了值类型对象，对于引用类型对象，只复制了引用，它指向原来引用的对象。Java中clone为浅复制。
深复制：对值类型和引用类型的对象都生成一份新的拷贝. Java中可以通过串行化来进行深复制,前提是对象以及对象内部所引用的对象都是可串行化的，否则需要考虑将那些不可串行化的对象可否设为transient,排除           在复制过程之外。

• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

      构造者模式（Builder Pattern）：构造者模式将一个复杂对象的构造过程和它的表现层分离开来，使得同样的构建过程可以创建不同的表示，又称为生成器模式。

    在软件系统 中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变 化，但是将它们组合在一起的算法确相对稳定。如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定 构建算法”不随着需求改变而改变？
      如果我们使用了构造者模式，那么用户就只需要指定需要构造的类型就可以得到它们，而具体的构造过程和细节就不需要知道了。

二、类图和图解

//产品类：
package com.javapatterns.builder;

public class Product{
    public Product(){
       // System.out.println("product is initing.");
    }
}

 //抽象建造方法：
package com.javapatterns.builder;

abstract public class Builder{
    public abstract void buildPart1();

    public abstract void buildPart2();

    public abstract Product retrieveResult();
}

//具体的建造类：产品的零件制造
package com.javapatterns.builder;

public class ConcreteBuilder extends Builder{

    private Product product = new Product() ;
    public void buildPart1(){
        System.out.println("build part one.");
    }

    public void buildPart2(){
        System.out.println("build part two.");
    }

    public Product retrieveResult(){
        return product;
    }
}

//产品的建造过程：
package com.javapatterns.builder;

public class Director{
    private Builder builder;

    public Director(Builder builder){
        this.builder = builder;
    }

   public void construct(){
        builder = new ConcreteBuilder();

        builder.buildPart1();

        builder.buildPart2();

        builder.retrieveResult();

        //continue with other code
    }
}

//测试：
package com.javapatterns.builder;

public class Client{

    private static Director director;

    private static Builder builder = new ConcreteBuilder();
       
    public void requestBuild(){
       // director = new Director(builder);
    }
   
     public static void main(String[] args) {
        director = new Director(builder);
        director.construct();
    }

}

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师

    抽象工厂（Abstract Factory）模式，又称工具箱（Kit 或Toolkit）模式。

二、创建过程如下

     一个具体工厂创建一个产品族，一个产品族是不同系列产品的组合，产品的创建的逻辑分在在每个具体工厂类中。所有的具体工厂继承自同一个抽象工厂。
    客户端创建不同产品族的工厂，产品族的工厂创建具体的产品对客户端是不可见的。
    增加新的产品族时，需要增加具体工厂类,符合OCP原则。
    增加新产品时，需要修改具体工厂类和增加产品类，不符合OCP原则
    如果没有应对“多系列对象创建”的需求变化，则没有必要使用抽象工厂模式，这时候使用简单的静态工厂完全可以。

三、一个简单的实例

// 产品 Plant接口
public interface IPlant { }
//具体产品PlantA，PlantB
public class PlantA implements IPlant {

　public PlantA () {
　　System.out.println("create PlantA !");
　}

　public void doSomething() {
　　System.out.println(" PlantA do something ...");
　}
}
public class PlantB implements IPlant {
　public PlantB () {
　　System.out.println("create PlantB !");
　}

　public void doSomething() {
　　System.out.println(" PlantB do something ...");
　}
}
// 产品 Fruit接口
public interface IFruit { }
//具体产品FruitA，FruitB
public class FruitA implements IFruit {
　public FruitA() {
　　System.out.println("create FruitA !");
　}
　public void doSomething() {
　　System.out.println(" FruitA do something ...");
　}
}
public class FruitB implements IFruit {
　public FruitB() {
　　System.out.println("create FruitB !");
　}
　public void doSomething() {
　　System.out.println(" FruitB do something ...");
　}
}
// 抽象工厂方法
public interface AbstractFactory {
　public IPlant createPlant();
　public IFruit createFruit() ;
}
//具体工厂方法
public class FactoryA implements AbstractFactory {
　public IPlant createPlant() {
　　return new PlantA();
　}
　public IFruit createFruit() {
　　return new FruitA();
　}
}
public class FactoryB implements AbstractFactory {
　public IPlant createPlant() {
　　return new PlantB();
　}
　public IFruit createFruit() {
　　return new FruitB();
　}
}

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

一 、工厂方法（Factory Method）模式
     工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

    工厂方法（Factory Method）模式，又称多态性工厂（Polymorphic Factory）模
式或虚拟构造子（Virtual Constructor）模式；

二、工厂方法模式角色与结构
    抽象工厂（Creator）角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
　 具体工厂（Concrete Creator）角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。在上图中有两个这样的角色：BulbCreator与TubeCreator。
　 抽象产品（Product）角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在上图中，这个角色是Light。
　 具体产品（Concrete Product）角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

三、创建过程如下

     一个工厂创建一个产品，所有的具体工厂继承自一个抽象工厂接口。
    客户端先创建不同产品的工厂，再由工厂创建具体产品，产品的创建逻辑分散在每个具体工厂类中。
    客户端只依赖于抽象工厂与抽象产品，不依赖任何具体的工厂与具体产品
    增加新产品时，需要增加工厂类和产品类，符合OCP原则

四、一个简单的实例　　　

// 产品 Plant接口
public interface IPlant { }
//具体产品PlantA，PlantB
public class PlantA implements IPlant {

　public PlantA () {
　　System.out.println("create PlantA !");
　}

　public void doSomething() {
　　System.out.println(" PlantA do something ...");
　}
}
public class PlantB implements IPlant {
　public PlantB () {
　　System.out.println("create PlantB !");
　}

　public void doSomething() {
　　System.out.println(" PlantB do something ...");
　}
}
// 工厂方法接口
public interface IFactory {
　public IPlant createPlant();
}
//具体工厂方法
public class FactoryA implements IFactory {
　public IPlant createPlant() {
　　return new PlantA();
　}
}
public class FactoryB implements IFactory {
　public IPlant createPlant() {
　　return new PlantB();
　}
} 	

//客户端

IFactory plantFactory = new FactoryA();

IPlant planta = plantFactory.createPlant();

 planta.doSomething();

 

//若增加新产品PlantC时，只需要增加FactoryC工厂类和PlantC产品类即可。

此外，还有一个数字的加减乘除例子

五、工厂方法模式与简单工厂模式

　　工厂方法模式与简单工厂模式再结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。

　　工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。

　　当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了"开放－封闭"原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。

　　工厂方法模式退化后可以演变成简单工厂模式

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师

//生产产品的工厂类
public class ProductFactory{
　　public static Product generateProduct(int which){ //这个方法是static的
　　if (which==1)
　　　　return new ProductA();
　　else if (which==2)
　　　　return new ProductB();
　　}
}

//抽象产品
public interface Product {
     .....
}

//具体产品A
public ProductA implement Product {
     ProductA () {}
}

//具体产品B
public ProductB implement Product {
     ProductB () {}
}

//调用工厂方法
public Client {
     public method1() {
         ProductFactory.generateProduct(1);
     }
}

interface a{}

class b implements a{};

class c implements a{};

//工厂类
public class factory{
     public static a createa(string name){
         class cls=class.forname(name);
         object obj=cls.getinstance();
         return (a)obj;
     }
}
//创建实例时
a　b=factory.createa("b");
a  c=factory.createa("c"); 

• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

如何学习设计模式？

1 先理解概念，再学习原则

先理解OO的基本概念，比如：封装、继承、多态、组合/聚合、依赖等，理解各概念的内涵，弄清楚这些概念的具体实现方式及各实现方式的优缺点。

2 先学习原则，再学习模式

设计原则是蕴含在设计模式后最根本的思想，掌握了基本的设计原则可以做到不拘泥于某个具体的设计模式，可以更容易的理解设计模式，知道在何种情况下应该采用某种模式，可以自己创造合理的设计模式。设计原则可以参考的2本书籍是《敏捷软件开发》与《UML与模式应用》。

3 从责任分配的角度学习设计模式

责任驱动的思想是学习设计模式的很好的思想，通过给各个类合理的分配实现某个需求的责任来理解设计模式。

4 类图与交互图并重

不要仅仅关注类图，类图仅仅是表达了类之间的静态关系，而交互图表达了对象之间的动态关系，可以看到对象与对象是如何写作完成一项事务。

5 从重构到模式

设计模式是一种固定的设计套路，是基于实践总结出来的可复用的解决方案，是一种经验的总结结果，如果仅仅看到最终的结果往往无法体会其用意，通过不断对某个需求的实现方案进行重构，得到最终的设计模式，可以对设计模式的背后的思想理解的更深刻。

6 记住典型案例

  通过类比，通过隐喻，通过记住某个典型案例，可以得到对设计模式的感性认识。

7 从客户的角度考虑如何使用

    在理解设计模式时，一定要从使用这些类的客户的角度来考虑是如何使用的？这样可以更容易理解该模式是如何对客户来封装的，实现了哪些封装，为了实现这些封装，采用了哪些手法？

在学习设计模式之前，最好先了解一下面向对象设计中的一些原则。

一、 "开放－封闭"原则(OCP)
     Open-Closed Principle原则讲的是：一个软件实体（类、模块、函数等等）应该可以扩展，但是不可修改。

    我们在做任何系统的时候，都不要指望系统一开始时需求确定，就再也不会变化，这是不现实也不科学的想法；儿既然需求是一定会变化的，那么如何在面对需求的 变化时，设计的软件可以相对容易修改，不至于说，新需求一来，就要把整个程序推到重来。怎样的设计才能面对需求的改变却可以保持相当稳定，从而使得系统可 以在第一个版本以后不断推出新的版本呢？这就要求我们遵循OCP原则，多扩展，少修改。面对新需求，对程序的改动是通过增加新代码进行的，而不是更改现有 的代码。通过扩展已有软件系统，可以提供新的行为。而对已有软件模块，特别是最重要的抽象层模块不能再修改，这使变化中的软件系统有一定的稳定性和延续 性。

    开放-封闭原则是面向对象设计的核心所在。遵循这个原则可以带来面向对象技术所声称的巨大好处，也就是可维护、可扩展、可复用、灵活性好。开发人员应该仅 对程序中呈现出频繁变化的那些部分做出抽象，然而，对于应用程序中的每个部分都刻意地进行抽象同样不是一个好注意。拒绝不成熟的抽象和抽象本身一样重要。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

　　应用程序结构和J2EE

　　J2EE是一个很成功的技术，它为一些基本的任务提供了一致的标准，例如数据库连接、分布式应用程序等。但是使用J2EE并不能保证开发人员开发出成功的应用程序。有些人认为J2EE本身就是一种框架技术，但是这种认识是不正确的，我们应该意识到J2EE并没有提供一个能够帮助开发人员开发出高质量应用程序的框架，因此很多有经验的开发人员通过利用设计模式来弥补这一缺项。

　　设计模式

　　在开发人员的圈子中，大家通过相互交流在开发过程中所遇到的问题以及解决方法来丰富整个圈子的 经验。而设计模式就是在这样的情况下产生的。一个设计模式必然是针对某个特定的问题的，这个问题的解决方案以及这样解决问题产生的后果。在解决利用 J2EE进行程序开发中出现的问题的过程中，人们把设计模式分为两类，一种是通用开发模式，一种是为了解决特定的J2EE问题的模式。下面让我们来看一看 每一种类型的开发模式都包含了哪些内容。

　　J2EE设计模式

　　J2EE设计模式在过去几年中随着Java开发人员经验的不断成长而发展。这些设计模式是针对 使用各种J2EE技术时可能出现的问题提出的，它们能够帮助开发人员构造出应用程序框架的要求。例如，Front Controller（前端控件）模式将servlet代码的开发转化为在图形用户界面下的开发。但是需要记住J2EE设计模型解决了那些在J2EE项目 中最可能出现的问题。如果你在J2EE遇到的问题很特殊，很有可能没有相应的设计模型来解决它。

　　软件开发设计模式

　　软件开发设计模式又被分为两种，一种是通用的面向对象设计模式。例如工厂（Factory）模式是一种面向对象的设计模式，它将对象的创建封装起来，使对象能够重用，这样就可以减少程序占用的系统资源。而另一种是基于Java的设计模式，这些设计模式要么是和Java的语言特性结合得很紧，要么是面向对象技术在Java中的深化。不要以为软件设计模式相对独立于J2EE就认为它们不重要，通常它们比J2EE设计模式更重要。这是因为：

　　1）J2EE设计模式是近几年才出现的，并且在不断变化，而软件开发设计模式经过了长时间的考验，比前者更加成熟和完善；

　　2）有些J2EE设计模式是建立在某些软件开发设计模式之上的；

　　3）软件开发模式为J2EE设计模式提供了坚实的基础。它的应用将影响到整个结构的稳定性和可扩充性。

　　在实际应用中，设计模式并不是一段具体的代码。设计模式通常是在设计说明书中描述。将设计模式应用到系统中的真正挑战在于如何在系统中应用模式中的思想。这些思想必须被应用到恰当的环境中。

　　根据设计模式的所解决的问题，又可以分为以下几个类型：

　　· 创建类型：创建类型的模式都是用于创建类的实例。但是和通过new来创建实例不同，这些模式提供了更加灵活的方式，是程序能够根据特定的情况创建特定的类。

　　· 结构类型：结构类型的模式帮助开发人员将简单对象组合在一起以后的更加复杂的结构。

　　· 行为类型：行为类型的模式帮助开发人员控制类之间的通讯。

　　创建类型的模式

　　所有创建类型的模式都和如何有效地创建类的实例相关。在Java中，如果开发人员要生成一个类的实例，最简单的方法是使用new关键字：

　　MyFoo = new Foo(); // 生成一个Foo的实例

　　这种方法只能够在程序中生成固定的类。但是在很多情况下，程序需要根据不同的情况生成不同的类的实例，这就需要将实例的生成过程抽象到一个特殊的创建类中，由该类在运行时决定生成哪种类的实例。这样使得程序有更好的灵活性和通用性。

　　创建类型的模式包括：

　　· 简单工厂模式（Factory Pattern）：根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，而这一组类有一个公共的抽象父类。

       工厂方法模式

　　· 抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式也可以根据提供的数据生成一组类中某一个类的实例，而这一组类有一个公共的抽象父类。只不过它定义的是一个接口。 例如：多数据库，多个表的访问

　　· 构造者模式（Builder Pattern）：构造者模式将一个复杂对象的构造过程和它的表现层分离开来，这样类就可以根据不同情况展现出不同的表现方式。

　　· 原型模式（Prototype Pattern）：原型模式通过对类的实例进行拷贝来创建新的实例。

　　· 单一模式（Singleton Pattern）：根据单一模式实现的类只允许有一个是类，并且提供了一个全局指针来引用该实例。

　　结构类型的模式

　　结构类型的模式将类和对象组合起来，以构成更加复杂的结构。它又被划分为类模式和对象模式。类模式和对象模式之间的区别在于类模式通过继承关系来提供有效的接口；而类模式通过对象合成或将对象包含在其它对象中的方式构成更加复杂的结构。

　　结构类型的模式包括了以下模式：

　　· 适配器模式（Adapter Pattern）：适配器模式可以将一个类的接口和另一个类的接口匹配起来。

　　· 桥梁模式（Bridge Pattern）：桥梁模式对客户端程序提供一个固定的接口，但是允许开发人员变化实际的实现类。这样开发人员就可以将接口是具体的实现类分离开来。

　　· 复合模式（Composite Pattern）：复合模式可以将多个对象进行复合，其中的每个对象可以是简单对象，也可以是复合对象。

　　· 代理模式（Proxy Pattern）：代理模式利用一个简单的对象替代一个复杂的对象，当复杂对象在需要的时候才会被加载到系统中，这样可以节约系统资源，提高系统的响应速度。在网络环境中这种模式很有用处。

　　· 修饰模式（Decorator Pattern）：通过修饰模式，开发人员可以在运行时将特定的功能绑定在对象上。

　　· 轻量模式（Flyweight Pattern）：轻量模式通过将对象中的一部分数据保存在对象外，在调用对象中的方法时再将这些数据传回对象。这样做可以减少大量比较简单的对象占用的空间。

　　· 正面模式（Fa?ade Pattern）：正面模式将复杂的类层次结构组织起来，通过一个简单的接口来获得层次结构中的数据。

　　行为类型的模式

　　行为类型的模式主要是那些处理对象之间通讯的模式，该类型的包括以下模式：

　　· 观测者模式（Observer Pattern）：观测者模式可以在发生变化时将变化通知多个类。

　　· 中介模式（Mediator Pattern）：中介模式可以通过一个中间类来控制若干个类之间的通讯，并且这些类相互之间不需要了解对方的信息。

　　· 回忆模式（Memento Pattern）：回忆模式可以在不破坏对象封装性的前提下保存和恢复对象的内部状态。

　　· 职责链模式（Chain of Responsibility）：职责链模式将请求传递给一组对象，只有特定的对象才会处理该请求。这样就进一步削弱类之间的联系。

　　· 命令模式（Command Pattern）：命令模式将请求传递给特定的对象，这样客户端即使在不知道服务器端如何处理请求的情况下也可以发送请求。

　　· 模板模式（Template Pattern）：模板模式提供了对算法的抽象定义。

　　· 策略模式（Strategy Pattern）: 策略模式定义了一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使这些算法在客户端调用它们的时候能够互不影响地变化。

　　· 访问者模式（Visitor Pattern）：访问者模式通过一个访问类来访问其他类中的数据。

　　· 状态模式（State Pattern）：状态模式将一个类实例的变量保存在独立的内存空间中。

　　· 迭代模式（Iterator Pattern）：迭代模式在不知道数据的内部表现形式的前提下，通过标准的接口来遍历数据集合中的数据。

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

> cd C:\src
> python ez_setup.py
> svn checkout http://svn.edgewall.org/repos/trac/trunk
> cd trunk
> python setup.py ins

            我的做法是先在d盘新建一个trac目录，然后执行：> trac-admin d:/trac/mytest initenv
     然后根据提示输入项目的名字(myproject)，数据库连接字符串（默认），你的源代码资源库路径。
  2.在8080端口上单项目运行
    
> cd C:\Python25\Scripts
> tracd -p 8080 d:/trac/mytest
    当看到 Serving on 0.0.0.0:8080 view at http://127.0.0.1:8080/ 时，就表示服务器启动成功了，可以打开浏览器，
看到如下效果图：
五、Apache+SVN与Trac集成
    上面的配置是运行在一个独立的服务器上，只能运行一个项目，一般只用于自己单机访问。考虑到我们前面安装的SVN是运
行在Apache服务器上，我们最好也让Trac运行在Apache服务器上，便于网上共享；而且和Apache集成有很多优点，比如充分利用
apache的强大功能以及ModPython的高效率，便于管理与控制，很方便支持ssl等等。在官方网站上提供的安装指南上面提供了三
种方法CGI, FastCGI and mod_python.为了提高性能，推荐使用后面两种，我安装时采用第三种。

1、在http://www.modpython.org/ 页面下载相应的安装程序，注意版本对应。我下载的是
mod_python-3.3.1.win32-py2.5-Apache2.2.exe，然后安装，安装过程中会要求选择apache的安装目录，并且自动把
mod_python.so复制到modules目录 。完成后还要进行配置，类似于SVN和apache的集成，我主要参考的是官方文档。

2、配置

• 配置ModPython
  在apache的httpd.conf中加入下面一行：
  LoadModule python_module modules/mod_python.so
• 配置trac
  在apache的httpd.conf中加入下面内容：
  #setup trac on mod_python
  /trac/mytest>
  SetHandler mod_python
  PythonInterpreter main_interpreter
  PythonHandler trac.web.modpython_frontend
  PythonOption TracEnv d:/trac/mytest #根据个人安装情况修改
  PythonOption TracUriRoot /trac/mytest
  
• 然后就通过http://localhost/trac/myjava来访问，点击“浏览源代码”就可以看到svn库中项目资源。

3、配置用户身份的验证

Trac可以使用Apache的身份验证。

• 创建密码文件,如为myjava创建密码文件，javatrac为用户名：
  转到%Apache%\bin>htpasswd -c d:/trac/mytest/conf/trac.passwd javatrac
  New password: ****
  Re-type new password: ****
  Adding password for user zhengjian
  若对密码不想加密可使用-cp参数，win平台下默认是MD5加密。
• 
  
• 配置身份验证 #设置myjava的Trac用户验证
  /trac/mytest/login>
  AuthType Basic
  AuthName myjavatrac
  AuthUserFile d:/trac/mytest/conf/trac.passwd
  Require valid-user
  
  

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• 先下载Http服务器，官方网站为http://httpd.apache.org/ ，目前最新版本为Apache 2.2.6，我下载的是apache_2.2.6-win32-x86-no_ssl.msi

• 再下载SVN服务器，官方网站为http://subversion.tigris.org/ ，最新版本为Subversion 1.4.6，可能是才发布，还没有安装程序，只有二进制解压版的，下载时要注意下载和Apache2.2.x版本对应的，我下载的是svn-win32- 1.4.6.zip；同时下载svn-python-1.4.6.win32-py2.5.exe
• TortoiseSVN，客户端程序。TortoiseSVN是扩展Windows Shell的一套工具，可以看作Windows资源管理器的插件，安装之后Windows就可以识别Subversion的工作目录，点鼠标右键即可看到。网址为http://tortoisesvn.tigris.org/ ，我下载的是TortoiseSVN-1.4.6.11647-win32-svn-1.4.6.msi
• TortoiseSVN的中文语言包，注意这个需要下和客户端程序版本相同的。这个可以在language packs下面下载。
  

1. 首先将Subversion安装目录bin\下面的两个文件：mod_authz_svn.so和mod_dav_svn.so复制到Apache安装目录modules\目录下； 再将Subversion安装目录bin\下面的所有.dll文件复制到Apache安装目录bin\目录下                                                                      
2. 需要再修改httpd.conf，并做如下修改：
   找到Apache安装目录下的conf目录，用文本编辑器打开httpd.conf，找到一下两行：
   
   #LoadModule dav_module modules/mod_dav.so
   #LoadModule dav_fs_module modules/mod_dav_fs.so
   
   将每行前面的注释符“#”去掉。再在所有LoadModule语句的最后添加一下几行：
   
   #SVN
   LoadModule dav_svn_module modules/mod_dav_svn.so
   LoadModule authz_svn_module modules/mod_authz_svn.so
   
   如图：
   
   
   
   注意下面的状态栏已经是Apache/2.2.6 SVN1.4.6 DAV/2
   
   
3. 建立一个SVN存放文件的目录，我在D盘下创建一个文件夹：D:/svn
4. 接下来我们必须告诉Apache我们的资源 库所在的路径，可以通过Location指令来完成这个设置。因为不希望为每个单独的项目都进行单独的设置，所以我们把所有项目都存放在统一的资源库目 录，那么可以使用SVNParentPath指令来指定存放所有项目的路径。在httpd.conf文件最后添加下面配置： 
   #SVN
   <Location /svn>
       DAV svn
       SVNListParentPath on
       SVNParentPath "D:/svn"
       #SVNPath "D:/svn/test"
    
       ####################认证的类型
       AuthType Basic
       ####################认证的名称,显示于登录提示框
       AuthName "Subversion 资源库，请登录!"
       ####################Which password file to use for authentication 存储用户登录信息的文件
       AuthUserFile D:\svn\passwd
       ####################限定各个用户或组在版本库中目录的访问权限
       AuthzSVNAccessFile D:\svn\svnaccessfile
       ####################让所有用户对版本库都有读的权限而只有特定的用户才有写的权限
       Require valid-user
   </Location>
5. 在命令行窗口中转到Apache所在的目录，执行下列命令,创建用户及密码
   说明：创建用户zj
   输入：htpasswd –c D:\svn\passwd zj
   说明：使用-c参数来创建一个passwd文件
   输出：
   New password: *****
   Re-type new password: *****
   Adding password for user zj
   

   再创建用户的时候就不用-c参数，而是用-m参数，因为文件passwd 已经创建。
   

   打开passwd文件，密码使用MD5加密过了，而且同样的密码加密出来的内容却不相同。用TortoiseSVN在D:/svn下创建test和java资源库.（很简单，不多说）

6. 然后用文本编辑器创建一个Subversion授权文件，文件名为svnaccessfile，内容如下：

   [groups]
   admin = john, kate
   devteam1 = john, rachel, sally
   devteam2 = kate, peter, mark
   
   # 为所有库指定默认访问规则
   # 所有人可以读，管理员可以写，危险分子没有任何权限，[/]代表根目录
   [/]
   * = r
   @admin = rw
   dangerman =
   
   # 允许开发人员可以完全访问他们的项目版本库
   [test:/]
   @devteam1 = rw
   [java:/]
   @devteam2 = rw
   
7. 保存好上面的所有配置文件之后，重新启动Apache服务器。此时我们就可以在IE里面通过http://localhost:8080/test 和http://localhost:8080/java 来测试用户登录，以及不同用户组权限。            
   

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

1. Application类： 是RCP应用程序的入口点，你可以把它想象成程序的控制器，类似于Model2架构中的控制器。它很简短，而且在不同的项目中变化不大；它所做的就是创建 一个工作台Workbench，同时将其于一个WorkbenchAdvisor联系起来。Workbench是RCP框架的一部分，一个RCP应用对应 一个Workbench，但一个     Workbench可以有多个Workbench窗口。
2. ApplicationWorkbenchAdvisor类：继承了WorkbenchAdvisor类，提供了两个方法，其中createWorkbenchWindowAdvisor方法将创建窗口的工作交给了ApplicationWorkbenchWindowAdvisor类。
3. WorkbenchAdvisor类： 该类不是一个接口，而是一个抽象类，它不包含任何的功能实现，因为将来很有可能在其中添加其它方法。Eclipse的设计者们希望每个RCP应用都实现 它，由平台来调用。Workbench和Workbench Window生命周期中的有一些重要事件，这些事件在WorkbenchAdvisor中都 有相应的方法，Platform调用这些方法从而执行你的定制代码。
   

   表1. WorkbenchAdvisor提供的事件处理方法

   方法	描述	参数
   initialize	第一个被调用，用来初始化，比如解析命令行，注册适配器，声明图像等。	IWorkbenchConfigurer
   preStartup	在初始化结束，但是在第一个窗口打开前调用。可以被用来设置一些选项来影响初始打开的编辑器和视图。
   postStartup	在所有窗口已经被打开或恢复后，但是在事件循环开始前调用。它可以被用来启动自动处理器，打开提示或其他窗口。
   preShutdown	在事件循环结束后，但在任何窗口被关闭前调用。
   postShutdown	在关闭Workbench过程中，所有窗口被关闭后调用。它可以被用来存储当前的应用状态和清理任何由initialize创建的东西。

   
   

   表2. WorkbenchAdvisor提供的事件循环钩子

   方法	描述	参数
   eventLoopException	在事件循环中如果有未检测的异常则调用给方法。默认的实现将记录错误信息。	Throwable
   eventLoopIdle	时间循环时什么也不做时调用	Display

   
   

   
   

   表3. WorkbenchAdvisor提供的信息获取方法，你可以在子类中覆盖

   方法	描述	参数
   getDefaultPageInput	返回新的Workbench页面的缺省输入，缺省值是null。
   getInitialWindowPerspectiveId	返回新创建的Workbench Window的初始透视图。这个方法必须提供。
   getMainPreferencePageId	返回第一个显示的首选参数页。缺省为null意味着首选参数页按字母顺序排序。

       上面的WorkbenchAdvisor事件对大多数应用来说是足够了，但是在某些情况，RCP又提供了两个方法来控制你的应用窗口和控件如何被创建。它们被列在表4，但是我觉得很多程序不需要用到这些。
   

   表4. WorkbenchAdvisor提供的高级方法

   方法	描述	参数
   openWindows	在启动时打开所有Workbench Window。缺省实现会恢复前面存储的Workbench状态。

   
   其它的方法在eclipse3.1后都被覆盖了。
4. ApplicationWorkbenchWindowAdvisor类：用来控制状态栏，工具栏，标题和窗口的大小等。但它将创建工具栏的任务交给了ApplicationActionBarAdvisor类。
5. WorkbenchWindowAdvisor类：查阅Javadoc文档可知，它是配置workbench窗口的公共基类。当窗口被创建时，该类就会被创建，用来配置窗口。用户应该继承该类并覆盖其中的某些方法来满足特定的需求。

   表5. WorkbenchWindowAdvisor提供的生命事件点

   方法	描述	参数
   preWindowOpen	在Workbench Window的构造器中调用。可以使用这个方法来指定窗口是否有菜单栏。然而，窗口的widget还没有创建，因此在这个方法中不能引用它们。
   postWindowRestore	当一个窗口从保存的状态恢复时，但在打开前，被调用。
   postWindowCreate	在窗口从保存状态恢复，或从scratch中创建后，但在打开前，被调用。
   openIntro	在窗口打开前一刻被调用，它用来创建introduction组件（如果有的话）。
   postWindowOpen	紧接着Workbench Window被打开后调用。它被用来组装窗口的widget，例如设置标题或修改它的大小。
   preWindowShellClose	在Workbench Window被关闭前调用（从技术上来说，是在它的shell被关闭前）。这是唯一能够终止关闭动作的方法，所以，它可以用来显示“你确定吗”这样的对话框。
   postWindowClose	在Workbench Window关闭后调用。它被用来清理任何由preWindowOpen创建的资源。

   表5. WorkbenchWindowAdvisor提供高级方法

   方法	描述	参数
   createWindowContents	创建窗口的内容，覆盖该方法来定义用户自己的内容和布局。	Shell
   createEmptyWindowContents	用来创建空页面的窗口，覆盖该方法来改变默认窗口背景	Composite

6. IWorkbenchWindowConfigurer接 口：为配置workbench窗口提供了专门的方法，Window configurer类和要配置的workbench是一对一对应的，用户可以用get/set方法将任意状态和window configurer类相连。注意这些类只供主应用程序使用，该接口不能被实现。
7. ApplicationActionBarAdvisor类：继承了ActionBarAdvisor类
8. ActionBarAdvisor类：是配置工作台窗口action bars的公用基类。用户应该继承该类并覆盖其中的某些方法来满足特定的需求。

   表7. ActionBarAdvisor提供的可以覆盖的方法

   方法	描述	参数
   makeActions	创建actions，供fill方法使用	IWorkbenchWindow
   fillMenuBar	用主菜单填充menubar，添加窗口的主菜单	IMenuManager
   fillCoolBar	用工具栏填充coolbar，添加窗口的工具栏	ICoolBarManager
   fillStatusLine	用状态栏填充statusline，添加窗口的状态栏	IStatusLineManager
   isApplicationMenu	返回是否是你创建的菜单	String

9. Activator类：是一个单例类，用来存储插件的全局信息，也可以有一些其他类会用到的实用方法。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！