devkuma – Design Pattern

デザインパターン(Design Pattern)の概念と種類

kc@example.com (kc kim) — Tue, 08 Mar 2022 08:52:00 +0900

デザインパターンとは?

デザインパターンは、ソフトウェアを設計するとき、特定の文脈でよく発生する慢性的な問題が再び発生した場合に再利用できる優れた解決策である。
「車輪の再発明をするな(Don’t reinvent the wheel)」とは、すでに作られてうまく機能しているものを、最初からもう一度作る必要はないという意味である。

パターンとは?

- それぞれ異なるソフトウェアモジュールや機能を持つ多様なアプリケーションソフトウェアシステムを開発するときにも、互いに共通する設計上の問題が存在し、それを処理する解決策の間にも共通点がある。このような類似点をパターンと言う。 - パターンは共通の言語を作り、チームメンバー間のコミュニケーションを円滑にする非常に重要な役割を果たす。

デザインパターンの種類

すでに知られているデザインパターンは、次のように23個に分けられている。大きく生成(Creational)、構造(Structural)、振る舞い(Behavioral)の3種類に分類される。これはGoF(Gang of Four)デザインパターンと呼ばれ、Erich Gamma、Richard Helm、Ralph Johnson、John Vissidesの4人の有名な開発者によって考案された。4人の開発者は「経験」や「内的な蓄積」を<デザインパターン>という形で整理した。この4人をthe Gang of Four、またはGoFと呼ぶ。

生成パターン(Creational Pattern)

オブジェクト生成に関するパターンであり、オブジェクトの生成と組み合わせをカプセル化し、特定のオブジェクトが生成または変更されてもプログラム構造が大きな影響を受けないように柔軟性を提供する。

抽象ファクトリメソッド(Abstract Factory Methods): 関連する部品を組み立てて製品を作る。
ファクトリメソッド(Factory Methods): インスタンス作成をサブクラスに任せる。
ビルダー(Builder): 複雑なインスタンスを組み立てる。
プロトタイプ(Prototype): コピーしてインスタンスを作る。
シングルトン(Singleton): ただ1つのインスタンス。

構造パターン(Structural Pattern)

クラスやオブジェクトを組み合わせて、より大きな構造を作るパターンである。例えば、互いに異なるインターフェースを持つ2つのオブジェクトをまとめて単一のインターフェースを提供したり、オブジェクト同士をまとめて新しい機能を提供したりするパターンである。

アダプター(Adapter): 一枚かぶせて再利用する。
ブリッジ(Bridge): 機能の階層と実装の階層を分離する。
コンポジット(Composite): 入れ物と中身を同一視する。
デコレーター(Decorator): 装飾と中身を同一視する。
ファサード(Facade): 簡単な窓口。
フライウェイト(Flyweight): 同じものを共有して無駄をなくす。
プロキシ(Proxy): 必要になったら作る。

振る舞いパターン(Behavioral Pattern)

オブジェクトやクラス間のアルゴリズムや責任分配に関するパターンであり、1つのオブジェクトが単独で実行できない作業を複数のオブジェクトにどのように分配するか、またその際にオブジェクト間の結合度を最小化することに重点を置く。

責任連鎖(Chain of Responsibility): 責任を次へ渡す。
コマンド(Command): 命令をクラスにする。
インタプリタ(Interpreter): 文法規則をクラスで表現する。
イテレーター(Iterator): 1つずつ数える。
メディエーター(Mediator): 相手はカウンセラー1人だけ。
メメント(Memento): 状態を保存する。
オブザーバー(Observer): 状態の変化を通知する。
ステート(State): 状態をクラスとして表現する。
ストラテジー(Strategy): アルゴリズムを丸ごと入れ替える。
テンプレートメソッド(Template Methods): 具体的な処理をサブクラスに任せる。
ビジター(Visitor): 構造の中を巡回しながら処理を行う。

Java例の出典

Java言語で學ぶデザインパタ-ン入門

参考

Design Pattern | Abstract Factory Methods

kc@example.com (kc kim) — Thu, 17 Mar 2022 15:26:00 +0900

Abstract Factoryパターンとは?

Abstract Factoryは抽象工場という意味である。
抽象的であるとは、具体的にどのように実装されているかは考慮せず、インターフェースだけに注目している状態である。
Abstract Factoryパターンは、部品の具体的な実装に注目せず、インターフェースに注目する。そして、そのインターフェースだけを使って部品を組み立て、製品としてまとめる方式である。
関連部品を組み合わせて製品を作るものである。
GoFデザインパターンでは、生成に関するデザインパターンに分類される。

Abstract Factoryパターンのサンプルプログラム

お気に入り一覧をHTML形式で出力するサンプルプログラムである。

Class Diagram

1. Factoryクラス

抽象工場を代表するクラスである。Link、Tray、Pageを作る。

Factory.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

public abstract class Factory {

    public abstract Link createLink(String caption, String url);

    public abstract Tray createTray(String caption);

    public abstract Page createPage(String title);

    public static Factory getFactory(String classname) {
        Factory factory = null;
        try {
            factory = (Factory) Class.forName(classname).getDeclaredConstructor().newInstance();
        } catch (ClassNotFoundException e) {
            System.err.println("클래스 " + classname + "를 찾을 수 없습니다.");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return factory;
    }
}

2. Itemクラス

LinkとTrayを統一的に扱うクラスである。

Item.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

public abstract class Item {
    protected String caption;

    public Item(String caption) {
        this.caption = caption;
    }

    public abstract String makeHTML();
}

3. Linkクラス

抽象部品: HTMLリンクを表すクラスである。

Link.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

public abstract class Link extends Item {
    protected String url;

    public Link(String caption, String url) {
        super(caption);
        this.url = url;
    }
}

4. Trayクラス

抽象部品: LinkとTrayを集めたクラスである。

Tray.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

import java.util.ArrayList;

public abstract class Tray extends Item {
    protected ArrayList tray = new ArrayList();

    public Tray(String caption) {
        super(caption);
    }

    public void add(Item item) {
        tray.add(item);
    }
}

5. Pageクラス

抽象部品: HTMLページを表すクラスである。

Page.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

public abstract class Page {
    protected String title;
    protected ArrayList content = new ArrayList();

    public Page(String title) {
        this.title = title;
    }

    public void add(Item item) {
        content.add(item);
    }

    public void output() {
        try {
            String filename = title + ".html";
            Writer writer = new FileWriter(filename);
            writer.write(this.makeHTML());
            writer.close();
            System.out.println(filename + "을 생성했습니다.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public abstract String makeHTML();
}

6. ListFactoryクラス

具体的な工場を表すクラスである。ListLink、ListTray、ListPageを作る。

ListFactory.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Factory;
import com.devkuma.designpattern.creational.abstractfactory.factory.Link;
import com.devkuma.designpattern.creational.abstractfactory.factory.Page;
import com.devkuma.designpattern.creational.abstractfactory.factory.Tray;

public class ListFactory extends Factory {
    public Link createLink(String caption, String url) {
        return new ListLink(caption, url);
    }

    public Tray createTray(String caption) {
        return new ListTray(caption);
    }

    public Page createPage(String title) {
        return new ListPage(title);
    }
}

7. ListLinkクラス

具体的な部品: HTMLリンクを表すクラスである。

ListLink.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Link;

public class ListLink extends Link {
    public ListLink(String caption, String url) {
        super(caption, url);
    }

    public String makeHTML() {
        return "  <li><a href=\"" + url + "\">" + caption + "</a></li>\n";
    }
}

8. ListTrayクラス

具体的な部品: LinkやTrayを集めたクラスである。

ListTray.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Item;
import com.devkuma.designpattern.creational.abstractfactory.factory.Tray;

import java.util.Iterator;

public class ListTray extends Tray {
    public ListTray(String caption) {
        super(caption);
    }

    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<li>\n");
        buffer.append(caption + "\n");
        buffer.append("<ul>\n");
        Iterator it = tray.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("</li>\n");
        return buffer.toString();
    }
}

9. ListPageクラス

具体的な部品: HTMLページを表すクラスである。

ListPage.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Item;
import com.devkuma.designpattern.creational.abstractfactory.factory.Page;

import java.util.Iterator;

public class ListPage extends Page {
    public ListPage(String title) {
        super(title);
    }

    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<html><head><title>" + title + "</title></head>\n");
        buffer.append("<body>\n");
        buffer.append("<h1>" + title + "</h1>\n");
        buffer.append("<ul>\n");
        Iterator it = content.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("</body></html>\n");
        return buffer.toString();
    }
}

10. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.creational.abstractfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Factory;
import com.devkuma.designpattern.creational.abstractfactory.factory.Link;
import com.devkuma.designpattern.creational.abstractfactory.factory.Page;
import com.devkuma.designpattern.creational.abstractfactory.factory.Tray;

public class Main {
    public static void main(String[] args) {

        Factory factory = Factory.getFactory("com.devkuma.designpattern.creational.abstractfactory.listfactory.ListFactory");

        Link devkuma = factory.createLink("Devkuma", "https://www.devkuma.com//");
        Link araikuma = factory.createLink("araikuma", "https://araikuma.tistory.com/");

        Link naver = factory.createLink("Naver", "https://www.naver.com/");
        Link daum = factory.createLink("Daum", "https://www.daum.com/");
        Link google = factory.createLink("Google", "https://www.google.com/");

        Tray pgTray = factory.createTray("프로그래밍");
        pgTray.add(devkuma);
        pgTray.add(araikuma);

        Tray searchTray = factory.createTray("검색사이트");
        searchTray.add(naver);
        searchTray.add(daum);
        searchTray.add(google);

        Page page = factory.createPage("즐겨찾기");
        page.add(pgTray);
        page.add(searchTray);
        page.output();
    }
}

11. 実行結果

プログラムで生成したファイルは以下のとおりである。

즐겨찾기.html

<html><head><title>즐겨찾기</title></head>
<body>
<h1>즐겨찾기</h1>
<ul>
<li>
프로그래밍
<ul>
  <li><a href="https://www.devkuma.com//">Devkuma</a></li>
  <li><a href="https://araikuma.tistory.com/">araikuma</a></li>
</ul>
</li>
<li>
검색사이트
<ul>
  <li><a href="https://www.naver.com/">Naver</a></li>
  <li><a href="https://www.daum.com/">Daum</a></li>
  <li><a href="https://www.google.com/">Google</a></li>
</ul>
</li>
</ul>
</body></html>

Abstract Factoryパターンのメリット

例えば、サンプルプログラムに新しい具体的な工場を追加する場合、Factory、Link、Tray、Pageのサブクラスを作り、それぞれの抽象メソッドを実装することになる。
つまり、factoryパッケージのクラスが持っている抽象部分を具体化していくだけである。このとき、どれだけ具体的な工場を追加しても、抽象工場を修正する必要はない。

Design Pattern | Builder Pattern(ビルダーパターン)

kc@example.com (kc kim) — Mon, 14 Mar 2022 00:25:00 +0900

Builderパターンとは?

Buildという単語は、構造を持つ大きなものを構築するという意味である。
複雑な構造を持つものを作るとき、一度に完成させるのは難しい。まず全体を構成する各部分を作り、段階を踏んで組み立てていくことになる。
同じ構築工程で、異なる表現オブジェクトを生成する。
コンストラクタに入るパラメータが多くても少なくても、順番にパラメータを受け取り、すべてのパラメータを受け取った後にこれらの変数を統合して一度に使用する。
Builderパターンは、構造を持つインスタンスを構築する方法である。
GoFデザインパターンでは、生成に関するデザインパターンに分類される。

Builderパターンのサンプルプログラム

文書を通常のテキストおよびHTML形式で出力するサンプルプログラムである。

Class Diagram

1. Builderクラス

文書を構成するためのメソッドを定義した抽象クラスである。

Builder.java

public abstract class Builder {
    public abstract void makeTitle(String title);
    public abstract void makeString(String str);
    public abstract void makeItems(String[] items);
    public abstract void close();
}

2. Guideクラス

1つの文書を作るクラスである。

Guide.java

package com.devkuma.designpattern.creational.builder;

public class Guide {

    private Builder builder;

    public Guide(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.makeTitle("야유회에 대해서");
        builder.makeString("일시");
        builder.makeItems(new String[]{
                "2022/3/14 (월)",
                "11:00~",
        });
        builder.makeString("장소");
        builder.makeItems(new String[]{
                "xxx 캠핌장",
        });
        builder.makeString("준비물");
        builder.makeItems(new String[]{
                "회비",
                "고기",
                "음료수",
        });
        builder.close();
    }
}

3. TextBuilderクラス

通常のテキストで文書を作るクラスである。

TextBuilder.java

package com.devkuma.designpattern.creational.builder;

public class TextBuilder extends Builder {

    private StringBuffer buffer = new StringBuffer();

    public void makeTitle(String title) {
        buffer.append("==============================\n");
        buffer.append("'" + title + "'\n");
        buffer.append("\n");
    }

    public void makeString(String str) {
        buffer.append("- " + str + "\n");
    }

    public void makeItems(String[] items) {
        for (int i = 0; i < items.length; i++) {
            buffer.append("　- " + items[i] + "\n");
        }
        buffer.append("\n");
    }

    public void close() {
        buffer.append("==============================\n");
    }

    public String getResult() {
        return buffer.toString();
    }
}

4. HTMLBuilderクラス

HTMLファイルとして文書を作成するクラスである。

HTMLBuilder.java

package com.devkuma.designpattern.creational.builder;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class HtmlBuilder extends Builder {

    private String filename;
    private PrintWriter writer;

    public void makeTitle(String title) {
        filename = title + ".html";
        try {
            writer = new PrintWriter(new FileWriter(filename));
        } catch (IOException e) {
            e.printStackTrace();
        }
        writer.println("<html><head><title>" + title + "</title></head><body>");
        writer.println("<h1>" + title + "</h1>");
    }

    public void makeString(String str) {
        writer.println("<p>" + str + "</p>");
    }

    public void makeItems(String[] items) {
        writer.println("<ul>");
        for (int i = 0; i < items.length; i++) {
            writer.println("<li>" + items[i] + "</li>");
        }
        writer.println("</ul>");
    }

    public void close() {
        writer.println("</body></html>");
        writer.close();
    }

    public String getResult() {
        return filename;
    }
}

5. Mainクラス

サンプルプログラムを実行するメインクラスである。

Main.java

package com.devkuma.designpattern.creational.builder;

public class Main {
    public static void main(String[] args) {

        if (args.length != 1) {
            System.exit(0);
        }
        if (args[0].equals("plain")) {
            TextBuilder textbuilder = new TextBuilder();
            Guide guide = new Guide(textbuilder);
            guide.construct();
            String result = textbuilder.getResult();
            System.out.println(result);
        } else if (args[0].equals("html")) {
            HtmlBuilder htmlbuilder = new HtmlBuilder();
            Guide guide = new Guide(htmlbuilder);
            guide.construct();
            String filename = htmlbuilder.getResult();
            System.out.println(filename + "이 작성되었습니다.");
        } else {
            System.exit(0);
        }
    }
}

6. 実行結果

テキスト

==============================
'야유회에 대해서'

- 일시
　- 2022/3/14 (월)
　- 11:00~

- 장소
　- xxx 캠핌장

- 준비물
　- 회비
　- 고기
　- 음료수

==============================

HTML

<html><head><title>야유회에 대해서</title></head><body>
<h1>야유회에 대해서</h1>
<p>일시</p>
<ul>
<li>2022/3/14 (월)</li>
<li>11:00~</li>
</ul>
<p>장소</p>
<ul>
<li>xxx 캠핌장</li>
</ul>
<p>준비물</p>
<ul>
<li>회비</li>
<li>고기</li>
<li>음료수</li>
</ul>
</body></html>

7. Builderパターンのメリット

サンプルプログラムを見ると、Mainクラスは文書の構築方法(Builderクラスのメソッド)を知らない。MainクラスはGuideクラスのconstructメソッドを呼び出すだけで文書を構築できる。
そして、GuideクラスはBuilderクラスを使って文書を作成するが、Guideクラスは自分が実際に利用しているクラスが何か(TextBuilderなのかHtmlBuilderなのか)を知らない。
TextBuilderのインスタンスをGuideに渡しても、HTMLBuilderのインスタンスをGuideに渡しても正しく機能するのは、GuideクラスがBuilderクラスの具体的なクラスを知らないためである。
知らないからこそ差し替えが可能であり、差し替えが可能だからこそ部品としての価値が高くなる。

Design Pattern | Factory Method(ファクトリメソッド)

kc@example.com (kc kim) — Sun, 13 Mar 2022 17:56:00 +0900

Factory Methodパターンとは?

Factoryという英単語は工場という意味である。工場では物を仕様に合わせて生産し、要求事項が少し変わればそれに合わせて少し違う物も生産する。
望む仕様を入力すると、それに合うinstanceを生成してくれるのがファクトリメソッドパターンである。
Factory Methodパターンは、インスタンスの作り方をスーパークラスで定め、具体的な生成処理はサブクラス側で行う方式である。
インスタンスを生成する工場をTemplate Methodパターンで構成したものがFactory Methodパターンである。
GoFデザインパターンでは、生成に関するデザインパターンに分類される。

Factory Methodパターンのサンプルプログラム

IDカード工場でIDカードを作るプログラムである。

Class Diagram

1. Productクラス

Factoryで生成されるオブジェクトの基本となるクラスである。

Product.java

package com.devkuma.designpattern.creational.factorymethod.framwork;

public abstract class Product {
    public abstract void use();
}

2. Factoryクラス

Factoryの基本となるクラスである。インスタンスを生成する。

Factory.java

package com.devkuma.designpattern.creational.factorymethod.framwork;

public abstract class Factory {

    public final Product create(String owner) {
        Product product = createProduct(owner);
        registerProduct(product);
        return product;
    }

    protected abstract Product createProduct(String owner);
    protected abstract void registerProduct(Product product);
}

3. IDCardクラス

Productクラスで定義されたメソッドを実装する具象クラスである。

IDCard.java

package com.devkuma.designpattern.creational.factorymethod.idcard;

import com.devkuma.designpattern.creational.factorymethod.framwork.Product;

public class IdCard extends Product {

    private String owner;

    IdCard(String owner) {
        System.out.println(owner + "의 카드를 만듭니다.");
        this.owner = owner;
    }

    public void use() {
        System.out.println(owner + "의 카드를 사용합니다.");
    }

    public String getOwner() {
        return owner;
    }
}

4. IDCardFactoryクラス

Factoryクラスで定義されたメソッドを実装する具象クラスである。

IDCardFactory.java

package com.devkuma.designpattern.creational.factorymethod.idcard;

import com.devkuma.designpattern.creational.factorymethod.framwork.Factory;
import com.devkuma.designpattern.creational.factorymethod.framwork.Product;

import java.util.ArrayList;

public class IdCardFactory extends Factory {

    private ArrayList<String> owners = new ArrayList();

    protected Product createProduct(String owner) {
        return new IdCard(owner);
    }

    protected void registerProduct(Product product) {
        IdCard icCard = (IdCard) product;
        String owner = icCard.getOwner();
        owners.add(owner);
    }

    public ArrayList<String> getOwners() {
        return owners;
    }
}

5. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.creational.factorymethod;

import com.devkuma.designpattern.creational.factorymethod.framwork.Factory;
import com.devkuma.designpattern.creational.factorymethod.framwork.Product;
import com.devkuma.designpattern.creational.factorymethod.idcard.IdCardFactory;

public class Main {
    public static void main(String[] args) {
        Factory factory = new IdCardFactory();
        Product card1 = factory.create("devkuma");
        Product card2 = factory.create("kimkc");
        Product card3 = factory.create("yunho");
        card1.use();
        card2.use();
        card3.use();
    }
}

6. 実行結果

devkuma의 카드를 만듭니다.
kimkc의 카드를 만듭니다.
yunho의 카드를 만듭니다.
devkuma의 카드를 사용합니다.
kimkc의 카드를 사용합니다.
yunho의 카드를 사용합니다.

Factory Methodパターンのメリット

Factory/Productはframeworkパッケージ、IDCardFactory/IDCardはidcardパッケージに存在する。
frameworkパッケージはidcardパッケージをimportしない。つまり、frameworkパッケージはidcardパッケージに依存しない形である。
まったく別の「製品」と「工場」を作りたい場合、frameworkパッケージの内容を修正する必要はない。

Design Pattern | Prototype Pattern(プロトタイプパターン)

kc@example.com (kc kim) — Mon, 14 Mar 2022 01:24:00 +0900

Prototypeパターンとは?

Prototypeという英単語は、原型や模範という意味である。
Prototypeパターンは、new Xxx()でクラスからインスタンスを生成するのではなく、インスタンスから別のインスタンスを生成する方式である。つまり、コピーしてインスタンスを作る。
複製を作る作業をcloneと言う。
GoFデザインパターンでは、生成に関するデザインパターンに分類される。

Prototypeパターンのサンプルプログラム

入力した文字列に下線を引いたり、囲んだりするサンプルプログラムである。

Class Diagram

1. Productインターフェース

複製メソッドを定義するインターフェースである。JavaのCloneableインターフェースを継承する。

Product.java

package com.devkuma.designpattern.creational.prototype.framework;

import java.lang.Cloneable;

public interface Product extends Cloneable {
    void use(String s);

    Product createClone();
}

2. Managerクラス

Productの生成指示や管理を行うクラスである。

Manager.java

package com.devkuma.designpattern.creational.prototype.framework;

import java.util.HashMap;

public class Manager {

    private HashMap showcase = new HashMap();

    public void register(String name, Product prototype) {
        showcase.put(name, prototype);
    }

    public Product create(String prototypeName) {
        Product p = (Product) showcase.get(prototypeName);
        return p.createClone();
    }
}

3. UnderlinePenクラス

Productインターフェースを実装するクラスである。このクラスは「文字に下線を引く」クラスになる。

UnderlinePen.java

package com.devkuma.designpattern.creational.prototype.product;

import com.devkuma.designpattern.creational.prototype.framework.Product;

public class UnderlinePen implements Product {

    private char underlineChar;

    public UnderlinePen(char underlineChar) {
        this.underlineChar = underlineChar;
    }

    public void use(String s) {

        int length = s.getBytes().length;

        System.out.println(s);

        for (int i = 0; i < length; i++) {
            System.out.print(underlineChar);
        }

        System.out.println();
    }

    public Product createClone() {
        Product p = null;
        try {
            p = (Product) clone();
        } catch (CloneNotSupportedException e) {
            // オブジェクトのクラスがCloneableインターフェースを実装していない場合にthrowされる例外。
            e.printStackTrace();
        }
        return p;
    }
}

4. MessageBoxクラス

Productインターフェースを実装するクラスである。このクラスは「文字を囲む」クラスになる。

MessageBox.java

package com.devkuma.designpattern.creational.prototype.product;

import com.devkuma.designpattern.creational.prototype.framework.Product;

public class MessageBox implements Product {

    private char decoChar;

    public MessageBox(char decoChar) {
        this.decoChar = decoChar;
    }

    public void use(String s) {

        int length = s.getBytes().length;

        for (int i = 0; i < length + 2; i++) {
            System.out.print(decoChar);
        }

        System.out.println();
        System.out.println(decoChar + s + decoChar);

        for (int i = 0; i < length + 2; i++) {
            System.out.print(decoChar);
        }

        System.out.println();
    }

    public Product createClone() {
        Product p = null;
        try {
            p = (Product) clone();
        } catch (CloneNotSupportedException e) {
            // オブジェクトのクラスがCloneableインターフェースを実装していない場合にthrowされる例外。
            e.printStackTrace();
        }
        return p;
    }
}

5. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.creational.prototype;

import com.devkuma.designpattern.creational.prototype.framework.Manager;
import com.devkuma.designpattern.creational.prototype.framework.Product;
import com.devkuma.designpattern.creational.prototype.product.MessageBox;
import com.devkuma.designpattern.creational.prototype.product.UnderlinePen;

public class Main {
    public static void main(String[] args) {

        Manager manager = new Manager();
        UnderlinePen upen = new UnderlinePen('~');
        MessageBox mbox = new MessageBox('*');
        MessageBox pbox = new MessageBox('+');
        manager.register("strong message", upen);
        manager.register("warning box", mbox);
        manager.register("slash box", pbox);

        Product p1 = manager.create("strong message");
        p1.use("Hello world");
        System.out.println();
        Product p2 = manager.create("warning box");
        p2.use("Hello world");
        System.out.println();
        Product p3 = manager.create("slash box");
        p3.use("Hello world");
    }
}

6. 実行結果

Hello world
~~~~~~~~~~~

*************
*Hello world*
*************

+++++++++++++
+Hello world+
+++++++++++++

Prototypeパターンのメリット

サンプルプログラムでは比較的単純な場合だったが、インスタンスを生成するうえで複雑な処理が必要だったり、時間がかかる処理が必要だったりすることもある。インスタンスを生成するたびにnew Xxx()を使うのは非常に非効率である。
Prototypeを作ってコピーすれば、簡単にインスタンスを生成できる。

Design Pattern | Singleton Pattern(シングルトンパターン)

kc@example.com (kc kim) — Thu, 13 May 2021 09:10:45 +0900

Singletonパターンとは?

Singleton(シングルトン)とは、1つの要素だけを持つ集合という意味である。
Singletonパターンは、インスタンスが1つだけ存在することを保証する方式である。
Singletonパターンは、プログラム内でインスタンスを一度だけ生成したいときに使われる。
グローバル変数を使わずにオブジェクトを1つだけ生成し、生成されたオブジェクトをどこからでも参照できるようにするパターンである。
プログラム全体で使われる設定情報値も、Singletonパターンを使って1つだけ生成し、情報を共有するために必要である。
例えば、システム設定を表すクラス、ウィンドウシステムを表すクラスなどが挙げられる。
GoFデザインパターンでは、生成に関するデザインパターンに分類される。

Singletonパターンのサンプルプログラム

シングルトンインスタンスを生成するプログラムである。

Class Diagram

1. Singletonクラス

唯一のインスタンスを返すクラスである。
Singletonクラスのコンストラクタはprivateに指定する。これはSingletonクラスの外からコンストラクタを呼び出せないようにするためである。

Singleton.java

package com.devkuma.designpattern.creational.singleton.ex1;

public class Singleton {

    private static Singleton singleton = new Singleton();

    private Singleton() {
        System.out.println("인스턴스를 생성하였습니다.");
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

2. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.creational.singleton.ex1;

public class Main {
    public static void main(String[] args) {
        Singleton obj1 = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();
        if (obj1 == obj2) {
            System.out.println("obj1와 obj2는 동일한 인스턴스입니다.");
        } else {
            System.out.println("obj1와 obj2는 동일한 인스턴스가 아닙니다.");
        }
    }
}

3. 実行結果

인스턴스를 생성하였습니다.
obj1와 obj2는 동일한 인스턴스입니다.

Singletonパターンのメリット

Singletonパターンはインスタンス数に制限を設けている。
インスタンスが複数存在すると、インスタンス同士が互いに影響し、予期しないバグを作る可能性がある。
しかし、インスタンスが1つだけである保証があれば、その前提条件でプログラミングできる。

synchronizedを使用したSingletonパターン

synchronizedを使用したSingletonパターンのプログラム例

複数のオブジェクトから同時にアクセスできるため、synchronizedを宣言すればスレッドセーフになる。

package com.devkuma.designpattern.creational.singleton.ex2;

public class SynchronizedSingleton1 {

    private static Singleton1 instance;

    /**
     * アクセスできないコンストラクタ
     */
    private SynchronizedSingleton1() {
    }

    public static synchronized Singleton1 getInstance() {
        if (instance == null) {
            instance = new Singleton1();
        }
        return instance;
    }

    public static void main(String[] args) {

        Singleton1 singleton1 = Singleton1.getInstance();
        Singleton1 singleton2 = Singleton1.getInstance();

        System.out.println(singleton1);
        System.out.println(singleton2);
    }
}

synchronizedの性能を改善したSingletonパターンのプログラム例

同期化によって性能関連の問題が発生する可能性があるため、以下のようなコードを書いて最初の1回だけ同期化することで性能を向上できる。

volatile: スレッド環境で1つの変数が正しく一度に動作することを保証するキーワード。

package com.devkuma.designpattern.creational.singleton.ex2;

public class SynchronizedSingleton2 {

    private volatile static Singleton2 instance;

    /**
     * アクセスできないコンストラクタ
     */
    private SynchronizedSingleton2() {
    }

    public static Singleton2 getInstance() {
        if (instance == null) {
            // 最初の1回だけインスタンスが生成される。
            synchronized (Singleton2.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {

        Singleton2 singleton1 = Singleton2.getInstance();
        Singleton2 singleton2 = Singleton2.getInstance();

        System.out.println(singleton1);
        System.out.println(singleton2);
    }
}

Design Pattern | Adapter Pattern(アダプターパターン)

kc@example.com (kc kim) — Sun, 13 Mar 2022 17:56:00 +0900

Adapterパターンとは?

Adapterという英単語は、適合させるものという意味である。
Adapterパターンは、すでに提供されているものをそのまま使えない場合に、必要な形へ変換して利用するための方式である。つまり、インターフェースを変更するための方式である。
アダプターは、電圧が合わないときに間に接続する変換プラグを考えるとよい。
パターンでも、両側に互いに合わないインターフェースがあるなら、この2つをつなげるBridgeを作ればよい。
継承を利用する方法と委譲を利用する方法がある。
- クラスによるAdapter Pattern
  - 継承を利用したAdapter Patternである。
- インスタンスによるAdapter Pattern
  - 委譲を使用したAdapter Patternである。
ラッパーパターンとも呼ばれる。ラッパーは包むものを意味する。
GoFのデザインパターンでは、構造に関するデザインパターンに分類される。

Adapterパターンのサンプルプログラム

学生の名前と年齢を表示するサンプルプログラムである。

1. クラス継承を利用した方法

Class Diagram

1-1. Humanクラス

もともと提供されたクラスである。

Human.java

package com.devkuma.designpattern.structural.adapter.ex1;

public class Human {

    private String name;
    private int age;

    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void printName() {
        System.out.println(name);
    }

    public void printAge() {
        System.out.println(age);
    }
}

1-2. Studentインターフェース

必要なインターフェースである。

Student.java

package com.devkuma.designpattern.structural.adapter.ex1;

public interface Student {
    void showName();

    void showAge();
}

1-3. HumanAdapterクラス

Adapter役となるクラスである。

HumanAdapter.java

package com.devkuma.designpattern.structural.adapter.ex1;

public class HumanAdapter extends Human implements Student {

    public HumanAdapter(String name, int age) {
        super(name, age);
    }

    public void showName() {
        printName();
    }

    public void showAge() {
        printAge();
    }
}

1-4. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.structural.adapter.ex1;

public class Main {
    public static void main(String[] args) {
        Student student = new HumanAdapter("devkuma", 25);
        student.showName();
        student.showAge();
    }
}

1-5. 実行結果

devkuma
25

2. 委譲を利用した方法

2-1. Humanクラス

もともと提供されたクラスである。

Human.java

package com.devkuma.designpattern.structural.adapter.ex2;

public class Human {

    private String name;
    private int age;

    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void printName() {
        System.out.println(name);
    }

    public void printAge() {
        System.out.println(age);
    }
}

2-2. Studentインターフェース

必要なインターフェースである。

Student.java

package com.devkuma.designpattern.structural.adapter.ex2;

public interface Student {
    void showName();

    void showAge();
}

2-3. HumanAdapterクラス

Adapter役となるクラスである。

HumanAdapter.java

package com.devkuma.designpattern.structural.adapter.ex2;

public class HumanAdapter implements Student {

    private Human human;

    public HumanAdapter(String name, int age) {
        this.human = new Human("田中", 25);;
    }

    public void showName() {
        human.printName();
    }

    public void showAge() {
        human.printAge();
    }
}

2-4. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.structural.adapter.ex2;

public class Main {
    public static void main(String[] args) {
        Student student = new HumanAdapter("devkuma", 25);
        student.showName();
        student.showAge();
    }
}

2-5. 実行結果

devkuma
25

Adapterパターンのメリット

Adapterパターンは、既存クラスに皮をかぶせ、必要なクラスを作る。このパターンを使うと、必要なメソッド群を素早く作ることができる。
もしバグが検出されたとしても、既存クラスが十分にテストされているなら、Adapter役のクラスを重点的に調査すればよくなるため、プログラムのチェックが楽になる。
また、Adapterパターンを使えば既存クラスに手を加えずに機能を実装できるため、既存クラスを再テストする手間を減らせる。

Design Pattern | Bridge Pattern(ブリッジパターン)

kc@example.com (kc kim) — Thu, 17 Mar 2022 14:30:00 +0900

Bridgeパターンとは?

Bridgeという英単語は橋という意味である。
現実世界の橋が川の両側をつなぐように、Bridgeパターンも2つの場所をつなぐ方式である。
実装と抽象を分離する。機能クラス階層と実装クラス階層の間に橋(Bridge)をかける役割を持つパターンである。
Bridgeパターンが交差する2つの場所は、機能クラス階層と実装クラス階層である。
- 機能クラスの階層: スーパークラスが基本的な機能を持ち、サブクラスで新しい機能を追加する場合の階層である。
- 実装クラスの階層: スーパークラスが抽象メソッドによってインターフェースを規定し、サブクラスで具象メソッドによってそのインターフェースを実装する場合の階層である。
GoFのデザインパターンでは、構造に関するデザインパターンに分類される。

Bridgeパターンのサンプルプログラム

入力した文字列を指定回数およびランダム回数表示するサンプルプログラムである。

Class Diagram

1. Displayクラス

機能クラス階層となる「表示」を行うクラスである。このクラスが持つimplフィールドが、2つのクラス階層の「橋」になる。

Display.java

package com.devkuma.designpattern.structural.bridge;

public class Display {

    private DisplayImpl impl;

    public Display(DisplayImpl impl) {
        this.impl = impl;
    }

    public void open() {
        impl.rawOpen();
    }

    public void print() {
        impl.rawPrint();
    }

    public void close() {
        impl.rawClose();
    }

    public final void display() {
        open();
        print();
        close();
    }
}

2. CountDisplayクラス

機能クラス階層となる「指定回数表示」という機能を追加したクラスである。

CountDisplay.java

package com.devkuma.designpattern.structural.bridge;

public class CountDisplay extends Display {

    public CountDisplay(DisplayImpl impl) {
        super(impl);
    }

    public void multiDisplay(int times) {
        open();
        for (int i = 0; i < times; i++) {
            print();
        }
        close();
    }
}

3. RandomCountDisplayクラス

機能クラス階層となる「ランダム回数表示」という機能を追加したクラスである。

RandomCountDisplay.java

package com.devkuma.designpattern.structural.bridge;

import java.util.Random;

public class RandomCountDisplay extends CountDisplay {

    private Random random = new Random();

    public RandomCountDisplay(DisplayImpl impl) {
        super(impl);
    }

    public void randomDisplay(int times) {
        multiDisplay(random.nextInt(times));
    }
}

4. DisplayImplクラス

実装クラス階層となる「表示」用のメソッドを定義したクラスである。

DisplayImpl.java

public abstract class DisplayImpl {
    public abstract void rawOpen();
    public abstract void rawPrint();
    public abstract void rawClose();
}

5. StringDisplayImplクラス

実装クラス階層となる「文字列を使って表示」するクラスである。

StringDisplayImpl.java

package com.devkuma.designpattern.structural.bridge;

public class StringDisplayImpl extends DisplayImpl {

    private String string;
    private int width;

    public StringDisplayImpl(String string) {
        this.string = string;
        this.width = string.getBytes().length;
    }

    public void rawOpen() {
        printLine();
    }

    public void rawPrint() {
        System.out.println("|" + string + "|");
    }

    public void rawClose() {
        printLine();
    }

    private void printLine() {
        System.out.print("+");
        for (int i = 0; i < width; i++) {
            System.out.print("-");
        }
        System.out.println("+");
    }
}

6. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.structural.bridge;

public class Main {

    public static void main(String[] args) {
        Display display = new Display(new StringDisplayImpl("Display Test"));
        CountDisplay countDisplay = new CountDisplay(new StringDisplayImpl("CountDisplay Test"));
        RandomCountDisplay randomCountDisplay = new RandomCountDisplay(new StringDisplayImpl("RandomCountDisplay Test"));
        display.display();
        countDisplay.multiDisplay(5);
        randomCountDisplay.randomDisplay(10);
    }
}

7. 実行結果

+------------+
|Display Test|
+------------+
+-----------------+
|CountDisplay Test|
|CountDisplay Test|
|CountDisplay Test|
|CountDisplay Test|
|CountDisplay Test|
+-----------------+
+-----------------------+
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
+-----------------------+

メリット

前述のとおり、Bridgeパターンの特徴は機能クラスの階層と実装クラスの階層を分けることである。この2つのクラス階層を分けておけば、それぞれのクラス階層を独立して拡張できる。
機能を追加するには、機能のクラス階層にクラスを追加する。このとき、実装クラス階層はまったく修正する必要がない。さらに、追加した機能はすべての実装で利用できるようになる。
サンプルプログラムでは、CountDisplayクラスやRandomCountDisplayクラスを追加することが機能追加に該当する。
このようにBridgeパターンでは、クラスの拡張を見通しよく行うことができる。

Design Pattern | Composite Pattern(コンポジットパターン)

kc@example.com (kc kim) — Thu, 17 Mar 2022 15:05:00 +0900

Compositeパターンとは?

Compositeという単語は混合または複合という意味である。
Compositeパターンは、容器と中身を同一視して再帰的な構造を作る方式である。
ディレクトリとファイルを一緒にディレクトリエントリとして扱うために、コンテナと中身を同じ種類のものとして扱うと便利な場合がある。例えば、容器の中には中身を入れてもよく、さらに容器を入れてもよい。このように再帰構造を作ることができる。
GoFデザインパターンでは、構造に関するデザインパターンに分類される。

Compositeパターンのサンプルプログラム

ディレクトリ、ファイル一覧を表示するサンプルプログラムである。

Class Diagram

1. Entryクラス

FileとDirectoryの基本となるクラスである。

Entry.java

package com.devkuma.designpattern.structural.composite;

public abstract class Entry {

    public abstract String getName();

    protected abstract void printList(String prefix);

    public void printList() {
        printList("");
    }
}

2. Fileクラス

ファイルを表すクラスである。

File.java

package com.devkuma.designpattern.structural.composite;

public class File extends Entry {

    private String name;

    public File(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    protected void printList(String prefix) {
        System.out.println(prefix + "/" + name);
    }
}

3. Directoryクラス

ディレクトリを表すクラスである。

Directory.java

package com.devkuma.designpattern.structural.composite;

import java.util.ArrayList;
import java.util.Iterator;

public class Directory extends Entry {

    private String name;
    private ArrayList<Entry> directory = new ArrayList();

    public Directory(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    public Entry add(Entry entry) {
        directory.add(entry);
        return this;
    }

    @Override
    protected void printList(String prefix) {
        System.out.println(prefix + "/" + name);
        Iterator<Entry> it = directory.iterator();
        while (it.hasNext()) {
            Entry entry = it.next();
            entry.printList(prefix + "/" + name);
        }
    }
}

4. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.structural.composite;

public class Main {
    public static void main(String[] args) {

        Directory workspaceDir = new Directory("workspace");
        Directory compositeDir = new Directory("composite");
        Directory testDir1 = new Directory("test1");
        Directory testDir2 = new Directory("test2");
        workspaceDir.add(compositeDir);
        workspaceDir.add(testDir1);
        workspaceDir.add(testDir2);

        File directory = new File("Directory.java");
        File entity = new File("Entity.java");
        File file = new File("file.java");
        File main = new File("main.java");
        compositeDir.add(directory);
        compositeDir.add(entity);
        compositeDir.add(file);
        compositeDir.add(main);
        workspaceDir.printList();
    }
}

5. 実行結果

/workspace
/workspace/composite
/workspace/composite/Directory.java
/workspace/composite/Entity.java
/workspace/composite/file.java
/workspace/composite/main.java
/workspace/test1
/workspace/test2

メリット

すべてのオブジェクト(File、Directory)は共通の抽象クラスを持つため、クライアントから見たとき、それがFileなのかDirectoryなのか、中身を意識する必要がなく、同じように扱える。
また、新しいクラス(例: SymbolicLink)を追加しても、基本クラス(Entry)のインターフェースが変わらなければ、クライアントの処理には影響しない。

Design Pattern | Decorator Pattern(デコレーターパターン)

kc@example.com (kc kim) — Sat, 19 Mar 2022 15:19:00 +0900

Decoratorパターンとは?

Decoratorという英単語は装飾する(Decorate)という意味である。既存の内容に何かを付け加えるという意味合いが強い。
Decoratorパターンは、オブジェクトに続けてデコレーション(装飾)を追加する方式である。
ピザを例にすると、既存のピザの上にトッピングを追加すると考えればよい。
スポンジケーキにクリーム、チョコレート、いちごなどで装飾できるように、オブジェクトにも機能を1つずつかぶせて装飾する方式である。
GoFデザインパターンでは、構造に関するデザインパターンに分類される。

Decoratorパターンのサンプルプログラム

入力した文字列に対して、枠線などの装飾を行うサンプルプログラムである。

Class Diagram

1. Displayクラス

文字列行表示用の抽象クラスである。

Display.java

package com.devkuma.designpattern.structural.decorator;

public abstract class Display {

    // 列の文字数を返す。
    public abstract int getColumns();

    // 行数を返す。
    public abstract int getRows();

    // 指定された行の文字列を返す。
    public abstract String getRowText(int row);

    public void show() {
        for (int i = 0; i < getRows(); i++) {
            System.out.println(getRowText(i));
        }
    }
}

2. StringDisplayクラス

1行だけで構成される文字列行表示用のクラスである。

StringDisplay.java

package com.devkuma.designpattern.structural.decorator;

public class StringDisplay extends Display {

    private String string;

    public StringDisplay(String string) {
        this.string = string;
    }

    public int getColumns() {

        return string.getBytes().length;
    }

    public int getRows() {
        return 1;
    }

    public String getRowText(int row) {
        return (row == 0) ? string : null;
    }
}

3. Borderクラス

装飾枠を表す抽象クラスである。

Border.java

package com.devkuma.designpattern.structural.decorator;

public abstract class Border extends Display {

    protected Display display;

    protected Border(Display display) {
        this.display = display;
    }
}

4. SideBorderクラス

左右に装飾枠を付けるクラスである。

SideBorder.java

package com.devkuma.designpattern.structural.decorator;

public class SideBorder extends Border {

    public SideBorder(Display display) {
        super(display);
    }

    public int getColumns() {
        // 文字数は内容の両側に装飾した文字数を加えた数。
        return 1 + display.getColumns() + 1;
    }

    public int getRows() {
        // 行数は内容の行数と同じ。
        return display.getRows();
    }

    public String getRowText(int row) {
        return "*" + display.getRowText(row) + "*";
    }
}

5. FullBorderクラス

上下左右に装飾枠を付けるクラスである。

FullBorder.java

package com.devkuma.designpattern.structural.decorator;

public class FullBorder extends Border {

    public FullBorder(Display display) {
        super(display);
    }

    public int getColumns() {
        // 文字数は内容の両側に左右の装飾文字数を加えた数。
        return 1 + display.getColumns() + 1;
    }

    public int getRows() {
        // 行数は内容の行数に上下の装飾文字数を加えた数。
        return 1 + display.getRows() + 1;
    }

    public String getRowText(int row) {
        if (row == 0) {
            // 上端の枠
            return "+" + makeLine('-', display.getColumns()) + "+";
        } else if (row == display.getRows() + 1) {
            // 下端の枠
            return "+" + makeLine('-', display.getColumns()) + "+";
        } else {
            // その他
            return "|" + display.getRowText(row - 1) + "|";
        }
    }

    private String makeLine(char ch, int count) {
        StringBuffer buf = new StringBuffer();
        for (int i = 0; i < count; i++) {
            buf.append(ch);
        }
        return buf.toString();
    }
}

6. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.structural.decorator;

public class Main {

    public static void main(String[] args) {
        Display display1 = new StringDisplay("Hello world");
        display1.show();
        System.out.println("");

        Display display2 = new SideBorder(display1);
        display2.show();
        System.out.println("");

        Display display3 = new FullBorder(display2);
        display3.show();
        System.out.println("");

        Display display4 =
                new FullBorder(
                        new SideBorder(
                                new FullBorder(
                                        new StringDisplay("Hello world"))));
        display4.show();
    }
}

7. 実行結果

Hello world

*Hello world*

+-------------+
|*Hello world*|
+-------------+

+---------------+
|*+-----------+*|
|*|Hello world|*|
|*+-----------+*|
+---------------+

Decoratorパターンのメリット

Decoratorパターンでは、装飾枠(Border)も中身(StringDisplay)も共通のインターフェースを持っている。インターフェースは共通だが、包めば包むほど機能が追加されていく。そのとき、包まれる側を修正する必要はない。包むものを変更せずに機能を追加できる。

Design Pattern | Facade Pattern(ファサードパターン)

kc@example.com (kc kim) — Sat, 19 Mar 2022 15:19:00 +0900

Facadeパターンとは?

Facadeという英単語は正面という意味である。
「建物の正面」を意味する単語であり、あるソフトウェアの別の大きなコード部分に対して、簡略化されたインターフェースを提供するデザインパターンを意味する。
大きなプログラムを使って処理を行うには、関連している多くのクラスを適切に制御しなければならない。その処理を行うための窓口を作っておけば、多くのクラスを個別に制御しなくてもよい。
Facadeパターンは、複雑なシステムに対する簡単な窓口を用意する方式である。
Facadeオブジェクトは、複雑なソフトウェアの外側のコードがライブラリ内部のコードに依存することを減らし、複雑なソフトウェアを使えるように簡単なインターフェースを提供する。
GoFのデザインパターンでは、構造に関するデザインパターンに分類される。

Facadeパターンのサンプルプログラム

ユーザーのWebページを作るサンプルプログラムである。

Class Diagram

1. PageMakerクラス

メールアドレスからユーザーのWebページを作るクラスである。このクラスがFacadeになる。

PageMaker.java

package com.devkuma.designpattern.structural.facade.pagemaker;

import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class PageMaker {

    private PageMaker() {}

    public static void makeWelcomePage(String mailaddr, String filename) {
        try {
            Properties mailProp = Database.getProperties("maildata");
            String username = mailProp.getProperty(mailaddr);
            HtmlWriter writer = new HtmlWriter(new FileWriter(filename));
            writer.title("Welcome to " + username + "'s page!");
            writer.paragraph(username + "의 페이지에 어서오세요.");
            writer.paragraph("문의 사항을 메일을 보내주세요.");
            writer.mailto(mailaddr, username);
            writer.close();
            System.out.println(filename + " is created for " + mailaddr + " (" + username + ")");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. HtmlWriterクラス

HTMLファイルを作成するクラスである。

HtmlWriter.java

package com.devkuma.designpattern.structural.facade.pagemaker;

import java.io.IOException;
import java.io.Writer;

public class HtmlWriter {

    private Writer writer;

    public HtmlWriter(Writer writer) {
        this.writer = writer;
    }

    public void title(String title) throws IOException {
        writer.write("<html>");
        writer.write("<head>");
        writer.write("<title>" + title + "</title>");
        writer.write("</head>");
        writer.write("<body>\n");
        writer.write("<h1>" + title + "</h1>\n");
    }

    public void paragraph(String msg) throws IOException {
        writer.write("<p>" + msg + "</p>\n");
    }

    public void link(String href, String caption) throws IOException {
        paragraph("<a href=\"" + href + "\">" + caption + "</a>");
    }

    public void mailto(String mailaddr, String username) throws IOException {
        link("mailto:" + mailaddr, username);
    }

    public void close() throws IOException {
        writer.write("</body>");
        writer.write("</html>\n");
        writer.close();
    }
}

3. Databaseクラス

メールアドレスからユーザー名を取得するクラスである。

Database.java

package com.devkuma.designpattern.structural.facade.pagemaker;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class Database {

    private Database() {
    }

    public static Properties getProperties(String dbname) {
        ClassLoader loader = Database.class.getClassLoader();
        String file = loader.getResource("facade/pagemaker/" + dbname + ".txt").getFile();
        Properties prop = new Properties();
        try {
            prop.load(new FileInputStream(file));
        } catch (IOException e) {
            System.out.println("Warning: " + file + " is not found.");
        }
        return prop;
    }
}

4. maildataデータベース

データベースファイルである。

maildata.txt

devkuma@devkuma.com=dekuma
ariakuma@devkuma.com=ariakuma
kimkc@devkuma.com=kim

5. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.structural.facade;

import com.devkuma.designpattern.structural.facade.pagemaker.PageMaker;

public class Main {
    public static void main(String[] args) {
        PageMaker.makeWelcomePage("devkuma@devkuma.com", "welcome.html");
    }
}

6. 実行結果

<html><head><title>Welcome to devkuma's page!</title></head><body>
<h1>Welcome to devkuma's page!</h1>
<p>devkuma의 페이지에 어서오세요.</p>
<p>문의 사항을 메일을 보내주세요.</p>
<p><a href="mailto:devkuma@devkuma.com">devkuma</a></p>
</body></html>

Facadeパターンのメリット

クラスやメソッドが多いと、プログラマーはどれを使えばよいか迷ったり、呼び出し順序に注意しなければならない。注意が必要ということは、それだけミスしやすいということである。
Facadeパターンを使うと、インターフェースを減らし、複雑なものを単純に見せることができる。
インターフェースの数が少ないということは、外部との結合が疎であるとも表現できる。つまり、疎結合になり、パッケージを部品として再利用しやすくする。

Design Pattern | Flyweight Pattern(フライウェイトパターン)

kc@example.com (kc kim) — Sat, 19 Mar 2022 16:31:00 +0900

Flyweightパターンとは?

Flyweightという英単語は「フライ級」という意味である。ボクシングで最も軽い階級を表す。
Flyweightパターンにおける重さは、メモリ使用量である。
Flyweightパターンは、インスタンスをできるだけ多く共有してメモリ使用量を減らす方法である。
GoFのデザインパターンでは、構造に関するデザインパターンに分類される。

Flyweightパターンのサンプルプログラム

ファイルから大きな文字のテキストを読み取り、それを表示するプログラムである。

Class Diagram

1. BigCharクラス

大きな文字を表すクラスである。

BigChar.java

package com.devkuma.designpattern.structural.flyweight;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BigChar {

    // 大きな文字を表す文字列('#'、'.'、'\n'の列)
    private String fontData;

    public BigChar(char charName) {
        try {
            ClassLoader loader = BigChar.class.getClassLoader();
            String file = loader.getResource("flyweight/big" + charName + ".txt").getFile();
            BufferedReader reader = new BufferedReader(new FileReader(file));
            String line;
            StringBuffer buf = new StringBuffer();
            while ((line = reader.readLine()) != null) {
                buf.append(line);
                buf.append("\n");
            }
            reader.close();
            this.fontData = buf.toString();
        } catch (IOException e) {
            this.fontData = charName + "?";
        }
    }

    // 大きな文字を表示する。
    public void print() {
        System.out.print(fontData);
    }
}

2. BigCharFactoryクラス

BigCharのインスタンスを共有しながら生成するクラスである。

BigCharFactory.java

package com.devkuma.designpattern.structural.flyweight;

import java.util.HashMap;

public class BigCharFactory {

    // すでに作成したBigCharインスタンスを管理する。
    private HashMap pool = new HashMap();

    private static BigCharFactory singleton = new BigCharFactory();

    private BigCharFactory() {
    }

    // 1つだけのインスタンスを返す。
    public static BigCharFactory getInstance() {
        return singleton;
    }

    // BigCharのインスタンス生成(共有)
    public synchronized BigChar getBigChar(char charName) {
        BigChar bigChar = (BigChar) pool.get("" + charName);
        if (bigChar == null) {
            bigChar = new BigChar(charName);
            pool.put("" + charName, bigChar);
        }
        return bigChar;
    }
}

3. BigStringクラス

BigCharを集めて作った「大きな文字列」を表すクラスである。

BigString.java

package com.devkuma.designpattern.structural.flyweight;

public class BigString {

    private BigChar[] bigChars;

    public BigString(String string) {
        bigChars = new BigChar[string.length()];
        BigCharFactory factory = BigCharFactory.getInstance();
        for (int i = 0; i < bigChars.length; i++) {
            bigChars[i] = factory.getBigChar(string.charAt(i));
        }
    }

    public void print() {
        for (int i = 0; i < bigChars.length; i++) {
            bigChars[i].print();
        }
    }
}

4. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.structural.flyweight;

public class Main {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Usage: java Main digits");
            System.out.println("Example: java Main 1234");
            System.exit(0);
        }
        BigString bs = new BigString(args[0]);
        bs.print();
    }
}

5. データ

以下のtxtファイルを参照する。
/java-design-pattern-tutorial/src/resources/com/devkuma/designpattern/flyweight

6. 実行結果

以下の結果は、プログラムに引数値として0329を入れて実行した結果である。

....######......
..##......##....
..##......##....
..##......##....
..##......##....
..##......##....
....######......
................
....######......
..##......##....
..........##....
......####......
..........##....
..##......##....
....######......
................
....######......
..##......##....
..........##....
......####......
....##..........
..##............
..##########....
................
....######......
..##......##....
..##......##....
....########....
..........##....
..##......##....
....######......
................

Flyweightパターンのメリット

インスタンスを共有すると、毎回newする必要がなくなるため、メモリ使用量が少ない。より一般的に言えば、インスタンスを共有すると、インスタンスを生成するために必要なリソース量を減らせる。リソースはコンピューターのリソースであり、メモリはリソースの一種である。
時間もリソースの一種である。インスタンスをnewするたびに一定の時間がかかるなら、Flyweightパターンを使ってインスタンスを共有することで、インスタンスをnewする回数を減らせる。そうすることでプログラムの速度を向上させられる。

Design Pattern | Proxy Pattern(プロキシパターン)

kc@example.com (kc kim) — Sat, 19 Mar 2022 15:19:00 +0900

Proxyパターンとは?

Proxyという英単語は代理人、代弁者という意味である。
既存要素の代わりをする方式である。
オブジェクト指向では、「自分」も「代理人」もオブジェクトになる。
Proxyパターンは、忙しくて作業できないオブジェクト自身の代わりに、オブジェクトの代理人が一部の作業をこなす方式である。
Proxyパターンで重要なのは、フロー制御だけを行い、結果値を操作したり変更したりしてはいけないという点である。
あるオブジェクトにアクセスするために代理人を使用する。
GoFのデザインパターンでは、構造に関するデザインパターンに分類される。

Proxyパターンのサンプルプログラム

画面に文字を表示する「名前付きプリンター」のサンプルプログラムである。

Class Diagram

1. Printableインターフェース

PrinterとPrinterProxyの共通インターフェースである。

Printable.java

package com.devkuma.designpattern.structural.proxy;

public interface Printable {
    // 名前設定
    void setPrinterName(String name);

    // 名前返却
    String getPrinterName();

    // 文字列表示(print out)
    void print(String string);
}

2. Printerクラス

名前付きプリンターを表すクラスである。(本人)

Printer.java

package com.devkuma.designpattern.structural.proxy;

public class Printer implements Printable {

    private String name;

    public Printer() {
        heavyJob("Printer의 인스턴스를 생성중");
    }

    public Printer(String name) {
        this.name = name;
        heavyJob("Printer의 인스턴스 (" + name + ")를 생성중");
    }

    public void setPrinterName(String name) {
        this.name = name;
    }

    public String getPrinterName() {
        return name;
    }

    public void print(String string) {
        System.out.println("=== " + name + " ===");
        System.out.println(string);
    }

    private void heavyJob(String msg) {
        System.out.print(msg);
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.print(".");
        }
        System.out.println("완료");
    }
}

3. PrinterProxyクラス

名前付きプリンターを表すクラスである。(代理人)

PrinterProxy.java

package com.devkuma.designpattern.structural.proxy;

public class PrinterProxy implements Printable {

    private String name;
    private Printer real;

    public PrinterProxy() {
    }

    public PrinterProxy(String name) {
        this.name = name;
    }

    public synchronized void setPrinterName(String name) {
        if (real != null) {
            real.setPrinterName(name);
        }
        this.name = name;
    }

    public String getPrinterName() {
        return name;
    }

    public void print(String string) {
        realize();
        real.print(string);
    }

    private synchronized void realize() {
        if (real == null) {
            real = new Printer(name);
        }
    }
}

4. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.structural.proxy;

public class Main {
    public static void main(String[] args) {
        Printable p = new PrinterProxy("Alice");
        System.out.println("현재 이름은 " + p.getPrinterName() + " 입니다.");
        p.setPrinterName("Bob");
        System.out.println("현재 이름은 " + p.getPrinterName() + " 입니다.");
        p.print("Hello, world.");
    }
}

5. 実行結果

현재 이름은 Alice 입니다.
현재 이름은 Bob 입니다.
Printer의 인스턴스 (Bob)를 생성중.....완료
=== Bob ===
Hello, world.

Proxyパターンのメリット

Proxyパターンでは、Proxyが代理人となり、可能な限り処理を肩代わりする。
サンプルプログラムでは、Proxy役を使うことで、実際にprintするまで重い処理(インスタンス生成)を遅延できた。
例えば、初期化に時間がかかる機能が多数存在するシステムの場合、起動時点で利用しない機能まで全部初期化してしまうと、アプリケーションの起動に時間がかかってしまう。
PrinterProxyクラスとPrinterクラスの2つに分けず、Printerクラス内に最初から遅延機能を入れておくこともできるが、クラスを分けることでプログラムの部品化が進み、個別に機能を追加しやすくなる。

Design Pattern | Chain of Responsibility(責任連鎖)

kc@example.com (kc kim) — Sat, 19 Mar 2022 21:26:00 +0900

Chain of Responsibilityパターンとは?

Chainは連鎖、Responsibilityは責任を意味する。つまりChain of Responsibilityは責任の連鎖という意味である。実際には、順番に回していく構造と考えると理解しやすい。
Chain of Responsibilityパターンは、複数のオブジェクトをチェーンでつなぎ、そのチェーンを順番にたどりながら最終的な処理オブジェクトを決める方式である。
ある人に要求が来たとき、その人が処理できれば処理する。処理できなければ、その要求を「次の人」へ渡す。これを繰り返すのがChain of Responsibilityパターンである。
GoFのデザインパターンでは、振る舞いに関するデザインパターンに分類される。

Chain of Responsibilityパターンのサンプルプログラム

入力された問題を、いずれかのサポート役で解決するプログラムである。

Class Diagram

主な役割は、発生した問題を表すTrouble、共通の支援役であるSupport、そして何もしない支援、上限値で判断する支援、奇数を処理する支援、特定番号を処理する支援などの具象クラスである。各支援役は自分で解決できるかを判断し、できなければ次の支援役へ問題を渡す。

メリット

このパターンは、要求を出す側と実際に処理する側を分離する。適切な処理役が見つかるまで要求をチェーン上で渡せるため、要求元を変更せずに処理役の追加、削除、順序変更がしやすい。

Design Pattern | Command Pattern(コマンドパターン)

kc@example.com (kc kim) — Sat, 19 Mar 2022 21:27:00 +0900

Commandパターンとは?

Commandという英単語は命令という意味である。
Commandパターンは、命令を表すクラスのインスタンスとして表現する方法である。
命令の履歴を管理したいときは、そのインスタンスの集合を管理すればよい。命令の集まりを保存すれば、同じ命令を再実行したり、複数の命令をまとめて新しい命令として再利用したりできる。
GoFのデザインパターンでは、振る舞いに関するデザインパターンに分類される。

Commandパターンのサンプルプログラム

簡単なお絵描きプログラムである。

Class Diagram

例では、execute()を持つCommandインターフェース、命令を保存する履歴、描画対象、描画命令、描画操作を作成して再実行するUIクラスを定義する。各描画操作はオブジェクトとして保持されるため、実行、保存、再実行、グループ化が可能になる。

メリット

命令をデータとして扱える。これにより、履歴、Undo/Redo、マクロ命令、キュー、ログ、遅延実行などを実装しやすくなり、要求元と実際の処理対象を分離できる。

Design Pattern | Interpreter Pattern(インタプリタパターン)

kc@example.com (kc kim) — Sat, 19 Mar 2022 21:29:00 +0900

Interpreterパターンとは?

Interpreterという英単語は通訳という意味である。
Interpreterパターンは、ある形式で書かれたファイルの内容を、「通訳」の役割を持つプログラムで解釈し表現する方式である。
GoFのデザインパターンでは、振る舞いに関するデザインパターンに分類される。

Interpreterパターンのサンプルプログラム

テキストファイルに書かれた言語を構文解析するプログラムである。

Class Diagram

構文解析対象のテキストで使用する言語の文法では、BNF表記法を使用する。

<program> ::= program <command list>
<command list> ::= <command>* end
<command> ::= <repeat command> | <primitive command>
<repeat command> ::= repeat <number> <command list>
<primitive command> ::= go | right | left

<program>は、トークンprogramの後にコマンド列が続くことを意味する。
<command list>は、0個以上のコマンドの後にトークンendが続くことを意味する。
<command>は、繰り返し命令または基本命令のいずれかである。|はORを表す。
<repeat command>は繰り返し実行を表す。
<primitive command>はgo、right、leftのような基本命令を表す。

例では、program、command list、command、repeat command、primitive commandといった文法概念をノードクラスに分ける。各ノードは自分の文法規則を解析し、構文木を作る。

メリット

言語やルール集合を文法として表現できる場合、Interpreterパターンでは各文法規則をクラスとして表現できる。これにより解析や拡張がしやすくなるが、文法が大きくなるとクラス数が増えやすい。

Design Pattern | Iterator Pattern(イテレーターパターン)

kc@example.com (kc kim) — Sun, 13 Mar 2022 17:56:00 +0900

Iteratorパターンとは?

Iterateという英単語は、何かを繰り返すという意味である。Iteratorは反復子という意味である。
Iteratorパターンは、集合体の要素に対して順番にアクセスする処理を行うための方式である。
GoFのデザインパターンでは、振る舞いに関するデザインパターンに分類される。

Visitorという英単語は訪問者という意味である。
Visitorパターンは、データ構造と処理を分離する方法である。
データ構造を巡回する訪問者クラスを用意し、処理を訪問者クラスに任せる。そして新しい処理を追加したいときは、新しい訪問者を作ればよい。データ構造側では訪問者を受け入れればよい。
GoFのデザインパターンでは、振る舞いに関するデザインパターンに分類される。

Visitorパターンのサンプルプログラム

ディレクトリ、ファイル一覧を表示するサンプルプログラムである。

Class Diagram

例では、Visitorを受け入れるデータ構造を表すElementインターフェース、Visitor抽象、ファイルとディレクトリのEntry、構造を巡回して表示する具象Visitorを定義する。

メリット

データ構造クラスを変更せずに、新しいVisitorを追加することで操作を追加できる。オブジェクト構造は安定しているが、その上で行う処理がよく変わる場合に有効である。