在深圳租房市场,有着许多的“二房东”,房主委托他们将房子租出去,而租客想要租房的话,也是和“二房东”沟通,租房期间有任何问题,找二房东解决。对于房主来说,委托给“二房东”可太省事了,只要签个委托协议,然后坐等收钱就可以了,可以不要跟租客打交道。 而对于租客来说,租房期间的任何问题,找“二房东”解决也比较方便。 当然付出的代价就是“中间商赚差价”了。这就是中介者模式。
1 中介者模式概述
如果一个系统中对象之间的联系呈现为网状结构,对象之间存在大量的多对多联系,将导致系统非常复杂。它们之间通过彼此相互作用实现系统的行为。这将导致系统过度耦合。
图 对象之间存在复杂关系的网状结构
通过引人中介者对象,可以将系统的网状结构变成以中介者为中心的星形结构。在这个星形结构中,同事对象不再之间与另一个对象联系,它通过中介者对象与另一个对象发生相互作用。
图 引入中介者对象的星形结构
中介者模式可以使对象之间的关系数量急剧减少。保证了对象结构上的稳定,系统的结构不会因为新对象的引入带来大量的修改工作。
1.1 模式定义
如果在一个系统中对象之间存在多对多的相互关系,可以将对象之间的一些交互行为从各个对象中分离出来,并集中封装在一个中介者对象中,由该中介者进行统一协调。
这样对象之间多对多的复杂关系就转化为相对简单的一对多关系。中介者模式是迪米特法则的一个典型应用。
图 中介者模式结构图
Mediator:抽象中介者,定义一个接口,用于与各同事对象之间进行通信。
ConcreteMediator: 具体中介者,通过协调各个同事对象来实现协作行为,维持了对各个同事对象的引用。
Colleague:抽象同事类,定义各个同事类公有的方法,并声明了一些抽象方法供子类实现,同时维持了一个对抽象中介者类的引用。
ConcreteColleague:具体同事类,当每个同事对象在需要和其他同事对象通信时,先于中介者通信,通过中介者来间接完成与其他同事类的通信。
public abstract class Colleague {protected final String name;protected Mediator mediator;public Colleague(String name,Mediator mediator) {this.name = name;this.mediator = mediator;}/*** 租房*/public abstract void renting(String position, double price, double area);}public class Landlord extends Colleague{public Landlord(String name, Mediator mediator) {super(name, mediator);}// 发布房源信息@Overridepublic void renting(String position, double price, double area) {mediator.publish(this,position,price,area);}@Overridepublic String toString() {return "房东:" + name;}
}public class Tenant extends Colleague{public Tenant(String name, Mediator mediator) {super(name, mediator);}// 求租@Overridepublic void renting(String position, double price, double area) {mediator.renting(this,position,price,area);}@Overridepublic String toString() {return "租客:" + name;}
}public interface Mediator {/*** 租房** @param position* 位置* @param price* 价格* @param area* 面积*/void renting(Tenant tenant,String position, double price, double area);/*** 发布房源信息**/void publish(Landlord landlord,String position, double price, double area);}public class ConcreteMediator implements Mediator{/*** 房东集合*/private final Set<Landlord> landlords = new HashSet<>();/*** 租户集合*/private final Set<Tenant> tenants = new HashSet<>();/*** 房源信息集合*/private final List<RoomInfo> roomInfos = new ArrayList<>();@Overridepublic void renting(Tenant tenant, String position, double price, double area) {System.out.print("【" + position + ",价格:" + price + "以下,面积" + area + "】");tenants.add(tenant);for (RoomInfo item : roomInfos) {if (item.getTenant() == null) {if (item.getPosition().equals(position) && item.getPrice() <= price && item.getArea() >= area) {item.setTenant(tenant);System.out.println("租房成功:" + item);return;}}}System.out.println("没有找到合适的房源");// 运行结果:
// 【罗湖区,价格:1800.0以下,面积25.0】没有找到合适的房源
// 【福田区,价格:3000.0以下,面积25.0】租房成功:RoomInfo(price=28.0, area=2800.0, position=福田区, tenant=租客:李四, landlord=房东:老张)}@Overridepublic void publish(Landlord landlord, String position, double price, double area) {landlords.add(landlord);RoomInfo roomInfo = new RoomInfo();roomInfo.setLandlord(landlord);roomInfo.setPosition(position);roomInfo.setPrice(price);roomInfo.setArea(area);roomInfos.add(roomInfo);}}@Data
public class RoomInfo {private double price;private double area;private String position;private Tenant tenant;private Landlord landlord;}public class Client {public static void main(String[] args) {Mediator mediator = new ConcreteMediator();Landlord landlord1 = new Landlord("老张",mediator);landlord1.renting("福田区",28,2800);landlord1.renting("福田区",20,2200);landlord1.renting("福田区", 7, 1500);Landlord landlord2 = new Landlord("老黄", mediator);landlord2.renting("龙岗区", 3400,70);landlord2.renting("龙岗区", 2800,50);Tenant tenant1 = new Tenant("张三",mediator);tenant1.renting("罗湖区", 1800, 25);Tenant tenant2 = new Tenant("李四",mediator);tenant2.renting("福田区", 3000, 25);}}
1.2 中介者类的作用
1)中转作用(结构性)。通过中介者提供的中转作用,各个同事对象就不再需要显式地引用其他同事。当需要和其他同事进行通信时,可通过中介者来实现间接调用。
2)协调作用(行为性)。中介者可进一步对同事之间的关系进行封装,同事可以一致地和中介者进行交互,而不需要指明中介者需要具体怎么做。中介者根据封装在自身内部的协调逻辑,对同事的请求进行进一步处理。将同事成员之间的关系行为进行分离和封装。
2 优缺点
优点:
- 简化对象间交互;
- 将各同事对象解耦,可以独立改变和复用每一个同事和中介者,增加新的中介者和同事类比较方便。
缺点:
- 中介者类包含大量同事之间的交互细节,会使得具体中介者类非常复杂。
3 适用场景
- 对象之间存在复杂的引用关系,系统结构混乱且难以理解。
- 想通过一个中间类来封装多个类中的行为,而又不想生成太多的子类。