设计模式 -- 委派模式（Delegate Pattern）

最新推荐文章于 2025-04-15 23:34:16 发布

MagicianHong

最新推荐文章于 2025-04-15 23:34:16 发布

阅读量2.7k

点赞数

CC 4.0 BY-SA版权

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.youkuaiyun.com/scoryy/article/details/123668098

设计模式专栏收录该内容

25 篇文章

订阅专栏

本文探讨了Java中的任务委派模式，如何通过`TaskDelegate`实现场景中的任务管理和调用，同时结合JDK类加载器的委派机制进行解释。讨论了其优点、缺点以及在不同场景的应用，如松耦合、服务编排等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

允许对象组合实现与继承相同的代码重用，负责任务的调用和分配

只对结果负责。

优点

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

缺点

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

应用场景

当你要实现表现层和业务层之间的松耦合的时候。
当你想要编排多个服务之间的调用的时候。
当你想要再封装一层服务查找和调用时候

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


/**
 * 具体实现类A
 */
public class ConcreteTaskA implements Task {
    public void doTask() {
        System.out.println("执行 , 由A实现");
    }
}
 
/**
 * 具体实现类B
 */
public class ConcreteTaskB implements Task {
    public void doTask() {
        System.out.println("执行 , 由B实现");
    }
}


/**
 * 代理角色
 */
public class TaskDelegate implements Task{

    @Override
    public void doTask() {
        System.out.println("代理执行开始....");
 
        Task task = null;
        if (new Random().nextBoolean()){
            task = new ConcreteTaskA();
            task.doTask();
        }else{
            task = new ConcreteTaskB();
            task.doTask();
        }
 
        System.out.println("代理执行完毕....");
    }
}


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

JDK源码中委派模式体现

一个类加载器在加载类时，先把这个请求委派给自己的父类加载器去执行，如果父类加载器还存在父类加载器，就继续向上委派，直到顶层的启动类加载器。

如果父类加载器能过完成类加载，就成功返回。如果父类加载器无法完成加载，那么子加载器才会尝试自己去加载。从定义中可看出双亲加载模型一个类加载器加载类时，首先不是自己加载，而是委派给父加载器。

public abstract class ClassLoader {
 
    //......中间代码省略
 
    // The parent class loader for delegation
    // Note: VM hardcoded the offset of this field, thus all new fields
    // must be added *after* it.
    private final ClassLoader parent;
    
    //.....中间代码省略
    
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }
 
                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);
 
                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
}

根据以下文章总结：