0134_委托模式 (Delegate)
委托模式 (Delegate)
意图
两个对象参与处理同一个请求，接收请求的对象将请求委托给另一个对象来处理。
委托模式的核心思想是：一个对象将某些职责交给另一个专门的对象去完成，从而实现职责的分离和代码的复用。
UML 图
优点
- 职责清晰分离：将具体实现逻辑与调用逻辑分离，每个类专注于自己的职责
- 易于扩展和维护：可以轻松添加新的委托实现，而不影响现有代码
- 提高代码复用性：多个委托者可以共享同一个委托对象
- 灵活性高：可以在运行时动态切换委托对象
- 符合开闭原则：对扩展开放，对修改关闭
缺点
- 增加系统复杂度：需要创建更多的类和接口
- 可能造成过度设计：对于简单场景，使用委托模式可能显得繁琐
- 调试难度增加：调用链变长，问题定位可能更困难
- 性能开销：多了一层方法调用，可能带来轻微的性能损失
代码示例：人类与机器人任务委托系统
场景描述
在一个智能工厂中，人类主管将不同类型的生产任务委托给** specialized 机器人**去执行。每个机器人专门负责特定类型的任务。
1. 任务接口 (Task Interface)
// 任务接口 - 定义所有机器人需要实现的能力
public interface Task {
/**
* 执行任务
* @param taskDetails 任务详细信息
* @return 执行结果
*/
String execute(String taskDetails);
/**
* 获取机器人类型
*/
String getRobotType();
/**
* 检查是否能够处理该任务
*/
boolean canHandle(String taskType);
}
2. 具体委托类 (Concrete Delegates)
// 装配机器人 - 专门负责装配任务
public class AssemblyRobot implements Task {
private String name;
public AssemblyRobot(String name) {
this.name = name;
}
@Override
public String execute(String taskDetails) {
return String.format("🔧 装配机器人[%s]正在执行装配任务: %s\n" +
" - 精确组装零部件\n" +
" - 质量检测\n" +
" - 完成产品装配", name, taskDetails);
}
@Override
public String getRobotType() {
return "装配机器人";
}
@Override
public boolean canHandle(String taskType) {
return taskType.contains("装配") || taskType.contains("组装") ||
taskType.contains("生产");
}
}
// 运输机器人 - 专门负责物料运输
public class TransportRobot implements Task {
private String name;
public TransportRobot(String name) {
this.name = name;
}
@Override
public String execute(String taskDetails) {
return String.format("🚚 运输机器人[%s]正在执行运输任务: %s\n" +
" - 路径规划\n" +
" - 安全运输\n" +
" - 送达目的地", name, taskDetails);
}
@Override
public String getRobotType() {
return "运输机器人";
}
@Override
public boolean canHandle(String taskType) {
return taskType.contains("运输") || taskType.contains("搬运") ||
taskType.contains("送达");
}
}
// 检测机器人 - 专门负责质量检测
public class InspectionRobot implements Task {
private String name;
public InspectionRobot(String name) {
this.name = name;
}
@Override
public String execute(String taskDetails) {
return String.format("🔍 检测机器人[%s]正在执行检测任务: %s\n" +
" - 外观检查\n" +
" - 功能测试\n" +
" - 质量评估", name, taskDetails);
}
@Override
public String getRobotType() {
return "检测机器人";
}
@Override
public boolean canHandle(String taskType) {
return taskType.contains("检测") || taskType.contains("检查") ||
taskType.contains("测试");
}
}
// 焊接机器人 - 专门负责焊接任务
public class WeldingRobot implements Task {
private String name;
public WeldingRobot(String name) {
this.name = name;
}
@Override
public String execute(String taskDetails) {
return String.format("⚡ 焊接机器人[%s]正在执行焊接任务: %s\n" +
" - 精确定位焊接点\n" +
" - 自动焊接\n" +
" - 焊缝检查", name, taskDetails);
}
@Override
public String getRobotType() {
return "焊接机器人";
}
@Override
public boolean canHandle(String taskType) {
return taskType.contains("焊接") || taskType.contains("连接");
}
}
3. 委托者类 (Delegator)
// 人类主管 - 委托者类
public class HumanSupervisor {
private String name;
private List<Task> availableRobots;
private Task currentDelegate;
public HumanSupervisor(String name) {
this.name = name;
this.availableRobots = new ArrayList<>();
initializeRobots();
}
private void initializeRobots() {
availableRobots.add(new AssemblyRobot("装配大师-001"));
availableRobots.add(new TransportRobot("迅捷运输-002"));
availableRobots.add(new InspectionRobot("精密检测-003"));
availableRobots.add(new WeldingRobot("焊接专家-004"));
}
/**
* 委托任务给合适的机器人
*/
public String delegateTask(String taskType, String taskDetails) {
System.out.println(String.format("\n👨💼 主管[%s]收到任务: %s - %s",
name, taskType, taskDetails));
// 寻找合适的机器人
Task suitableRobot = findSuitableRobot(taskType);
if (suitableRobot == null) {
return String.format("❌ 错误: 没有找到能够处理'%s'任务的机器人", taskType);
}
this.currentDelegate = suitableRobot;
System.out.println(String.format(" → 委托给: %s[%s]",
suitableRobot.getRobotType(), getRobotName(suitableRobot)));
// 执行委托
return suitableRobot.execute(taskDetails);
}
/**
* 动态添加新的机器人
*/
public void addRobot(Task robot) {
availableRobots.add(robot);
System.out.println(String.format("✅ 新机器人上线: %s[%s]",
robot.getRobotType(), getRobotName(robot)));
}
/**
* 显示所有可用的机器人
*/
public void displayAvailableRobots() {
System.out.println(String.format("\n📋 主管[%s]可调度的机器人:", name));
for (int i = 0; i < availableRobots.size(); i++) {
Task robot = availableRobots.get(i);
System.out.println(String.format(" %d. %s - %s",
i + 1, robot.getRobotType(), getRobotName(robot)));
}
}
private Task findSuitableRobot(String taskType) {
return availableRobots.stream()
.filter(robot -> robot.canHandle(taskType))
.findFirst()
.orElse(null);
}
private String getRobotName(Task robot) {
// 通过反射获取机器人的name字段（简化实现）
try {
java.lang.reflect.Field field = robot.getClass().getDeclaredField("name");
field.setAccessible(true);
return (String) field.get(robot);
} catch (Exception e) {
return "未知";
}
}
// Getter方法
public Task getCurrentDelegate() {
return currentDelegate;
}
public List<Task> getAvailableRobots() {
return new ArrayList<>(availableRobots);
}
}
4. 客户端代码
public class DelegatePatternDemo {
public static void main(String[] args) {
System.out.println("=== 委托模式演示 - 人类与机器人任务协作系统 ===\n");
// 创建人类主管
HumanSupervisor supervisor = new HumanSupervisor("张主管");
// 显示可用机器人
supervisor.displayAvailableRobots();
// 演示任务委托
System.out.println("\n" + "=".repeat(50));
System.out.println("开始任务委托演示:");
System.out.println("=".repeat(50));
// 委托装配任务
String result1 = supervisor.delegateTask("装配任务", "汽车发动机组装");
System.out.println(result1);
// 委托运输任务
String result2 = supervisor.delegateTask("运输任务", "将原材料运送到生产线A");
System.out.println(result2);
// 委托检测任务
String result3 = supervisor.delegateTask("质量检测", "成品手机功能测试");
System.out.println(result3);
// 委托焊接任务
String result4 = supervisor.delegateTask("焊接任务", "钢结构框架连接");
System.out.println(result4);
// 演示动态添加新机器人
System.out.println("\n" + "=".repeat(50));
System.out.println("动态扩展演示:");
System.out.println("=".repeat(50));
Task newRobot = RobotFactory.createRobot("assembly", "高效装配-005");
supervisor.addRobot(newRobot);
supervisor.displayAvailableRobots();
// 演示无法处理的任务
System.out.println("\n" + "=".repeat(50));
System.out.println("错误处理演示:");
System.out.println("=".repeat(50));
String result5 = supervisor.delegateTask("烹饪任务", "制作员工午餐");
System.out.println(result5);
System.out.println("\n=== 演示完成 ===");
// 显示最终的委托关系
System.out.println("\n最终委托状态:");
System.out.println("当前委托的机器人: " +
(supervisor.getCurrentDelegate() != null ?
supervisor.getCurrentDelegate().getRobotType() : "无"));
}
}
在Spring的应用
在Spring框架中，委托模式被广泛应用：
// Spring中的委托模式示例
@Service
public class OrderProcessingService {
// 通过依赖注入委托给不同的处理器
@Autowired
private List<OrderHandler> orderHandlers;
public void processOrder(Order order) {
// 委托给合适的处理器
OrderHandler suitableHandler = orderHandlers.stream()
.filter(handler -> handler.canHandle(order.getType()))
.findFirst()
.orElseThrow(() -> new RuntimeException("No suitable handler found"));
suitableHandler.handle(order);
}
}
// 处理器接口
public interface OrderHandler {
boolean canHandle(OrderType type);
void handle(Order order);
}
// 具体处理器
@Service
public class OnlineOrderHandler implements OrderHandler {
@Override
public boolean canHandle(OrderType type) {
return type == OrderType.ONLINE;
}
@Override
public void handle(Order order) {
// 处理在线订单
}
}
总结
委托模式 vs 代理模式：
- 委托模式：强调职责转移，委托对象真正执行任务
- 代理模式：强调访问控制，代理对象控制对真实对象的访问
委托模式的核心价值：
- 专业分工：每个机器人专注于自己擅长的领域
- 灵活调度：人类主管可以根据任务类型动态选择最合适的执行者
- 易于扩展：新增机器人类型不影响现有系统
- 职责清晰：人类负责决策和调度，机器人负责具体执行
这种模式在现实世界的团队协作、微服务架构、任务调度系统等场景中都有广泛应用，体现了"让专业的人做专业的事"的设计哲学。
浙公网安备 33010602011771号