Fatal编程技术网
  • java/
  • Java 对于实现几乎相似但方法的输入和输出不同的类，是组合还是继承？

Java 对于实现几乎相似但方法的输入和输出不同的类，是组合还是继承？

java oop inheritance design-patterns

Java 对于实现几乎相似但方法的输入和输出不同的类，是组合还是继承？,java,oop,inheritance,design-patterns,object-oriented-analysis,Java,Oop,Inheritance,Design Patterns,Object Oriented Analysis,我有以下几个类，它们有非常相似的方法实现。只有类的方法输入和输出看起来是不同的类型。当我这样说时，听起来像是继承的例子，然而，输入和输出是不同的，并且与两个lambda相关，这一事实让我想知道它们是否应该保持没有任何关系，因为一个lambda不能被认为是另一个（继承的例子） 我的第一节课如下所示 public class JobPersistenceManager { private String jobIndexName; private JobLambda JobLambda

我有以下几个类，它们有非常相似的方法实现。只有类的方法输入和输出看起来是不同的类型。当我这样说时，听起来像是继承的例子，然而，输入和输出是不同的，并且与两个lambda相关，这一事实让我想知道它们是否应该保持没有任何关系，因为一个lambda不能被认为是另一个（继承的例子）

我的第一节课如下所示

public class JobPersistenceManager {
    private String jobIndexName;
    private JobLambda JobLambda;
    private MyDataPersistence myDataPersistence;
    private DataProcessorUtils dataProcessorUtils;
    private static final String JOB_ID = "jobId";
    private static final String JOB_NAME = "jobName";

    @Inject
    public JobPersistenceManager(@Named("jobIndexName") String jobIndexName,
                                 JobLambda JobLambda,
                                 MyDataPersistence myDataPersistence) {
        this.jobIndexName = jobIndexName;
        this.JobLambda = JobLambda;
        this.myDataPersistence = myDataPersistence;
        createIndexIfNotExists(this.jobIndexName);
    }

    public SearchDocumentResult searchJob(MyJobInput myJobInput) throws IOException {
        return myDataPersistence
                .searchDocument(this.jobIndexName,
                        dataProcessorUtils.transformObjectDataPayloadToMap(myJobInput));
    }

    public MyJobOutput invokeCreateJobLambdaAndIndexData(final MyJobInput myJobInput)
            throws IOException {
        String personRequestPayload = dataProcessorUtils.transformObjectDataInputJson(myJobInput);
        Map<String, String> createdJobOutput = this.JobLambda.invokeLambda(personRequestPayload);
        this.indexCreatedJob(myJobInput, createdPersonOutput);
        return MyJobOutput.builder().withJobID(createdJobOutput.get(JOB_ID))
                .withJobName(createdJobOutput.get(JOB_NAME)).build();
    }

    public int indexCreatedJob(final MyJobInput myJobInput,
                               final Map<String, String> createdJobOutput) throws IOException {
        myJobInput = modifyJobInput(myJobInput);
        String documentToIndex = dataProcessorUtils.transformObjectDataInputJson(myJobInput);
        return myDataPersistence.indexDocument(this.jobIndexName, documentToIndex);
    }

    private void createIndexIfNotExists(final String indexName) {
        if (!myDataPersistence.doesIndexExist(indexName)) {
            myDataPersistence.createIndex(CreateIndexInput.builder().indexName(indexName).build());
        }
    }
}

public class EmployeePersistenceManager {
    private EmployeeLambda employeeLambda;
    private MyTestDataPersistence myTestDataPersistence;
    private DataProcessorUtils dataProcessorUtils;
    private String employeeIndexName;
    private static final String PERSON_ID_KEY = "personId";
    private static final String PERSON_NAME_KEY = "personName";

    @Inject
    public EmployeePersistenceManager(@Named("employeeIndexName") String employeeIndexName,
                                    EmployeeLambda employeeLambda,
                                    MyTestDataPersistence myTestDataPersistence,
                                    DataProcessorUtils dataProcessorUtils) {
        this.employeeIndexName = employeeIndexName;
        this.employeeLambda = employeeLambda;
        this.myTestDataPersistence = myTestDataPersistence;
        this.dataProcessorUtils = dataProcessorUtils;
        createIndexIfNotExists(employeeIndexName);
    }

    public SearchDocumentResult searchPerson(EmployeeInput employeeInput) throws IOException {
        return myTestDataPersistence
                .searchDocument(employeeIndexName,
                        dataProcessorUtils.transformObjectDataPayloadToMap(employeeInput));
    }

    public EmployeeOutput invokeCreatePersonLambdaAndIndexData(final EmployeeInput employeeInput)
            throws IOException {
        String personRequestPayload = dataProcessorUtils.transformObjectDataInputJson(employeeInput);
        Map<String, String> createdPersonOutput = this.employeeLambda.invokeLambda(personRequestPayload);
        this.indexCreatedEmployee(employeeInput, createdPersonOutput);
        return EmployeeOutput.builder().withPersonId(createdPersonOutput.get(PERSON_ID_KEY))
                .withPersonName(createdPersonOutput.get(PERSON_NAME_KEY)).build();
    }

    public int indexCreatedEmployee(final EmployeeInput employeeInput,
                                  final Map<String, String> createdPersonOutput) throws IOException {
        employeeInput = modifyEmployeeInput(employeeInput);
        String documentToIndex = dataProcessorUtils.transformObjectDataInputJson(employeeInput);
        return myTestDataPersistence.indexDocument(this.employeeIndexName, documentToIndex);
    }

    public Map.Entry<String, Map<String, String>> invokeLambda(final String payload) {
        return new AbstractMap.SimpleEntry<>(payload, this.employeeLambda.invokeLambda(payload));
    }

    private void createIndexIfNotExists(final String indexName) {
        if (!myTestDataPersistence.doesIndexExist(indexName)) {
            myTestDataPersistence.createIndex(CreateIndexInput.builder().indexName(indexName).build());
        }
    }
}

公共类JobPersistenceManager{
私有字符串jobIndexName；
私营企业；
私有MyDataPersistence MyDataPersistence；
专用DataProcessorUtils DataProcessorUtils；
私有静态最终字符串JOB\u ID=“jobId”；
私有静态最终字符串JOB_NAME=“jobName”；
@注入
public JobPersistenceManager（@Named（“jobIndexName”）字符串jobIndexName，
JobLambda JobLambda，
MyDataPersistence（MyDataPersistence）{
this.jobIndexName=jobIndexName；
this.JobLambda=JobLambda；
this.myDataPersistence=myDataPersistence；
createIndexIfNotExists（this.jobIndexName）；
}
public SearchDocumentResult searchJob（MyJobInput MyJobInput）引发IOException{
返回myDataPersistence
.searchDocument（此.jobIndexName，
transformObjectDataPayloadToMap（myJobInput））；
}
公共MyJobOutput调用CreateJobLambda和IndexData（最终MyJobInput MyJobInput）
抛出IOException{
字符串personRequestPayload=dataProcessorUtils.transformObjectDataInputJson（myJobInput）；
Map createdJoboOutput=this.JobLambda.invokeLambda（personRequestPayload）；
this.indexCreatedJob（myJobInput，createdPersonOutput）；
返回MyJobOutput.builder（）.withJobID（createdJobOutput.get（JOB_ID））
.withJobName（createdJoboOutput.get（JOB_NAME））.build（）；
}
public int indexCreatedJob（最终MyJobInput MyJobInput，
最终映射CreatedJoboOutput）引发IOException{
myJobInput=修改JobInput（myJobInput）；
String documentToIndex=dataProcessorUtils.transformObjectDataInputJson（myJobInput）；
返回myDataPersistence.indexDocument（this.jobIndexName，documentToIndex）；
}
私有void createIndexIfNotExists（最终字符串indexName）{
如果（！myDataPersistence.DoesIndexist（indexName））{
myDataPersistence.createIndex（CreateIndexInput.builder（）.indexName（indexName.build（））；
}
}
}
我的第二节课如下所示

public class JobPersistenceManager {
    private String jobIndexName;
    private JobLambda JobLambda;
    private MyDataPersistence myDataPersistence;
    private DataProcessorUtils dataProcessorUtils;
    private static final String JOB_ID = "jobId";
    private static final String JOB_NAME = "jobName";

    @Inject
    public JobPersistenceManager(@Named("jobIndexName") String jobIndexName,
                                 JobLambda JobLambda,
                                 MyDataPersistence myDataPersistence) {
        this.jobIndexName = jobIndexName;
        this.JobLambda = JobLambda;
        this.myDataPersistence = myDataPersistence;
        createIndexIfNotExists(this.jobIndexName);
    }

    public SearchDocumentResult searchJob(MyJobInput myJobInput) throws IOException {
        return myDataPersistence
                .searchDocument(this.jobIndexName,
                        dataProcessorUtils.transformObjectDataPayloadToMap(myJobInput));
    }

    public MyJobOutput invokeCreateJobLambdaAndIndexData(final MyJobInput myJobInput)
            throws IOException {
        String personRequestPayload = dataProcessorUtils.transformObjectDataInputJson(myJobInput);
        Map<String, String> createdJobOutput = this.JobLambda.invokeLambda(personRequestPayload);
        this.indexCreatedJob(myJobInput, createdPersonOutput);
        return MyJobOutput.builder().withJobID(createdJobOutput.get(JOB_ID))
                .withJobName(createdJobOutput.get(JOB_NAME)).build();
    }

    public int indexCreatedJob(final MyJobInput myJobInput,
                               final Map<String, String> createdJobOutput) throws IOException {
        myJobInput = modifyJobInput(myJobInput);
        String documentToIndex = dataProcessorUtils.transformObjectDataInputJson(myJobInput);
        return myDataPersistence.indexDocument(this.jobIndexName, documentToIndex);
    }

    private void createIndexIfNotExists(final String indexName) {
        if (!myDataPersistence.doesIndexExist(indexName)) {
            myDataPersistence.createIndex(CreateIndexInput.builder().indexName(indexName).build());
        }
    }
}

public class EmployeePersistenceManager {
    private EmployeeLambda employeeLambda;
    private MyTestDataPersistence myTestDataPersistence;
    private DataProcessorUtils dataProcessorUtils;
    private String employeeIndexName;
    private static final String PERSON_ID_KEY = "personId";
    private static final String PERSON_NAME_KEY = "personName";

    @Inject
    public EmployeePersistenceManager(@Named("employeeIndexName") String employeeIndexName,
                                    EmployeeLambda employeeLambda,
                                    MyTestDataPersistence myTestDataPersistence,
                                    DataProcessorUtils dataProcessorUtils) {
        this.employeeIndexName = employeeIndexName;
        this.employeeLambda = employeeLambda;
        this.myTestDataPersistence = myTestDataPersistence;
        this.dataProcessorUtils = dataProcessorUtils;
        createIndexIfNotExists(employeeIndexName);
    }

    public SearchDocumentResult searchPerson(EmployeeInput employeeInput) throws IOException {
        return myTestDataPersistence
                .searchDocument(employeeIndexName,
                        dataProcessorUtils.transformObjectDataPayloadToMap(employeeInput));
    }

    public EmployeeOutput invokeCreatePersonLambdaAndIndexData(final EmployeeInput employeeInput)
            throws IOException {
        String personRequestPayload = dataProcessorUtils.transformObjectDataInputJson(employeeInput);
        Map<String, String> createdPersonOutput = this.employeeLambda.invokeLambda(personRequestPayload);
        this.indexCreatedEmployee(employeeInput, createdPersonOutput);
        return EmployeeOutput.builder().withPersonId(createdPersonOutput.get(PERSON_ID_KEY))
                .withPersonName(createdPersonOutput.get(PERSON_NAME_KEY)).build();
    }

    public int indexCreatedEmployee(final EmployeeInput employeeInput,
                                  final Map<String, String> createdPersonOutput) throws IOException {
        employeeInput = modifyEmployeeInput(employeeInput);
        String documentToIndex = dataProcessorUtils.transformObjectDataInputJson(employeeInput);
        return myTestDataPersistence.indexDocument(this.employeeIndexName, documentToIndex);
    }

    public Map.Entry<String, Map<String, String>> invokeLambda(final String payload) {
        return new AbstractMap.SimpleEntry<>(payload, this.employeeLambda.invokeLambda(payload));
    }

    private void createIndexIfNotExists(final String indexName) {
        if (!myTestDataPersistence.doesIndexExist(indexName)) {
            myTestDataPersistence.createIndex(CreateIndexInput.builder().indexName(indexName).build());
        }
    }
}

公共类EmployeePersistenceManager{
私人雇员lambda EmployeeLambda；
私有MyTestDataPersistence MyTestDataPersistence；
专用DataProcessorUtils DataProcessorUtils；
私有字符串employeeIndexName；
私有静态最终字符串PERSON\u ID\u KEY=“personId”；
私有静态最终字符串PERSON\u NAME\u KEY=“personName”；
@注入
公共EmployeePersistenceManager（@Named（“employeeIndexName”）字符串employeeIndexName，
EmployeeLambda EmployeeLambda，
MyTestDataPersistence MyTestDataPersistence，
DataProcessorUtils（DataProcessorUtils）{
this.employeeIndexName=employeeIndexName；
this.employeeLambda=employeeLambda；
this.myTestDataPersistence=myTestDataPersistence；
this.dataProcessorUtils=dataProcessorUtils；
createIndexIfNotExists（employeeIndexName）；
}
公共SearchDocumentResult searchPerson（EmployeeInput EmployeeInput）引发IOException异常{
返回myTestDataPersistence
.searchDocument（employeeIndexName，
transformObjectDataPayloadToMap（employeeInput））；
}
公共EmployeeOutput调用CreatePersonLambda和IndexData（最终EmployeeInput EmployeeInput）
抛出IOException{
字符串personRequestPayload=dataProcessorUtils.transformObjectDataInputJson（employeeInput）；
Map createdPersonOutput=this.employeeLambda.invokeLambda（personRequestPayload）；
this.indexCreatedEmployee（employeeInput，createdPersonOutput）；
返回EmployeeOutput.builder（），其中包含PersonId（createdPersonOutput.get（PERSON\u ID\u KEY））
.withPersonName（createdPersonOutput.get（PERSON\u NAME\u KEY））.build（）；
}
public int indexCreatedEmployee（最终EmployeeInput EmployeeInput，
最终映射createdPersonOutput）引发IOException{
employeeInput=修改employeeInput（employeeInput）；
String documentToIndex=dataProcessorUtils.transformObjectDataInputJson（employeeInput）；
返回myTestDataPersistence.indexDocument（this.employeeIndexName，documentToIndex）；
}
public Map.Entry invokeLambda（最终字符串负载）{
返回新的AbstractMap.SimpleEntry（有效负载，this.employeeLambda.invokeLambda（有效负载））；
}
私有void createIndexIfNotExists（最终字符串indexName）{
如果（！myTestDataPersistence.DoesIndexist（indexName））{
myTestDataPersistence.createIndex（CreateIndexInput.builder（）.indexName（indexName.build（））；
}
}
}
如您所见，这些方法执行几乎相同的操作。只有类中的
indexcreatedeemployee
和
indexCreatedJob
方法具有处理输入的额外步骤

我应该保持这些类现在的状态，而不在它们之间建立任何关系，还是应该创建一个抽象的持久性管理器类并执行以下操作

public class JobPersistenceManager {
    private String jobIndexName;
    private JobLambda JobLambda;
    private MyDataPersistence myDataPersistence;
    private DataProcessorUtils dataProcessorUtils;
    private static final String JOB_ID = "jobId";
    private static final String JOB_NAME = "jobName";

    @Inject
    public JobPersistenceManager(@Named("jobIndexName") String jobIndexName,
                                 JobLambda JobLambda,
                                 MyDataPersistence myDataPersistence) {
        this.jobIndexName = jobIndexName;
        this.JobLambda = JobLambda;
        this.myDataPersistence = myDataPersistence;
        createIndexIfNotExists(this.jobIndexName);
    }

    public SearchDocumentResult searchJob(MyJobInput myJobInput) throws IOException {
        return myDataPersistence
                .searchDocument(this.jobIndexName,
                        dataProcessorUtils.transformObjectDataPayloadToMap(myJobInput));
    }

    public MyJobOutput invokeCreateJobLambdaAndIndexData(final MyJobInput myJobInput)
            throws IOException {
        String personRequestPayload = dataProcessorUtils.transformObjectDataInputJson(myJobInput);
        Map<String, String> createdJobOutput = this.JobLambda.invokeLambda(personRequestPayload);
        this.indexCreatedJob(myJobInput, createdPersonOutput);
        return MyJobOutput.builder().withJobID(createdJobOutput.get(JOB_ID))
                .withJobName(createdJobOutput.get(JOB_NAME)).build();
    }

    public int indexCreatedJob(final MyJobInput myJobInput,
                               final Map<String, String> createdJobOutput) throws IOException {
        myJobInput = modifyJobInput(myJobInput);
        String documentToIndex = dataProcessorUtils.transformObjectDataInputJson(myJobInput);
        return myDataPersistence.indexDocument(this.jobIndexName, documentToIndex);
    }

    private void createIndexIfNotExists(final String indexName) {
        if (!myDataPersistence.doesIndexExist(indexName)) {
            myDataPersistence.createIndex(CreateIndexInput.builder().indexName(indexName).build());
        }
    }
}

public class EmployeePersistenceManager {
    private EmployeeLambda employeeLambda;
    private MyTestDataPersistence myTestDataPersistence;
    private DataProcessorUtils dataProcessorUtils;
    private String employeeIndexName;
    private static final String PERSON_ID_KEY = "personId";
    private static final String PERSON_NAME_KEY = "personName";

    @Inject
    public EmployeePersistenceManager(@Named("employeeIndexName") String employeeIndexName,
                                    EmployeeLambda employeeLambda,
                                    MyTestDataPersistence myTestDataPersistence,
                                    DataProcessorUtils dataProcessorUtils) {
        this.employeeIndexName = employeeIndexName;
        this.employeeLambda = employeeLambda;
        this.myTestDataPersistence = myTestDataPersistence;
        this.dataProcessorUtils = dataProcessorUtils;
        createIndexIfNotExists(employeeIndexName);
    }

    public SearchDocumentResult searchPerson(EmployeeInput employeeInput) throws IOException {
        return myTestDataPersistence
                .searchDocument(employeeIndexName,
                        dataProcessorUtils.transformObjectDataPayloadToMap(employeeInput));
    }

    public EmployeeOutput invokeCreatePersonLambdaAndIndexData(final EmployeeInput employeeInput)
            throws IOException {
        String personRequestPayload = dataProcessorUtils.transformObjectDataInputJson(employeeInput);
        Map<String, String> createdPersonOutput = this.employeeLambda.invokeLambda(personRequestPayload);
        this.indexCreatedEmployee(employeeInput, createdPersonOutput);
        return EmployeeOutput.builder().withPersonId(createdPersonOutput.get(PERSON_ID_KEY))
                .withPersonName(createdPersonOutput.get(PERSON_NAME_KEY)).build();
    }

    public int indexCreatedEmployee(final EmployeeInput employeeInput,
                                  final Map<String, String> createdPersonOutput) throws IOException {
        employeeInput = modifyEmployeeInput(employeeInput);
        String documentToIndex = dataProcessorUtils.transformObjectDataInputJson(employeeInput);
        return myTestDataPersistence.indexDocument(this.employeeIndexName, documentToIndex);
    }

    public Map.Entry<String, Map<String, String>> invokeLambda(final String payload) {
        return new AbstractMap.SimpleEntry<>(payload, this.employeeLambda.invokeLambda(payload));
    }

    private void createIndexIfNotExists(final String indexName) {
        if (!myTestDataPersistence.doesIndexExist(indexName)) {
            myTestDataPersistence.createIndex(CreateIndexInput.builder().indexName(indexName).build());
        }
    }
}
将
createIndexIfNotExists
移动到抽象类 创建抽象方法
search（）
，
invokeLambda（）
和
indexCr

PersistenceManager employeePersistenceManager = new EmployeePersistenceManager(...);
employeePersistenceManager.search(employeeInput); //<-- the code is in the base class