设计模式-外观模式

一、外观模式(结构型模式)
1.定义
外观模式(Facade Pattern)又叫作门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。
该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。
2.外观模式角色
**(1). 外观角色：**为多个子系统对外提供一个共同的接口。
**(2).子系统角色：**实现系统的部分功能，客户可以通过外观角色访问它。
**(3).客户角色：**通过一个外观角色访问各个子系统的功能。
3.代码实现方式
(1).创建需要的多个子系统角色，定义自己的方法。
(2).创建外观角色，组合依赖各个子系统角色，提供统一的方法，里面调用各个子系统的方法。
4.代码实现
(1).场景
比如我们的老板想了解我们一个项目整个的流程，这时候你总不能让项目经理，一个一个的把开发啊、测试啊、运维啊、产品啊都喊过去给给老板汇报工作吧，这时候就需要项目经理整理出一份报告，然后具体各个兄弟姐妹们的工作细节，由每个人自己整理好发到项目经理那，然后给老板看。
(2).具体代码

package com.tw.designPattern.facade;

/**
 * 员工 （子系统角色）
 */
public class Worker {

    private String name;

    private String job;

    public Worker(String name,String job){
        this.name = name;
        this.job = job;
    }

    public String getName() {
        return name;
    }

    public String getJob() {
        return job;
    }


}

package com.tw.designPattern.facade;

/**
 * 项目经理 (子系统角色)
 */
public class ProjectManager extends Worker{

    public ProjectManager(String name,String job){
        super(name,job);
    }

    public void makeProjectPlan(){
        System.out.println(super.getName() + "-" + super.getJob() + "指定项目计划...");
    }

    public void analysisRequirement(){
        System.out.println(super.getName() + "-" + super.getJob() + "分析项目需求...");
    }
}

package com.tw.designPattern.facade;

/**
 * 开发经理 (子系统角色)
 */
public class DevelopManager extends Worker{

    public DevelopManager(String name,String job){
        super(name,job);
    }

    public void makeDevelopPlan(){
        System.out.println(super.getName() + "-" + super.getJob() + "制定研发计划...");
    }
}

package com.tw.designPattern.facade;

/**
 * 开发攻城狮 (子系统角色)
 */
public class DevelopmentEngineer extends Worker{

    public DevelopmentEngineer(String name,String job){
        super(name,job);
    }

    public void develop(){
        System.out.println(super.getName() + "-" + super.getJob() + "开始研发...");
    }
}

package com.tw.designPattern.facade;

/**
 * 测试攻城狮
 */
public class QualityAssurance extends Worker{

    public QualityAssurance(String name,String job){
        super(name,job);
    }

    public void test(){
        System.out.println(super.getName() + "-" + super.getJob() + "开始测试...");
    }
}

package com.tw.designPattern.facade;

/**
 * 运维攻城狮 (子系统角色)
 */
public class Operations extends Worker{

    public Operations(String name,String job){
        super(name,job);
    }

    public void operationAndMaintenance(){
        System.out.println(super.getName() + "-" + super.getJob() + "开始运维...");
    }
}

package com.tw.designPattern.facade;

import java.util.List;

/**
 * 
 *  外观角色
 */
public class Project {

    /**
     * 姓名
     */
    private String name;

    /**
     * 项目经理
     */
    private ProjectManager projectManager;

    /**
     * 研发经理
     */
    private DevelopManager developManager;

    /**
     * 研发工程师
     */
    private List<DevelopmentEngineer> developmentEngineerList;

    /**
     * 测试工程师
     */
    private List<QualityAssurance> qualityAssuranceList;

    /**
     * 运维工程师
     */
    private List<Operations> operationsList;

    public Project(String name, ProjectManager projectManager, DevelopManager developManager, List<DevelopmentEngineer> developmentEngineerList, List<QualityAssurance> qualityAssuranceList, List<Operations> operationsList) {
        this.name = name;
        this.projectManager = projectManager;
        this.developManager = developManager;
        this.developmentEngineerList = developmentEngineerList;
        this.qualityAssuranceList = qualityAssuranceList;
        this.operationsList = operationsList;
    }

    public void developProject(){
        System.out.println(name + "项目启动...");
        // 项目经理需求分析
        projectManager.analysisRequirement();
        // 项目经理制定项目计划
        projectManager.makeProjectPlan();
        // 研发经理制定研发计划
        developManager.makeDevelopPlan();
        // 研发工程师开始研发
        developmentEngineerList.forEach(DevelopmentEngineer::develop);
        // 测试工程师开始测试
        qualityAssuranceList.forEach(QualityAssurance::test);
        // 运维工程师开始运维
        operationsList.forEach(Operations::operationAndMaintenance);
        System.out.println(name + "项目上线平稳运行...");
    }
}

package com.tw.designPattern.facade;

import java.util.ArrayList;
import java.util.List;

public class FacadeTest {

    public static void main(String[] args) {
        String projectName = "外观模式实例项目";
        ProjectManager projectManager = new ProjectManager("王一一", "项目经理王一一");
        DevelopManager developManager = new DevelopManager("王一二", "研发经理王一二");
        List<DevelopmentEngineer> developmentEngineerList = new ArrayList<>();
        DevelopmentEngineer developmentEngineer1 = new DevelopmentEngineer("王一三", "JAVA开发工程师王一三");
        DevelopmentEngineer developmentEngineer2 = new DevelopmentEngineer("王一四", "JAVA开发工程师王一四");
        developmentEngineerList.add(developmentEngineer1);
        developmentEngineerList.add(developmentEngineer2);
        List<QualityAssurance> qualityAssuranceList = new ArrayList<>();
        QualityAssurance qualityAssurance1 = new QualityAssurance("王一五", "测试工程师王一五");
        QualityAssurance qualityAssurance2 = new QualityAssurance("王一六", "测试工程师王一六");
        qualityAssuranceList.add(qualityAssurance1);
        qualityAssuranceList.add(qualityAssurance2);
        List<Operations> operationsList = new ArrayList<>();
        Operations operations1 = new Operations("王一七", "运维工程师王一七");
        Operations operations2 = new Operations("王一八", "运维工程师王一八");
        operationsList.add(operations1);
        operationsList.add(operations2);
        Project project = new Project(projectName, projectManager, developManager, developmentEngineerList, qualityAssuranceList, operationsList);
        project.developProject();
    }
}

测试结果

外观模式实例项目项目启动...
王一一-项目经理王一一分析项目需求...
王一一-项目经理王一一指定项目计划...
王一二-研发经理王一二制定研发计划...
王一三-JAVA开发工程师王一三开始研发...
王一四-JAVA开发工程师王一四开始研发...
王一五-测试工程师王一五开始测试...
王一六-测试工程师王一六开始测试...
王一七-运维工程师王一七开始运维...
王一八-运维工程师王一八开始运维...
外观模式实例项目项目上线平稳运行...

注：别看这代码量多啊，其实这个是最简单的一个设计模式了，就是提供一个方法，把其他的方法放进来，然后客户端就调用那个一个方法就可以访问到其他的各个方法了，其实和我们平时代码封装啥的差不多，只不过语义不同罢了。
5.优缺点
(1).优点
(1-1).简化了调用过程，客户端无需深入了解子系统
(1-2).迪米特法则的应用
(2).缺点
(1-1).不符合开闭原则，当增加一个子系统时，需要修改源码
(1-2).外观角色有时候会违背单一原则
6.应用场景
(1).对分层结构系统构建时，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系。
(2).当一个复杂系统的子系统很多时，外观模式可以为系统设计一个简单的接口供外界访问。
(3).当客户端与多个子系统之间存在很大的联系时，引入外观模式可将它们分离，从而提高子系统的独立性和可移植性。
注：内容参考网络上各种资料，还有一些本人的理解和思想，仅为了学习记录和分享一下自己所学之处，如有不足的地方麻烦大牛指出，如有侵权的地方，请联系删除，谢谢。