通达信语言接口-二十年阿里入土级架构师含泪吐血总结23种设计模式

23种设计模式

下面是23种常见的设计模型：

工厂模式工厂创建对象spring抽象工厂模式抽象工厂创建对象spring单例模式只有一个对象spring建造者模式一个对象用来构建一个复杂对象mybatis的configuration复杂对象原型模式使用clone对象快速创建对象适配器模式让原本不兼容的对象可以一起工作继承实现桥接模式针对一个事物不同维度，利用抽象实现的手段分离开，需要的时候通过拼接的形式组合到一起过滤器模式对一个事物的属性进行过滤组合模式将对象组合成树形结构以表示“整体-部分”的层次结构装饰器模式使用通达信语言接口,接口抽象继承手段对一个事物层层包装添加新的功能外观模式外观模式提供了一个简单的通达信语言接口,接口，隐藏了子系统的实现细节，使得使用子系统变得更加方便和易于理解。享元模式减少系统资源消耗，避免重复创建对象，用容器保存已经创建的对象代理模式控制对原始对象的访问，并允许在访问过程中添加额外的逻辑。日志缓存责任链模式将请求和处理者解耦，并将多个处理者形成一个链条，使得请求可以沿着这个链条依次传递命令模式将请求封装成一个对象，使得请求的发送者和接收者解耦，从而可以灵活地处理请求、撤销操作或者记录日志等。解释器模式解释和解析特定语法的表达式，将其转换为可执行的操作将复杂的表达式进行分解组装迭代器模式统一的接口来遍历不同类型的集合对象，而不需要关心其内部的具体实现遍历中介者模式两者之间需要第三者来帮助传话备忘录模式将想要备份的信息交给备忘录对象来管理，这样就不用担心原本的信息丢失了观察者模式观察者模式定义了一种对象之间的一对多依赖关系，当一个对象的状态发生变化时，它的所有依赖对象都会自动收到通知并进行相应的更新。状态模式状态模式是一种行为设计模式，它允许对象在内部状态发生改变时改变其行为，使得对象在不同的状态下具有不同的行为表现。策略模式策略模式是一种行为设计模式，它定义了一系列算法，并将每个算法封装在独立的可互换的策略类中，使得算法可以独立于客户端而变化。模板方法模式模板方法模式是一种行为设计模式，它定义了一个算法的骨架，在抽象类中封装了算法的结构，具体的步骤由子类去实现，以达到在不改变算法结构的情况下，允许子类重定义算法中的某些步骤。

这些设计模型可以分为三大类：

每种设计模型都有其独特的应用场景和优点，开发人员可以根据具体情况选择合适的设计模型来提供高代号的可阅读性、可维护性和可扩展性。

工厂模式

下面是一个简单的Java代码示例，展示了工厂模型的实现：

// 产品接口
interface Product {
    void doSomething();
}

// 具体产品类A
class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA do something");
    }
}

// 具体产品类B
class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB do something");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂类A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂类B
class ConcreteFactoryB implements Factory {
            @Override
            public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class FactoryPatternExample {
    public static void main(String[] args) {
        // 创建工厂对象
        Factory factoryA = new ConcreteFactoryA();
        Factory factoryB = new ConcreteFactoryB();

        // 使用工厂对象创建产品对象
        Product productA = factoryA.createProduct();
        Product productB = factoryB.createProduct();

        // 调用产品对象的方法
        productA.doSomething();
        productB.doSomething();
    }
}

在上面的示例中，我们首先确定了一个产品接口Product，它包含一个doSomething方法，用于执行产品的操作。

然后，我们发现了两个具体产品类型ConcreteProductA和ConcreteProductB，它们分别发现了产品接口中的方法。

我们确定了工厂接口Factory，它包含一个createProduct方法，用于创建产品对像。

我们还发现了两个实体工厂类ConcreteFactoryA和ConcreteFactoryB，他们分别发现了工厂接口中的方法，根据需要创建不同的产品对比。

在客户端代码中，我们创建了工厂对像，并使用工厂对像分别创建了实体的产品对像。通过工厂的创建方法，我们可以轻松地获取产品对像，并调整使用其他方法进行操作。

抽象工厂模式

抽象工厂模式是一种创建设计模型，它提供了一种方法来创建一个系列相关或相互依赖的对象，而不需要指定具体的类。

下面是一个简单的Java代码示例，展示了抽像工厂模型的现实：

// 抽象产品接口A
interface ProductA {
    void doSomething();
}

// 具体产品类A1
class ConcreteProductA1 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA1 do something");
    }
}

// 具体产品类A2
class ConcreteProductA2 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA2 do something");
    }
}

// 抽象产品接口B
interface ProductB {
    void doSomething();
}

// 具体产品类B1
class ConcreteProductB1 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB1 do something");
    }
}

// 具体产品类B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB2 do something");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂类1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂类2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class AbstractFactoryPatternExample {
    public static void main(String[] args) {
        // 创建工厂对象
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractFactory factory2 = new ConcreteFactory2();

        // 使用工厂对象创建产品对象
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();

        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();

        // 调用产品对象的方法
        productA1.doSomething();
        productB1.doSomething();

        productA2.doSomething();
        productB2.doSomething();
    }
}

在上面描述的例子中，我们首先确定了抽像产品接口ProductA和ProductB，它们分别代表两个产品系列。

然后，我们发现了具体的产品类型ConcreteProductAConcreteProductAConcreteProductB1和ConcreteProductB分别发现了抽像产品接口中的方法。

我们确定了抽像工厂接口AbstractFactory，它包含两个方法用于创建产品对像。

我们还发现了两个实体工厂类ConcreteFactory1和ConcreteFactory它们分别实现了抽像工厂接口中的方法，根据需要创建不同系列的产品对像。

在客户端代码中，我们创建了实体的工厂对象，并使用工厂对象创建了实体的产品对象。通过工厂对象的方法，我我们可以轻松地获取对应系列的产品对像，并调整使用其他方法进行操作。

文章为作者独立观点，不代表股票程序化软件自动交易接口观点