设计模式
适配器模式：将一个类的接口转换程调用方希望的另外一个接口，解决两个接口不兼容的问题。
  Adaptee：Adapter的父类，作为适配源
  Adapter：需要实现适配目标接口
  其中基于类的Adapter模式比较适合于应用与Adapter想修改Adaptee部分方法的情况
  其中基于对象的Adapter模式比较适用于Adapter想为Adaptee添加新的方法的情况。
 
代理模式：通常用于对已经存在的软件系统扩充的场景中
  对于应用的相应速度与处理速度都没有帮助。
  前提：必须面向接口编程。
 
桥接模式：在两个互相不可到达的对象之间，搭起一座起到连通作用的桥梁。把抽象和实现分离。    

 
观察者模式：定义了对象间的多对多的依赖关系。当一个对象状态发生改变时，所有依赖于它的对象都得到了同志并被自动的更新。  

command模式：把一个请求或者操作封装到一个对象中。该模式把发出命令的责任和执行命令的的责任分开

职责链模式：储存一个相同类的对象实例，以便保存传递

任务分配中心模式：将请求与实际的处理者分离，并且请求与处理者互相不知道对方的存在，而只有任务分配中心知道。
请求接口:
  public interfac Request{
    //设置请求目标方法
    public void setRequestObject(String objectvie);
    //获取请求目标方法
    public String getRequestObjective();
  }
 
//具体请求类
public class ConcreateRequestA implements Request{
  //请求目标属性
  private String bjectve = null;
 
  public CconcreateRequestA{}
 
  //摄制处理目标方法
  public void setRequestObjective(String objective){
    this.objective = objectvie;
  }
 
  //获取请求目标方法
  public String getRequestObjective(){
    return this.objective;
  }
}  

//具体请求类
public class ConcreateRequestB implements Request{
  //请求目标属性
  private String bjectve = null;
 
  public CconcreateRequestB{}
 
  //摄制处理目标方法
  public void setRequestObjective(String objective){
    this.objective = objectvie;
  }
 
  //获取请求目标方法
  public String getRequestObjective(){
    return this.objective;
  }
}  

//处理者接口(Handler)
  public interface Handler{
    //处理请求方法
    public void handleRequest(Request request);
  }

//具体的处理者类
  public class ConcreateHandlerA implements Handler{
    public ConcreateHandlerA(){}
    
    //处理请求方法
    public void handleRequest(Request request){
      //处理请求
    }
  }

  public class ConcreateHandlerB implements Handler{
    public ConcreateHandlerB(){}
    
    //处理请求方法
    public void handleRequest(Request request){
      //处理请求
    }
  }
 
//任务分配中心类
  public class TaskAssignmentCenter{
    //请求对象
    private Request request = null;
    //构造器
    public TaskAssignmentCenter(){
    }
    //接受请求方法
    public void acceptRequest(Request request){
      this.request = request;
    }
    //分配任务方法
    public void assignTask(){
      String requestObjective = request.getReqestObject();
      if(requestobjective.equals("ATask")){
        new ConcreateHandlerA().handleRequest(Request);
      }else if (requestobjective.equals("BTask"){
        new ConcreateHandlerB().handleRequest(Request);
      }
    }
    
  }  

//配置文件工具类
  public class ConfigUTIL{
    //配置信息属性
    private static Proties prop = new Properties();
    //判断是否加载国配置文件，防止重复加载文件降低系统性能
    private static boolean isLoaded = false;
    //获取配置信息
    public static Properties getConfigInfo(){
      return prop;
    }
    //读取配置文件静态模块
    static{
      if (!isLoaded){
        try{
          InputStream is = new
            ConfigUTIL().getClass().getResourceAsStream("RequstAndHandler.conf");
          prop.load(is);
          isLoaded = true;//更改状态
        }
        catch{IOException ex}{
         isLoaded = false;
         ex.printStackTrace();
        }
      }
    }
    
  }

//最后需要修改任务分配中心类中的assginTask()方法汇总的代码
  ...   ...
//分配任务方法
    public void assignTask(){
      String requestObjective = request.getReqestObject();
      /*
      if(requestobjective.equals("ATask")){
        new ConcreateHandlerA().handleRequest(Request);
      }else if (requestobjective.equals("BTask"){
        new ConcreateHandlerB().handleRequest(Request);
      }
      */
      java.util.Properties prop = ConfigUTIL.getConfigInfo();
      try{
        Handler handler = (Handler)Class.forName(prop.getProperty(requestObjective)).newInsance();
      }
      catch(ClassNotFoundException cex){
        cex.printStaceTrace();
      }
      catch(IllegalAccessException iex){
        iex.printStaceTrace();
      }
      catch(InstantantiationException ex){
        ex.printStaceTrace();
      }
    
  }
  修改过的代码主要做了三件事件
  1.获取配置信息
  2。根据配置信息，动态装在具体处理者
  3。令具体的处理者处理具体的请求
这样的改动，在系统添加新的请求于处理时，不需要改动与重新编译任何已经存在的代码。
如果需要添加一个新的处理者C来处理新的请求C(RequestC)  则可以通过如下简单的步骤来完成
  1。创建新的具体的处理者C
//具体的处理者类
  public class ConcreateHandlerC implements Handler{
    public ConcreateHandlerA(){}
    
    //处理请求方法
    public void handleRequest(Request request){
      //处理请求
    }
  }  
 
  2。创建新的具体的请求C
//具体请求类
public class ConcreateRequestC implements Request{
  //请求目标属性
  private String bjectve = null;
 
  public CconcreateRequestC{}
 
  //摄制处理目标方法
  public void setRequestObjective(String objective){
    this.objective = objectvie;
  }
 
  //获取请求目标方法
  public String getRequestObjective(){
    return this.objective;
  }
}    

  3.在配置文件RequestAndHandler。conf中 添加一行新的配置信息
    CTask = ConcreateHandlerC

  4.编译并发布上面的两个类到新的系统中
  完成上面的四个步骤，就可以在请求的客户端中添加下面的代码把请求发送给任务分配中心了
  ...   ...
  //创建具体的请求类ConcreleRequestC实例
  ConcreateRequest crc = new ConcreateRequestC();
  //设置请求任务
  crc.setRequestObjective("CTask");
  ...  ...
  同时，可以通过下面的方式来命令任务分配中心处理新的请求C了
  ...  ..
  //处理具体请求C
  tac.acceptRequest(crc);
  //分配任务
  tac.assignTask();