如何用多种方法优化重复零件

Question

我有一些旧的验证方法，它们都有一个共同的部分。

@Service 
public class Validator implements IValidator { 

    @Resource 
    private CompanyRepository companyRepository; 

    @Override 
    public void validA(String paramA, Long id) { 

     //do some logic processing of the paramA 

     Company company = companyRepository.load(id); 
     //convert company to companyDto 
     CompanyDto companyDto = CompanyParser.fromCompany(company); 

     //do some logic 
    } 

    @Override 
    public void validB(String paramB, Long id) { 

     //do some logic processing of the paramB 

     Company company = companyRepository.load(id); 
     //convert company to companyDto 
     CompanyDto companyDto = CompanyParser.fromCompany(company); 

     //do some logic 
    } 

    @Override 
    public void validC(String paramC, Long id) { 

     //do some logic processing of the paramC 

     Company company = companyRepository.load(id); 
     //convert company to companyDto 
     CompanyDto companyDto = CompanyParser.fromCompany(company); 

     //do some logic 
    } 

} 

现在，我有一个需要验证在一气呵成许多参数的新方法，如：

validA(paramA, id); 
    validB(paramB, id); 
    validC(paramC, id); 

如果公司是大，CompanyParser.fromCompany的方法（公司）需要很长时间。

如果我们不修改旧的方法，有没有什么好的方法来优化？

Answer 1

首先，提取出一个公司/ DTO的装载和转换，并添加过载采取的，而不是一个id一个CompanyDto：的

@Service 
public class Validator implements IValidator { 

    @Resource 
    private CompanyRepository companyRepository; 

    @Override 
    public void validA(String paramA, Long id) { 
     validA(paramA, loadCompanyDto(id)); 
    } 

    private void validA(String paramA, CompanyDto companyDto) { 

     //do some logic processing of the paramA 

     //do some logic 
    } 

    private CompanyDto loadCompanyDto(Long id) { 
     Company company = companyRepository.load(id); 
     //convert company to companyDto 
     return CompanyParser.fromCompany(company); 
    } 
} 

此重构不会改变外部接口（合同）该类，它应该继续正常执行（你的单元测试仍然应该通过）。

然后你就可以创建新的方法：

public validParams(String paramA, String paramB, String paramC, Long id) { 
    CompanyDto companyDto = loadCompanyDto(id); 
    validA(paramA, companyDto); 
    validB(paramB, companyDto); 
    validC(paramC, companyDto); 
} 

Answer 2

要接听comment，我必须写一个答案：

import com.google.common.cache.*; 

class CompanyParser { 
    private static final LoadingCache<Company, CompanyDto> cache = 
     CacheBuilder.newBuilder() 
     .maximumSize(whateverSizeYouWant) 
     // set more properties if needed 
     .build(new CacheLoader<Company, CompanyDto>() { 
      public CompanyDto load(Company company) { 
       return originalFromCompany(company); 
      } 
     }; 

    private static CompanyDto originalFromCompany(Company company) { 
     ... the original non-caching code 
    } 

    public static CompanyDto fromCompany(Company company) { 
     return cache.getUnchecked(company); 
    } 
} 

使用番石榴（或caffeine），缓存是非常容易的。它快速且线程安全，并且可以获得内存缓存可以执行的所有操作。

这里，它使用equals和hashCode的Company。如果你没有定义它们，那么从Object继承的那些就可以很好地适用于你的用例（假设存储库总是返回与名称相同的id的相同实例）。

也许，一个简单的单元素自制缓存也可以，但要小心线程。