月度归档：2018年04月

设计模式之工厂家族

发表于由
回复

《冒号课堂编程范式与OOP思想》 13.1 创建模式笔记

工厂家族

构造器的弊端：名字必须与类名一致，缺乏表现力；每次调用都会创建新对象；无法多态，new 必须使用具体类型，没法使用抽象的超类型。

抽象工厂模式：
1. 把静态工厂拆分成了一个接口和若干个实现类；
2. 把工厂方法模式中的主题类中的抽象工厂方法提炼为一个接口，用对象合成取代了类继承。

代码说明示例

1. 静态工厂模式：

public class StaticFactory {
    public enum Type {
        AWT, SWING
    };

    public static Container createFrame(Type type, String title) {
        switch (type) {
            case AWT:
                return new Frame(title);
            case SWING:
                return new JFrame(title);
            default:
                return null;
        }
    }

    public static Component createLabel(Type type, String text) {
        switch (type) {
            case AWT:
                return new Label(text);
            case SWING:
                return new JLabel(text);
            default:
                return null;
        }
    }
}

// 使用静态公共方法的类
class LoginForm {
    public Container createLoginWindow() {
        // 使用前要指定具体的类型
        StaticFactory.Type type = StaticFactory.Type.AWT;
        Container frame = StaticFactory.createFrame(type, "标题");
        Component label = StaticFactory.createLabel(type, "文本");
        // 组装组件
        return null;
    }
}

每个创建对象的方法都通过参数来指定要创建的具体对象类型，调用方必须指定具体的类型。

继续阅读 →

RxJava 线程模型

发表于由
回复

本文基于 RxJava 2.1.2 。根据代码和输出日志会更容易理解。

RxJava 的线程模型如下：

1. 不指定线程的情况

  • 不指定线程也就是不使用 observeOn 和 subscribeOn，所有操作在调用 subscribe 的线程执行。
@Test
public void noThread() {
    buildObservable().subscribe();
}

上面代码的输出为：

Thread[main]   execute   Action start emmit
Thread[main]   execute   Operation-1, event: 1
Thread[main]   execute   Operation-2, event: 1

2. subscribeOn

  • subscribeOn 不管调用多少次，只以第一次为准。如果只使用了 subscribeOn、没有使用 observeOn，则所有操作在第一次调用生成的线程里执行。
@Test
public void subscribeOn() throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(1);

    Observable<Integer> observable = buildObservable();
    observable
        .subscribeOn(scheduler("subscribeOn-1"))
        .subscribeOn(scheduler("subscribeOn-2"))
        .subscribe(i -> {
            showMessageWithThreadName("Action subscribe");
            latch.countDown();
        });

    latch.await();
}

上面代码的输出为：

create scheduler subscribeOn-2
create scheduler subscribeOn-1
Thread[subscribeOn-1]   execute   Action start emmit
Thread[subscribeOn-1]   execute   Operation-1, event: 1
Thread[subscribeOn-1]   execute   Operation-2, event: 1
Thread[subscribeOn-1]   execute   Action subscribe

3. observeOn

  • observeOn 必须跟 subscribeOn 一起使用，单独使用会抛出空引用异常。
  • observeOn 应在 subscribeOn 的后面调用，否则会出现死锁的情况。
  • observeOn 操作会更改后续操作的执行线程，直至下一个 observeOn 调用之前的操作或 subscribe 操作。

继续阅读 →