Facade

Facade Pattern

The Facade Pattern is used to consolidate numerous complicated objects and function calls in a single interface. It does not necessarily encapsulate the objects behind the facade, as it commonly allows the client to work directly with the object.

A facade is like a house. Someone walking by the house sees the exterior and knows the functionality contained within the house (shelter, kitchen, bathroom, bedrooms, etc), but does not know how they are set up or laid out (ie implemented). The person walking by can approach the house and interact with its functionality through the front door, which is the single point of access to that which is contained within the house (ie sub-system).

UML Example

used under GNU FDL

Code Examples

Java

Design Patterns Facade

public class FacadeCuppaMaker {  
   boolean teaBagIsSteeped; 
    
   public FacadeCuppaMaker() {
       System.out.println(
         "FacadeCuppaMaker ready to make you a cuppa!");
   }
   
   public FacadeTeaCup makeACuppa() {
       FacadeTeaCup cup = new FacadeTeaCup();
       FacadeTeaBag teaBag = new FacadeTeaBag();
       FacadeWater water = new FacadeWater();
       cup.addFacadeTeaBag(teaBag);
       water.boilFacadeWater();
       cup.addFacadeWater(water);
       cup.steepTeaBag();
       return cup;
   }
}

PHP5

Introducing Facade Pattern in PHP5

// define 'CompressContentFacade' class
class CompressContentFacade{
   public static function stripContent($content){
     // remove new lines from content
     $strippedContent=StripContent::stripString($content);
     // compress content by using GZIP algorithm
     $gzippedContent=GzipContent::compressString
($strippedContent);
     return $gzippedContent;
   }
}

C# .NET

Design Pattern in C# (via Data & Object Factory)]

 // Facade pattern -- Structural example

using System;
namespace DoFactory.GangOfFour.Facade.Structural
{
// Mainapp test application
class MainApp
  {
    public static void Main()
    {
      Facade facade = new Facade();
      facade.MethodA();
      facade.MethodB();
      // Wait for user
      Console.Read();
    }
  }
  // "Subsystem ClassA"
  class SubSystemOne
  {
    public void MethodOne()
    {
      Console.WriteLine(" SubSystemOne Method");
    }
  }
  // Subsystem ClassB"
  class SubSystemTwo
  {
    public void MethodTwo()
    {
      Console.WriteLine(" SubSystemTwo Method");
    }
  }
  // Subsystem ClassC"
  class SubSystemThree
  {
    public void MethodThree()
    {
      Console.WriteLine(" SubSystemThree Method");
    }
  }
  // Subsystem ClassD"
  class SubSystemFour
  {
    public void MethodFour()
    {
      Console.WriteLine(" SubSystemFour Method");
    }
  }
  // "Facade"
  class Facade
  {
    SubSystemOne one;
    SubSystemTwo two;
    SubSystemThree three;
    SubSystemFour four;

    public Facade()
    {
      one = new SubSystemOne();
      two = new SubSystemTwo();
      three = new SubSystemThree();
      four = new SubSystemFour();
    }
    public void MethodA()
    {
      Console.WriteLine("\nMethodA() ---- ");
      one.MethodOne();
      two.MethodTwo();
      four.MethodFour();
    }
    public void MethodB()
    {
      Console.WriteLine("\nMethodB() ---- ");
      two.MethodTwo();
      three.MethodThree();
    }
  }
}

Open Source Applications

Apache Excalibur

Excalibur Facade Class Code (via Google! Code Search)

/**
 * A facade to the modularized *LoggerManager building system.
 * Add methods here to create LoggerManagers to your preference.
 *
 * @author <a href="mailto:dev@nospamavalon.apache.org">Avalon Development Team</a>
 * @version CVS $Revision: 1.3 $ $Date: 2004/03/10 13:54:50 $
 * @since 4.0
 */

public class Facade
{
    /**
     * Assemble a new LoggerManager running on top of LogKit
     * configured from a configuration file logging to a supplied
     * logger as a fallback.
     * Use this method as a sample showing how to assemble your
     * own LoggerManager running on top of LogKit flavour.
     */
    public static LoggerManager createLogKitConfigurable(
            final String prefix, final String switchTo )
    {
        final org.apache.log.Hierarchy hierarchy = new Hierarchy();

        final LoggerManager bare = new LogKitAdapter( hierarchy );
        final LoggerManager decorated = applyDecorators( bare, prefix, switchTo );
        final LoggerManagerTee tee = new LoggerManagerTee( decorated );

        tee.addTee( new LogKitLoggerHelper( hierarchy ) );
        tee.addTee( new LogKitConfHelper( hierarchy ) );
        tee.makeReadOnly();

        return tee;
    }

    /**
     * Assemble LoggerManager for Log4J system configured
     * via a configuration file. All the logging errors
     * will go to System.err however.
     */
    public static LoggerManager createLog4JConfigurable(
            final String prefix, final String switchTo )
    {
        final LoggerManager bare = new Log4JConfAdapter();
        final LoggerManager decorated = applyDecorators( bare, prefix, switchTo );
        return decorated;
    }

    private static LoggerManager applyDecorators( LoggerManager target,
            final String prefix, final String switchTo )
    {
        if ( switchTo != null )
        {
            target = new LogToSelfDecorator( target, switchTo );
        }
        if ( prefix != null && prefix.length() > 0 )
        {
            target = new PrefixDecorator( target, prefix );
        }
        target = new CachingDecorator( target );
        return target;
    }
}

Apache Tomcat