你以为委派模式很神秘,其实你每天都在用
本文节选自《设计模式就该这样学》1 使用委派模式模拟任务分配场景 我们用代码来模拟老板给员工分配任务的业务场景。
首先创建IEmployee员工接口。
public interface IEmployee {
void doing(String task);
}
创建员工EmployeeA类。
public class EmployeeA implements IEmployee {
protected String goodAt = "编程";
public void doing(String task) {
System.out.println("我是员工A,我擅长" + goodAt + ",现在开始做" +task + "工作");
}
}
创建员工EmployeeB类。
public class EmployeeB implements IEmployee {
protected String goodAt = "平面设计";
public void doing(String task) {
System.out.println("我是员工B,我擅长" + goodAt + ",现在开始做" +task + "工作");
}
}
创建项目经理Leader类。
public class Leader implements IEmployee {private Map employee = new HashMap();
public Leader(){
employee.put("爬虫",new EmployeeA());
employee.put("海报图",new EmployeeB());
}public void doing(String task) {
if(!employee.containsKey(task)){
System.out.println("这个任务" +task + "超出我的能力范围");
return;
}
employee.get(task).doing(task);
}
}
然后创建Boss类下达命令。
public class Boss {
public void command(String task,Leader leader){
leader.doing(task);
}
}
最后编写客户端测试代码。
public class Test {
public static void main(String[] args) {
new Boss().command("海报图",new Leader());
new Boss().command("爬虫",new Leader());
new Boss().command("卖手机",new Leader());
}
}
通过上面代码,我们生动地还原了老板分配任务的业务场景,这也是委派模式的生动体现。其类图如下图所示。
文章图片
2 委派模式在JDK源码中的应用 JDK中有一个典型的委派,众所周知,JVM在加载类时用双亲委派模型,这又是什么呢?一个类加载器在加载类时,先把这个请求委派给自己的父类加载器去执行。如果父类加载器还存在父类加载器,则继续向上委派,直到顶层的启动类加载器;如果父类加载器能够完成类加载,则成功返回;如果父类加载器无法完成加载,则子加载器尝试自己去加载。从定义中可以看到,当双亲委派加载的一个类加载器加载类时,首先不是自己加载,而是委派给父类加载器。下面来看loadClass()方法的源码,此方法在ClassLoader中。在这个类里定义了一个双亲,用于下面的类加载。
public abstract class ClassLoader {
...
private final ClassLoader parent;
...
protected Class> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
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) {
}if (c == null) {
long t1 = System.nanoTime();
c = findClass(name);
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
...
}
同样,在Method类里,常用的代理执行方法invoke()也存在类似机制,代码如下。
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, obj, modifiers);
}
}
MethodAccessor ma = methodAccessor;
// read volatile
if (ma == null) {
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}
看完代码,相信小伙伴们把委派模式和代理模式的区别弄清楚了吧。
3 委派模式在Spring源码中的应用 下面来看委派模式在Spring中的应用,Spring IoC模块中的DefaultBeanDefinitionDocumentReader类,当调用doRegisterBeanDefinitions()方法时,即在BeanDefinition进行注册的过程中,会设置BeanDefinitionParserDelegate类型的Delegate对象传给this.delegate,并将这个对象作为一个参数传入parseBeanDefinitions(root, this.delegate)。主要的解析工作就是由delegate作为主要角色来完成的,代码如下。
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//判断节点是否属于同一命名空间,如果是,则执行后续的解析
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0;
i < nl.getLength();
i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele, delegate);
}
else {
//注解定义的Context的nameSpace进入这个分支
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
上面代码中的parseDefaultElement(ele, delegate)方法,主要功能是针对不同的节点类型,完成Bean的注册操作,而在这个过程中,delegate会调用element的parseBeanDefinitionElement()方法,从而得到一个BeanDefinitionHolder类型的对象,之后通过这个对象完成注册。
再来还原一下Spring MVC的DispatcherServlet是如何实现委派模式的。创建业务类MemberController。
/**
* Created by Tom.
*/
public class MemberController {public void getMemberById(String mid){}}
创建OrderController类。
/**
* Created by Tom.
*/
public class OrderController {public void getOrderById(String mid){}}
创建SystemController类。
/**
* Created by Tom.
*/
public class SystemController {public void logout(){}
}
创建DispatcherServlet类。
public class DispatcherServlet extends HttpServlet {private Map handlerMapping = new HashMap();
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doDispatch(req,resp);
}private void doDispatch(HttpServletRequest req, HttpServletResponse resp) {
String url = req.getRequestURI();
Method method = handlerMapping.get(url);
//此处省略反射调用方法的代码
...}@Override
public void init() throws ServletException {
try {
handlerMapping.put("/web/getMemeberById.json", MemberController.class.getMethod("getMemberById", new Class[]{String.class}));
}catch (Exception e){
e.printStackTrace();
}
}
}
配置web.xml文件。
Web Application delegateServlet
com.tom.pattern.delegate.mvc.DispatcherServlet
1 delegateServlet
/*
这样,一个完整的委派模式就实现了。当然,在Spring中运用委派模式的情况还有很多,大家通过命名就可以识别。在Spring源码中,只要以Delegate结尾的都实现了委派模式。例如,BeanDefinitionParserDelegate根据不同的类型委派不同的逻辑来解析BeanDefinition。
【推荐】Tom弹架构:收藏本文,相当于收藏一本“设计模式”的书
【你以为委派模式很神秘,其实你每天都在用】本文为“Tom弹架构”原创,转载请注明出处。技术在于分享,我分享我快乐!
如果本文对您有帮助,欢迎关注和点赞;如果您有任何建议也可留言评论或私信,您的支持是我坚持创作的动力。关注微信公众号『 Tom弹架构 』可获取更多技术干货!
推荐阅读
- 热闹中的孤独
- 放屁有这三个特征的,请注意啦!这说明你的身体毒素太多
- 尽力
- 你到家了吗
- 爱就是希望你好好活着
- 为什么你的路演总会超时()
- 死结。
- 跌跌撞撞奔向你|跌跌撞撞奔向你 第四章(你补英语,我补物理)
- 奔向你的城市
- 喂,你结婚我给你随了个红包