1.定义
中介模式:用一个中介对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使其耦合松散,而且可以独立地改变它们之间的交互。
中介模式中一个重要的角色就是中介者,它处于多个对象之间,处理对象之间多对多的关系。中介者就像我们日常生活的房产中介,负责处理房子买家和卖家的联系。
2.案例
在下面的案例中,有一下三种角色:
● Mediator 抽象中介者角色
抽象中介者角色定义统一的接口,用于各同事角色之间的通信。
● Concrete Mediator 具体中介者角色
具体中介者角色通过协调各同事角色实现协作行为,因此它必须依赖于各个同事角色。
● Colleague 同事角色
每一个同事角色都知道中介者角色,而且与其他的同事角色通信的时候,一定要通过中介者角色协作。
/**
* 抽象同事类
*/
public abstract class AbstractColleague {
protected AbstractMediator mediator;
public AbstractColleague(AbstractMediator mediator) {
this.mediator = mediator;
}
}
/**
* 购买者
*/
public class Purchaser extends AbstractColleague {
public Purchaser(AbstractMediator mediator) {
super(mediator);
}
//买电脑
public void buyComputer(int number) {
mediator.execute("Purchaser.buy", number);
}
//拒绝买电脑
public void refuseBuy() {
System.out.println("拒绝买电脑...");
}
}
/**
* 销售员
*/
public class SaleClerk extends AbstractColleague {
public SaleClerk(AbstractMediator mediator) {
super(mediator);
}
//卖电脑
public void sellComputer(int number) {
mediator.execute("SaleClerk.sell", number);
}
//打折出售
public void offSale() {
mediator.execute("SaleClerk.offSell");
}
//获取销售情况
public int getSaleStatus() {
Random rand = new Random(System.currentTimeMillis());
int saleStatus = rand.nextInt(100);
return saleStatus;
}
}
/**
* 库存员
*/
public class StockClerk extends AbstractColleague {
public StockClerk(AbstractMediator mediator) {
super(mediator);
}
//设置电脑总数量为100
private static int COMPUTER_NUMBER = 100;
//增加库存
public void increase(int number) {
COMPUTER_NUMBER += number;
}
//减少库存
public void decrease(int number) {
COMPUTER_NUMBER -= number;
}
//获取库存数量
public int getStockNumber() {
return COMPUTER_NUMBER;
}
//清库存
public void clearStock() {
mediator.execute("StockClerk.clear");
}
}
/**
* 抽象中介者类
*/
public abstract class AbstractMediator {
//购买者
protected Purchaser purchaser;
//销售员
protected SaleClerk saleClerk;
//库存员
protected StockClerk stockClerk;
//构造函数
public AbstractMediator() {
purchaser = new Purchaser(this);
saleClerk = new SaleClerk(this);
stockClerk = new StockClerk(this);
}
//中介者的执行方法
public abstract void execute(String str, Object... objects);
}
//具体的中介者
public class Mediator extends AbstractMediator {
@Override
public void execute(String str, Object... objects) {
if ("Purchaser.buy".equalsIgnoreCase(str)) { //买电脑
buyComputer((Integer) objects[0]);
} else if ("SaleClerk.sell".equalsIgnoreCase(str)) { //卖电脑
sellComputer((Integer) objects[0]);
} else if ("SaleClerk.offSell".equalsIgnoreCase(str)) { //打折出售
offSell();
} else if ("StockClerk.clear".equalsIgnoreCase(str)) { //清库存
clearStock();
}
}
//买电脑
private void buyComputer(int number) {
int saleStatus = saleClerk.getSaleStatus();
if(saleStatus>80){ //销售情况良好
System.out.println("采购电脑:" + number + "台");
stockClerk.increase(number);
}else{ //销售情况不好
int buyNumber = number/2; //折半采购
System.out.println("采购电脑:"+ buyNumber + "台");
}
}
//卖电脑
private void sellComputer(int number) {
if(stockClerk.getStockNumber() < number){ //库存数量不够销售
purchaser.buyComputer(number);
}
stockClerk.decrease(number);
System.out.println("卖电脑:"+ number + "台");
}
//打折出售
private void offSell() {
System.out.println("折价销售电脑: "+ stockClerk.getStockNumber() + "台");
}
//清库存
private void clearStock() {
//要求清仓销售
saleClerk.offSale();
//要求采购人员不要采购
purchaser.refuseBuy();
}
}
public class MediatorPatternDemo {
public static void main(String[] args) {
AbstractMediator mediator = new Mediator();
//采购人员采购电脑
System.out.println("------采购人员采购电脑--------");
Purchaser purchaser = new Purchaser(mediator);
purchaser.buyComputer(100);
//销售人员销售电脑
System.out.println("\n------销售人员销售电脑--------");
SaleClerk saleClerk = new SaleClerk(mediator);
saleClerk.sellComputer(1);
//库房管理人员管理库存
System.out.println("\n------库房管理人员清库处理--------");
StockClerk stockClerk = new StockClerk(mediator);
stockClerk.clearStock();
}
}
其中,购买者Purchaser、售货员SaleClerk和库存员StockClerk通过中介者Mediator来交互,而交互的工作由中介者来处理,购买者、售货员和库存员不需要知道其具体过程,这就达到解耦的目的。