框架设计之设计模式

àì夳堔傛蜴生んèń 2023-02-20 03:20 1阅读 0赞

来源于架构师训练营第三章，总结。

我们都知道设计模式和基础设计原则是架构师掌握的基础知识，就是学java的人掌握java语法一个道理，那我们在日常开发工作中又怎么对待设计模式呢？我们会刻意的为了一段代码去选择用设计模式吗？今天我们来说一下设计模式。

# 什么是设计模式 #

想知道什么是设计模式之前我们需要了解什么是开发原则，可以通过文章《[基础框架之设计原则][Link 1]》和文章《[设计模式之SOLID原则][SOLID]》了解一些基础概念。

设计模式定义：设计模式是描述一种问题的通用解决方案。这种问题在我们的环境中，不停的出现，为了解决这种问题，抽象出来的一种可以重复使用的解决方案。

设计模式组成部分：一个设计模式总共有四个组成部分；模式名称：由少量字组成的名称，有助于表达我们的设计；待解决问题，什么时候需要用这种设计模式，和运用模式的上下文；解决方案，描述组成的设计元素、关系、职责。一般的解决方案都是抽象的，并不代表具体实现；结论，运用这种方案带来的利和弊，主要是指系统弹性、扩展性、和可移植性等影响。

# 设计模式划分 #

设计模式一共23种，我们可以通过类型做作用大致分为三类。

*  创建型设计模式：主要是对实例化过程的抽象，包括：单例模式、工厂模式、建造者模式、原型模式；
 *  结构型设计模式：将类或者对象结合在一起形成更大的结构，包括：代理模式、桥接模式、装饰器模式、适配器模式、门面模式、组合模式、享元模式；
 *  行为型设计模式：对在不同的对象之间划分责任和算法的抽象画，包括“观察者模式、模板模式、策略模式、职责链模式、迭代器模式、状态模式、访问者模式、备忘录模式、命令模式、解释器模式、中介模式；

我们在不了解设计模式的情况下有用到设计模式吗？但肯定是用的，而且用到的设计模式还不少，只是没有对应到具体的设计模式。

# 设计模式部分讲解 #

## 工厂模式 ##

工厂模式包括简单工厂、工厂方法、抽象工厂这 3 种细分模式。工厂模式用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。实际上，如果创建对象的逻辑并不复杂，那我们直接通过 new 来创建对象就可以了，不需要使用工厂模式。当创建逻辑比较复杂，是一个“大工程”的时候，我们就考虑使用工厂模式，封装对象的创建过程，将对象的创建和使用相分离。

示例:

public class NodeComponentFactory {
    
        private final static Map<String,NodeParser> cacheParser = new HashMap<>();
    
        static {
            cacheParser.put(NodeParserEnum.method.name(),new MethodNodeComponent());
            cacheParser.put(NodeParserEnum.bean.name(),new BeanNodeComponent());
            cacheParser.put(NodeParserEnum.condition.name(),new ConditionNodeComponent());
        }
    
        public static NodeParser getNodeInstance(String nodeName){
            return cacheParser.get(nodeName);
        }
    }

## 单例模式 ##

单例模式用来创建全局唯一的对象。一个类只允许创建一个对象（或者叫实例），那这个类就是一个单例类，这种设计模式就叫作单例模式。单例有几种经典的实现方式，它们分别是：饿汉式、懒汉式、双重检测、静态内部类、枚举。

public class FlowContext {
        private static FlowContext instance;
        private FlowContext(){}
        public static FlowContext getInstance(){
            if(instance == null){
                synchronized (FlowContext.class){
                    if(instance == null){
                        instance = new FlowContext();
                    }
                }
            }
            return instance;
        }
    }

## 适配器模式 ##

适配器提供跟原始类不同的接口。适配器模式是用来做适配的，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。适配器模式有两种实现方式：类适配器和对象适配器。其中，类适配器使用继承关系来实现，对象适配器使用组合关系来实现。

public interface Node {
        void setName();
        void setId();
        void setNext();
    }
    public class MethodNode {
        public void setMethodName(){}
        public void setMethodId(){}
        public void setMethodNext(){}
    }
    public class BeanNode extends MethodNode implements Node {
        @Override
        public void setName() {
            super.setMethodName();
        }
        @Override
        public void setId() {
            super.setMethodId();
        }
        @Override
        public void setNext() {
            super.setMethodNext();
        }
    }

## 模板模式 ##

模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。

public abstract class AbstractNode {
        public void init(String inputUrl, BaseInput baseInput){
            parser();
            setNodeMap();
        }
        public abstract void parser();
        public abstract void setNodeMap();
    }
    public class TestNode extends AbstractNode{
        @Override
        public void parser() {
            System.out.println("parser");
        }
    
        @Override
        public void setNodeMap() {
            System.out.println("setNodeMap");
        }
    }

## 策略模式 ##

策略模式定义一组算法类，将每个算法分别封装起来，让它们可以互相替换。策略模式可以使算法的变化独立于使用它们的客户端（这里的客户端代指使用算法的代码）。策略模式用来解耦策略的定义、创建、使用。实际上，一个完整的策略模式就是由这三个部分组成的。

public interface Strategy {
        void test();
    }
    public class TestAStrategy implements Strategy {
        @Override
        public void test() {
            System.out.println("test");
        }
    }
    public class TestBStrategy implements Strategy {
        @Override
        public void test() {
            System.out.println("test");
        }
    }

## 组合模式 ##

组合模式主要是用来处理树形结构数据。正因为其应用场景的特殊性，数据必须能表示成树形结构，这也导致了这种模式在实际的项目开发中并不那么常用。但是，一旦数据满足树形结构，应用这种模式就能发挥很大的作用，能让代码变得非常简洁。

## 装饰器模式 ##

装饰器模式主要解决继承关系过于复杂的问题，通过组合来替代继承，给原始类添加增强功能。这也是判断是否该用装饰器模式的一个重要的依据。除此之外，装饰器模式还有一个特点，那就是可以对原始类嵌套使用多个装饰器。为了满足这样的需求，在设计的时候，装饰器类需要跟原始类继承相同的抽象类或者接口。

public interface IA {
      void f();
    }
    public class A impelements IA {
        public void f(){ //... }
      }
    public class AProxy impements IA {
      private IA a; public AProxy(IA a) { this.a = a; }
      public void f() {
      // 新添加的代理逻辑
      a.f();
      // 新添加的代理逻辑
      }
    }

[Link 1]: https://blog.csdn.net/zhangchangbin123/article/details/106754574
[SOLID]: https://blog.csdn.net/zhangchangbin123/article/details/103602558