架构第三周 - 学习总结

关注
发布于: 2020 年 06 月 23 日
这周主要的学习内容就是关于设计模式、设计原则、重构
心得体会除了课堂内的内容，还有些比较重要的题外话我想先拿出来讲一下。
找出问题的人比解决问题的人高出一个Level。好比发现设计问题比去用这些设计模式更NB一点。
阅读源码最好是好奇心驱动、工作驱动。
其实我在找工作的之前或者过程中做了这部分补充，比如我阅读了spring的源码，串联了知识体系，理解了IOC、AOP的设计源码和原理。源码之下无秘密，所言不虚！
忽略不必要的细节以节省精力专注于更加重要的事情上。当然这个也是因人而异。
﻿
SOLID设计原则单一职责原则（S）
开闭原则（O）
里式替换原则（L）：与多态思想不同，是一种指导子类设计的设计原则，子类的设计要保证在替换父类的时候，不改变原有程序的逻辑以及不破坏原有程序的正确性。
接口隔离原则（I）：客户端不应该被强迫依赖它不需要的接口。
依赖倒置原则（D）：高层模块不要依赖底层模块，抽象不要依赖具体。
其他还有：KISS原则（Keep It Simple and Stupid） DRY原则、YAGNI原则、迪米特法则（有限知识原则、不要和陌生人说话）
﻿
设计模式策略模式策略的定义策略类的定义比较简单，包含一个策略接口和一组实现这个接口的策略类。
因为所有的策略类都实现相同的接口。所以，客户端代码基于接口而非实现编程，可以灵活地替换不同的策略！
﻿
策略的创建因为策略模式会包含一组策略，在使用它们的时候，一般会通过类型（type）来判断创建哪个策略来使用。
为了封装创建逻辑，我们需要对客户端代码屏蔽创建细节。我们可以把根据 type 创建策略的逻辑抽离出来，放到工厂类中。
﻿
本质上都是借助“查表法”，根据 type 查表（代码中的 strategies 就是表）替代根据 type 分支判断。
无状态策略这样的策略对象是可以被共享使用的，不需要在每次调用 getStrategy() 的时候，都创建一个新的策略对象。
﻿
这个工厂代码存放的一般是无状态策略。
﻿
有状态策略如果策略类是有状态的，根据业务场景的需要，我们希望每次从工厂方法中，获得的都是新创建的策略对象，而不是缓存好可共享的策略对象，那我们就需要按照如下方式来实现策略工厂类！
﻿
﻿
单例模式的几种方式饿汉式在类加载的时候静态实例就已经初始化好了，线程安全。
﻿
﻿
懒汉式延迟加载初始化，一把大锁，线程安全。
﻿
﻿
双重检测﻿
﻿
原型模式原型模式：其实就是从一个对象再创建另外一个可定制的对象，而不需要知道任何的创建细节。
分为浅层复制和深层复制。
java的clone()方法默认为浅层复制。引用类型只会复制指针但是不会复制数据。
深层复制的实现方式：
﻿
工厂模式简单工厂模式+工厂方法模式
简单工厂模式直接在条件判断中根据不同参数将目标对象new了出来。
﻿
﻿
工厂方法模式是将目标对象的创建过程根据参数分别抽取到各自独立的工厂类中，以应对目标对象创建过程的复杂度。条件分支可以使用map来缓存起来！
﻿
﻿
﻿
案例：java.util.Calendar的getInstance() 方法可以根据不同 TimeZone 和 Locale，创建不同的 Calendar 子类对象。也是用到建造者模式。
建造者模式通过内部的Builder类主导目标对象的创建同时校验必选属性之间的依赖关系。如下set方法中包含一些校验，然后再build()中统一校验。
﻿
new ConstructorArg.Builder()
.setIsRef(false).setType(String.class).setObject(2)
.build()
﻿
﻿
装饰器模式装饰器模式把每个要装饰的功能放到单独的类中，并让这个类包装它所需要装饰的对象，从而实现对原始类的增强。
代理模式与装饰器模式的区别：
装饰器模式中，装饰器类附加的是跟原始类相关的增强功能。
代理模式中，代理类附加的是跟原始类无关的功能
案例：java的IO类库比如InputStream和BufferInputStream。还有Collections类。
﻿
﻿
职责链模式在职责链模式中，多个处理器依次处理同一个请求。
一个请求先经过 A 处理器处理，然后再把请求传递给 B 处理器，B 处理器处理完后再传递给 C 处理器，以此类推，形成一个链条。链条上的每个处理器各自承担各自的处理职责，所以叫作职责链模式。
﻿
在 GoF 给出的定义中，如果处理器链上的某个处理器能够处理这个请求，那就不会继续往下传递请求(下面代码所示)。实际上，职责链模式还有一种变体，那就是请求会被所有的处理器都处理一遍，不存在中途终止的情况。
﻿
职责链模式有两种常用的实现。一种是使用链表来存储处理器，另一种是使用数组来存储处理器，后面一种实现方式更加简单。
应用场景：Servlet中的Filter、Netty的ChannelPipeline.
﻿
public interface IHandler {
  boolean handle();
}
public class HandlerA implements IHandler {
  @Override
  public boolean handle() {
    boolean handled = false;
    //...
    return handled;
  }
}
public class HandlerB implements IHandler {
  @Override
  public boolean handle() {
    boolean handled = false;
    //...
    return handled;
  }
}
public class HandlerChain {
  private List<IHandler> handlers = new ArrayList<>();
  public void addHandler(IHandler handler) {
    this.handlers.add(handler);
  }
  public void handle() {
    for (IHandler handler : handlers) {
      boolean handled = handler.handle();
      if (handled) {
        break;
      }
    }
  }
}
// 使用举例
public class Application {
  public static void main(String[] args) {
    HandlerChain chain = new HandlerChain();
    chain.addHandler(new HandlerA());
    chain.addHandler(new HandlerB());
    chain.handle();
  }
}
﻿
代理模式静态代理
jdk动态代理：被代理类需要实现接口
﻿
﻿
cglib动态代理：不需要实现接口
如果被代理类被标记成final，也就无法通过CGLIB去创建动态代理:
java.lang.IllegalArgumentException: Cannot subclass final class class spring.PersonServiceImpl
﻿
如果被代理方法被标记为final，也无法正常实现代理功能
﻿
﻿
SpringAOP的实现：
如果目标对象实现了接口，默认采用JDK动态代理。
如果没有实现接口则采用CGLIB动态代理。
﻿
模板方法模式
由父类实现通用逻辑，具体细节留给子类去实现。减少代码重复度！
﻿
﻿
适配器模式这个模式就是用来做适配的，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。
适配器模式有两种实现方式：类适配器和对象适配器。其中，类适配器使用继承关系来实现，对象适配器使用组合关系来实现
﻿
代码实现：
其中，ITarget 表示要转化成的接口定义。Adaptee 是一组不兼容 ITarget 接口定义的接口，Adaptor 将 Adaptee 转化成一组符合 ITarget 接口定义的接口
类适配器: 基于继承﻿
public interface ITarget {
  void f1();
  void f2();
  void fc();
}
public class Adaptee {
  public void fa() { //... }
  public void fb() { //... }
  public void fc() { //... }
}
public class Adaptor extends Adaptee implements ITarget {
  public void f1() {
    super.fa();
  }
  
  public void f2() {
    //...重新实现f2()...
  }
  
  // 这里fc()不需要实现，直接继承自Adaptee，这是跟对象适配器最大的不同点
}
﻿
对象适配器：基于组合﻿
public interface ITarget {
  void f1();
  void f2();
  void fc();
}
public class Adaptee {
  public void fa() { //... }
  public void fb() { //... }
  public void fc() { //... }
}
public class Adaptor implements ITarget {
  private Adaptee adaptee;
  
  public Adaptor(Adaptee adaptee) {
    this.adaptee = adaptee;
  }
  
  public void f1() {
    adaptee.fa(); //委托给Adaptee
  }
  
  public void f2() {
    //...重新实现f2()...
  }
  
  public void fc() {
    adaptee.fc();
  }
}
﻿
如何选择？
如果 Adaptee 接口并不多，那两种实现方式都可以！
如果 Adaptee 接口很多呢？
Adaptee 和 ITarget 接口定义大部分都相同，推荐使用类适配器，因为可以让 Adaptor 复用父类 Adaptee 的接口。
Adaptee 和 ITarget 接口定义大部分都不相同，推荐使用对象适配器，因为组合结构相对于继承更加灵活！
﻿
SpringMVC中适配器模式
﻿
针对Servlet、Controller、注解的Handler组件适配为HandlerAdapter，统一调用handle(...)方法进行逻辑处理，省去了handler具体实现类的判断。
﻿
// 之前的实现方式
Handler handler = handlerMapping.get(URL);
if (handler instanceof Controller) {
  ((Controller)handler).handleRequest(...);
} else if (handler instanceof Servlet) {
  ((Servlet)handler).service(...);
} else if (hanlder 对应通过注解来定义的Controller) {
  反射调用方法...
}
// 现在实现方式
HandlerAdapter handlerAdapter = handlerMapping.get(URL);
handlerAdapter.handle(...);
﻿