Spring 版MediatR--中介者模式实现库

背景

C# 版本库 MediatR 是一个中介者模式实现类库,其核心是一个中介 者模式的.NET实现,其目的是消息发送和消息处理的解耦。它支持单播和多播形式使用同步或异步的模式来发布消息,创建和帧听事件。
java中没有找到类似类库,在对MediatR源码阅读中,发现其主要思路是借助IOC获取Request与Handler对应关系并进行处理。

中介者模式

中介者模式:用一个中介对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使耦合松散,而且可以独立地改变他们之间的交互。

image.png

使用中介模式,对象之间的交互将封装在中介对象中,对象不再直接交互(解耦),而是通过中介进行交互,这减少了对象之间的依赖性,从而减少了耦合。


image.png

应用

单播消息传输

单播消息传输,也就是一对第一的消息传递,一个消息对应一个消息处理,通过 IReust 抽象单播消息,使用 IRequestHandler 进行消息处理


@ExtendWith(SpringExtension.class)
@Import(
        value = {
                Mediator.class,
                PingPongTest.PingHandler.class,
        }
)
public class PingPongTest {

    @Autowired
    IMediator mediator;

    @Test
    public void should() {
        String send = mediator.send(new Ping());

        assertThat(send).isNotNull();
        assertThat(send).isEqualTo("Pong");
    }

    public static class Ping implements IRequest {
    }

    public static class PingHandler implements IRequestHandler {
        @Override
        public String handle(Ping request) {
            return "Pong";
        }
    }

}

多播消息传输

多播消息传输,是一对多的消息传递,一个消息对应多个消息处理,通过 INotification 抽象多播消息,使用 INotificationHanlder 进行消息处理


@ExtendWith(SpringExtension.class)
@Import(
        value = {
                Mediator.class,
                PingNoticeTests.Pong1.class,
                PingNoticeTests.Pong2.class,
        }
)
public class PingNoticeTests {

    @Autowired
    IMediator mediator;

    @Autowired
    Pong1 pong1;

    @Autowired
    Pong2 pong2;

    @Test
    public void should() {
        mediator.publish(new Ping());

        assertThat(pong1.getCode()).isEqualTo("Pon1");
        assertThat(pong2.getCode()).isEqualTo("Pon2");
    }

    public static class Ping implements INotification {
    }

    public static class Pong1 implements INotificationHandler {

        private String code;

        public String getCode() {
            return code;
        }

        @Override
        public void handle(Ping notification) {
            this.code = "Pon1";
        }
    }

    public static class Pong2 implements INotificationHandler {

        private String code;

        public String getCode() {
            return code;
        }

        @Override
        public void handle(Ping notification) {
            this.code = "Pon2";
        }
    }

}

实现

核心实现

其主要点是从Spring的ApplicationContext中获取相关接口bean,然会执行bean方法。
核心方法有两个:public(多播)和send(单播)。
借助ResolvableType类型构造解析bean信息,得到信息后从spring中获取对象实例。


/**
 * 中介者实现类
 * 

* 依赖 ApplicationContext */ @Component public class Mediator implements IMediator, ApplicationContextAware { private ApplicationContext context; /** * 发布同步 *

* 根据通知类型和INotificationHandler,从ApplicationContext获取Handler的BeanNames, * 将 BeanNames 转化为 INotificationHandler 的实例,每个实例调用一次handler * * @param notification 通知内容 * @param 通知类型 */ @Override public void publish(TNotification notification) { ResolvableType handlerType = ResolvableType.forClassWithGenerics( INotificationHandler.class, notification.getClass()); String[] beanNamesForType = this.context.getBeanNamesForType(handlerType); List> list = new ArrayList<>(); for (String beanBane : beanNamesForType) { list.add((INotificationHandler) this.context.getBean(beanBane)); } list.forEach(h -> h.handle(notification)); } /** * 发送求取 *

* 根据request类型,获取到response类型, * 根据IRequestHandler、request类型、response类型从ApplicationContext获取 * IRequestHandler实例列表,取第一个实例执行handler方法。 *

*

* 如果为找到handler实例,抛出NoRequestHandlerException异常 * * @param request 请求 * @param 响应类型 * @return 响应结果 */ @Override public TResponse send(IRequest request) { Type[] genericInterfaces = request.getClass().getGenericInterfaces(); Type responseType = null; for (Type type : genericInterfaces) { if ((type instanceof ParameterizedType)) { ParameterizedType parameterizedType = (ParameterizedType) type; if (!parameterizedType.getRawType().equals(IRequest.class)) { continue; } responseType = parameterizedType.getActualTypeArguments()[0]; break; } } if (responseType == null) { // 抛出异常 throw new NoRequestHandlerException(request.getClass()); } Class requestClass = request.getClass(); Class responseClass = (Class) responseType; ResolvableType handlerType = ResolvableType.forClassWithGenerics( IRequestHandler.class, requestClass, responseClass); String[] beanNamesForType = this.context.getBeanNamesForType(handlerType); List, TResponse>> list = new ArrayList<>(); for (String beanBane : beanNamesForType) { list.add((IRequestHandler, TResponse>) this.context.getBean(beanBane)); } if (list.isEmpty()) { throw new NoRequestHandlerException(request.getClass()); } return list.stream() .findFirst() .map(h -> h.handle(request)) .orElseThrow(() -> new NoRequestHandlerException(request.getClass())); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.context = applicationContext; } }

public interface IBaseRequest {
}
多播接口
public interface INotification {
}
单播接口
public interface IRequest extends IBaseRequest {
}
public interface IPublisher {
     void publish(TNotification notification);
}
public interface ISender {
     TResponse send(IRequest request);
}
public interface IMediator extends ISender, IPublisher {
}
多播处理接口
public interface INotificationHandler {
    void handle(TNotification notification);
}
单播处理接口
public interface IRequestHandler, TResponse> {
    TResponse handle(TRequest request);
}
public abstract class AbsRequestHandler, TResponse>
        implements IRequestHandler {
    @Override
    public abstract TResponse handle(TRequest request);
}
public abstract class AbsNotificationHandler
        implements INotificationHandler {
    @Override
    public abstract void handle(TNotification notification);
}
public class Unit implements Comparable {
    public static final Unit VALUE = new Unit();

    private Unit() {
    }

    @Override
    public boolean equals(Object obj) {
        return true;
    }

    @Override
    public int hashCode() {
        return 0;
    }

    @Override
    public String toString() {
        return "()";
    }

    @Override
    public int compareTo(@NotNull Unit o) {
        return 0;
    }
}
public interface IUnitRequest extends IRequest {
}
public class MediatorException extends RuntimeException {
}
@Getter
public class NoRequestHandlerException extends MediatorException {
    private Class requestClass;

    public NoRequestHandlerException(
            Class requestClass
    ) {
        this.requestClass = requestClass;
    }
}

应用场景

mediatr 是一种进程内消息传递机制,使用泛型支持消息的只能调度,其核心是 消息解耦 ,基于MediatR可以实现CQRS/EventBus等。

解除构造函数的依赖注入

public class DashboardController(
                ICustomerRepository customerRepository,
                IOrderService orderService,
                ICustomerHistoryRepository historyRepository,
                IOrderRepository orderRepository,
                IProductRespoitory productRespoitory,
                IRelatedProductsRepository relatedProductsRepository,
                ISupportService supportService,
                ILog logge
        ) {

        }

借助 Mediator,仅需构造注入ImediatR即可

public class DashboardController(
                IMediator
                ) {

        }

service 循环依赖,使用mediatr 进行依赖解耦,并使用mediatr进行消息传递

两个service类和接口如下


    public static interface IDemoAService {
        String hello();

        String helloWithB();
    }

    public static interface IDemoBService {
        String hello();

        String helloWithA();
    }

    public static class DemoAService implements IDemoAService {
        private final IDemoBService bService;

        public DemoAService(IDemoBService aService) {
            this.bService = aService;
        }

        @Override
        public String hello() {
            return this.bService.helloWithA();
        }

        @Override
        public String helloWithB() {
            return "call A in B";
        }
    }

    public static class DemoBService implements IDemoBService {
        private final IDemoAService aService;

        public DemoBService(IDemoAService aService) {
            this.aService = aService;
        }

        @Override
        public String hello() {
            return this.aService.helloWithB();
        }

        @Override
        public String helloWithA() {
            return "call B in A";
        }
    }

此时,如果通过构造函数或属性注入(@Autowird),程序在运行时会报一下错误, 提示检测是否包括循环引用

image.png
使用 mediatr 解耦循环依赖

使用mediatr的service如下,在service构造函数注 IMediator ,并实现 IRequestHandler 接口


    public static class DemoAService implements IDemoAService, IRequestHandler {
        //private final IDemoBService bService;

        private final IMediator mediator;

        public DemoAService(IMediator mediator) {
            this.mediator = mediator;
        }

        @Override
        public String hello() {
            return this.mediator.send(new RequestBService());
        }

        @Override
        public String helloWithB() {
            return "call A in B";
        }

        @Override
        public String handle(RequestAService request) {
            return this.helloWithB();
        }
    }

    public static class DemoBService implements IDemoBService, IRequestHandler {
        //private final IDemoAService aService;
        private final IMediator mediator;

        public DemoBService(IMediator mediator) {
            this.mediator = mediator;
        }

        @Override
        public String hello() {
            return this.mediator.send(new RequestAService());
        }

        @Override
        public String helloWithA() {
            return "call B in A";
        }

        @Override
        public String handle(RequestBService request) {
            return this.helloWithA();
        }
    }

    public static class RequestAService implements IRequest {
    }

    public static class RequestBService implements IRequest {
    }

测试代码如下


@ExtendWith(SpringExtension.class)
@Import(
        value = {
                Mediator.class,
                ServiceCycTests.DemoAService.class,
                ServiceCycTests.DemoBService.class,
        }
)
public class ServiceCycTests {

    @Autowired
    IDemoAService aService;

    @Autowired
    IDemoBService bService;

    @Test
    public void should() {
        String a = aService.hello();
        assertThat(a).isEqualTo("call B in A");

        String b = bService.hello();
        assertThat(b).isEqualTo("call A in B");
    }
}

测试结果

image (1).png

你可能感兴趣的:(Spring 版MediatR--中介者模式实现库)