二Dubbo设计基础--6设计模式
二Dubbo设计基础--6设计模式
2.6 设计模式
2.3.1 责任链模式
在[wrapper机制](#2.2 Wrapper机制)中使用到该模式。
1 责任链原型
（1）抽象出接口AbstractHandler
有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。
public abstract class AbstractHandler {
private Handler handler;
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
}
Abstracthandler类提供了get和set方法，方便MyHandle类设置和修改引用对象，MyHandle类是核心，实例化后生成一系列相互持有的对象，构成一条链
public class MyHandler extends AbstractHandler implements Handler {
private String name;
public MyHandler(String name) {
this.name = name;
}
@Override
public void operator() {
//调用链之前，业务操作
System.out.println(name+"before deal!");
if(getHandler()!=null){
getHandler().operator();
}
//调用链之后，业务操作
System.out.println(name+"after deal!");
}
}
public class Test {
public static void main(String[] args) {
MyHandler h1 = new MyHandler("h1");
MyHandler h2 = new MyHandler("h2");
MyHandler h3 = new MyHandler("h3");
h1.setHandler(h2);
h2.setHandler(h3);
h1.operator();
}
}
此处强调一点就是，链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同时，在一个时刻，命令只允许由一个对象传给另一个对象，而不允许传给多个对象
（2）不抽象接口
2 dubbo内的责任链设计
dubbo内对过滤器Filter构建责任链
private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
Invoker<T> last = invoker;
List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
if (filters.size() > 0) {
for (int i = filters.size() - 1; i >= 0; i --) {
final Filter filter = filters.get(i);
final Invoker<T> next = last;
last = new Invoker<T>() {
public Class<T> getInterface() {
return invoker.getInterface();
}
public URL getUrl() {
return invoker.getUrl();
}
public boolean isAvailable() {
return invoker.isAvailable();
}
public Result invoke(Invocation invocation) throws RpcException {
//构成链的关键，next就是指向下一个filter处理Invoker的操作链
return filter.invoke(next, invocation);
}
public void destroy() {
invoker.destroy();
}
@Override
public String toString() {
return invoker.toString();
}
};
}
}
return last; //返回起始的filter生成的Invoker，其内invoke(next)。责任链的关键，在于filter的Invoke(invoker)内部，调用invoker.invoke，因此形成链
}
2.3.2 动态代理
详细见spring中内容
2.3.3 装饰模式
装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
要求在不改变原类文件和适用继承的情况下，动态地扩展一个对象地功能。它是通过创建一个包装对象，也就是装饰来包裹真实地对象。
关系图如下：
source是被装饰类，decorator是装饰类。
public class Decorator implements Sourceable {
private Sourceable source;
public Decorator(Sourceable source){
super();
this.source = source;
}
@Override
public void method() {
System.out.println("before decorator!");
source.method();
System.out.println("after decorator!");
}
}
测试类：
public class DecoratorTest {
public static void main(String[] args) {
Sourceable source = new Source();
Sourceable obj = new Decorator(source);
obj.method();
}
}
特点:
1.装饰对象和真实对象具有相同地接口。这样客户端对象就能以真实对象相同地方式和装饰对象交互
2.装饰对象包含一个真实对象地引用（GameObject）
3.装饰对象接受所有来自客户端的请求，它把这些请求转发给真实对象
4.装饰对象可以在转发这些以前或者以后增加一些附加功能，这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展
适用条件:
1.需要扩展一个类的功能，或给一个类添加附加职责
2.需要动态的给一个对象添加功能，这些功能还可以再动态的撤销
3.需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使得继承关系变得不现实
4.当不能采用生成子类的方法进行扩充时，一种情况是:可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类
优点:
1.Decorator模式与继承关系的目的都是要扩展对象的功能，但是Decorator可以提供比继承更多的灵活性
2.通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合
缺点:
1.这种比继承更加灵活机动的特性，也同时意味着更加多的复杂性
2.装饰模式会导致设计出来许多小类，如果过度使用，会使程序变得很复杂
3.装饰模式是针对抽象组件(Component)类型编程，但是，如果要针对具体组件编程时，就应该重新思考你的应用架构，以及装饰者是否合适。
装饰器模式的应用场景：
1、需要扩展一个类的功能。
2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）
缺点：产生过多相似的对象，不易排错！
2.3.4 观察者模式
Dubbo 的 Provider 启动时，需要与注册中心交互，先注册自己的服务，再订阅自己的服务，订阅时，采用了观察者模式，开启一个 listener。注册中心会每 5 秒定时检查是否有服务更新，如果有更新，向该服务的提供者发送一个 notify 消息，provider 接受到 notify 消息后，即运行 NotifyListener 的 notify 方法，执行监听器方法。
