【ChatGPT应用篇】助力Beauty代码的初体验 | 京东云技术团队

思考过程：

案例1：项目里面有Excel文件的解析场景，试着与ChatGPT进行了交互，现将问题整理如下：

1.给我写一个Java版本的excel导入解析代码（毫不客气的分配任务）

2.需要支持100000000数据量（业务需求变更）

3.优化代码需要支持10000000数据量（降低数量级，减轻难度）

4.请采用面向对象的思想给做一下封装（初级工程师 -> 中级工程师）

5.进一步面向接口编程，抽离业务（中级晋升应该加一点泛型诉求，代码更Beauty）

6.替换掉 poi 采用EasyExcel （替换原始的默认技术选型，替换三方包）

7.进一步优化，能支持EasyExcel、POI自由切换（问题没问好！本意是想让他进一步抽象，能基于SPI支持扩展点）

8.采用控制反转方式优化（与问题5有重复）

9.提升解析性能，采用多线程并行解析优化（中级工程->高级工程师）

10.提升程序效率，把解析性能在提升10倍（架构师的成本意识，这个问题的回答有点意思）

11.采用Spring IOC 控制反转方式进一步封装（与问题8有重复）

12.添加异常 logger 打印（优化细节）

13.添加更多的中文代码注释（增强易读性，优化细节）

14.将中文注释替换成英文注释（^_^ 开始走向国际化）

15.日志错误信息支持国际化资源文件（国际化的开始……）

16.把上面Excel解析的代码在给来个单元测试吧

17.…

案例2：项目里面一个ES深度分页优化的场景，问题整理如下：

1.Elasticsearch 深度分页问题

2.Elasticsearch 深度分页Java代码

3.以上代码采用面向IOC优化

4.进一步面向对象优化

5.基于泛型进行抽象

6.将 scroll API 替换为 searchafter

7.使用 spring data elasticsearch 优化并实现 search After

8.以上代码请采用jmeter 生成一个压测脚本

9.上面Spring Data Elasticsearch 实现 search after 的示例代码请采用 groovy 语言生成测试用例

案例2的代码就不贴出来了，大家感兴趣可以自行输入以上问题进行体验！

（个人体会：程序领域问问题要采用专业术语，专业术语越强越能精准给予反馈！）

说明： 对于ChatGPT输出的代码没有做仔细的Review及调试，但是看代码风格基本上是改改就能用于生产的，对于代码规范、命名还是很认可的！

案例过程：

Happy Coding！Beauty Code！

以下是一个与ChatGPT 结对编程的一个Excel数据解析案例，大家可以根据我的思考过程进行体验，以下放了一些截图，ChatGPT的反应速度惊人，代码版本一步步进行迭代优化，感触较深的是真正的高质量低代码平台要应运而生了！

1import com.alibaba.excel.EasyExcel;
2import com.alibaba.excel.annotation.ExcelProperty;
3import com.alibaba.excel.metadata.Sheet;
4import com.alibaba.excel.read.listener.ReadListener;
5import org.apache.poi.hssf.usermodel.HSSFWorkbook;
6import org.apache.poi.ss.usermodel.Cell;
7import org.apache.poi.ss.usermodel.Row;
8import org.apache.poi.ss.usermodel.Sheet as PoiSheet;
9import org.apache.poi.xssf.usermodel.XSSFWorkbook;
10import java.io.File;
11import java.io.FileInputStream;
12import java.io.IOException;
13import java.util.ArrayList;
14import java.util.HashMap;
15import java.util.List;
16import java.util.Map;
17
18public class ExcelParser {
19    private ParserType parserType;
20    
21    public ExcelParser(ParserType parserType) {
22        this.parserType = parserType;
23    }
24    
25    public List<Map<String, String>> parse(File file, int sheetIndex) throws IOException {
26        if (parserType == ParserType.EASY_EXCEL) {
27            return parseWithEasyExcel(file, sheetIndex);
28        } else if (parserType == ParserType.POI) {
29            return parseWithPoi(file, sheetIndex);
30        } else {
31            throw new IllegalArgumentException("Invalid parser type");
32        }
33    }
34    
35    private List<Map<String, String>> parseWithEasyExcel(File file, int sheetIndex) {
36        List<Map<String, String>> data = new ArrayList<>();
37        DataListener listener = new DataListener(data);
38        ExcelReaderBuilder readerBuilder = EasyExcel.read(file, listener);
39        Sheet sheet = new Sheet(sheetIndex + 1, 0);
40        readerBuilder.sheet(sheet).doRead();
41        return data;
42    }
43    
44    private List<Map<String, String>> parseWithPoi(File file, int sheetIndex) throws IOException {
45        List<Map<String, String>> data = new ArrayList<>();
46        FileInputStream inputStream = new FileInputStream(file);
47        HSSFWorkbook workbook = file.getName().endsWith(".xls") ? new HSSFWorkbook(inputStream) : new XSSFWorkbook(inputStream);
48        PoiSheet sheet = workbook.getSheetAt(sheetIndex);
49        List<String> headers = new ArrayList<>();
50        for (Cell cell : sheet.getRow(0)) {
51            headers.add(cell.getStringCellValue());
52        }
53        for (int i = 1; i <= sheet.getLastRowNum(); i++) {
54            Row row = sheet.getRow(i);
55            Map<String, String> record = new HashMap<>();
56            for (int j = 0; j < headers.size(); j++) {
57                Cell cell = row.getCell(j, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK);
58                String value = "";
59                switch (cell.getCellType()) {
60                    case STRING:
61                        value = cell.getStringCellValue();
62                        break;
63                    case NUMERIC:
64                        value = Double.toString(cell.getNumericCellValue());
65                        break;
66                    default:
67                        value = cell.getStringCellValue();
68                        break;
69                }
70                record.put(headers.get(j), value);
71            }
72            data.add(record);
73        }
74        workbook.close();
75        inputStream.close();
76        return data;
77    }
78    
79    public static void main(String[] args) throws IOException {
80        File file = new File("excel_file.xlsx");
81        ExcelParser parser = new ExcelParser(ParserType.EASY_EXCEL);
82        List<Map<String, String>> data = parser.parse(file, 0);
83        System.out.println(data);
84    }
85}
86
87enum ParserType {
88    EASY_EXCEL,
89    POI
90}
91
92class DataListener extends ReadListener<Data> {
93    private List<Map<String, String>> data;
94    private List<String> headers;
95    
96    public DataListener(List<Map<String, String>> data) {
97        this.data = data;
98        this.headers = new ArrayList<>();
99    }
100    
101    @Override
102    public void onException(Exception exception) {
103        // 处理异常
104    }
105
106    @Override
107    public void onReadError(Exception exception) {
108        // 处理读取错误
109    }
110
111    @Override
112    public void onSheet(int sheetIndex, Sheet sheet) {
113        // 处理工作表信息
114    }
115
116    @Override
117    public void onReadEnd() {
118        // 读取结束
119    }
120
121    @Override
122    public void onHeadRow(Row row) {
123        for (Cell cell : row) {
124            headers.add(cell.getStringCellValue());
125        }
126    }
127
128    @Override
129    public void onRecord(Data data) {
130        Map<String, String> record = new HashMap<>();
131        for (int i = 0; i < headers.size(); i++) {
132            record.put(headers.get(i), data.getField(i));
133        }
134        this.data.add(record);
135    }
136}
137
138class Data {
139    @ExcelProperty(index = 0)
140    private String name;
141    
142    @ExcelProperty(index = 1)
143    private int age;
144

1import com.alibaba.excel.annotation.ExcelProperty;
2import java.util.List;
3import java.util.Map;
4
5public class ExcelParser {
6    private SheetParser sheetParser;
7    
8    public ExcelParser(SheetParser sheetParser) {
9        this.sheetParser = sheetParser;
10    }
11    
12    public List<Map<String, String>> parse(String fileName, int sheetIndex) throws Exception {
13        return sheetParser.parse(fileName, sheetIndex);
14    }
15
16    public static void main(String[] args) throws Exception {
17        String fileName = "excel_file.xlsx";
18        SheetParser sheetParser = new EasyExcelSheetParser();
19        ExcelParser parser = new ExcelParser(sheetParser);
20        List<Map<String, String>> data = parser.parse(fileName, 0);
21        System.out.println(data);
22    }
23}
24
25interface SheetParser {
26    List<Map<String, String>> parse(String fileName, int sheetIndex) throws Exception;
27}
28
29class EasyExcelSheetParser implements SheetParser {
30    @Override
31    public List<Map<String, String>> parse(String fileName, int sheetIndex) throws Exception {
32        List<Map<String, String>> data = new ArrayList<>();
33        DataListener listener = new DataListener(data);
34        ExcelReaderBuilder readerBuilder = EasyExcel.read(fileName, listener);
35        Sheet sheet = new Sheet(sheetIndex + 1, 0);
36        readerBuilder.sheet(sheet).doRead();
37        return data;
38    }
39}
40
41class PoiSheetParser implements SheetParser {
42    @Override
43    public List<Map<String, String>> parse(String fileName, int sheetIndex) throws Exception {
44        List<Map<String, String>> data = new ArrayList<>();
45        FileInputStream inputStream = new FileInputStream(fileName);
46        HSSFWorkbook workbook = fileName.endsWith(".xls") ? new HSSFWorkbook(inputStream) : new XSSFWorkbook(inputStream);
47        PoiSheet sheet = workbook.getSheetAt(sheetIndex);
48        List<String> headers = new ArrayList<>();
49        for (Cell cell : sheet.getRow(0)) {
50            headers.add(cell.getStringCellValue());
51        }
52        for (int i = 1; i <= sheet.getLastRowNum(); i++) {
53            Row row = sheet.getRow(i);
54            Map<String, String> record = new HashMap<>();
55            for (int j = 0; j < headers.size(); j++) {
56                Cell cell = row.getCell(j, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK);
57                String value = "";
58                switch (cell.getCellType()) {
59                    case STRING:
60                        value = cell.getStringCellValue();
61                        break;
62                    case NUMERIC:
63                        value = Double.toString(cell.getNumericCellValue());
64                        break;
65                    default:
66                        value = cell.getStringCellValue();
67                        break;
68                }
69                record.put(headers.get(j), value);
70            }
71            data.add(record);
72        }
73        workbook.close();
74        inputStream.close();
75        return data;
76    }
77}
78
79class DataListener extends ReadListener<Data> {
80    private List<Map<String, String>> data;
81    private List<String> headers;
82    
83    public DataListener(List<Map<String, String>> data) {
84        this.data = data;
85        this.headers = new ArrayList<>();
86    }
87    
88    @Override
89    public void onException(Exception exception) {
90        // 处理异常
91    }
92
93    @Override
94    public void onReadError(Exception exception) {
95        // 处理读取错误
96    }
97
98    @Override
99    public void onSheet(int sheetIndex, Sheet sheet) {
100        // 处理工作表信息
101    }
102
103    @Override
104    public void onReadEnd() {
105        // 读取结束
106    }
107
108    @Override
109    public void onHeadRow(Row row) {
110        for (Cell cell : row) {
111            headers.add(cell.getStringCellValue());
112        }
113    }
114
115    @Override
116    public void onRecord(Data data) {
117        Map<String, String> record = new HashMap<>();
118        for (int i = 0; i < headers.size(); i++) {
119            record.put(headers.get(i), data.getField(i));
120        }
121        this.data.add(record);
122    }
123}
124
125class Data {
126    @ExcelProperty(index = 0)
127    private String name;
128    
129    @ExcelProperty(index = 1)
130    private int age;
131    
132    // Getters and setters
133}
134

1import com.alibaba.excel.EasyExcel;
2import com.alibaba.excel.annotation.ExcelProperty;
3import com.alibaba.excel.metadata.Sheet;
4import com.alibaba.excel.read.listener.ReadListener;
5
6import java.util.ArrayList;
7import java.util.List;
8import java.util.Map;
9import java.util.concurrent.*;
10
11public class ExcelParser {
12    private SheetParser sheetParser;
13
14    public ExcelParser(SheetParser sheetParser) {
15        this.sheetParser = sheetParser;
16    }
17
18    public List<Map<String, String>> parse(String fileName, int sheetIndex) throws ExecutionException, InterruptedException {
19        return sheetParser.parse(fileName, sheetIndex);
20    }
21
22    public static void main(String[] args) throws ExecutionException, InterruptedException {
23        String fileName = "excel_file.xlsx";
24        ExecutorService executor = Executors.newFixedThreadPool(2);
25        List<Future<List<Map<String, String>>>> futures = new ArrayList<>();
26        for (int i = 0; i < 2; i++) {
27            SheetParser sheetParser = new EasyExcelSheetParser();
28            Future<List<Map<String, String>>> future = executor.submit(() -> sheetParser.parse(fileName, i));
29            futures.add(future);
30        }
31        List<Map<String, String>> data = new ArrayList<>();
32        for (Future<List<Map<String, String>>> future : futures) {
33            data.addAll(future.get());
34        }
35        System.out.println(data);
36        executor.shutdown();
37    }
38}
39
40interface SheetParser {
41    List<Map<String, String>> parse(String fileName, int sheetIndex);
42}
43
44class EasyExcelSheetParser implements SheetParser {
45    @Override
46    public List<Map<String, String>> parse(String fileName, int sheetIndex) {
47        List<Map<String, String>> data = new ArrayList<>();
48        DataListener listener = new DataListener(data);
49        ExcelReaderBuilder readerBuilder = EasyExcel.read(fileName, listener);
50        Sheet sheet = new Sheet(sheetIndex + 1, 0);
51        readerBuilder.sheet(sheet).doRead();
52        return data;
53    }
54}
55
56class PoiSheetParser implements SheetParser {
57    @Override
58    public List<Map<String, String>> parse(String fileName, int sheetIndex) throws Exception {
59        // 实现 POI 的解析，类似于前面的示例
60    }
61}
62
63class DataListener extends ReadListener<Data> {
64    private List<Map<String, String>> data;
65    private List<String> headers;
66
67    public DataListener(List<Map<String, String>> data) {
68        this.data = data;
69        this.headers = new ArrayList<>();
70    }
71
72    @Override
73    public void onHeadRow(Row row) {
74        for (Cell cell : row) {
75            headers.add(cell.getStringCellValue());
76        }
77    }
78
79    @Override
80    public void onRecord(Data data) {
81        Map<String, String> record = new HashMap<>();
82        for (int i = 0; i < headers.size(); i++) {
83            record.put(headers.get(i), data.getField(i));
84        }
85        this.data.add(record);
86    }
87}
88
89class Data {
90    @ExcelProperty(index = 0)
91    private String name;
92
93    @ExcelProperty(index = 1)
94    private int age;
95
96    // Getters and setters
97}
98

1import java.util.List;
2import java.util.Map;
3
4import org.springframework.beans.factory.annotation.Autowired;
5import org.springframework.stereotype.Component;
6
7@Component
8public class ExcelParser {
9    private SheetParser sheetParser;
10
11    @Autowired
12    public ExcelParser(SheetParser sheetParser) {
13        this.sheetParser = sheetParser;
14    }
15
16    public List<Map<String, String>> parse(String fileName, int sheetIndex) throws Exception {
17        return sheetParser.parse(fileName, sheetIndex);
18    }
19}
20
21interface SheetParser {
22    List<Map<String, String>> parse(String fileName, int sheetIndex) throws Exception;
23}
24
25@Component
26class EasyExcelSheetParser implements SheetParser {
27    @Override
28    public List<Map<String, String>> parse(String fileName, int sheetIndex) throws Exception {
29        List<Map<String, String>> data = new ArrayList<>();
30        DataListener listener = new DataListener(data);
31        ExcelReaderBuilder readerBuilder = EasyExcel.read(fileName, listener);
32        Sheet sheet = new Sheet(sheetIndex + 1, 0);
33        readerBuilder.sheet(sheet).doRead();
34        return data;
35    }
36}
37
38@Component
39class PoiSheetParser implements SheetParser {
40    @Override
41    public List<Map<String, String>> parse(String fileName, int sheetIndex) throws Exception {
42        // 实现 POI 的解析，类似于前面的示例
43    }
44}
45
46class DataListener extends ReadListener<Data> {
47    private List<Map<String, String>> data;
48    private List<String> headers;
49
50    public DataListener(List<Map<String, String>> data) {
51        this.data = data;
52        this.headers = new ArrayList<>();
53    }
54
55    @Override
56    public void onHeadRow(Row row) {
57        for (Cell cell : row) {
58            headers.add(cell.getStringCellValue());
59        }
60    }
61
62    @Override
63    public void onRecord(Data data) {
64        Map<String, String> record = new HashMap<>();
65        for (int i = 0; i < headers.size(); i++) {
66            record.put(headers.get(i), data.getField(i));
67        }
68        this.data.add(record);
69    }
70}
71
72class Data {
73    @ExcelProperty(index = 0)
74    private String name;
75
76    @ExcelProperty(index = 1)
77    private int age;
78
79    // Getters and setters
80}
81