• springmvc http请求，支持get，post,附件传输和参数传输

    主要解决http请求支持get,post,put,delete等常规方法，支持@RequestParam,@RequestBody,@PathVariable等参数格式传输，支持传输附件同时传递参数等，主体代码如下：

    1. package mes.client.action;
    2.  
    3. import cn.hutool.crypto.digest.DigestUtil;
    4. import com.alibaba.fastjson.JSON;
    5. import mes.client.pojo.po.CommonEntityPo;
    6. import mes.client.pojo.vo.ResponseInfo;
    7. import org.slf4j.Logger;
    8. import org.slf4j.LoggerFactory;
    9.  
    10. import java.io.*;
    11. import java.net.HttpURLConnection;
    12. import java.net.URL;
    13. import java.util.List;
    14. import java.util.Map;
    15.  
    16. public class MesMomConnectAction {
    17.  
    18.     private static Logger logger = LoggerFactory.getLogger(MesMomConnectAction.class);
    19.     
    20.     /**
    21.      * 无请求体body,向指定URL发送方法的请求
    22.      *
    23.      * @param url   发送请求的URL
    24.      * @return URL 所代表远程资源的响应结果
    25.      */
    26.     public static ResponseInfo getHttpParamReq(String url,String requestMethodType) {
    27.         StringBuilder result = new StringBuilder();
    28.         BufferedReader in = null;
    29.         HttpURLConnection connection = null;
    30.         try {
    31.             URL getUrl = new URL(url);
    32.             // 打开和URL之间的连接
    33.             connection = (HttpURLConnection) getUrl.openConnection();
    34.  
    35.             // 在connect之前，设置通用的请求属性
    36.             connection.setRequestProperty("accept", "*/*");
    37.             connection.setRequestProperty("connection", "Keep-Alive");
    38.             connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
    39.             connection.setRequestProperty("Charsert", "UTF-8");
    40.             //添加必须的头部信息
    41.             addHeader(connection);
    42.  
    43.             // 配置本次连接的Content-type，form表单是"application/x-www-form-urlencoded"，json是"application/json"等
    44.             // 根据需求自己调整Content-type
    45.             connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
    46.             // 设置连接主机服务器的超时时间：15000毫秒
    47.             connection.setConnectTimeout(15000);
    48.             // 设置读取远程返回的数据时间：60000毫秒
    49.             connection.setReadTimeout(60000);
    50.             // 设置连接方式：get
    51.             connection.setRequestMethod(requestMethodType);
    52.             // 建立实际的连接，可不写，注意connection.getOutputStream会隐含的进行connect。
    53.             connection.connect();
    54.  
    55.             // 定义BufferedReader输入流来读取URL的响应
    56.             in = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
    57.             String line;
    58.             while ((line = in.readLine()) != null) {
    59.                 result.append(line);
    60.             }
    61.  
    62.             ResponseInfo responseInfo = JSON.parseObject(result.toString(), ResponseInfo.class);
    63.             if(responseInfo.getStatusCode() == null){
    64.                 return getFailResponse(result.toString());
    65.             }
    66.             return responseInfo;
    67.         } catch (Exception e) {
    68.             logger.error("调用MES4.0接口异常",e);
    69.             return getExceptionResponse(e);
    70.         }
    71.         // 使用finally块来关闭输入流
    72.         finally {
    73.             try {
    74.                 if (in != null) {
    75.                     in.close();
    76.                 }
    77.                 if (connection != null) {
    78.                     //关闭连接
    79.                     connection.disconnect();
    80.                 }
    81.             } catch (Exception e2) {
    82.                 e2.printStackTrace();
    83.             }
    84.         }
    85.         
    86.     }
    87.     
    88.     /** 
    89.      * @description: get请求
    90.      * @date: 2023-10-16 16:58:30 
    91.      * @param url 
    92.      * @return ResponseInfo 
    93.      */
    94.     public static ResponseInfo sendGet(String url){
    95.         return getHttpParamReq(url,"GET");
    96.     }
    97.  
    98.     /** 
    99.      * @description:方法说明
    100.      * @date: 2023-10-16 15:42:33 
    101.      * @param url 
    102.      * @return ResponseInfo 
    103.      */
    104.     public static ResponseInfo sendDelete(String url) {
    105.         return getHttpParamReq(url,"DELETE");
    106.     }
    107.     
    108.     /** 
    109.      * @description: post请求
    110.      * @date: 2023-10-16 17:04:07 
    111.      * @param url 
    112.      * @param param 
    113.      * @return ResponseInfo 
    114.      */
    115.     public static ResponseInfo sendPost(String url, CommonEntityPo param){
    116.         return getHttpBodyReq(url,param,"POST");
    117.     }
    118.     
    119.     /** 
    120.      * @description: put请求
    121.      * @date: 2023-10-16 17:05:05 
    122.      * @param url 
    123.      * @param param 
    124.      * @return ResponseInfo 
    125.      */
    126.     public static ResponseInfo sendPut(String url, CommonEntityPo param){
    127.         return getHttpBodyReq(url,param,"PUT");
    128.     }
    129.  
    130.     /**
    131.      * 有请求体body,向指定 URL 发送方法的请求
    132.      *
    133.      * @param url   发送请求的 URL
    134.      * @param param 请求参数。
    135.      * @return 所代表远程资源的响应结果
    136.      */
    137.     public static ResponseInfo getHttpBodyReq(String url, CommonEntityPo param, String requestMethodType) {
    138.         BufferedReader in = null;
    139.         InputStream inputStream = null;
    140.         HttpURLConnection connection = null;
    141.         StringBuilder result = new StringBuilder();
    142.         try {
    143.             URL postUrl = new URL(url);
    144.             // 打开和URL之间的连接
    145.             connection = (HttpURLConnection) postUrl.openConnection();
    146.  
    147.             // 在connect之前，设置通用的请求属性
    148.             connection.setRequestProperty("accept", "*/*");
    149.             connection.setRequestProperty("connection", "Keep-Alive");
    150.             connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
    151.             connection.setRequestProperty("Charsert", "UTF-8");
    152.             //添加一些必要的请求头信息
    153.             addHeader(connection);
    154.             //connection.setRequestProperty("Authorization","Bearer eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJiUlR5WGJ0Q05aaS1fUkVKSGUwNHNEd2RYaTNVSHRLOWZoWndXdGdPdWdNIn0.eyJleHAiOjE2OTc0MzM5NDksImlhdCI6MTY5NzAwMTk0OSwiYXV0aF90aW1lIjoxNjk2NzYwOTcxLCJqdGkiOiJiMjcyYzM2My1kMDQ1LTRhMTAtOTc5Ni0xZGE0ZmYwNDkxYTkiLCJpc3MiOiJodHRwOi8vaWRtLWRldi5zdW53b2RhLWV2Yi5jb20vYXV0aC9yZWFsbXMvc3RhbmRhcmQiLCJhdWQiOiJhY2NvdW50Iiwic3ViIjoiNmIxOTE4NWYtODcxZi00NTk1LWIxZTUtYTIwZTQ1MzcyZjQ3IiwidHlwIjoiQmVhcmVyIiwiYXpwIjoibnRzLWZyb250LXRlc3QiLCJub25jZSI6Ijc3MjBkM2QyLTg3NDQtNDI3Yy1iMzBhLTE5YWU2ZDM5NzY3NiIsInNlc3Npb25fc3RhdGUiOiJhNDJlNzU0ZC04MmRjLTQxNTgtOWQyYi1iZWZkNzNmMGI4NzUiLCJhY3IiOiIwIiwiYWxsb3dlZC1vcmlnaW5zIjpbIioiXSwicmVhbG1fYWNjZXNzIjp7InJvbGVzIjpbIm9mZmxpbmVfYWNjZXNzIiwidW1hX2F1dGhvcml6YXRpb24iXX0sInJlc291cmNlX2FjY2VzcyI6eyJhY2NvdW50Ijp7InJvbGVzIjpbIm1hbmFnZS1hY2NvdW50IiwibWFuYWdlLWFjY291bnQtbGlua3MiLCJ2aWV3LXByb2ZpbGUiXX19LCJzY29wZSI6Im9wZW5pZCBlbWFpbCBwcm9maWxlIiwiZW1haWxfdmVyaWZpZWQiOmZhbHNlLCJuYW1lIjoi6IuP5pWPIiwicHJlZmVycmVkX3VzZXJuYW1lIjoieHdkMTYiLCJnaXZlbl9uYW1lIjoi6IuP5pWPIiwibG9jYWxlIjoiemgtQ04ifQ.AUnf5meZWqYNYbfbzyqY3C9WoiL-ISCoVebvtJV-1EF8iQe2FXVEE22CLKnTvHBEoY-W62F8LtG3eW3B5LP54WBXq0JyxnMSLTjqZWMfvYmxNLfjO3rcviK9jAqqxrvLy1IR4ZVFz8ez4ThfCr3TrbammQvZgxF1jie_hx_-3RTiLTra1qyTUj8CrFRaVDBvWTt8nDu6FsRBAkqImPgZ3Jdhf-WDeVlwOkDCGPd5cUQ9KAQs2JUMY4H_jC9cgcSpQuUjNOQOnu1lnYjnsREswR7iBNSkaW6DlRry-HhD8FRs1QLOwKGcgFCBU7O9O-NCH8EyrZOriSpiPaElE2-i2Q");
    155.  
    156.             connection.setConnectTimeout(15000);
    157.             connection.setReadTimeout(60000);
    158.             // 发送POST请求必须设置如下两行，参数要放在http正文内
    159.             connection.setDoOutput(true);
    160.             connection.setDoInput(true);
    161.             // 默认是 GET方式
    162.             connection.setRequestMethod(requestMethodType);
    163.             // Post 请求不使用缓存
    164.             connection.setUseCaches(false);
    165.             // 配置连接的Content-type，form表单是"application/x-www-form-urlencoded"，json是"application/json"等
    166.             connection.setRequestProperty("Content-Type", "application/json");
    167.             connection.connect();
    168.             
    169.             //参数处理
    170.             if(param != null){
    171.                 //打印接口入参
    172.                 logger.info("post请求接口入参：{}",JSON.toJSONString(param.getData()));
    173.                 
    174.                 BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream(), "UTF-8"));
    175.                 writer.write(JSON.toJSONString(param.getData()));
    176.                 writer.close();
    177.             }
    178.  
    179.             // 定义BufferedReader输入流来读取URL的响应
    180.             in = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
    181.             String line;
    182.             while ((line = in.readLine()) != null) {
    183.                 result.append(line);
    184.             }
    185.             
    186.             ResponseInfo responseInfo = JSON.parseObject(result.toString(), ResponseInfo.class);
    187.             if(responseInfo.getStatusCode() == null){
    188.                 return getFailResponse(result.toString());
    189.             }
    190.             return responseInfo;
    191.         } catch (Exception e) {
    192.             logger.error("调用MES4.0接口异常",e);
    193.             return getExceptionResponse(e);
    194.         } finally {
    195.             try {
    196.                 if (in != null) {
    197.                     in.close();
    198.                 }
    199.                 if(inputStream != null){
    200.                     inputStream.close();
    201.                 }
    202.                 if (connection != null) {
    203.                     //关闭连接
    204.                     connection.disconnect();
    205.                 }
    206.             } catch (IOException ex) {
    207.                 ex.printStackTrace();
    208.             }
    209.         }
    210.     }
    211.     
    212.     /*public static void main(String[] args) throws IOException {
    213.         //=========================================邮箱==================================================
    214.         List<Map<String, Object>> files = new ArrayList<>();
    215.         Map<String, Object> map = new HashMap();
    216.         File file = new File("C:\\Users\\86188\\Desktop\\t1.png");
    217.         map.put("name", "t1.png");
    218.         map.put("file", file);
    219.         files.add(map);
    220.  
    221.         Map<String, Object> param = new HashMap();
    222.         param.put("data", "data");
    223.         sendFileUrl("http://127.0.0.1:8080/sendReport", files, param);
    224.     }*/
    225.     
    226.     /** 
    227.      * @description: 有附件和参数的发送方法的请求（调用方式参考实例如上方法）
    228.      * @date: 2023-10-23 10:41:40 
    229.      * @param actionUrl ：请求链接url
    230.      * @param files : 附件
    231.      * @param param ：请求参数
    232.      * @return ResponseInfo 
    233.      */
    234.     public static void sendFileUrl(String actionUrl, List<Map<String, Object>> files, Map param){
    235.         HttpURLConnection conn = null;
    236.         DataOutputStream outStream = null;
    237.         try {
    238.             final String NEWLINE = "\r\n";
    239.             String BOUNDARY = java.util.UUID.randomUUID().toString();
    240.             String PREFIX = "--", LINEND = "\r\n";
    241.             String MULTIPART_FROM_DATA = "multipart/form-data";
    242.             String CHARSET = "UTF-8";
    243.             URL uri = new URL(actionUrl);
    244.             conn = (HttpURLConnection) uri.openConnection();
    245.             conn.setConnectTimeout(15000);
    246.             conn.setReadTimeout(60000);
    247.             conn.setDoInput(true);// 允许输入
    248.             conn.setDoOutput(true);// 允许输出
    249.             conn.setUseCaches(false);
    250.             conn.setRequestMethod("POST"); // Post方式
    251.             conn.setRequestProperty("connection", "keep-alive");
    252.             conn.setRequestProperty("Charsert", "UTF-8");
    253.             conn.setRequestProperty("Accept", "application/json;charset=UTF-8");
    254.             conn.setRequestProperty("Content-Type", MULTIPART_FROM_DATA
    255.                     + ";boundary=" + BOUNDARY);
    256.  
    257.             outStream = new DataOutputStream(
    258.                     conn.getOutputStream());
    259.  
    260.  
    261.             // 获取表单中上传控件之外的控件数据，写入到输出流对象（根据上面分析的抓包的内容格式拼凑字符串）；
    262.             if (param != null && !param.isEmpty()) { // 这时请求中的普通参数，键值对类型的，相当于上面分析的请求中的username，可能有多个
    263.                 for (Map.Entry<String, Object> entry : param.entrySet()) {
    264.                     String key = entry.getKey(); // 键，相当于上面分析的请求中的username
    265.                     Object value = param.get(key); // 值，相当于上面分析的请求中的sdafdsa
    266.                     outStream.writeBytes(PREFIX + BOUNDARY + NEWLINE); // 像请求体中写分割线，就是前缀+分界线+换行
    267.                     outStream.writeBytes("Content-Disposition: form-data; "
    268.                             + "name=\"" + key + "\"" + NEWLINE); // 拼接参数名，格式就是Content-Disposition: form-data; name="key" 其中key就是当前循环的键值对的键，别忘了最后的换行
    269.                     outStream.writeBytes(NEWLINE); // 空行，一定不能少，键和值之间有一个固定的空行
    270.                     outStream.write(value.toString().getBytes("UTF-8")); // 将值写入,用字节流防止乱码
    271.                     // 或者写成：dos.write(value.toString().getBytes(charset));
    272.                     outStream.writeBytes(NEWLINE); // 换行
    273.                 }
    274.             }
    275.  
    276.             // 发送文件数据
    277.             if (files != null)
    278.                 for (Map<String, Object> file : files) {
    279.                     StringBuilder sb1 = new StringBuilder();
    280.                     sb1.append(PREFIX);
    281.                     sb1.append(BOUNDARY);
    282.                     sb1.append(LINEND);
    283.                     sb1.append("Content-Disposition: form-data; name=\"file\"; filename=\""
    284.                             + file.get("name") + "\"" + LINEND);
    285.                     sb1.append("Content-Type: application/octet-stream; charset="
    286.                             + CHARSET + LINEND);
    287.                     sb1.append(LINEND);
    288.                     outStream.write(sb1.toString().getBytes("utf-8"));    //getBytes()不加utf-8 传输中文名附件时，接收附件的地方解析文件名会乱码
    289.  
    290.                     InputStream is = new FileInputStream((File) file.get("file"));
    291.                     byte[] buffer = new byte[1024];
    292.                     int len = 0;
    293.                     while ((len = is.read(buffer)) != -1) {
    294.                         outStream.write(buffer, 0, len);
    295.                     }
    296.  
    297.                     is.close();
    298.                     outStream.write(LINEND.getBytes());
    299.                 }
    300.  
    301.             // 请求结束标志
    302.             byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINEND).getBytes();
    303.             outStream.write(end_data);
    304.             outStream.flush();
    305.  
    306.             // 得到响应码
    307.             int res = conn.getResponseCode();
    308.             //if (res == 200) {
    309.                 InputStream in = conn.getInputStream();
    310.                 InputStreamReader isReader = new InputStreamReader(in,"UTF-8");
    311.                 BufferedReader bufReader = new BufferedReader(isReader);
    312.                 String line = "";
    313.                 String data = "";
    314.                 while ((line = bufReader.readLine()) != null) {
    315.                     data += line;
    316.                 }
    317.                 logger.info("读取后最后结果：" + data);
    318.             //}
    319.         } catch (Exception e) {
    320.             e.printStackTrace();
    321.         } finally {
    322.             try {
    323.                 //关闭流
    324.                 if(outStream != null){
    325.                     outStream.close();
    326.                 }
    327.                 //关闭连接
    328.                 if(conn != null){
    329.                     conn.disconnect();
    330.                 }
    331.             } catch (IOException e) {
    332.                 e.printStackTrace();
    333.             }
    334.         }
    335.     }
    336.     
    337.     
    338.     //multipartFile格式文件发送
    339.     public static void sendMultipartFileUrl(String actionUrl, MultipartFile file, Map<String, Object> param){
    340.         HttpURLConnection conn = null;
    341.         DataOutputStream outStream = null;
    342.         try {
    343.             final String NEWLINE = "\r\n";
    344.             String BOUNDARY = java.util.UUID.randomUUID().toString();
    345.             String PREFIX = "--", LINEND = "\r\n";
    346.             String MULTIPART_FROM_DATA = "multipart/form-data";
    347.             String CHARSET = "UTF-8";
    348.             URL uri = new URL(actionUrl);
    349.             conn = (HttpURLConnection) uri.openConnection();
    350.             conn.setConnectTimeout(15000);
    351.             conn.setReadTimeout(60000);
    352.             conn.setDoInput(true);// 允许输入
    353.             conn.setDoOutput(true);// 允许输出
    354.             conn.setUseCaches(false);
    355.             conn.setRequestMethod("POST"); // Post方式
    356.             conn.setRequestProperty("connection", "keep-alive");
    357.             conn.setRequestProperty("Charsert", "UTF-8");
    358.             conn.setRequestProperty("Accept", "application/json;charset=UTF-8");
    359.             conn.setRequestProperty("Content-Type", MULTIPART_FROM_DATA
    360.                     + ";boundary=" + BOUNDARY);
    361.  
    362.             outStream = new DataOutputStream(
    363.                     conn.getOutputStream());
    364.  
    365.  
    366.             // 获取表单中上传控件之外的控件数据，写入到输出流对象（根据上面分析的抓包的内容格式拼凑字符串）；
    367.             if (param != null && !param.isEmpty()) { // 这时请求中的普通参数，键值对类型的，相当于上面分析的请求中的username，可能有多个
    368.                 for (Map.Entry<String, Object> entry : param.entrySet()) {
    369.                     String key = entry.getKey(); // 键，相当于上面分析的请求中的username
    370.                     Object value = param.get(key); // 值，相当于上面分析的请求中的sdafdsa
    371.                     outStream.writeBytes(PREFIX + BOUNDARY + NEWLINE); // 像请求体中写分割线，就是前缀+分界线+换行
    372.                     outStream.writeBytes("Content-Disposition: form-data; "
    373.                             + "name=\"" + key + "\"" + NEWLINE); // 拼接参数名，格式就是Content-Disposition: form-data; name="key" 其中key就是当前循环的键值对的键，别忘了最后的换行
    374.                     outStream.writeBytes(NEWLINE); // 空行，一定不能少，键和值之间有一个固定的空行
    375.                     outStream.write(value.toString().getBytes("UTF-8")); // 将值写入,用字节流防止乱码
    376.                     // 或者写成：dos.write(value.toString().getBytes(charset));
    377.                     outStream.writeBytes(NEWLINE); // 换行
    378.                 }
    379.             }
    380.  
    381.             // 发送文件数据
    382.             if (file != null){
    383.                 StringBuilder sb1 = new StringBuilder();
    384.                 sb1.append(PREFIX);
    385.                 sb1.append(BOUNDARY);
    386.                 sb1.append(LINEND);
    387.                 sb1.append("Content-Disposition: form-data; name=\"file\"; filename=\""
    388.                         + file.getOriginalFilename() + "\"" + LINEND);
    389.                 sb1.append("Content-Type: application/octet-stream; charset="
    390.                         + CHARSET + LINEND);
    391.                 sb1.append(LINEND);
    392.                 outStream.write(sb1.toString().getBytes("utf-8"));    //getBytes()不加utf-8 传输中文名附件时，接收附件的地方解析文件名会乱码
    393.                 
    394.                 InputStream is = file.getInputStream();
    395.                 byte[] buffer = new byte[1024];
    396.                 int len = 0;
    397.                 while ((len = is.read(buffer)) != -1) {
    398.                     outStream.write(buffer, 0, len);
    399.                 }
    400.  
    401.                 is.close();
    402.                 outStream.write(LINEND.getBytes());
    403.             }
    404.  
    405.             // 请求结束标志
    406.             byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINEND).getBytes();
    407.             outStream.write(end_data);
    408.             outStream.flush();
    409.  
    410.             // 得到响应码
    411.             int res = conn.getResponseCode();
    412.             //if (res == 200) {
    413.             InputStream in = conn.getInputStream();
    414.             InputStreamReader isReader = new InputStreamReader(in,"UTF-8");
    415.             BufferedReader bufReader = new BufferedReader(isReader);
    416.             String line = "";
    417.             String data = "";
    418.             while ((line = bufReader.readLine()) != null) {
    419.                 data += line;
    420.             }
    421.             logger.info("读取后最后结果：" + data);
    422.             //}
    423.         } catch (Exception e) {
    424.             e.printStackTrace();
    425.         } finally {
    426.             try {
    427.                 //关闭流
    428.                 if(outStream != null){
    429.                     outStream.close();
    430.                 }
    431.                 //关闭连接
    432.                 if(conn != null){
    433.                     conn.disconnect();
    434.                 }
    435.             } catch (IOException e) {
    436.                 e.printStackTrace();
    437.             }
    438.         }
    439.     }
    440.     
    441.     /** 
    442.      * @description: 需要额外添加一些请求头信息
    443.      * @date: 2023-10-11 14:42:07 
    444.      */
    445.     private static void addHeader(HttpURLConnection connection){
    446.         //针对一些第三方系统加密header
    447.     }
    448.     
    449.     /** 
    450.      * @description: 返回请求异常信息
    451.      * @date: 2023-10-15 17:43:36 
    452.      * @param e 
    453.      * @return ResponseInfo 
    454.      */
    455.     private static ResponseInfo getExceptionResponse(Exception e){
    456.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    457.         e.printStackTrace(new PrintStream(baos));
    458.         String failMsg = baos.toString();
    459.         return getFailResponse(failMsg);
    460.     }
    461.     
    462.     /** 
    463.      * @description: 封装返回信息结果
    464.      * @date: 2023-10-19 19:44:23 
    465.      * @param failMsg 
    466.      * @return ResponseInfo 
    467.      */
    468.     private static ResponseInfo getFailResponse(String failMsg){
    469.         ResponseInfo responseInfo = new ResponseInfo();
    470.         responseInfo.setStatusCode(400);
    471.         responseInfo.setMessage(failMsg);
    472.         return responseInfo;
    473.     }
    474. }

  • 相关阅读:
    Java核心知识体系4：AOP原理和切面应用
    如何彻底搞懂组合（Composite）设计模式？
    Linux实现原理 — I/O 处理流程与优化手段
    Piramiko实现root权限登录
    Metabase学习教程：权限-1
    新闻文化建设杂志新闻文化建设杂志社新闻文化建设编辑部2022年第14期目录
    (附源码)计算机毕业设计ssmJAVA高校田径运动会管理
    Codeforces 802I - Fake News(hard) 后缀数组+单调栈
    Pytest-xdist并行执行用例时的“坑”
    算法竞赛入门【码蹄集进阶塔335题】(MT2281-2285）
  • 原文地址：https://blog.csdn.net/qq_25313187/article/details/133989948