设计模式—中介者模式

定义

用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立的改变它们直接的交互

代码

中介抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public abstract class Mediator {

    private Purchase purchase;
    private Stock stock;

    public Purchase getPurchase() {
        return purchase;
    }

    public void setPurchase(Purchase purchase) {
        this.purchase = purchase;
    }

    public Stock getStock() {
        return stock;
    }

    public void setStock(Stock stock) {
        this.stock = stock;
    }

    public abstract void salePhone(int number);
    public abstract void purchasePhone(int number);


}

中介处理业务类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class ConcreteMediator extends Mediator {

    @Override
    public void salePhone(int number) {
        if(super.getStock().getStockNumber()<number){
            System.out.println("手机数量不够，需要采购");
            super.getPurchase().purchasePhone(number);
        }else{
            System.out.println("卖了"+number+"件手机");
            super.getStock().decreaseStock(number);
        }
    }

    @Override
    public void purchasePhone(int number) {
        super.getStock().addStock(number);
    }
}

抽象的注入中介依赖类

1
2
3
4
5
6
7
public abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
}

相关的业务类

1
2
3
4
5
6
7
8
9
10
11
public class Sale extends Colleague {

    public Sale(Mediator mediator) {
        super(mediator);
    }

    public void salePhone(int number) {
        super.mediator.salePhone(number);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
public class Purchase extends Colleague{

    public Purchase(Mediator mediator) {
        super(mediator);
    }

    public void purchasePhone(int number){
        System.out.println("采购了"+number+"件手机");
        super.mediator.purchasePhone(number);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Stock extends Colleague{

    public Stock(Mediator mediator) {
        super(mediator);
    }

    private static Integer number = 100;

    public int getStockNumber(){
        return number;
    }

    public void decreaseStock(int num){
        number = number - num;
    }

    public void addStock(int num){
        number = number + num;
    }

}

测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MediatorTest {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        Stock stock = new Stock(mediator);
        Purchase purchase = new Purchase(mediator);
        mediator.setPurchase(purchase);
        mediator.setStock(stock);

        Sale sale = new Sale(mediator);
        purchase.purchasePhone(90);
        sale.salePhone(180);
    }
}

中介者模式主要是解决几个对象相互依赖的耦合太紧的问题，主要应用在N个对象之间有依赖关系。