问题描述
我有以下类，它们具有非常相似的方法实现。只有类的方法输入和输出似乎是不同的类型。当我这样说时，听起来像是继承的情况，但是，输入和输出不同并且与两个 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,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());
}
}
}
如您所见，这些方法执行几乎相同的操作。只有类中的 indexCreatedEmployee 和 indexCreatedJob 方法具有处理输入的额外步骤。
我应该保留这些类，它们之间没有任何关系，还是应该创建一个抽象的持久性管理器类并执行以下操作。
移动createIndexIfNotExists到抽象类
创建抽象方法 search()、invokeLambda() 和 indexCreatedData() 方法并在每个子类中实现它们。数据类型 MyJobInput 和 MyEmployeeInput 是没有任何关系的 POJO 类。所以我猜我提到的这些方法会采用“对象”参数？
EmployeeLambda 和 JobLambda 也是类，它们之间没有关系。我对创建某种继承的另一个担忧是，Employee Lambda 和 JobLambda 不能互换使用。所以想知道它们是否应该继承同一个父类，因为它们都是 lambda 类。
或者有其他方法可以解决这个问题吗？任何建议将不胜感激。预先非常感谢您。
解决方法
正如昨天所承诺的，这就是我要做的。
创建一个Lambda接口并让JobLambda和EmployeeLambda实现它
public interface Lambda {
Map<String,String> invokeLambda(String payload);
}
public class JobLambda implements Lambda {
//... your implementation
}
public class EmployeeLambda implements Lambda {
//... your implementation
}
对 DataPersistence 执行相同操作
public interface DataPersistence {
boolean doesIndexExist(String indexName);
void createIndex(CreateIndexInput createIndexInput);
int indexDocument(String indexName,String documentToIndex);
SearchDocumentResult searchDocument(String indexName,Map<String,String> payloadMap);
}
public class MyDataPersistence implements DataPersistence {
//... your implementation
}
public class MyTestDataPersistence implements DataPersistence {
//... your implementation
}
然后创建一个父类 PersistenceManager，其中包含所有重复的方法，并针对输入/输出类型进行参数化：
（注意：我没有完成所有的事情，但我做了一些事情只是为了让你理解这个概念）
public class PersistenceManager<I,O> {
protected static final String ID = "Id";
protected static final String NAME = "Name";
private String indexName;
private Lambda lambda;
private DataPersistence dataPersistence;
private DataProcessorUtils dataProcessorUtils;
public PersistenceManager(String indexName,Lambda lambda,DataPersistence dataPersistence,DataProcessorUtils dataProcessorUtils) {
this.indexName = indexName;
this.lambda = lambda;
this.dataPersistence = dataPersistence;
this.dataProcessorUtils = dataProcessorUtils;
createIndexIfNotExists(indexName);
}
public SearchDocumentResult search(I input) {
return dataPersistence.searchDocument(indexName,dataProcessorUtils.transformObjectDataPayloadToMap(input));
}
public O invokeCreateLambdaAndIndexData(final I input) {
String requestPayload = dataProcessorUtils.transformObjectDataInputJson(input);
Map<String,String> createdOutput = this.lambda.invokeLambda(requestPayload);
//continue generalizing following the same logic
}
public int indexCreated(I input,String> createdOutput) {
//continue generalizing following the same logic
}
private void createIndexIfNotExists(final String indexName) {
if (!dataPersistence.doesIndexExist(indexName)) {
dataPersistence.createIndex(CreateIndexInput.builder().indexName(indexName).build());
}
}
}
此时，您可以通过简单地选择参数来专门化您的类
...所有其余的代码将在父类中共享。
public class JobPersistenceManager extends PersistenceManager<MyJobInput,MyJobOutput> {
private static final String JOB_ID = "Job" + ID;
private static final String JOB_NAME = "Job" + NAME;
public JobPersistenceManager(String indexName,DataProcessorUtils dataProcessorUtils) {
super(indexName,lambda,dataPersistence,dataProcessorUtils);
}
}
public class EmployeePersistenceManager extends PersistenceManager<MyEmployeeInput,MyEmployeeOutput> {
private static final String EMPLOYEE_ID = "Employee" + ID;
private static final String EMPLOYEE_NAME = "Employee" + NAME;
public EmployeePersistenceManager(String indexName,dataProcessorUtils);
}
}
...并像这样使用它们：
PersistenceManager employeePersistenceManager = new EmployeePersistenceManager(...);
employeePersistenceManager.search(employeeInput); //<-- the code is in the base class