软件设计模式(二)：工厂、门面、调停者和装饰器模式

前言

        在这篇文章中，荔枝将会梳理软件设计模式中的四种：工厂模式、Facade模式、Mediator模式和装饰器Decorator模式。其中比较重要的就是工厂模式和装饰器模式，工厂模式在开发中使用的频数比较高。希望荔枝的这篇文章能讲清楚哈哈哈哈，希望能帮助到有需要的小伙伴~~~

---

文章目录

前言

一、工厂模式

1.1 简单工厂

1.2 工厂方法

1.3 抽象工厂

二、调停者模式和门面模式

2.1 门面模式Facade

2.2 调停者模式Mediator

三、装饰器模式Decorator 

总结

---

一、工厂模式

1.1 简单工厂

首先定义一个交通工具的工厂函数接口Moveable。

package com.crj.factorymethod;
/**
 * 工厂函数接口
 */
public interface Moveable {
    void go();
}

 我们要实现某一种方式的交通工具就需要通过将该交通工具类实现该接口并重写go方法。

package com.crj.factorymethod;
 
/**
 * Car类继承工厂函数接口
 */
public class Car implements  Moveable {
    public void go() {
        System.out.println("Car go wuwuwuwuw....");
    }
}

通过简单工厂模式来返回实例化后的交通工具对象。

package com.crj.factorymethod;
 
/**
 * 简单工厂模式
 * 简单工厂的可扩展性不好
 */
public class SimpleVehicleFactory {
    public Car createCar() {
        //before processing
        return new Car();
    }
 
    public Broom createBroom() {
        return new Broom();
    }
}

1.2 工厂方法

        上文中可以看出，简单工厂模式的可扩展性比较差，但我们需要新创建一种交通方式的时候就需要重新在工厂SimpleVehicleFactory定义并写死相应的对象方法，这在后期的时候并不容易维护。那么还可以通过不同交通工具各自有一个工厂，方法类型都是继承自Moveable，返回值也是Moveable类型。

package com.crj.factorymethod;
 
/**
 * 工厂方法
 */
public class CarFactory {
    public Moveable create() {
        System.out.println("a car created!");
        return new Car();
    }
}

main方法

package com.crj.factorymethod;
 
public class Main {
    public static void main(String[] args) {
        Moveable m = new CarFactory().create();
        m.go();
    }
}

1.3 抽象工厂

前面我们已经把产品的构建和工厂一一对应了，但是我们操作起产品簇还不是很方便，我们可以通过抽象工厂直接操作创建一整个产品簇。在实现创建产品簇之前，我们需要创建抽象产品类、抽象工厂、具体产品类和具体的工厂。

抽象产品类

首先定义一些抽象产品类，并定义相应的抽象方法。

抽象工厂AbstractFactory

抽象工厂定义抽象的方法用于创建相应的产品簇中的类型产品。 

package com.mashibing.dp.abstractfactory;
 
public abstract class AbastractFactory {
    abstract Food createFood();
    abstract Vehicle createVehicle();
    abstract Weapon createWeapon();
}

具体工厂类

具体工厂类继承自抽象工厂类，并重写不同类型的产品创建产品的方法。 

具体产品类

具体的产品类继承自抽象产品类

main文件

        在main文件中我们通过实例化具体产品类得到对象并调用相应的产品创建方法首先产品簇的创建。可以看到在这段demo中我们即使需要得到不同的产品簇，也仅需要通过实例化不同的工厂类即可。

package com.mashibing.dp.abstractfactory;
 
public class Main {
    public static void main(String[] args) {
        AbastractFactory f = new ModernFactory();
 
        Vehicle c = f.createVehicle();
        c.go();
        Weapon w = f.createWeapon();
        w.shoot();
        Food b = f.createFood();
        b.printName();
    }
}

具体的逻辑可以看一下这张图，荔枝感觉还是没讲得很清楚，剩下三分自己就得靠大家聪明得脑瓜啦。

---

二、调停者模式和门面模式

2.1 门面模式Facade

        门面模式要求一个系统外部与其内部的通信必须通过一个统一的对象进行，通过一个高层次的接口管理外部通信与内部对象簇之间的通信，简单理解就是一个中介（门面），外部仅需要跟这个中介对接即可，中介再委派客户端发送的请求到相应的子系统中，这也是一种黑箱操作。在该模式下可以同时拥有一个或者多个系统，每个系统是一个类的集合，同时系统对于门面只是当成客户端来处理。

需要注意的是：

• 一个系统可以有多个门面

• 门面不参与系统内的业务逻辑

2.2 调停者模式Mediator

        调停者模式相当于一个星型连接，该模式多用于消息中间件如MQ中，对象间只需要跟中间人进行沟通即可，由中间人进行消息的收发和处理，是一种解耦的操作。对于门面模式和调停者模式的区别详情可以下图，二者其实区别并不大并且在某些场景下是可以互换的。

---

三、装饰器模式Decorator 

装饰器（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些功能的模式，它属于对象结构型模式。

优点：

• 装饰器是继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态的给一个对象扩展功能，即插即用
• 通过使用不用装饰类及这些装饰类的排列组合，可以实现不同效果
• 装饰器模式完全遵守开闭原则

缺点：装饰器模式会增加许多子类，过度使用会增加程序复杂性。

大致看了一些概念性的东西大机器是不是感觉不是特别具象，下面我们可以通过一个例子来理解一下装饰器模式具体是一个怎样的软件设计模式。 

package com.crj.Decorator;
 
public class Decorator {
    /**
     * 装饰器模式
     * 使用实体装饰类装饰
     * @param args
     */
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        RedShapeDecorator rda = new RedShapeDecorator(a);
        rda.draw();
        BlueShapeDecorator rdb = new BlueShapeDecorator(b);
        rdb.draw();
    }
}
 
/**
 * 接口
 */
interface Shape{
    void draw();
}
 
/**
 * 接口实现类
 */
class A implements Shape{
    @Override
    public void draw() {
        System.out.println("这是A类");
    }
}
class B implements  Shape{
    @Override
    public void draw() {
        System.out.println("这是B类");
    }
}
 
/**
 * 抽象装饰类
 */
abstract class ShapeDecorator implements Shape{
    protected Shape decoratedShape;
 
    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }
 
    @Override
    public void draw() {
        decoratedShape.draw();
    }
}
 
/**
 * 第一个实体装饰类
 */
class RedShapeDecorator extends ShapeDecorator{
    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }
 
    @Override
    public void draw() {
        super.draw();
        setRedShapeDecorator(decoratedShape);
    }
    private void setRedShapeDecorator(Shape decoratedShape){
        System.out.println("Red");
    }
}
/**
 * 第二个实体装饰类
 */
class BlueShapeDecorator extends ShapeDecorator{
    public BlueShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }
    @Override
    public void draw() {
        super.draw();
        setRedShapeDecorator(decoratedShape);
    }
    private void setRedShapeDecorator(Shape decoratedShape){
        System.out.println("Blue");
    }
}

        在上面的demo中，我们定义了一个普通接口、两个基本的接口实现类、一个抽象装饰类和两个实体装饰类。接口实现类和抽象装饰类都实现了接口的实现方法并重写接口的方法。实体装饰类继承自抽象装饰类，由于抽象装饰类中含有有参构造方法，因此需要使用super关键字声明继承对象。我们通过往实体装饰类对象中传入一个实体类对象，实现了对对象调用的draw()方法的装饰。

        可以看一下这张图，我们可以发现其实在Shape接口上我们定义了一个ShapeDecorator抽象装饰类来装饰，所谓装饰其实也是增加功能。在前面中我们也提及装饰的本质就是使用抽象类继承接口，再使用具体的实现类装饰上功能，这种方式极好的解决了子类爆炸的问题。

---

总结

        到现在荔枝也梳理了几种设计模式了，总结一下自己的学习方法：主要是根据文档和大佬视频资源讲解梳理的，再自己手敲示例实现一遍，收获和体会确实是挺大的。学习设计模式可能会比较枯燥，大家加油，荔枝要继续前行咯~

今朝已然成为过去，明日依然向往未来！我是小荔枝，在技术成长的路上与你相伴，码文不易，麻烦举起小爪爪点个赞吧哈哈哈~~~ 比心心♥~~~