基于Java中的输入调用服务/方法

我需要根据输入值动态调用服务

说-如果我们收到

输入A-呼叫服务X和服务Y

输入B-呼叫服务Y和服务Z

输入C-呼叫服务Z

现在这个列表可以更改了，所以我想在属性文件中保留这个列表，然后加载 这将在运行时执行，并将其存储在地图中

我将使用Switch-case语句来处理服务调用，如-

如果输入是A，则从加载的映射中获取服务列表

迭代并调用invokeMethod（服务标识符）

invokeMethod将具有开关盒

---

请告诉我是否有任何其他改进上述过程的建议

我宁愿使用SpringFramework，但您仍然可以自己做，如

interface IService {
    void call(Object param);
}

public static void main(final String[] args) {

    Map<String, IService> services = new TreeMap<>();

    // initialize your services
    services.put("A", new IService(){

            @Override
            public void call(Object param) {

            }
    });

    services.put("B", p -> {});
    services.put("C", System.out::println);

    class D implements IService {
        private Map<String, IService> services;
        public D(Map<String, IService> services) {
            this.services = services;
            services.put("D", this);
        }

        @Override
        public void call(Object p) {
            services.get("A").call("");
            services.get("C").call("");
        }

    }

    D d = new D(services);

    // now check if exists and call them
    if (services.containsKey("D")) {
        services.get("D").call("param");
    }

}

接口设备{
无效调用（对象参数）；
}
公共静态void main（最终字符串[]args）{
映射服务=新树映射（）；
//初始化您的服务
services.put（“A”，新的IService（）{
@凌驾
公共无效调用（对象参数）{
}
});
服务。put（“B”，p->{}）；
服务输出（“C”，系统输出：：println）；
D类实现IService{
私人地图服务；
公共关系科（地图服务）{
这是服务=服务；
服务。将（“D”，本）；
}
@凌驾
公共作废调用（对象p）{
服务。获取（“A”）。呼叫（“”）；
服务。获取（“C”）。呼叫（“”）；
}
}
D=新的D（服务）；
//现在检查是否存在并调用它们
if（服务集装箱（“D”））{
服务。获取（“D”）。呼叫（“param”）；
}
}

您可能有一个了解每个元音服务（XServiceImpl、YServiceImpl、ZServiceImpl）的元音处理程序，以及一个方法，该方法在给定输入时为您返回可处理该输入的服务列表

您的元音服务可以是一个接口，它有一个方法来检查给定的输入是否返回，服务是否可以处理该输入。这个接口可能有一个进程方法，用于打印正在运行的服务（模拟您想要的行为）

我们几乎完成了，我们可以在VouelHandler接口上有一个subscribe方法，允许您注册每个VouelService

interface VowelService {
    boolean canHandle(String vowel);
    void process();
}

class XServiceImpl implements VowelService {
    @Override
    public boolean canHandle(String vowel) {
        return vowel.equals("A");
    }

    @Override
    public void process() {
        System.out.println("Running X service ...");
    }
}

class YServiceImpl implements VowelService {
    @Override
    public boolean canHandle(String vowel) {
        return vowel.equals("A") || vowel.equals("B");
    }

    @Override
    public void process() {
        System.out.println("Running Y service ...");
    }
}

class ZServiceImpl implements VowelService {
    @Override
    public boolean canHandle(String vowel) {
        return vowel.equals("B") || vowel.equals("C");
    }

    @Override
    public void process() {
        System.out.println("Running Z service ...");
    }
}

interface VowelHandler {
    void subscribe(VowelService vowelService);
    List<VowelService> getVowelService(String vowel);
}

class VowelHandlerImpl implements VowelHandler {
    private final List<VowelService> vowelServices = new ArrayList<>();

    @Override
    public void subscribe(VowelService vowelService) {
        vowelServices.add(vowelService);
    }

    @Override
    public List<VowelService> getVowelService(String vowel){
        return vowelServices
                .stream()
                .filter(service -> service.canHandle(vowel))
                .collect(Collectors.toList());
    }
}

以及输出：

Running X service ...
Running Y service ...
Running Y service ...
Running Z service ...

---

这样我们就有了一个松散耦合的代码，因为每个类都有自己的职责，所以每次需要创建另一个元音服务时，只需要实现元音服务接口并订阅/注册元音Handler。如果我们把重点放在spring引导方法上，这可能会有所不同，因为您可以通过元音Handler中的列表注入元音服务。因此，Spring将处理每个元音服务实现的初始化，而不是我们在main方法上手动注册。

因此，请求对工作状态进行代码审查并不合适code@sam你读过Spring框架文档了吗？假设您的服务名是Bean名，并且每个服务/Bean都实现了相同的接口，该接口具有通用的调用方法，那么使用Bean就可以做到这一点。谢谢，您能指导我在Spring中如何实现这一点吗

public static void main(String [] args) {
    VowelHandler vowelHandler = new VowelHandlerImpl();
    VowelService vowelServiceX = new XServiceImpl();
    vowelHandler.subscribe(vowelServiceX);
    VowelService vowelServiceY = new YServiceImpl();
    vowelHandler.subscribe(vowelServiceY);
    VowelService vowelServiceZ = new ZServiceImpl();
    vowelHandler.subscribe(vowelServiceZ);

    List.of("A", "B")
            .forEach(vowel -> vowelHandler
                .getVowelService(vowel)
                    .forEach(VowelService::process)
    );
}

Running X service ...
Running Y service ...
Running Y service ...
Running Z service ...