设计模式 06 简单化-柚子小站

Facade 外观模式
练习
Mediator 仲裁者模式
练习

Facade 模式

这个模式其实很简单, 就是如果一个程序内部很复杂, 与其对外要求程序的使用者先做这个在做这个, 不如用一个东西包装一下, 用一个窗口对外即可. 用术语就是将互相关联在一起的类整理出高层接口API, Facade角色来具备这个API, 对外只需要暴露Facade角色即可. 作者的例子也很简单, 是一个生成HTML页面的类. 类里有一个生成段落和生成HTML结构的两个类, 这里隐含着必须先生成title等内容, 才能再生成正文的顺序. 如果将类交给用户使用, 用户就必须注意其中的顺序, 然而我们可以包装一个类, 只需要名字和文件名, 就可以隐藏其中的细节, 直接生成HTML文件. 先来看生成名字的类:

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

public class Database {

    private Database() {

    }

    public static Properties getProperties(String name) {
        String filename = name + ".txt";
        Properties properties = new Properties();

        try {
            properties.load(new FileInputStream(filename));

        } catch (IOException e) {
            System.out.println("加载文件失败");
        }
        return properties;
    }

}

这个类是一个通过文件加载Properties的类, 很简单. 然后是写HTML的类, 之前已经很多次编写过类似的类了:

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>");
        writer.write(title);
        writer.write("</title>");
        writer.write("</head>");
        writer.write("<body>\n");
        writer.write("<h1>\n");
        writer.write(title);
        writer.write("</h1>");

    }

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

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

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

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

其中拼接HTML都是传统艺能了, 这里主要是看一个顺序, 即必须先生成头部信息, 然后填充正文才行. 如果交给用户自己使用这个类, 则用户必须按照这个顺序调用. 现在就该Facade角色出场了, 我们编写一个PageMaker类, 使用用户名然后在其中正确的调用这些方法并且生成文件:

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

public class PageMaker {

    private PageMaker() {

    }

    public static void makeWelcomePage(String mailaddr, String filename) {
        try {
            Properties mailprop = Database.getProperties("maildata.txt");
            String username = mailprop.getProperty(mailaddr);
            HtmlWriter writer = new HtmlWriter(new PrintWriter(filename));
            writer.title("Welcome to" + username + "'s page!");
            writer.paragraph("waiting....");
            writer.mailto(mailaddr, username);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个类也很简单, 重点看其中只用了一个API就可以操作了.

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

这个模式我感觉其实就是最基本的封装, 而且Facade角色可以嵌套, 一层套一层来使用.

练习

习题15-1 这个很简单,如果不想要外边的包访问Database和HtmlWriter, 只需要将其权限改为包访问权限即可.

习题15-2 这个也很简单, 只不过是再添加一个方法即可. 其中的title部分可以复用. 从Properties中取出所有的邮件地址和用户名来复用生成link的方法即可.

public static void makeLinkPage(String filename) {
    try {
        Properties mailprop = Database.getProperties("maildata");
        HtmlWriter writer = new HtmlWriter(new PrintWriter(filename));
        writer.title("Link Page");

        for (String name : mailprop.stringPropertyNames()) {
            writer.mailto(name, mailprop.getProperty(name) );
        }
        writer.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Mediator 仲裁者模式

这个模式我想了一下, 应该适用那些整体状态非常多的时候, 每个组件都需要向一个集中管理状态的组件进行报告的时候使用. 以后自己如果写前端的话, 应该可以使用到这个模式. 简单的说, 调整多个对象之间的关系, 就可以用到仲裁者模式, 即不让各个组件之间通信, 而是增加一个角色负责管理. 这里作者举了一个AWT的例子, 其本质和Web开发的理念是一样的. 其中有两个接口, 一个表示仲裁者, 一个表示成员对象.

public interface Mediator {

    //创建符合仲裁者模式要求的成员对象
    void createColleagues();

    //让组员向仲裁者报告变化的方法, 由组员调用
    void colleagueChanged();
}

public interface Colleague {

    //设置自己的仲裁者
    void setMediator(Mediator mediator);

    //设置自己的状态为是否可用, 这个方法教给仲裁者来调用, 而不是自己设置
    void setColleagueEnabled(boolean enabled);

}

在这两个接口的状态下, 我们就可以来编写仲裁者和团队成员类了:

import java.awt.Button;

public class ColleagueButton  extends Button implements Colleague {

    private Mediator mediator;

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

    @Override
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    //这个其实是利用了awt包里的特性, 比如setEnabled表示是否禁用
    @Override
    public void setColleagueEnabled(boolean enabled) {
        setEnabled(enabled);
    }
}

import java.awt.*;
import java.awt.event.TextEvent;

public class ColleagueTextField extends TextField implements Colleague, TextListener {

    private Mediator mediator;

    public ColleagueTextField(String text, int columns) {
        super(text, columns);
    }

    @Override
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void setColleagueEnabled(boolean enabled) {
        setEnabled(enabled);
        setBackground(enabled ? Color.white : Color.lightGray);
    }

    //自己的文字发生变化的时候通知仲裁者
    //这是一个接口, 会在文字发生变化的时候被awt框架调用
    public void textValueChanged(TextEvent event) {
        mediator.colleagueChanged();
    }

}

这里注意红字的实现了一个额外的接口, 这是awt框架用来检测变化事件的.下边的Checkbox也类似:

import java.awt.*;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

public class ColleagueCheckbox extends Checkbox implements Colleague, ItemListener {

    private Mediator mediator;

    public ColleagueCheckbox(String caption, CheckboxGroup checkboxGroup, boolean state) {
        super(caption, checkboxGroup, state);
    }

    @Override
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void setColleagueEnabled(boolean enabled) {
        setEnabled(enabled);
    }

    public void itemStateChanged(ItemEvent event) {
        mediator.colleagueChanged();
    }
}

最后就可以来编写仲裁者类了, 会根据各个组件的通知来管理状态:

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class LoginFrame extends Frame implements ActionListener, Mediator {


    //这是为了实现界面所需要的各个组件
    private ColleagueCheckbox checkGuest;
    private ColleagueCheckbox checkLogin;
    private ColleagueTextField textUser;
    private ColleagueTextField textPass;
    private ColleagueButton buttonOk;
    private ColleagueButton buttonCancel;

    public LoginFrame(String title) {

        //绘制框体和创建组件
        super(title);
        setBackground(Color.lightGray);
        setLayout(new GridLayout(4, 2));
        createColleagues();

        //添加所有组件
        add(checkGuest);
        add(checkLogin);
        add(new Label("Username: "));
        add(textUser);
        add(new Label("Password: "));
        add(textPass);
        add(buttonOk);
        add(buttonCancel);

        //设置初始状态
        colleagueChanged();

        pack();
        show();
    }

    @Override
    public void createColleagues() {
        CheckboxGroup g = new CheckboxGroup();
        //这个猜着就能看懂, 一组两个checkbox, 一个默认选中 , 一个默认不选
        checkGuest = new ColleagueCheckbox("Guest", g, true);
        checkLogin = new ColleagueCheckbox("Login", g, false);

        textUser = new ColleagueTextField("", 10);
        textPass = new ColleagueTextField("", 10);
        //设置密码框的覆盖字符
        textPass.setEchoChar('*');

        buttonOk = new ColleagueButton("OK");
        buttonCancel = new ColleagueButton("Cancel");

        //设置仲裁者为当前对象
        checkGuest.setMediator(this);
        checkLogin.setMediator(this);
        textUser.setMediator(this);
        textPass.setMediator(this);
        buttonOk.setMediator(this);
        buttonCancel.setMediator(this);

        //添加事件监听器, 这个应该是套路
        checkGuest.addItemListener(checkGuest);
        checkLogin.addItemListener(checkLogin);
        textUser.addTextListener(textUser);
        textPass.addTextListener(textPass);
        buttonOk.addActionListener(this);
        buttonCancel.addActionListener(this);
    }

    @Override
    public void colleagueChanged() {
        //如果客户被选中, 禁止两个文本框, OK按钮可以选中
        if (checkGuest.getState()) {
            textUser.setColleagueEnabled(false);
            textPass.setColleagueEnabled(false);
            buttonOk.setColleagueEnabled(true);
        } else {
            textUser.setColleagueEnabled(true);
            //这是抽取出来的方法, 用于改变状态
            userpassChanged();
        }
    }

    private void userpassChanged() {
        buttonOk.setEnabled(false);
        //如果用户名中输入了字符就让密码框可以使用. 密码框可用的时候, 如果有字符就让OK键可以用, 否则OK键无法使用
        if (textUser.getText().length() > 0) {
            textPass.setColleagueEnabled(true);
            if (textPass.getText().length() > 0) {
                buttonOk.setColleagueEnabled(true);
            } else {
                buttonOk.setColleagueEnabled(false);

            }
        }
    }


    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println(e.toString());
        System.exit(0);

    }
}

这个逻辑还是比较好懂的, 先创建一系列控件, 然后添加好, 之后每次监听到任何事件, 比如输入文字和单选框发生变化, 都跳到colleagueChanged()方法中对逻辑进行统一处理. 使用起来就是使用awt框架:

public class Main {
    public static void main(String[] args) {
        new LoginFrame("Mediator Sample");
    }
}

回头看看这个模式, 这个模式的关键在于, 各个控件没有更改自身的状态, 而是统一交给仲裁者来管理, 这样有一大好处就是如果出现BUG, 几乎可以确定是仲裁者编写出现问题, 而无需一个一个到各个组件中寻找错误所在. 一般仲裁者由于利用了其他类的一些具体功能特性, 使得难以复用. 不过组件一般都是可以复用的. 这个模式特别适合使用在GUI模式中, 也就意味着在编写Web前端应用的时候, 可以考虑使用该模式.

练习

练习16-1 修改成当用户名和密码的长度都大于等于4个字符的时候OK按钮才有效. 很显然, 在修改需求的时候, 仲裁者模式只需要修改仲裁者类:

private void userpassChanged() {
    buttonOk.setEnabled(false);
    //如果用户名中输入了字符就让密码框可以使用. 密码框可用的时候, 如果有字符就让OK键可以用, 否则OK键无法使用
    if (textUser.getText().length() > 0) {
        textPass.setColleagueEnabled(true);
        if (textPass.getText().length() >=4  && textUser.getText().length()>=4) {
            buttonOk.setColleagueEnabled(true);
        } else {
            buttonOk.setColleagueEnabled(false);

        }
    }
}

练习16-2 无法在接口中定义, 因为接口中如果定义域, 只能定义静态域.