使用Java8的设计模式建议/实现

我必须通过一系列步骤来处理请求

例如：如果请求1出现，那么我必须应用步骤1、步骤2、步骤3和最后步骤4，这将把处理后的请求持久保存到数据库中

我考虑实现模板设计模式，因为它解决了类似的问题

当我开始实现设计模式时，我突然发现很难实现，因为逻辑复杂

让我解释一下要求：

请求->控制器->运行（）

请求将包含

列表

在run方法中，将触发一系列操作

request.parallelStream()
    .map(step1 -> executeStep1.apply(step1))
    .map(step2 -> executeStep2.apply(step2, action))
    .map(step3 -> executeStep3.apply(step3, rules))
    .map(step4 -> executeStep4.apply(step4))
    .collect(Collectors.toList());

    Function<String, List<PersonDto>> executeStep1= person-> {
        return metaData.getMetaDataPerson(person);
    };

    BiFunction<List<PersonDto>, String, TransTemplateDTO> executeStep2= (metaData, action) -> {
        return temlate.createTemplate(metaData, action);
    };

request.parallelStream（）
.map（步骤1->executeStep1.apply（步骤1））
.map（步骤2->executeStep2.apply（步骤2，操作））
.map（步骤3->executeStep3.apply（步骤3，规则））
.map（步骤4->executestesp4.apply（步骤4））
.collect（Collectors.toList（））；
函数executeStep1=人->{
返回metaData.getMetaDataPerson（person）；
};
双功能executesp2=（元数据，操作）->{
返回temlate.createTemplate（元数据、操作）；
};

现在，我们可以看到，我将

request

的第一个元素作为输入传递给step1（），然后对其进行处理，并进一步将输出作为输入传递给后续步骤

• 问题1：
  到目前为止，没有问题。但是需求突然改变了，现在我不得不在步骤3中添加规则逻辑，即

  executeStep3.apply（步骤3）

  步骤3取两个参数，一个是步骤2的输出，另一个是列表规则。
  步骤3应应用所有规则并返回与规则相同的结果。
  例如，如果有3条规则，则步骤3应返回3个对象的列表。
  假设步骤3收到了包含10项的

  PersonDto

  列表和包含3项的规则列表，那么步骤3应该返回10*3=30条记录。
  此外，对于每个人，规则将根据命令而有所不同

• 问题2：
  在步骤3中，我需要request对象，以便使用值。 类似这样的内容：
  

  .map（步骤3->executeStep3.apply（步骤3，规则，请求））

什么设计模式在这里有帮助？如何帮助？

您应该使用设计模式

import java.util.ArrayList；
导入java.util.List；
类PersonDto{
受保护的int-id；
受保护的字符串名称；
公共int getId（）{
返回id；
}
公共无效集合id（内部id）{
this.id=id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
}
公共阶级责任链{
受保护的列表处理程序=新的ArrayList（）；
公共void addHandler（处理程序处理程序）{
this.handlers.add（handler）；
}
公共无效句柄（PersondToPerson）引发异常{
for（处理程序：处理程序）
处理人，处理人；
}
公共静态接口处理程序{
无效句柄（PersondToPerson）抛出异常；
}
公共静态类ValidatePersonHandler实现处理程序{
@凌驾
公共无效句柄（个人对个人）{
if（person.getName（）==null）
抛出新的IllegalArgumentException（“名称不能为空”）；
}
}
公共静态类SetPersonIdHandler实现处理程序{
@凌驾
公共无效句柄（个人对个人）{
人.setId（1）；
}
}
公共静态类InsertPersonToDBHandler实现处理程序{
@凌驾
公共无效句柄（个人对个人）{
//插入到数据库
System.out.println（“插入person:+person.getName（）+”到db”）；
}
}
公共静态void main（字符串[]args）引发异常{
责任链=新的责任链（）；
addHandler（新的ValidatePersonHandler（））；
addHandler（新的SetPersonIdHandler（））；
addHandler（新的InsertPersonToDBHandler（））；
PersonDto person=新的PersonDto（）；
person.setName（“foo”）；
链条、手柄（人）；
}
}

正如邓塔凡（dung ta van）已经提到的，首先想到的是责任链模式。我将重用该示例并在那里更改一些内容

public class ChainOfResponsibility {

    protected List<RequestProcessor> handlers = new ArrayList<>();

    public void addHandler(RequestProcessor handler) {
        this.handlers.add(handler);
    }

    @SuppressWarnings("unchecked")
    public void handle(Request request) {
        handlers
                .stream()
                .reduce(RequestProcessor::andThen)
                .orElseThrow(() -> new RuntimeException("Functions can't be composed"))
                .apply(request, null);
    }

    public interface RequestProcessor<T, R> extends BiFunction<Request, T, R> {

        default <V> RequestProcessor<T, V> andThen(BiFunction<Request, ? super R, ? extends V> after) {
            Objects.requireNonNull(after);
            return (Request r, T t) -> after.apply(r, apply(r, t));
        }

    }

    public static class PersonExtractor implements RequestProcessor<Void, PersonDto> {
        @Override
        public PersonDto apply(Request request, Void aVoid) {
            return new PersonDto("Nick");
        }
    }

    public static class ValidatePersonHandler implements RequestProcessor<PersonDto, PersonDto> {
        @Override
        public PersonDto apply(Request request, PersonDto personDto) {
            if (personDto.getName() == null) {
                throw new IllegalArgumentException("name can't be null");
            }
            return personDto;
        }
    }

    public static class SetPersonIdHandler implements RequestProcessor<PersonDto, List<?>> {

        private final List<Rule> rules;

        public SetPersonIdHandler(List<Rule> rules) {
            this.rules = rules;
        }

        @Override
        public List<?> apply(Request request, PersonDto personDto) {
            personDto.setId(1);
            rules.forEach(rule -> System.out.println("invoke rule " + rule.toString()));
            return Arrays.asList(personDto, personDto, personDto);
        }

    }

    public static class InsertPersonToDBHandler implements RequestProcessor<List<PersonDto>, Object> {

        @Override
        public List<?> apply(Request request, List<PersonDto> persons) {
            persons.forEach(person -> System.out.println("insert person: " + person.getName() + " to db"));
            return null;
        }
    }

    public static void main(String[] args) {
        ChainOfResponsibility chain = new ChainOfResponsibility();

        chain.addHandler(new PersonExtractor());
        chain.addHandler(new ValidatePersonHandler());
        chain.addHandler(new SetPersonIdHandler(Arrays.asList(new Rule("1"), new Rule("2"))));
        chain.addHandler(new InsertPersonToDBHandler());

        chain.handle(new Request());
    }
}

公共类责任链{
受保护的列表处理程序=新的ArrayList（）；
public void addHandler（RequestProcessor处理程序）{
this.handlers.add（handler）；
}
@抑制警告（“未选中”）
公共无效句柄（请求）{
处理者
.stream（）
.reduce（请求处理器：：和）
.orelsetrow（（）->新运行时异常（“无法组合函数”））
.apply（请求，空）；
}
公共接口RequestProcessor扩展了双功能{
默认的RequestProcessor和THEN（之后的双功能）{
对象。requirennull（之后）；
return（Request r，tt）->after.apply（r，apply（r，T））；
}
}
公共静态类PersonExtractor实现RequestProcessor{
@凌驾
要申请的公共人员（请求、无效避免）{
将新人归还给（“尼克”）；
}
}
公共静态类ValidatePersonHandler实现RequestProcessor{
@凌驾
申请的公众人士（请求、个人申请、个人申请）{
if（personDto.getName（）==null）{
抛出新的IllegalArgumentException（“名称不能为空”）；
}
返回个人；
}
}
公共静态类SetPersonIdHandler实现RequestProcessor apply（请求请求，PersonDto PersonDto）{
personDto.setId（1）；