门面模式（外观模式）

参考：http://www.cnblogs.com/java-my-life/archive/2012/05/02/2478101.html

/DesignPatterns/src/com/louis/Facade/ModuleA.java

/**
 * Project Name:DesignPatterns
 * File Name:ModuleA.java
 * Package Name:com.louis.Facade
 * Date:2017年11月2日下午4:17:32
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
*/

package com.louis.Facade;
/**
 * ClassName:ModuleA
 * Function: TODO ADD FUNCTION.
 * Reason:     TODO ADD REASON.
 * Date:     2017年11月2日 下午4:17:32
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class ModuleA {
    //示意方法
    public void testA(){
        System.out.println("调用ModuleA中的testA方法");
    }
}

/DesignPatterns/src/com/louis/Facade/ModuleB.java

/**
 * Project Name:DesignPatterns
 * File Name:ModuleA.java
 * Package Name:com.louis.Facade
 * Date:2017年11月2日下午4:17:32
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
*/

package com.louis.Facade;
/**
 * ClassName:ModuleA
 * Function: TODO ADD FUNCTION.
 * Reason:     TODO ADD REASON.
 * Date:     2017年11月2日 下午4:17:32
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class ModuleB {
    //示意方法
    public void testB(){
        System.out.println("调用ModuleB中的testB方法");
    }
}

/DesignPatterns/src/com/louis/Facade/ModuleC.java

/**
 * Project Name:DesignPatterns
 * File Name:ModuleA.java
 * Package Name:com.louis.Facade
 * Date:2017年11月2日下午4:17:32
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
*/

package com.louis.Facade;
/**
 * ClassName:ModuleA
 * Function: TODO ADD FUNCTION.
 * Reason:     TODO ADD REASON.
 * Date:     2017年11月2日 下午4:17:32
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class ModuleC {
    //示意方法
    public void testC(){
        System.out.println("调用ModuleC中的testC方法");
    }
}

/DesignPatterns/src/com/louis/Facade/Facade.java

/**
 * Project Name:DesignPatterns
 * File Name:Facade.java
 * Package Name:com.louis.Facade
 * Date:2017年11月2日下午4:19:03
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
*/

package com.louis.Facade;
/**
 * ClassName:Facade
 * Function: TODO ADD FUNCTION.
 * Reason:     TODO ADD REASON.
 * Date:     2017年11月2日 下午4:19:03
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class Facade {
    public void test(){
        ModuleA a = new ModuleA();
        a.testA();
        ModuleB b = new ModuleB();
        b.testB();
        ModuleC c = new ModuleC();
        c.testC();
    }
}

/DesignPatterns/src/com/louis/Facade/Client.java

/**
 * Project Name:DesignPatterns
 * File Name:Client.java
 * Package Name:com.louis.Facade
 * Date:2017年11月2日下午4:20:14
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
*/

package com.louis.Facade;
/**
 * ClassName:Client
 * Function: TODO ADD FUNCTION.
 * Reason:     TODO ADD REASON.
 * Date:     2017年11月2日 下午4:20:14
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.test();
    }
}

　　使用门面模式还有一个附带的好处，就是能够有选择性地暴露方法。一个模块中定义的方法可以分成两部分，一部分是给子系统外部使用的，一部分是子系统内部模块之间相互调用时使用的。有了Facade类，那么用于子系统内部模块之间相互调用的方法就不用暴露给子系统外部了。

/DesignPatterns/src/com/louis/Facade/ModuleAA.java

/**
 * Project Name:DesignPatterns
 * File Name:Module.java
 * Package Name:com.louis.Facade
 * Date:2017年11月2日下午4:25:11
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
*/

package com.louis.Facade;
/**
 * ClassName:Module
 * Function: TODO ADD FUNCTION.
 * Reason:     TODO ADD REASON.
 * Date:     2017年11月2日 下午4:25:11
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class ModuleAA {
     /**
     * 提供给子系统外部使用的方法
     */
    public void a1(){};

    /**
     * 子系统内部模块之间相互调用时使用的方法
     */
    public void a2(){};
    public void a3(){};
}

/DesignPatterns/src/com/louis/Facade/ModuleBB.java

/**
 * Project Name:DesignPatterns
 * File Name:Module.java
 * Package Name:com.louis.Facade
 * Date:2017年11月2日下午4:25:11
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
*/

package com.louis.Facade;
/**
 * ClassName:Module
 * Function: TODO ADD FUNCTION.
 * Reason:     TODO ADD REASON.
 * Date:     2017年11月2日 下午4:25:11
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class ModuleBB {
     /**
     * 提供给子系统外部使用的方法
     */
    public void b1(){};

    /**
     * 子系统内部模块之间相互调用时使用的方法
     */
    public void b2(){};
    public void b3(){};
}

/DesignPatterns/src/com/louis/Facade/ModuleCC.java

/**
 * Project Name:DesignPatterns
 * File Name:Module.java
 * Package Name:com.louis.Facade
 * Date:2017年11月2日下午4:25:11
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
*/

package com.louis.Facade;
/**
 * ClassName:Module
 * Function: TODO ADD FUNCTION.
 * Reason:     TODO ADD REASON.
 * Date:     2017年11月2日 下午4:25:11
 * @author   michael
 * @version
 * @since    JDK 1.7
 * @see
 */
public class ModuleCC {
     /**
     * 提供给子系统外部使用的方法
     */
    public void c1(){};

    /**
     * 子系统内部模块之间相互调用时使用的方法
     */
    public void c2(){};
    public void c3(){};
}

/DesignPatterns/src/com/louis/Facade/ModuleFacade.java

/**
 * Project Name:DesignPatterns
 * File Name:ModuleFacade.java
 * Package Name:com.louis.Facade
 * Date:2017年11月2日下午4:27:28
 * Copyright (c) 2017, [email protected] All Rights Reserved.
 *
 */

package com.louis.Facade;

/**
 * ClassName:ModuleFacade Function: TODO ADD FUNCTION. Reason: TODO ADD REASON.
 * Date: 2017年11月2日 下午4:27:28
 *
 * @author michael
 * @version
 * @since JDK 1.7
 * @see
 */
public class ModuleFacade {
    ModuleAA a = new ModuleAA();
    ModuleBB b = new ModuleBB();
    ModuleCC c = new ModuleCC();

    /**
     * 下面这些是A、B、C模块对子系统外部提供的方法
     */
    public void a1() {
        a.a1();
    }

    public void b1() {
        b.b1();
    }

    public void c1() {
        c.c1();
    }
}

这样定义一个ModuleFacade类可以有效地屏蔽内部的细节，免得客户端去调用Module类时，发现一些不需要它知道的方法。比如a2()和a3()方法就不需要让客户端知道，否则既暴露了内部的细节，又让客户端迷惑。对客户端来说，他可能还要去思考a2()、a3()方法用来干什么呢？其实a2()和a3()方法是内部模块之间交互的，原本就不是对子系统外部的，所以干脆就不要让客户端知道。

门面模式在Tomcat中的使用

参考：http://www.cnblogs.com/java-my-life/archive/2012/05/02/2478101.html

时间： 2024-10-03 14:00:51

门面模式（外观模式）的相关文章

门面模式/外观模式

原文链接:http://www.tutorialspoint.com/design_pattern/facade_pattern.htm Facade Pattern(门面模式/外观模式) 隐藏了系统的复杂性,为客户端访问系统提供了一个接口.Facade Pattern 属于结构型模式的一种,通过添加一个接口来隐藏现有系统的复杂性. Facade Pattern 涉及到一个类,这个类代理调用了现有系统的类的一些方法,从而为客户端提供了简化的方法来访问系统. 实现我们将会创建一个 Shape 接

第12章结构型模式—外观模式

1. 外观(门面)模式(Facade Pattern)的定义 (1)为子系统中的一组接口提供一个一致的界面,Façade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用. ①这里说的界面是指从一个组件外部来看这个组件,能够看到什么,也就是外观.如从一个类外部看这个类,那么这个类的public方法或接口就是他的外观. ②这里所说的“接口”是指外部和内部交互的一个通道(方法),可以是类的方法,也可以是interface的方法. (2)外观模式的结构和说明 ①Façade:定义子系统的多个模

设计模式--结构型模式--外观模式

医院的例子: 现代的软件系统都是比较复杂的,设计师处理复杂系统的一个常见方法便是将其“分而治之”,把一个系统划分为几个较小的子系统.如果把医院作为一个子系统,按照部门职能,这个系统可以划分为挂号.门诊.划价.化验.收费.取药等.看病的病人要与这些部门打交道,就如同一个子系统的客户端与一个子系统的各个类打交道一样,不是一件容易的事情. 首先病人必须先挂号,然后门诊.如果医生要求化验,病人必须首先划价,然后缴费,才可以到化验部门做化验.化验后再回到门诊室. 上图描述的是病人在医院里的体验,图中的

11 结构型模式-----外观模式

模式动机(Facade Pattern):在设计一个复杂系统时,一般会将其分解为若干个具有特定功能的子系统以便于分析设计,这样的话就会导致数量众多的子系统接口出现,使得与调用者的交互变得复杂了.解决办法是在所有子系统的上一层提供一个外观类(Facade),其负责对所有子系统的统一调用,客户只需和外观类交互即可. 模式结构图: 模式代码: bt_外观模式.h: 1 #ifndef FP_H 2 #define FP_H 3 #include <iostream> 4 5 /* 6 定义子系统Su

java设计模式--结构型模式--外观模式

1 外观模式 2 概述 3 为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用. 4 5 6 适用性 7 1.当你要为一个复杂子系统提供一个简单接口时.子系统往往因为不断演化而变得越来越 8 复杂.大多数模式使用时都会产生更多更小的类.这使得子系统更具可重用性,也更容 9 易对子系统进行定制,但这也给那些不需要定制子系统的用户带来一些使用上的困难. 10 Facade可以提供一个简单的缺省视图,这一视图对大多数用户来说已经足够,而那些需

建造模式 + 外观模式示例:实现扣除用户金币及写入用户明细

实现功能: 扣除用户金币及写入金币明细,这是同一个行为,使用外观模式金币明细需要多个参数来保证对象的完整,参数过多,所以使用建造模式一.用户明细类 class MoneyDetail { const MONEY_PAY = 1; // 充值获得 const MONEY_EXCHANGE = 2; // 兑换 private $type; private $quantity; private $desc; private $time; public function __construct(M

【编程思想】【设计模式】【结构模式Structural】门面模式/外观模式Facade

Python版 https://github.com/faif/python-patterns/blob/master/structural/facade.py #!/usr/bin/env python # -*- coding: utf-8 -*- """ *What is this pattern about? The Facade pattern is a way to provide a simpler unified interface to a more com

外观模式门面模式 Facade 创建型设计模式（十三）

外观模式(FACADE) 又称为门面模式意图为子系统中的一组接口提供一个一致的界面 Facade模式定义了一个高层接口,这一接口使得这一子系统更加易于使用. 意图解析随着项目的持续发展,系统基本上都是会往功能更全面的方向发展,那么也就意味着我们的系统将会变得更加复杂. 系统会被划分为多个单独的子系统,每个子系统完成一部分功能,通过分工协作完成全部功能. 一个子系统也可能进一步拆分为更小的几个子系统. 程序中的文件将会越来越多,相互关联也会变得更加复杂当使用一个功能的时候,作为客户端你需

iOS开发-适配器和外观模式

适配器模式,属于结构型模式,其主要作用是将一个类的接口转换成客户希望的另外一个接口.适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作.适配器模式有对象适配器和类适配器两种,类适配器模式需要语言实现多继承,OC不支持多继承,所以一般我们都实现对象适配器.外观模式提供了一个统一的接口,用来访问子系统中的一群接口,外观定义了一个高层接口,让子系统更容易使用.适配器是为了转换接口,外观模式是为了简化接口. 适配器模式对象适配器模式UML类图: 关于适配模式最常见的就是手机充电的例子,

设计模式之- 外观模式（Facade Pattern）

外观模式外观模式(Facade Pattern):外部与一个子系统的通信必须通过一个统一的外观对象进行,为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用.外观模式又称为门面模式,它是一种对象结构型模式. C++代码: #include<iostream> using namespace std; class Shape { public: virtual void draw()=0; }; class Rectangle : public