精华内容
下载资源
问答
  • Facade

    2011-04-06 09:14:00
    这就是Facade模式的简单应用的场合,有人可能会想为什么不直接调用DAO层呢?因为在实际的应用中,也许DAO中的方法太多,而我们实际用到的方法只是其中的一个或几个,所有把业务中用到的方法在提出出来封装处理,对...
    原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。 http://weijie.blog.51cto.com/340746/67135
          在许多开源的框架中都充分的利用了设计模式这一概念,Struts典型的MVC模式的化身,Spring是工厂模式和单例模式的充分体现。在项目开发中,能充分利用设计模式的思想来考虑问题,来解决问题,来通过代码去实现。不但可以提高代码的质量,对程序的扩展,重用带来很大方便。其实我们项目中用设计模式编程就是加了一个封装层,减少客户必须处理的对象的数量。
          在设计模式中一般都遵循这样的原则:
          (1)按接口编程。
          (2)尽量用聚合代替继承。
          (3)找出变化并封装之。
         上面主要讲了一些设计模式的作用和原则。接下来我要讲的是在实际项目中应用的比较多的其中一个模式----->门面模式(Facade),有的叫正面,外观模式,其实都是一个意识,都指的这个模式。它也是美国著名的四人帮(GOF)写的23种模式之一。
           简单的理解:我们需要用一种比原有的方法更简单的方法与系统交互,或者说,我们需要以一种特殊的方式使用系统。主要是为子系统中的一组接口提供一个统一的接口。Facade模式定义了一个更高的接口,使子系统更加容易使用。它的意图要求一个一致的高层接口。
           我简单的用代码方式表现出来。我写的都是一些伪代码。主要是来讲清Facade的应用。
           以简单的登录为例:
           我们一般都会写一个DAO层,主要封装了数据库里增,删,该,查作用。
    我们一般会写一个接口:简单声明一个方法。根据用户名和密码来从数据库中查找是否存在。
    public interface UserDAO {
       public abstract List findByUserName(Object userName,Object passWord);
     public abstract List findByUserName(Object userName);
     public abstract List findByUserPassword(Object userPassword);
     public abstract List findByUserPortraitUrl(Object userPortraitUrl);
     public abstract List findByEmail(Object email);
     public abstract List findByUrl(Object url);
     public abstract List findByRole(Object role);
    }
     然后再写一个接口的实现:
    public class UserDAOImp implements W3csTUserDAO {
             public  List findByUserName(Object userName,Object passWord){
             //判断用户是否存在。存在返回一个list,反之为null.
     }
      public List findByUserName(Object userName){
        //实现
    }
     public  List findByUserPassword(Object userPassword){
        //实现
    }
     public   List findByUserPortraitUrl(Object userPortraitUrl){
        //实现
    }
     public  List findByEmail(Object email){
        //实现
    }
     public  List findByUrl(Object url){
        //实现
    }
     public  List findByRole(Object role){
        //实现
    }
    }
        我们一般应用门面模式是在业务层。我们在写一个业务方法:和上面一样先声明一个接口。
    public interface UserService{
          public boolean login(Stirng userName,String passWord);
    }
       在写一个业务接口的实现。
      public class UserServiceImp implements UserService{
         private UserDAO userDao;
         public void setUserDAO(UserDAO userDao){
                 this.userDao = userDao;
     }
         public UserDAO getUserDao(){
                   return userDao;         
        }
         public boolean login(Stirng userName,String passWord){
                if(userDao.findByUserName(userName,passWord)!=null){
           //合法用户,登录成功。
      }else{
             //登录失败。 
    }
      }
    }
     
          我们可以看到我们在业务层中对DAO层又进行了一层封装。这就是Facade模式的简单应用的场合,有人可能会想为什么不直接调用DAO层呢?因为在实际的应用中,也许DAO中的方法太多,而我们实际用到的方法只是其中的一个或几个,所有把业务中用到的方法在提出出来封装处理,对调用者来说也很方便,它不会直接接触到DAO,我们把DAO封装在Service层中是为了让各个层职责分明。这样做还有一个用处,我们可能还会对用户的登录信息进行记录,这是我们就可以在Service层中处理,以及事务等。之所以把它封装在业务层中,避免了用户直接对数据库DAO层的直接操作,对用户来说是透明的。这样就简单了实现了松耦合。
          Facade模式可以应用于:
      <1>不需要使用一个复杂系统的所有功能,而且可以创建一个新的类,包含访问系统的所用规则。如果只需要使用系统的部分功能,那么你为新类创建的API将比原有系统的API简单的多。
      <2>希望封装或者隐藏原系统。
      <3>希望使用原系统的功能,而且还希望增加一些附件功能。
     

    Façade模式的几个要点:

           1、从客户程序的角度看,Facade模式不仅简化了整个组件系统的接口,同时对于组件内部与外部客户程序来说,从某种程度上也达到了一种“解耦”的效果——内部子系统的任何变化不会影响到Facade接口的变化。

    2Facade设计模式更注重从架构的层次去看整个系统,而不是单个类的层次。Facade很多时候更是一种架构设计模式。

    转载于:https://www.cnblogs.com/lancidie/archive/2011/04/06/2006345.html

    展开全文
  • facade

    千次阅读 2004-10-17 11:33:00
    公司里平凡的一天...(叮铃铃 电话铃响)客户(对开发人员):你们的那个软件的问题什么时候处理啊,不是说星期二过来吗.....小孙(对客户):这个问题你要联系一下我们老板...(客户与老板激情讨论...)老板(对开发人员):小仲,...
    公司里平凡的一天...
    (叮铃铃 电话铃响)
    客户(对开发人员):你们的那个软件的问题什么时候处理啊,不是说星期二过来吗.....
    小孙(对客户):这个问题你要联系一下我们老板...
    (客户与老板激情讨论...)
    老板(对开发人员):小仲,小孙你们一起把这个问题解决一下...
    老板(对客户):我们下个礼拜过来...

    这里,老板就是facade,客户无须与开发部打交道,所有事宜联系老板即可(除非……)


    定义

    名称:Facade

    结构:



    意图:
    为子系统中的一组接口提供一个一致的界面,Facade 模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

    适用性:
    • 当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性,也更容易对子系统进行定制,但这也给那些不需要定制子系统的用户带来一些使用上的困难。Facade 可以提供一个简单的缺省视图,这一视图对大多数用户来说已经足够,而那些需要更多的可定制性的用户可以越过facade 层。
    • 客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade 将这个子系统与客户以及其他的子系统分离,可以提高子系统的独立性和可移植性。
    • 当你需要构建一个层次结构的子系统时,使用facade 模式定义子系统中每层的入口点。如果子系统之间是相互依赖的,你可以让它们仅通过facade进行通讯,从而简化了它们之间的依赖关系。


    经典案例

    1、J2EE:  Session Facade(会话外观)
            在J2EE应用环境中,存在着很多实现相关功能的EntityBean,这时候如果你要让用户端应用程序进行每次操作、创建Entity,那么不但实现复杂,而且效率极低,如果使用一个Session作为facade,那么就会解决很多问题。
            参考EJB设计模式概述 http://dev2dev.bea.com.cn/techdoc/other/20031085.html
            J2EE体系结构设计http://www.sawin.com.cn/doc/SD/Architect/j2eemvc.htm


    最佳实践

    1、很多项目在开发的过程中很有可能需要和别的系统打交道。而在这过程中我们又不需要使用到别的系统的全部接口,在这种情况下我们就可以使用Facade模式。把我们需要的用到的一些功能包装起来,做成一些函数,甚至是类,以方便本项目的使用。如果清楚的列举了当前项目中可能需要用到的别的系统中的地方的话,那么只要少数的几个人去理解,并整理出接口,而别的开发人员只需要直接调用这些接口就可以了,节省时间。

    2、使用facade在体系结构上实现分层,提供layer-layer之间一个简洁抽象的接口.


    相关模式
    1、facade vs proxy
            facade模式有些地方翻译成门面模式,是个很形象的名字。
    我这里有很多组件提供很多的服务,而调用的一端就要和这些组件直接打交道,你可以想成一个多对多的关系。而facade模式就是给这些服务的组件提供一个共同的门面,调用的地方要访问这些服务,对不起不要直接找组件,找我,我去帮你搞定,你可以想成一个多对一和一个一对多两个关系。而facade就是中间那个“一”,也就是一个门户。
            Proxy模式就是代理模式,就是对一个对象提供一个代理,控制其他对象对他的访问。
    比如保护代理,就要控制你有没有权限访问被代理的对象,也就是说你要想访问XXX,要先过我这一关。
    当然,proxy也不一定都是用来控制权限,比如可以在被代理对象的方法执行的前后做一些log的事情啊什么的。注意这里proxy和被代理的对象实现的是同一接口。

    2、facade vs adapter
            Adapter用于把两个接口匹配,而Facade则用于包装一组接口。
            如果你拿到一个工具包,你到底是采用何种方法才能复用工具包内的类。
            其实选择很明显,对我而言,Adapter是一种白箱复用,而Facade则是一种黑箱复用。所谓的白箱复用,就是说你在使用Adapter是需要知道Adaptee的接口,然后你从它的接口继承(类Adptee)或者把你自己接口上的操作分派到Adaptee(对象Adaptee).而所谓的黑箱复用,就是说不管该工具箱或者说是框架时你实现还是别人实现,那么你可以直接使用Facade而不是去继承。
            第二个问题是,你现在实现Facade的时候,一般来说,facade内部包括的子系统或者类之间具有较强的耦合,其他人要使用这些类的时候,往往要进行一系列的对象创建过程,同时需要调用许多类的方法才能实现一个功能,这时候,你最好使用facade进行包装,facade的具体应用的一个很好的例子是在J2EE应用环境中,存在着很多实现相关功能的EntityBean,这时候如果你要让用户端应用程序进行每次操作、创建Entity,那么不但实现复杂,而且效率极低,如果使用一个Session作为facade,那么就会解决很多问题。
            Facade的其他重要作用包括在体系结构上实现分层,提供layer-layer之间一个简洁抽象的接口,而Adpater则主要应用于对系统的局部可以插入可变的实现。
            要说的话可能还有很多很多,设计模式的应用要从实际出发,如果你在实际中经常去使用这些东西,对你以前的程序经常去refactor,那么很多东西都是自然而然的。


    参考文章
    1、EJB设计模式概述
           http://dev2dev.bea.com.cn/techdoc/other/20031085.html
    2、 J2EE体系结构设计
           http://www.sawin.com.cn/doc/SD/Architect/j2eemvc.htm
    3、Pattern Tips 之一
       (讲解Adapter,Bridge,Facade,Proxy的异同,pattern tips 系列着重讲解GOF设计模式之间的关系)
           http://www.vckbase.com/document/viewdoc/?id=751
    展开全文
  • Facade模式

    2017-06-22 17:13:26
    Facade模式在本文架构里占有重要角色,关于这个模式很多JavaScript类库或者框架里都有体现,其中最大的作用,就是包括High level的API,以此来隐藏具体的实现,这就是说,我们只暴露接口,内部的实现我们可以自己...

    Facade模式在本文架构里占有重要角色,关于这个模式很多JavaScript类库或者框架里都有体现,其中最大的作用,就是包括High level的API,以此来隐藏具体的实现,这就是说,我们只暴露接口,内部的实现我们可以自己做主,也意味着内部实现的代码可以很容易的修改和更新,比如今天你是用jQuery来实现的,明天又想换YUI了,这就非常方便了。

    下面这个例子了,可以看到我们提供了很多私有的方法,然后通过暴露一个简单的 API来让外界执行调用内部的方法:

    var module = (function () {
        var _private = {
            i: 5,
            get: function () {
                console.log('current value:' + this.i);
            },
            set: function (val) {
                this.i = val;
            },
            run: function () {
                console.log('running');
            },
            jump: function () {
                console.log('jumping');
            }
        };
        return {
            facade: function (args) {
                _private.set(args.val);
                _private.get();
                if (args.run) {
                    _private.run();
                }
            }
        }
    } ());
    
    module.facade({run:true, val:10});
    //outputs current value: 10, running

    Facade和mediator的区别是,facade只提供现有存在的功能,而mediator可以增加新功能。

    展开全文
  • Facade原理

    2019-09-03 23:20:44
    Facade 是一个可以从容器访问对象的类。你可以为任何的非静态类库定义一个facade类,并静态访问其方法。 参考文档: thinkPHP5文档 1.定义一个普通类 <?php namespace app\comm; class FacadeTest { ...

    Facade 是一个可以从容器访问对象的类。你可以为任何的非静态类库定义一个facade类,并静态访问其方法。

    参考文档: thinkPHP5文档

    1.定义一个普通类

    <?php
    namespace app\comm;
    
    class FacadeTest {
        
        protected $str = 'hello';
    
        public function index() {
            echo $this->str.'<br/>';
        }
        
        public static function index2($name = '', $code = '') {
            echo '22'.'<br/>';
        }
    }

     

    2.定义一个静态代理类

    <?php
    namespace app\facade;
    
    use app\comm\MyFacade;
    
    //门面(Facade)
    class FacadeTest extends MyFacade
    {
        protected static function getFacadeClass()
        {
        	return 'app\comm\FacadeTest';
        }
    }

    3.Facade原理

    <?php
    namespace app\comm;
    
    use Exception;
    
    class MyFacade{
        
        /**
         * 获取当前Facade对应类名(或者已经绑定的容器对象标识)
         * @access protected
         * @return string
         */
        protected static function getFacadeClass()
        {}
       
    
        // 调用不存在的静态方法
        public static function __callStatic($method, $params)
        {  
            //这里简单处理,直接实例化类
            //对于有构造函数的类可以参考有关反射实例化类
            $name = '\\' . static::getFacadeClass();
            return call_user_func_array([new $name, $method], $params);
        }
    }

    4.测试类

    <?php
    namespace app\index\controller;
    
    use think\Controller;
    
    use app\facade\FacadeTest as Test1;
    use app\comm\FacadeTest as Test2;
    use app\facade\MyFacadeTest as Test3;
    
    class FacadeTest extends Controller
    {
        
        public function index()
        {
            Test1::index();
            Test1::index2();
            
            $test2 = new Test2;
            $test2->index();
            Test2::index2();
            
            
            Test3::index();
            Test3::index2(['name' => 10], 100);
        }
    }
    
    
    <?php
    namespace app\comm;
    
    use ReflectionClass;
    use ReflectionException;
    use ReflectionFunction;
    use ReflectionMethod;
    use ReflectionProperty;
    use Exception;
    
    class MyFacade{
        protected static function createFacade($class = '', $args = [], $newInstance = false)
        {
            $class = $class ?: static::class;
    
            $facadeClass = static::getFacadeClass();
    
            if ($facadeClass) $class = $facadeClass;
            
            return \think\Container::getInstance()->make($class, $args, $newInstance);
        }
        
        /**
         * 获取当前Facade对应类名(或者已经绑定的容器对象标识)
         * @access protected
         * @return string
         */
        protected static function getFacadeClass()
        {}
       
    
        // 调用实际类的方法
        public static function __callStatic($method, $params)
        {
            //return call_user_func_array([static::createFacade(), $method], $params);
            
            return call_user_func_array([static::createFacade2(), $method], $params);
            
            //$name = '\\' . static::getFacadeClass();
            //return call_user_func_array([new $name, $method], $params);
        }  
        
        
        
        
        protected static function createFacade2($class = '', $args = [])
        {
    
            $class = static::getFacadeClass();
            if(!$class){
                throw new Exception('class miss');
            }
    
            return static::createObject($class, $args);
        }
        
        protected static function createObject($class, $args)
        {
           try {
                $reflect = new ReflectionClass($class);
                $constructor = $reflect->getConstructor();
                $args = $constructor ? static::bindParams($constructor, $args) : [];
                return $reflect->newInstanceArgs($args);
            } catch (ReflectionException $e) {
                echo $e->getMessage();
            }
        }
        
        /**
         * 绑定参数
         * @access protected
         * @param  \ReflectionMethod|\ReflectionFunction $reflect 反射类
         * @param  array                                 $vars    参数
         * @return array
         */
        protected static function bindParams($reflect, $vars = [])
        {
            if ($reflect->getNumberOfParameters() == 0) {
                return [];
            }
    
            reset($vars);
            $type   = key($vars) === 0 ? 1 : 0;
            $params = $reflect->getParameters();
            
            foreach ($params as $param) {
                $name      = $param->getName();
                $class     = $param->getClass();
    
                if ($class) {
                    $args[] = static::getObjectParam($class->getName(), $vars);
                } elseif (1 == $type && !empty($vars)) {
                    $args[] = array_shift($vars);
                } elseif (0 == $type && isset($vars[$name])) {
                    $args[] = $vars[$name];
                } elseif ($param->isDefaultValueAvailable()) {
                    $args[] = $param->getDefaultValue();
                } else {
                    throw new Exception('method param miss:' . $name);
                }
            }
    
            return $args;
        }
        
        /**
         * 获取对象类型的参数值
         * @access protected
         * @param  string   $className  类名
         * @param  array    $vars       参数
         * @return mixed
         */
        protected static function getObjectParam($className, &$vars)
        {
            $array = $vars;
            $value = array_shift($array);
    
            if ($value instanceof $className) {
                $result = $value;
                array_shift($vars);
            } else {
                throw new Exception('error param :' . $className);
            }
    
            return $result;
        }
        
    }

     

    展开全文
  • Route::get('/', function () { return view('welcome'); }); ...这里Route就是用Facade实现类方法...Laravel中的Facade解决类什么问题? 在php中,很多情况都需要使用一个容器获取到所有的对象,然后再调用改对象的...
  • facade pattern

    2019-09-27 03:56:26
    Facade Patternprovides a unified interface to a set of interfaces in subsystems. Facade defines a higher-level interface that makes the subsystem easier to use.p. 185, Design Patterns, El...
  • facade模式

    2017-06-13 19:00:06
    设计模式--外观模式Facade(结构型): 1. 概述  外观模式,我们通过外观的包装,使应用程序只能看到外观对象,而不会看到具体的细节对象,这样无疑会降低应用程序的复杂度,并且提高了程序的可维护性。 例子...
  • 2.7.1. 目的门面模式的最初目的并不是为了避免让你阅读复杂的 API 文档,这只是一个附带作用。其实它的本意是为了降低耦合性并且遵循 Demeter 定律。一个门面旨在通过嵌入许多(但有时只有一个)接口来分离客户端和子...
  • 门面模式 Facade Pattern

    万次阅读 2018-10-23 15:16:40
    一、定义: 门面模式(Facade Pattern),是指提供一个统一的接口去访问多个...二、门面模式的作用: 参考文章: The facade pattern (also spelled façade) is a software-design pattern commonly used with obj...
  • 门面模式的核心为Facade即门面对象,门面对象核心为几个点: 知道所有子角色的功能和责任 将客户端发来的请求委派到子系统中,没有实际业务逻辑 不参与子系统内业务逻辑的实现 大致上来看,对门面模式的回顾到这里...
  • 学习 使用设计模式也快两年了,中间也看了很多书,也看了很多 网上的帖子。现在,我也把自己的理解写出来和大家...这是GOF 定义的 意图,看了以后 可能还是很模糊,不知道到底该模式有什么好处,为什么要使用它。那...
  • 外观模式(facade)

    2014-03-11 23:39:57
    什么是facade模式?  外观模式为子系统中的各类(或结构与方法)提供一个简明一致的界面,隐藏子系统的复杂性,使子系统更加容易使用。既当子系统复杂或者繁琐时,我们让子系统提供一个窗口,程序中称为接口,其它程序...
  • 设计模式 Facade模式

    2012-10-04 13:04:44
    什么是(Facade)模式?  Facade(外观)模式为子系统中的各类(或结构与方法)提供一个简明一致的界面,隐藏子系统的复杂性,使子系统更加容易使用(出自百度文库)。即当子系统复杂或者繁锁时,我们让子系统提供一...
  • facade-门面模式

    2018-06-08 03:05:12
    客户端调用逻辑与业务代码有效隔离,使得客户端调用只和Facade进行交互,内部的调用逻辑由Facade进行实现。此模式也可以和接口化编程结合,进一步降低客户端与业务逻辑的耦合 应用场景 它主要应用在代码结构的设计,...
  • 外观模式(Facade

    2018-08-01 09:49:44
    9、外观模式(Facade) 外观模式是为了解决类与类之家的依赖关系的,像spring一样,可以将类和类之间的关系配置到配置文件中,而外观模式就是将他们的关系放在一个Facade类中,降低了类类之间的耦合度,该模式中...
  • 外观模式 Facade

    2012-06-13 16:02:04
    先做个总结: 外观模式就是提供一个高层接口来集成、制定、调用子系统的功能,达到客户端和子系统之间的解耦 ... Facade  这个外观类为子系统中Packages 1、2、3提供一个共同的对外接口 ...
  • 门面(Facade)模式

    2019-12-02 19:27:09
    动机:接口之间如果有依赖,需要添加一层(稳定)接口解耦合 例如: 假设A方案是MYSQL的连接模型,如果按照A方案设计的话,客户需求改动(改成ORACLE...Facade设计模式更重要的是从架构层次看系统,主要是隔离作...
  • 我最早接触这种设计模式是在杭州的时候,那个时候服务端的Facade层主要有2个作用,一个是提供给Flex客户端的接口用。一个是作为包含多个service操作的统一接口。GoF《设计模式》中说道:为子系统中的一组接口提供一...
  • 目录 重载的概念 魔术方法中的重载 属性重载 方法重载 Laravel中的Facade 扩展 谈谈__invoke ...Laravel提供了许多易用的Facade,让我们用起来特步顺手,那么这些Facade的原理是什么呢?...
  • Facade(外观)

    2019-11-25 15:24:36
    Facade(外观) 结构型 对象 1 Intent_意图2 提供了一个统一的接口,用来访问子系统中的一群接口。外观定义了一个高层接口,让子系统更容易使用 Motivation_动机3 降低访问复杂系统的内部子系统时的复杂度,简化客户...
  • 阅读建议 在阅读这篇文章之前,我...如果你使用过第三方的 composer 包,它会提醒你,把它的 ServiceProvider 和 Facade 写入到 config/app.php 文件中,如下: 当然了,注册 Facade 和 ServiceProvider 不止这么一
  • 设计模式之门面模式---Facade Pattern

    千次阅读 2016-08-08 11:37:30
    模式的定义门面模式(Facade Pattern)也叫做外观模式,定义如下:Provide a unified interface to a set of interfaces in a subsystem. Facade defines a highet-level interface that makes the subsystem easier ...
  • 门面(Facade)模式和中介者(Mediator)模式有着共同的目的。它们都是调配一组相互耦合的对象的通信。不过门面模式关注的是这组复杂对象如何与外界通信,而中介者模式是调配这组复杂对象之间的通信。 门面(Facade)...
  • 外观模式-Facade

    2016-11-05 20:50:00
    外观模式是为了解决类与类之间依赖关系的,外观模式将类间关系放在一个Facade类中,降低了类类之间的耦合度,该模式中不涉及接口 举一个经典的例子: CPU类: 1 public class CPU { 2 public void startup...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,752
精华内容 8,300
关键字:

facade作用是什么