Java 对象继承-重构问题-创建灵活服务的可能性

这应该很容易，但显然我缺乏基本的知识。 我有一项服务，可以在

错误跟踪系统中创建票证。
创建插件是一项非常艰巨的任务。有一个接口

public interface BugTracker {
    boolean createAndSendIssue(Issue issue);
    boolean updateAndSendIssue(Issue issue);
    boolean closeIssue(Issue issue);
}

JIRA的API客户端：

@Component
public class JiraClient implements BugTracker {
    @Override
    public boolean createAndSendIssue(Issue issue) {
        //Logic for using JIRA REST API
        return false;
    }

    @Override
    public boolean updateAndSendIssue(Issue issue) {
        //Logic for using JIRA REST API
        return false;
    }

    @Override
    public boolean closeIssue(Issue issue) {
        //Logic for using JIRA REST API
        return false;
    }
}

Bugzilla的API客户端：

@Component
public class BugzillaClient implements BugTracker {

    @Override
    public boolean createAndSendIssue(Issue issue) {
        //Logic for using BUGZILLA REST API
        return false;
    }

    @Override
    public boolean updateAndSendIssue(Issue issue) {
        //Logic for using BUGZILLA REST API
        return false;
    }

    @Override
    public boolean closeIssue(Issue issue) {
        //Logic for using BUGZILLA REST API
        return false;
    }
}

正在处理
MVC
的
服务出现问题。它的一部分看起来像：

@Service
public class BugTrackerService {
    private final BugzillaClient bugzillaClient;
    private final JiraClient jiraClient;
    private static final String JIRA_TYPE = "Jira";
    private static final String BUGZILLA_TYPE = "Bugzilla";

    @Autowired
    BugTrackerService(BugzillaClient bugzillaClient, JiraClient jiraClient) {
        this.bugzillaClient = bugzillaClient;
        this.jiraClient = jiraClient;
    }

    boolean processIssueTicketRequest(Issue issue){
        if ( issue.getBugTrackerType().bugTrackingSystemType.name.equals(JIRA_TYPE)) {
            return jiraClient.createAndSendIssue(issue);
        } else if (issue.getBugTrackerType().bugTrackingSystemType.name.equals(BUGZILLA_TYPE)){
            return bugzillaClient.createAndSendIssue(issue);
        } else {
            return false;
        }
    }
}

是否有可能在没有所有客户端自动连线的情况下创建方法
BugTrackerService.processIssueTicketRequest
？目前问题不大，但在与越来越多的系统集成后，此服务将变得复杂。
将类型转换为
枚举
，并让
错误跟踪器
决定是否可以处理它。然后注入所有
BugTracker
实例的集合，对它们进行迭代，如果它支持该类型，则调用相应的方法

public enum SystemType { JIRA, BUGZILLA }

然后向您的
BugTracker
添加一个方法，例如
支持（问题）

boolean supports(Issue issue);

在实现中检查它是否可以处理，例如在
JiraClient
中执行类似操作

public boolean supports(Issue issue) {
  return JIRA == issue.getBugTrackerType();
}

然后在
BugTrackerService
中，获取所有
BugTracker
实例的列表，迭代并调用相应的实例

@Service
public class BugTrackerService {

    private final List<BugTracker> bugTrackers;

    BugTrackerService(List<BugTracker> bugTrackers) {
        this.bugTrackers=bugTrackers;
    }

    boolean processIssueTicketRequest(Issue issue){
        for (BugTracker bugTracker : this.bugTrackers) {
            if (bugTracker.supports(issue) ) {
                bugTracker.createAndSendIssue(issue);
                return true;
            }
        }
        return false;
    }
}

@服务
公共类BugTrackerService{
私人最终名单错误追踪者；
BugTrackerService（列出bugTrackers）{
这个.bugTrackers=bugTrackers；
}
布尔processIssueTicketRequest（问题）{
用于（BugTracker BugTracker:this.bugTrackers）{
if（bugTracker.supports（问题））{
bugTracker.createAndSendIssue（问题）；
返回true；
}
}
返回false；
}
}

现在，您可以随心所欲地灵活使用，并且可以支持任意数量的用户
 根据您希望实现的可重用程度，我可能会将检查给定问题是否与接口中的输入匹配的逻辑放在一起，例如

boolean canWorkWithGivenIssue(Issue issue);

有了它，你就不需要知道你分派的跟踪程序的实际类型，只需将它们汇总到列表中即可。如果您使用@Autowired注释集合，Spring将为您这样做，在这种情况下，它将为您提供具有匹配类型的所有bean。你的服务可能是这样的

@Autowired List<BugTracker> trackers; //autowired on field for brevity

boolean processIssueTicketRequest(Issue issue){
    for (BugTracker t : trackers)
        if (t.canWorkWithGivenIssue(issue))
            return t.createAndSendIssue(issue);
    return false;
}

@自动连线列表跟踪器//现场自动接线，简洁明了
布尔processIssueTicketRequest（问题）{
用于（BugTracker t:跟踪器）
如果（t.CanworkwithGivinissue（issue））
返回t.createAndSendIssue（发行）；
返回false；
}
您可以将查找
BugTracker
的正确实现的责任转交给
BugTrackerFactory

@组件
类BugTrackerFactory{
@自动连线
私人最终BugzillaClient BugzillaClient；
@自动连线
私人最终JiraClient JiraClient；
私有静态最终字符串JIRA_TYPE=“JIRA”；
私有静态最终字符串BUGZILLA_TYPE=“BUGZILLA”；
公共BugTracker getBugTracker（字符串类型）{
if（JIRA_类型等于（类型））{
返回jiraClient；
}else if（BUGZILLA_TYPE.equals（TYPE））{
返回bugzillaClient；
}否则{
//抛出一些异常
}
}
}

BugTrackerService：

@服务
公共类BugTrackerService{
私人最终BugTrackerFactory BugTrackerFactory；
@自动连线
BugTrackerService（BugTrackerFactory BugTrackerFactory）{
this.bugTrackerFactory=bugTrackerFactory；
}
布尔processIssueTicketRequest（问题）{
返回bugTrackerFactory.getBugTracker（issue.getBugTrackerType（）.bugTrackingSystemType.name）.createAndSendIssue（issue）；
}
}
它看起来很棒，但我不知道如何自动连接这样的字段。默认情况下，接口上的Autowire注释会将所有实现链接到列表？列表上的Autowire会得到特殊处理，是的。from:
对于数组、集合或映射依赖类型，容器自动连接与声明值类型匹配的所有bean。
关于这一点的知识将使我的生活变得更加轻松：），谢谢！类似的问题/解决方案如下：