Java：如何修复多种方法中的代码重复？

Question

I have some theoretical knowledge related to Design Patterns and now I have some issues to make these info and another ones in action.

I have the following 2 methods in my ServiceImpl class:

@Override
public MultipartFile exportA() throws IOException {
    
    // repeated lines-I same as exportB method (code omitted for brevity)
    
    // other lines special to exportA method

    // repeated lines-II same as exportB method (code omitted for brevity)
}

@Override
public MultipartFile exportB() throws IOException {
    
    // repeated lines-I same as exportA method (code omitted for brevity)
    
    // other lines special to exportB method

    // repeated lines-II same as exportA method (code omitted for brevity)
}

As it is shown, there are repeated parts in all of these methods. So, should I create 2 methods for repeated lines-I and II, eand then move these code blocks to these newly created 2 methods? Or, is there a better way for Design Patterns?

Answer 1

If I have well understood your statement, this sounds to me a Builder Pattern that you are looking for. You methods are building a MultipartFile whereas the build process itself depends on 'arguments/parameters' (here I guess sheet file path) and distinct code (the one you referred to as "other lines special to this method").

For that I would create a class MultipartFileBuilder that does the staff and that I would call in each method; of course, by means of setting the appropriate parameters and "code" each time. The code is simply an implementation of the java.util.function.Consumer<T> functional interface used in the following code (*2) and other parameters are using simple setters as well (here (*1)).

Note that I invoked the Consumer<T> as lambda expression here (the c->... construct). And note also that the type parameter <T> in Consumer<T> here is a new class I introduced MultipartFileBuildContext to allow multiple information to be passed to the code you are willing to write in each method. I guest the 'sheet' var would be a starting point. You can add other information if you need to.

To summer up things, this is how the code would look :

    
    @Override
    public MultipartFile exportMethodA() throws IOException {
        return new MultipartFileBuilder()
                .setSheetPath("sheetA/path") (*1)
                .setAction(c->{
                    //(*2) do your staff here for method A
                    // the "other lines special to this method"
                    XSSFSheet sheet=c.getSheet()
                    ...
                }).build();
    }

    @Override
    public MultipartFile exportMethodB() throws IOException {
        return new MultipartFileBuilder()
                .setSheetPath("sheetB/path") (*1)
                .setAction(c->{
                    //(*2) do your staff here for method B
                    // the "other lines special to this method"
                    XSSFSheet sheet=c.getSheet()
                    ...
                }).build();
    }

    class MultipartFileBuildContext {
        private XSSFSheet sheet;
        public MultipartFileBuildContext(XSSFSheet sheet){this.sheet=sheet;}
        public String getSheetPath() {
            return sheetPath;
        }
    }
    
    class MultipartFileBuilder {
        String sheetPath; 
        Consumer<MultipartFileBuildContext> action; 

        public String getSheetPath() {
            return sheetPath;
        }

        public MultipartFileBuilder setSheetPath(String sheetPath) {
            this.sheetPath = sheetPath;
            return this;
        }

        public Consumer<MultipartFileBuildContext> getAction() {
            return action;
        }

        public MultipartFileBuilder setAction(Consumer<MultipartFileBuildContext> action) {
            this.action = action;
            return this;
        }
        
        public MockMultipartFile build() {
            // repeated lines
            workbook = new XSSFWorkbook();
            sheet = workbook.createSheet(sheetPath);

            //
            if(action!=null){
                MultipartFileBuildContext c=new MultipartFileBuildContext(sheet);
                action.accept(c);
            }
        
        // repeated lines ======================================================
        outputFile = File.createTempFile(...);
        try (FileOutputStream outputStream = new FileOutputStream(outputFile)) {
                workbook.write(outputStream);
            } catch (IOException e) {
                LoggingUtils.error("Writing failed ", e);
            }
            final FileInputStream input = new FileInputStream(outputFile);

            final String fileName = TextBundleUtil.read(...);
            return new MockMultipartFile(fileName,
                    fileName, CONTENT_TYPE, IOUtils.toByteArray(input));
            //
        }
    }

At the end, this pattern needs to be used with care because you need to factorize all that you can to make the builder really useful, but not too much to make it a "boat of anything". For instance, you can have as input the sheet path or an inputstream of it to make it more useful/generic.