标签：return 接口 查询 管道 RequestHandler 处理器 handle 设计模式 public

　　最近，我被分配了一个任务，以创建一个/ search服务，该服务使用来自搜索引擎的数据。 在调用搜索引擎之前和之后，它还会执行许多其他任务。 其中一些任务包括获取给定过滤器查询的配置规则，查询更正，意图识别，缓存查找以及从搜索引擎获取结果后对结果进行重新排名。

　　在这里，我将讨论可用于设计查询管道的一些模式，并讨论用于服务的函数（功能组合）的细节。

　　设计模式选择1.责任链（CoR）

　　通过这种方法，您将链接处理器，如果尚未处理/完成请求，则每个处理器将调用链中的下一个处理器。 每个处理器都拥有链中下一个处理器的实例。

　　CoR的目的是让处理器仅在先前的处理器无法解决请求时才处理该请求。 但是，我们的意图是运行所有处理器。

　　我们不选择CoR的原因：

　　· 我个人不喜欢处理器保留另一个（下一个）处理器实例的想法。 这将使单元测试变得复杂，并且我们将需要一个模拟框架来模拟这些下一个处理器对象。

　　· 链中的所有处理器都需要实现相同的接口，并且您不能链接不兼容的接口。

　　但是，如果您想从中间步骤返回，则此模式可能是您的理想选择。 但是，通过一些调整（不是干净的方法），也可以使用其他模式来实现相同的目的。

　　2.流程清单

　　另一种模式是维护处理器实例的列表。 然后依次调用每个处理器以处理请求。

　　该实现将类似于：

　　class QueryPipeline{

　　private Collection requestHandlers;

　　public void registerHandler(RequestHandler rh){

　　requestHandlers.add(rh)

　　}

　　public PipelineContextObject run(PipelineContextObject input){

　　for(RequestHandler rh: requesthandlers){

　　rh.handle(input);

　　}

　　return input;

　　}

　　}

　　PipelineContextObject可以具有管道流程中的输入和输出对象以及其他参数，才能满足请求。

　　在您的服务类中，您可以注入此管道对象并调用run方法。 可以在应用程序启动期间在QueryPipeline中注册RequestHandler对象。

　　这种模式很简单，易于实现。 但是，它有一些限制：

　　· 没有干净的解决方案可以从中间步骤返回结果-需要维护每个步骤之间的状态，并检查循环中的该状态以打破中断状态。

　　· 所有步骤都需要实现相同的接口。

　　3.功能组合

　　函数组合的思想是通过将一个函数作为参数传递给另一个函数来链接不同的函数。 许多现代语言已经支持这一点。 在Java 8中，可以使用"功能接口"来实现。

　　功能接口表示功能而不是数据，并且可以传递给另一个功能。

　　我们如何使用功能性接口创建管道？

　　创建一个自定义接口（这将是我们的Functional接口），管道中的所有步骤都将实现此接口。

　　实现此接口的每个类都将是它正在解决的功能，而这些将是我们的功能，这些功能将被链接在一起。

　　想法是按顺序调用这些函数，其中一个函数的输出将用作下一个函数的输入。

　　1.创建一个功能接口。

　　@FunctionalInterface

　　interface RequestHandler<I, O>{

　　O handle(I input);

　　/**

　　Returns a composed function that first applies this function to its input,

　　and then applies the function to the result.

　　*/

　　default RequestHandler<I, V> thenCall(

　　RequestHandler<? super O, ? extends V> nextHandler) {

　　Objects.requireNonNull(nextHandler);

　　return (I t) -> nextHandler.handle(RequestHandler.this.handle(t));

　　}

　　}

　　默认方法负责函数的组成。 以下是默认方法的扩展形式-请遵循以下注释以了解：

　　/**

　　when this method is called with the instance of next handler,

　　it creates a new RequestHandler object to call the next handlers handle method.

　　For next handler the input will be the output of current/this handler.

　　*/

　　default RequestHandler<I, V> thenCall(

　　RequestHandler<? super O, ? extends V> nextHandler) {

　　Objects.requireNonNull(nextHandler);

　　return new RequestHandler<I, V>() {

　　@Override

　　public V handle(I t) {

　　// First RequestHandler.this.handle(t) line is called

　　// output of RequestHandler.this.handle(t) is used as input in nextHandler.handle()

　　return nextHandler.handle(RequestHandler.this.handle(t));

　　}

　　};

　　}

　　/*

　　For instance:

　　say we have chain: queryCorrectionHandler.thenCall(searchEnginehandler)

　　In this case we are calling `.thenCall` on queryCorrectionHandler object.

　　This will return the new RequestHandler object in which handle method will

　　invoke searchEnginehandler.handle(queryCorrectionHandler.handle())

　　So, eventually queryCorrectionHandler.handle() is called first and outout of

　　queryCorrectionHandler.handle() is used as input of searchEnginehandler.handle() and so on

　　*/

　　2.实施此界面以创建您的具体功能。

　　@Service

　　class QueryUnderstandingHandler implements Requesthandler<SearchCriteria, SearchCriteria>{

　　@Override

　　public SearchCriteria handle(SearchCriteria sc){

　　//update sc based on QUS API result

　　return sc;

　　}

　　}

　　@Service

　　class SearchEngineRequestHandler implements Requesthandler<SearchCriteria, SearchResponse>{

　　@Override

　　public SearchResponse handle(SearchCriteria sc){

　　//get the data from search engine

　　return searchResponse;

　　}

　　}

　　@Service

　　class ReRankHandler implements Requesthandler<SearchResponse, SearchResponse>{

　　@Override

　　public SearchResponse handle(SearchResponse sr){

　　//re-rank the results based on some ML model

　　return sr;

　　}

　　}

　　3.然后，您可以在应用程序启动时构造对象并创建功能链。 如果您正在使用spring框架，则可以在Configuration类中创建一个bean。

　　下面是一个Spring Bean示例：

　　@Bean("queryPipeline")

　　public RequestHandler<SearchCriteria, SearchResponse> queryPipeline(

　　RequestHandler<SearchCriteria, SearchCriteria> queryUnderstandinghandler,

　　RequestHandler<SearchCriteria, SearchResponse> searchEnineRequestHandler,

　　RequestHandler<SearchResponse, SearchResponse> reRankHandler) {

　　return queryUnderstandinghandler.thenCall(searchEnineRequestHandler)

　　.thenCall(reRankHandler);

　　}

　　如果您没有使用spring框架，则可以调用以下方法，并在应用程序启动时将管道对象注入服务类中：

　　public static RequestHandler<SearchCriteria, SearchResponse> getQueryPipeline() {

　　RequestHandler<SearchCriteria, SearchCriteria> queryUnderstandinghandler=new QueryUnderstandingHandler();

　　RequestHandler<SearchCriteria, SearchResponse> searchEnineRequestHandler=new SearchEngineRequesthandler();

　　RequestHandler<SearchResponse, SearchResponse> reRankHandler=new ReRankHandler();

　　return queryUnderstandinghandler.thenCall(searchEnineRequestHandler)

　　.thenCall(reRankHandler);

　　}

　　queryPipeline Bean链接所有Bean /对象。 在这里，一个功能的响应用作下一个功能的请求。

　　4.最后，在服务类中使用queryPipeline bean：

　　class SearchServiceImpl implements SearchService{

　　// Autowire the bean or do constructor injection

　　private RequestHandler<SearchCriteria, SearchResponse> queryPipeline

　　@Override

　　public SearchResponse search(SearchCriteria sc){

　　return queryPipeline.handle(sc);

　　}

　　}我们如何链接功能接口的功能不一样？

　　假设我们的ReRank处理程序实现ReRankStrategy而不是RequestHandler接口。

　　// Re-ranking interface

　　interface ReRankStrategy{

　　SearchResponse reRank(SearchResponse sr);

　　}

　　// class implementing re-rank interface

　　class PopularityBasedReRank implements ReRankStrategy{

　　public SearchResponse reRank(SearchResponse sr){

　　// Do re-ranking of the results here and set back to sr

　　return sr;

　　}

　　}

　　解决方案很简单。 将ReRankStrategy实现包装在RequestHandler对象内。 然后在RequestHandler对象的handle（）方法内执行reRankStrategy.reRank（）方法。

　　包装reRankStrategy的其他方法是：

　　· 创建一个匿名类或

　　· 使用Lambda函数或

　　· 如果您的ReRankStrategy类是一个功能接口，则使用方法参考（仅一个非默认方法）

　　//Anonymous class

　　RequestHandler<SearchResponse, SearchResponse> reRankHandler=new RequestHandler<SearchResponse, SearchResponse>() {

　　@Override

　　public SearchResponse handle(SearchResponse input) {

　　return reRankStrategy.reRank(input);

　　}

　　};

　　// Lambda Function

　　RequestHandler<SearchResponse, SearchResponse> reRankHandler=input -> reRankStrategy.reRank(input);

　　// Method Reference

　　RequestHandler<SearchResponse, SearchResponse> reRankHandler=reRankStrategy::reRank;

　　因此，在这种情况下，queryPipeline Bean定义将如下所示：

　　@Bean("queryPipeline")

　　public RequestHandler<SearchCriteria, SearchResponse> queryPipeline(

　　RequestHandler<SearchCriteria, SearchCriteria> queryUnderstandinghandler,

　　RequestHandler<SearchCriteria, SearchResponse> searchEnineRequestHandler,

　　ReRankStrategy popularityBasedReRank) {

　　//wrap re-rank strategy inside RequestHandler

　　RequestHandler<SearchResponse, SearchResponse> reRankHandler=popularityBasedReRank::reRank;

　　return queryUnderstandinghandler.thenCall(searchEnineRequestHandler)

　　.thenCall(reRankHandler);

　　}

　　您始终可以使用Java 8 Function接口，而不是创建自己的RequestHandler接口。 创建新接口的原因是为了维护命名约定。 最好使用相对的接口名称，而不要使用" Function" :)

　　总结

　　在这三种用于实现查询管道的模式中，如果打算从中间状态返回，那么CoR将是理想的选择。 但是，具有"进程列表"更易于实现且不太复杂。

　　在我们的服务中，我们实现了功能组合，因为它更加整洁，因为它不会将下一处理器的对象保持在链中，并且可以将不兼容的接口绑定在一起。

标签：return,接口,查询,管道,RequestHandler,处理器,handle,设计模式,public
来源： https://www.cnblogs.com/ebuybay/p/15862909.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。