? 中介者模式通过引入一个中介者对象来封装一组对象之间的交互，从而可以使这些对象不需要直接相互引用，也就是将系统内多个对象之间的复杂关系转化为多个对象与中介者之间的简单关系。
? 在生活中，可以看到不少网红在直播卖货，也可以看出中介者模式。在主播卖货的过程中，由于设计到多个对象，比如商品、观众、平台等，每个对象都有自己的任务和职责，但是它们之间需要相互协调和交互才能顺利完成卖货的过程。其中主播可以充当中介者的角色，负责协调和调度各个对象的交互。
package com.technologystatck.designpattern.mode.tertiumquid;
import java.util.ArrayList;
import java.util.List;
public class TertiumQuid {
public static void main(String[] args) {
//创建中介者
ConcreteMediator mediator = new ConcreteMediator();
//创建同事对象
Colleague colleague1 = new ConcreteColleague1(mediator);
Colleague colleague2 = new ConcreteColleague2(mediator);
//注册同事对象到中介者
mediator.register(colleague1);
mediator.register(colleague2);
//同事对象发送消息
colleague1.send("Hello, colleague2!");
colleague2.send("Hello, colleague1!");
}
}
//抽象中介者
abstract class Mediator {
void register(Colleague colleague){};
//定义一个抽象的发送消息方法
public abstract void send(String message, Colleague colleague);
}
//具体中介者
class ConcreteMediator extends Mediator{
private List<Colleague> colleagues = new ArrayList<>();
@Override
public void register(Colleague colleague) {
colleagues.add(colleague);
}
@Override
public void send(String message,Colleague colleague) {
for (Colleague c : colleagues) {
//排除发送消息的同事对象
if(c!=colleague){
c.receive(message);
}
}
}
}
//抽象同事对象
abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator=mediator;
}
//发送消息
public abstract void send(String message);
//接收消息
public abstract void receive(String message);
}
//具体同事对象1
class ConcreteColleague1 extends Colleague{
public ConcreteColleague1(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.send(message,this);
}
@Override
public void receive(String message) {
System.out.println("ConcreteColleague1 received: "+message);
}
}
//具体同事对象2
class ConcreteColleague2 extends Colleague{
public ConcreteColleague2(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.send(message,this);
}
@Override
public void receive(String message) {
System.out.println("ConcreteColleague1 received: "+message);
}
}
小明正在设计一个简单的多人聊天室系统，有多个用户和一个聊天室中介者，用户通过中介者进行聊天，请你帮他完成这个系统的设计。
第一行包括一个整数N,表示用户的数量（1 <= N <= 100) 第二行是N个用户，比如User1 User2 User3，用空格分隔 第三行开始，每行包含两个字符串，表示消息的发出者和消息内容，用空格分隔
对于每个用户，输出一行，包含该用户收到的所有消息内容。
package com.technologystatck.designpattern.mode.tertiumquid;
import java.util.*;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int nums=scanner.nextInt();
//获取用户名列表，用于创建用户对象。
ArrayList<String> userNames = new ArrayList<>();
for(int i=0;i<nums;i++){
userNames.add(scanner.next());
}
ChatRoomMediator mediator = new ChatRoomMediatorImpl();
//批量创建用户
for (String userName : userNames) {
new ConcreteChatUser(userName,mediator);
}
//发送消息并输出
while(scanner.hasNext()){
String sender = scanner.next();
String message = scanner.next();
//获取发送者信息
//获取信息具体内容
ChatUser user = mediator.getUsers().get(sender);
//若用户不为空，则输出信息，否则输出用户不存在。
if(user!=null){
user.sendMessage(message);
}
}
}
}
//抽象中介者
interface ChatRoomMediator {
//发送消息方法
void sendMessage(String sender,String message);
//添加用户方法
void addUser(ChatUser user);
//获取用户列表方法，用于输出消息时输出用户列表信息
Map<String,ChatUser> getUsers();
}
//具体中介者
class ChatRoomMediatorImpl implements ChatRoomMediator{
//用户列表，用于存储所有用户对象，以便后续发送消息时，
//遍历所有用户对象，并发送消息给所有用户对象。
private Map<String,ChatUser> users=new LinkedHashMap<>();
@Override
public void sendMessage(String sender, String message) {
//遍历所有用户对象，并发送消息给所有用户对象。
for(ChatUser user:users.values()){
if(!user.getName().equals(sender)){
user.receiveMessage(sender,message);
}
}
}
@Override
public void addUser(ChatUser user) {
users.put(user.getName(),user);
}
@Override
public Map<String, ChatUser> getUsers() {
return users;
}
}
//抽象同事类
abstract class ChatUser{
private String name;
private ChatRoomMediator mediator;
private List<String> receivedMessages=new ArrayList<>();
public ChatUser(String name, ChatRoomMediator mediator) {
this.name = name;
this.mediator = mediator;
mediator.addUser(this);
}
public String getName() {
return name;
}
//发送消息的方法，由子类实现，实现不同的发送方式
public void sendMessage(String message){
mediator.sendMessage(name,message);
}
//接受到消息的方法，由子类实现，实现不同的接受方式
public abstract void receiveMessage(String sender,String message);
//获取接受者的消息
public List<String> getReceivedMessages() {
return receivedMessages;
}
//添加接受者的消息
protected void addReceivedMessage(String message){
receivedMessages.add(message);
}
}
//具体同事类
class ConcreteChatUser extends ChatUser{
public ConcreteChatUser(String name, ChatRoomMediator mediator) {
super(name, mediator);
}
//接受到消息的方法，实现不同的接受方式
@Override
public void receiveMessage(String sender, String message) {
String receivedMessage=getName()+" received: "+message;
addReceivedMessage(receivedMessage);
System.out.println(receivedMessage);
}
}