1、概述
中介者模式是一种行为设计模式， 能让你减少对象之间混乱无序的依赖关系。 该模式会限制对象之间的直接交互， 迫使它们通过一个中介者对象进行合作。
2、适用场景
1）当一些对象和其他对象紧密耦合以致难以对其进行修改时， 可使用中介者模式。
2）当组件因过于依赖其他组件而无法在不同应用中复用时， 可使用中介者模式。
3）如果为了能在不同情景下复用一些基本行为， 导致你需要被迫创建大量组件子类时， 可使用中介者模式。
3、实例
有以下场景：
有一个商城系统，内部又很多个功能：
订单功能，支付功能，商品功能，购物车功能，库存功能。
假设功能依赖关系如下。
订单需要关联支付、商品、库存。
支付需要关联订单、商品。
商品需要关联库存。
购物车需要关联商品、订单、库存。
使用中介者优化。
创建商品抽象接口：
/**
* shop抽象接口
* @date: 2021/1/13
* @author weirx
* @version 3.0
*/
public interface IShop {
}
创建商城的五个组件：
/**
* 商品
* @date: 2021/1/13
* @author weirx
* @version 3.0
*/
public class Goods implements IShop {
public void getGoods() {
System.out.println("查询商品信息");
}
}
/**
* 支付
* @date: 2021/1/13
* @author weirx
* @version 3.0
*/
public class Pay implements IShop {
public void pay() {
System.out.println("支付成功");
}
}
/**
* 库存
* @date: 2021/1/13
* @author weirx
* @version 3.0
*/
public class Inventory implements IShop {
public void getInventory() {
System.out.println("查询库存信息成功");
}
}
/**
* 订单
* @date: 2021/1/13
* @author weirx
* @version 3.0
*/
public class Order implements IShop {
public void order(){
System.out.println("下单成功");
}
}
/**
* 购物车
* @date: 2021/1/13
* @author weirx
* @version 3.0
*/
public class ShoppingCar implements IShop {
public void addShoppingCar() {
System.out.println("添加购物城成功");
}
}
中介者抽象接口：
/**
* 中介者
* @date: 2021/1/13
* @author weirx
* @version 3.0
*/
public interface Mediator {
/**
* 下单
*/
void order();
/**
* 查询商品
*/
void getGoods();
/**
* 查询库存
*/
void getInventory();
/**
* 支付
*/
void pay();
/**
* 添加购物车
*/
void addShoppingCar();
}
具体的中介者类：
/**
* 具体商品中介者
* @date: 2021/1/13
* @author weirx
* @version 3.0
*/
public class ShopMediator implements Mediator {
private Order order;
private Goods goods;
private Inventory inventory;
private Pay pay;
private ShoppingCar shoppingCar;
@Override
public void order() {
order.order();
}
@Override
public void getGoods() {
goods.getGoods();
}
@Override
public void getInventory() {
inventory.getInventory();
}
@Override
public void pay() {
pay.pay();
}
@Override
public void addShoppingCar() {
shoppingCar.addShoppingCar();
}
public void register(IShop shop){
if (shop.getClass().getName() == Order.class.getName()){
order = new Order();
}
if (shop.getClass().getName() == Pay.class.getName()){
pay = new Pay();
}
if (shop.getClass().getName() == Goods.class.getName()){
goods = new Goods();
}
if (shop.getClass().getName() == Inventory.class.getName()){
inventory = new Inventory();
}
if (shop.getClass().getName() == ShoppingCar.class.getName()){
shoppingCar = new ShoppingCar();
}
}
}
测试类：
/**
* 测试类
* @date: 2021/1/13
* @author weirx
* @version 3.0
*/
public class TestDemo {
public static void main(String[] args) {
//创建一个商城中介者
ShopMediator shopMediator = new ShopMediator();
//注册商城内的元素
shopMediator.register(new Goods());
shopMediator.register(new ShoppingCar());
shopMediator.register(new Order());
shopMediator.register(new Pay());
shopMediator.register(new Inventory());
//调用方法
shopMediator.getGoods();
shopMediator.getInventory();
shopMediator.addShoppingCar();
shopMediator.order();
shopMediator.pay();
}
}
结果：
查询商品信息
查询库存信息成功
添加购物城成功
下单成功
支付成功
4、分析
在没有使用中介者的情况下，各功能的调用情况如下所示：
未使用.png
使用中介者后，如下所示：
中介者.png
中介者的关系图：
image.png
综上能看到，使用中介者模式，确实能使各组件间达到解耦的目的，但是过度的使用会导致中介者过大。
5、总结
优点：
1）单一原则。
2）开闭原则。
3）降低组件间的耦合。
缺点：
过度使用会导致中介者称为上帝对象。
