委派（委托）模式

简介

委派模式（Delegate Pattern）又叫作委托模式，是一种面向对象的设计模式，允许对象组合实现与继承相同的代码重用。它的基本作用就是负责任务的调用和分配，是一种特殊的静态代理模式，可以理解为全权代理模式，但是代理模式注重过程，而委派模式注重结果。委派模式属于行为型设计模式，不属于GoF的23种设计模式。

通用模板

1. 创建抽象任务角色：定义一个抽象接口，它有若干实现类。

   // 抽象任务角色
   public interface ITask {
       void doTask();
   }
   

2. 创建具体任务角色：真正执行任务的角色。

   // 具体任务A
   public class ConcreteTaskA implements ITask {
       @Override
       public void doTask() {
           System.out.println("任务由A执行");
       }
   }
   

   // 具体任务B
   public class ConcreteTaskB implements ITask {
       @Override
       public void doTask() {
           System.out.println("任务由B执行");
       }
   }
   

3. 创建委派者角色：负责在各个具体角色实例之间做出决策，判断并调用具体实现的方法。

   import java.util.Random;
   
   // 委派者角色
   public class Delegate implements ITask {
       @Override
       public void doTask() {
           System.out.println("委派者开始委派任务");
           ITask task;
           if (new Random().nextBoolean()) {
               task = new ConcreteTaskA();
               task.doTask();
           } else {
               task = new ConcreteTaskB();
               task.doTask();
           }
   
           System.out.println("委派者执行完毕");
       }
   }
   

模板测试

1. 测试代码

   public class Client {
       public static void main(String[] args) {
           new Delegate().doTask();
       }
   }
   

2. 结果

   委派者开始委派任务
   任务由A执行
   委派者执行完毕
   

应用场景

现实生活中，常有委派模式的场景发生，例如，老板给项目经理下达任务，项目经理会根据实际情况给每个员工都分配工作任务，待员工把工作任务完成之后，再由项目经理向老板汇报工作进度和结果。再比如，我们经常写授权委托书，授权他人代办事务。
委派模式适用于以下应用场景。
（1）需要实现表现层和业务层之间的松耦合。
（2）需要编排多个服务之间的调用。
（3）需要封装一层服务查找和调用。

优点

通过任务委派能够将一个大型任务细化，然后通过统一管理这些子任务的完成情况实现任务的跟进，加快任务执行的效率。

缺点

任务委派方式需要根据任务的复杂程度进行不同的改变，在任务比较复杂的情况下，可能需要进行多重委派，容易造成紊乱。

“生搬硬套”实战

场景描述

老板给项目经理下达任务，项目经理会根据实际情况给每个员工都分配工作任务，待员工把工作任务完成之后，再由项目经理向老板汇报工作进度和结果。

代码开发

1. 创建抽象任务角色（这里指的是员工统一接口）

   // 员工接口
   public interface IEmployee {
       void doing(String task);
   }
   

2. 创建具体任务角色（这里只具体的员工）

   // 员工A
   public class EmployeeA implements IEmployee {
       String goodAt = "编程";
   
       @Override
       public void doing(String task) {
           System.out.println("我是员工A，我擅长" + goodAt + "，现在开始做" + task + "工作");
       }
   }
   

   // 员工B
   public class EmployeeB implements IEmployee {
       String goodAt = "平面设计";
   
       @Override
       public void doing(String task) {
           System.out.println("我是员工B，我擅长" + goodAt + "，现在开始做" + task + "工作");
       }
   }
   

3. 创建委派者角色（委派者就是项目经理，这里加入一个Boss类给项目经理发排活，而项目经理作为委派者，给不同员工派活）

   // 委派者：项目经理类
   public class Leader implements IEmployee {
       private Map<String, IEmployee> employee = new HashMap<>();
   
       public Leader() {
           employee.put("爬虫", new EmployeeA());
           employee.put("海报图", new EmployeeB());
       }
   
       @Override
       public void doing(String task) {
           if (!employee.containsKey(task)) {
               System.out.println("这个任务"+task+"超出我的能力范围了");
               return;
           }
           employee.get(task).doing(task);
       }
   
   }
   
   

   // 老板
   public class Boss {
       public void command(String task, Leader leader) {
           leader.doing(task);
       }
   }
   

至此，我们就通过“生搬硬套”委派者模式的模板设计出一套老板委派项目经理给员工派活的逻辑，接下来我们进行测试：

• 测试代码

  public class Client {
      public static void main(String[] args) {
        new Boss().command("爬虫",new Leader());
        new Boss().command("海报图",new Leader());
        new Boss().command("买手机",new Leader());
      }
  }
  

• 结果

  我是员工A，我擅长编程，现在开始做爬虫工作
  我是员工B，我擅长平面设计，现在开始做海报图工作
  这个任务买手机超出我的能力范围了
  

总结

委派模式是一种设计模式，其中一个对象（委派人）将任务委托给另一个对象（受托人）来执行。委派人和受托人之间通常是通过接口或抽象类联系起来的，委派人通过持有受托人的引用，将任务交给受托人处理。

特点

• 责任转移：委派人将部分或全部职责转移给受托人。
• 松耦合：委派人和受托人之间通过接口通信，而不是直接调用实现。
• 灵活性：委派人和受托人可以独立地扩展，不会互相影响。
• 多态性：委派人可以调用受托人的方法，而不知道具体是谁在执行。