中介者模式主要是用来降低多个类之间的通信复杂度,它通过一个中介者类来处理多个类之间的通信,从而降低类与类之间的耦合度,使代码易于维护。中介者模式是行为型模式的一种。
中介者模式简单来说就是介入类与类之间,由原来的类与类相互引用变为所有类引用中介者,从而让类与类相互解耦。在Spring中Bean与Bean相互引用会存在循环依赖的问题,而使用中介者模式就可以解决这个问题。中介者模式结构图示如下:
先用简单的例子简单的表述一下中介者模式,以聊天室为例,用户加入聊天室,某个用户发送了一条消息,其他所有用户则会接收这条消息。
模型分析:这里聊天室就是中介者,用户发送消息到聊天室,所以用户需要依赖中介者对象
先创建中介者接口,它具有某个用户发送消息的功能和用户加入聊天室的功能
public interface Mediator {
void sendMessage(String uid, String message);
void addUser(User... user);
}
再创建聊天室(中介者的实现类)和用户实体,用户实体需要依赖聊天室对象并具有发送消息和接收消息的功能
public class ChatRoom implements Mediator{
private List<User> users = new ArrayList<>();
@Override
public void sendMessage(String uid, String message) {
//聊天室中,uid发送了消息,那么其他人则接收消息
users.stream()
.filter(user -> !user.getUid().equals(uid))
.forEach(user -> user.receive(message));
}
@Override
public void addUser(User... user) {
users.addAll(Arrays.asList(user));
}
}
@Data
public class User {
private String uid;
private String name;
private Mediator mediator;
public User(String uid, String name, Mediator mediator) {
this.uid = uid;
this.name = name;
this.mediator = mediator;
}
public void send(String message) {
System.out.println(name + "发送消息:" + message);
mediator.sendMessage(uid, message);
}
public void receive(String message){
System.out.println(name + "接收消息:" + message);
}
}
编写测试代码
public static void main(String[] args) {
//创建聊天室(中介者)
ChatRoom chatRoom = new ChatRoom();
//创建用户,用依赖中介者
User user1 = new User("1", "张三", chatRoom);
User user2 = new User("2", "李四", chatRoom);
User user3 = new User("3", "王五", chatRoom);
//用户加入聊天室
chatRoom.addUser(user1, user2, user3);
user1.send("我是张三,你们好");
System.out.println("---------------");
user2.send("我叫李四");
System.out.println("---------------");
user3.send("我是王五");
}
以实际开发中实践例子,我们在做游戏中的天梯系统时,就用到了中介者模式。
我们使用SpringBoot开发天梯系统,天梯系统包含赛季信息,用户段位,排行榜等模块,模块之间存在相互调用,最原始的代码是这样的,创建了三个Service:
//天梯赛季信息模块,提供查询赛季信息的方法
@Service
public class LadderSeasonService {
@Resource
private LadderRankService ladderRankService;
/**
* 查询当前天梯赛季id
*/
public SeasonVO queryCurrentSeason(){
SeasonVO seasonVO = new SeasonVO();
seasonVO.setSeasonId(1L);
seasonVO.setSeasonUserCount(ladderRankService.queryRankCount());
return seasonVO;
}
}
//天梯用户段位模块,提供单个/批量查询用户段位的方法
@Service
public class LadderLevelService {
@Resource
private LadderSeasonService ladderSeasonService;
@Resource
private LadderRankService ladderRankService;
public UserLevelVO queryUserLevel(String uid){
SeasonVO seasonVO = ladderSeasonService.queryCurrentSeason();
UserLevelVO levelVO = new UserLevelVO();
levelVO.setUid(uid);
levelVO.setSeasonId(seasonVO.getSeasonId());
levelVO.setLevel(1);
levelVO.setLevelName("一等兵");
levelVO.setRank(ladderRankService.queryUserRank(uid));
return levelVO;
}
public List<UserLevelVO> queryUserLevel(List<String> uids){
SeasonVO seasonVO = ladderSeasonService.queryCurrentSeason();
int i = uids.size();
List<UserLevelVO> list = new ArrayList<>();
for(String uid : uids){
UserLevelVO levelVO = new UserLevelVO();
levelVO.setUid(uid);
levelVO.setSeasonId(seasonVO.getSeasonId());
levelVO.setLevel(1 + i);
levelVO.setLevelName(i + "等兵");
list.add(levelVO);
i--;
}
return list;
}
}
//天梯排行榜模块,提供查询全站排名和单个用户排名的方法
@Service
public class LadderRankService {
//模拟数据库查询用户排名
private static final List<String> DB_LIST = new ArrayList<>();
static {
DB_LIST.add("10000");
DB_LIST.add("10001");
DB_LIST.add("10002");
DB_LIST.add("10003");
DB_LIST.add("10004");
}
@Resource
private LadderLevelService ladderLevelService;
@Resource
private LadderSeasonService ladderSeasonService;
public List<UserLevelVO> queryRank() {
SeasonVO seasonVO = ladderSeasonService.queryCurrentSeason();
//模拟查询用户排名
List<String> uids = queryUidsByRank();
List<UserLevelVO> list = ladderLevelService.queryUserLevel(uids);
return list;
}
public Integer queryUserRank(String uid){
return DB_LIST.indexOf(uid) + 1;
}
public Integer queryRankCount(){
return DB_LIST.size();
}
private List<String> queryUidsByRank(){
return DB_LIST;
}
}
这里我们看到,查询用户段位时又调用了赛季的查询赛季信息方法和排行榜的查询用户排名的方法,查询排行榜时又调用了段位模块批量查询用户段位的方法。即使只有三个模块,模块与模块之间混乱调用,不仅导致spring的循环依赖,还会让代码非常难以维护,虽然我们强调需要在规范上防止这种混乱发生,但那毕竟不是最佳实践。
我们用中介者模式改造上面的代码,新增一个中介类ILadderMediator,它装载天梯的所有子模块,在某个模块开发时需要用到其他模块,直接引用这个中介者即可。
首先声明所有子模块的枚举和所有子模块的公共接口
@Getter
public enum LadderModuleEnum {
SEASON,
LEVEL,
RANK,
}
public interface ILadderModule {
LadderModuleEnum getModule();
}
其次先新建所有子模块的Service的接口层,让Service实现自己的接口
//赛季子模块接口
public interface IILadderSeasonService extends ILadderModule {
SeasonVO queryCurrentSeason();
}
//用户段位子模块接口
public interface ILadderLevelService extends ILadderModule{
UserLevelVO queryUserLevel(String uid);
List<UserLevelVO> queryUserLevel(List<String> uids);
}
//排行榜子模块接口
public interface ILadderRankService extends ILadderModule{
List<UserLevelVO> queryRank();
Integer queryUserRank(String uid);
Integer queryRankCount();
}
再创建中介者接口和实现类,提供访问子模块的方法
//中介者接口,提供子模块访问入口
public interface ILadderMediator {
Map<LadderModuleEnum, ILadderModule> moduleMap = new ConcurrentHashMap<>(8);
//获取赛季子模块
default IILadderSeasonService getSeasonModule() {
return getModule(LadderModuleEnum.SEASON);
}
//获取段位子模块
default ILadderLevelService getLevelModule() {
return getModule(LadderModuleEnum.LEVEL);
}
//获取排名子模块
default ILadderRankService getRankModule() {
return getModule(LadderModuleEnum.RANK);
}
default <T extends ILadderModule> T getModule(LadderModuleEnum module) {
return (T) moduleMap.get(module);
}
}
//中介者实现类,获取所有子模块装在到moduleMap
@Component
public class LadderMediator implements ILadderMediator {
@Resource
private Set<ILadderModule> moduleSet;
@PostConstruct
private void init() {
moduleSet.forEach(module -> {
moduleMap.put(module.getModule(), module);
});
}
}
最后就是改造Service层的引用逻辑
//天梯赛季信息模块,提供查询赛季信息的方法
@Service
public class LadderSeasonService implements IILadderSeasonService {
@Resource
private ILadderMediator ladderMediator;
@Override
public LadderModuleEnum getModule() {
return LadderModuleEnum.SEASON;
}
/**
* 查询当前天梯赛季id
*/
public SeasonVO queryCurrentSeason(){
SeasonVO seasonVO = new SeasonVO();
seasonVO.setSeasonId(1L);
seasonVO.setSeasonUserCount(ladderMediator.getRankModule().queryRankCount());
return seasonVO;
}
}
//天梯用户段位模块,提供单个/批量查询用户段位的方法
@Service
public class LadderLevelService implements ILadderLevelService{
@Resource
private ILadderMediator ladderMediator;
@Override
public LadderModuleEnum getModule() {
return LadderModuleEnum.LEVEL;
}
public UserLevelVO queryUserLevel(String uid){
SeasonVO seasonVO = ladderMediator.getSeasonModule().queryCurrentSeason();
UserLevelVO levelVO = new UserLevelVO();
levelVO.setUid(uid);
levelVO.setSeasonId(seasonVO.getSeasonId());
levelVO.setLevel(1);
levelVO.setLevelName("一等兵");
levelVO.setRank(ladderMediator.getRankModule().queryUserRank(uid));
return levelVO;
}
public List<UserLevelVO> queryUserLevel(List<String> uids){
SeasonVO seasonVO = ladderMediator.getSeasonModule().queryCurrentSeason();
int i = uids.size();
List<UserLevelVO> list = new ArrayList<>();
for(String uid : uids){
UserLevelVO levelVO = new UserLevelVO();
levelVO.setUid(uid);
levelVO.setSeasonId(seasonVO.getSeasonId());
levelVO.setLevel(1 + i);
levelVO.setLevelName(i + "等兵");
list.add(levelVO);
i--;
}
return list;
}
}
//天梯排行榜模块,提供查询全站排名和单个用户排名的方法
@Service
public class LadderRankService implements ILadderRankService {
//模拟数据库查询用户排名
private static final List<String> DB_LIST = new ArrayList<>();
static {
DB_LIST.add("10000");
DB_LIST.add("10001");
DB_LIST.add("10002");
DB_LIST.add("10003");
DB_LIST.add("10004");
}
@Resource
private ILadderMediator ladderMediator;
@Override
public LadderModuleEnum getModule() {
return LadderModuleEnum.RANK;
}
public List<UserLevelVO> queryRank() {
SeasonVO seasonVO = ladderMediator.getSeasonModule().queryCurrentSeason();
//模拟查询用户排名
List<String> uids = queryUidsByRank();
List<UserLevelVO> list = ladderMediator.getLevelModule().queryUserLevel(uids);
return list;
}
public Integer queryUserRank(String uid){
return DB_LIST.indexOf(uid) + 1;
}
public Integer queryRankCount(){
return DB_LIST.size();
}
private List<String> queryUidsByRank(){
return DB_LIST;
}
}
这样,所有的子模块调用其他子模块,都是注入中介者ILadderMediator 来获取其他子模块的实例对象,未来扩展更多子模块,只需要扩展ILadderMediator 的获取子模块的方法即可,实现了业务模块之间的完全解耦。
中介者模式满足开闭原则和最少知道原则,类与类的解耦可以使我们非常方便的添加扩展别的类功能。中介者思想在生活中、编程中我们会经常遇到,学会用中介者思想解决我们的实际问题是一个非常好的方法。