[Java] What is the Facade pattern useful for?

2 minute read


Briefly explain what the Facade pattern is useful for (with code)

How useful is the Facade pattern?

Simply put, ** a coordinator for multiple processes **.
Therefore, it is useful in that it does various jobs with one request.

Facade pattern requirements

–The Facade class only throws work inside the subsystem and does not have a complicated implementation.
–The Facade class is never used by the subsystem itself.
–The Facade pattern does not interfere with the direct use of subsystems.

Class diagram

Facade pattern class diagram


Source: Wiki –Facade pattern

Class diagram of the code explained this time

It is a specification from the standpoint that Librarian has BookList and LendingList, and there is no change in the implementation itself of using it as a window.

Each role in the class diagram

Facade: Librarian class
Subsystem: BookList class, LendingList class
Client: Visitor class

Involvement of each class

–Librarian (librarian) can take on the role of searching for books.
–Visitors can ask the Librarian to search for books, or they can search for them themselves.
–BookList and LendingList are used by Librarian or Visitor.



package facade;

public class Librarian {
    private BookList _bookList;
    private LendingList _lendingList;

    Librarian(BookList bookList, LendingList lendingList){
        _bookList = bookList;
        _lendingList = lendingList;

    public String searchBook(String bookName) {
        //Is it in the possession?
        if(!_bookList.existsBook(bookName)) return "The book is not in the possession";

        //Is it on the bookshelf?
        if (_lendingList.isLending(bookName)) return "Lending";

        //Collection location
        return _bookList.searchLocation(bookName);


package facade;

import java.util.HashMap;
import java.util.Map;

//Collection book ledger
public class BookList {
    private Map<String, String> _record = new HashMap<String, String>();

    public void addRecord(String bookName, String locationName) {
        _record.put(bookName, locationName);

    public boolean existsBook(String bookName) {
        return _record.containsKey(bookName);

    public String searchLocation(String bookName) {
        return (String)_record.get(bookName);


package facade;

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

//Lending book
public class LendingList {
    private List<String> _record = new ArrayList<String>();

    public void lending(String bookName) {

    public void returned(String bookName) {

    public boolean isLending(String bookName) {
        return _record.contains(bookName);


package facade;

public class Visitor {
    private String _name;
    private String _targetBookName;

    Visitor(String name){
        _name = name;

    public void setTargetBookName(String targetBookName) {
        _targetBookName = targetBookName;

    public String targetBookName() {
        return _targetBookName;

    public String name() {
        return _name;


package facade;

import java.io.PrintStream;

public class Main {
    public static void main(String[] args) {
        //Initial value set
        // (Collection list)
        BookList bookList = new BookList();
        bookList.addRecord("Insect picture book", "Shelf number 1");
        bookList.addRecord("Animal picture book", "Shelf number 1");
        bookList.addRecord("Momotaro", "Shelf number 2");
        bookList.addRecord("Kintaro", "Shelf number 2");
        bookList.addRecord("How the computer works", "Shelf number 3");
        bookList.addRecord("Java programming", "Shelf number 3");
        // (Lending list)
        LendingList lendingList = new LendingList();
        lendingList.lending("Insect picture book");
        lendingList.lending("How the computer works");

        PrintStream out = System.out;

        //user[Yamada-kun]:librarian[Nakamura-kun]When requesting
        Visitor yamada = new Visitor("Yamada");
        yamada.setTargetBookName("Insect picture book");
        // (Window[Nakamura-kun])
        Librarian nakamura = new Librarian(bookList, lendingList);
        // (Ask Nakamura-kun about the location of the insect picture book)
        out.println(yamada.name() + "Result:");

        //user[Kinoshita-kun]: When searching by yourself
        Visitor kinoshita = new Visitor("Kinoshita");
        kinoshita.setTargetBookName("Animal picture book");
        if(!bookList.existsBook(kinoshita.targetBookName())) {
            out.println("Let's make another book");
        if(lendingList.isLending(kinoshita.targetBookName())) {
            out.println("Let's make another book");
        out.println(kinoshita.name() + "Result:");

Please change the targetBookName of Yamada-kun and Kinoshita-kun and check the operation.


Where to use

Once you start writing a series of code that calls multiple processes in various places,
Consider using the Facade pattern.

However, as required, it should not contain complex logic.
To the last, it is required to devote itself to the role of bundling processing.


Facade pattern

Source of code (modified based on this)