从零开始的 JavaWeb 之旅

本文最后更新于：14 天前

心怀希望，即使在最深的黑暗中也能找到光明。

系统学习

2024 年 5 月 31 日

JSP 运行原理_jsp 网页运行原理-CSDN 博客

JSP 技术原理_jsp 运行原理-CSDN 博客

JSP 运行原理_简述 jsp 的基本运行原理-CSDN 博客

1
JSP全名是Java Server Pages，它是建立在Servlet规范之上的动态网页开发技术。在JSP文件中，HTML代码与Java代码共同存在，其中，HTML代码用来实现网页 中静态内容的显示，Java代码用来实现网页中动态内容的显示。为了与传统HTML有所区别，JSP文件的扩展名为 .jsp

Servlet 是什么？怎么使用？_什么是 servlet-CSDN 博客

Servlet 简单介绍_servlet 是什么-CSDN 博客

1
2
3
4
5
6
7
Web Client 向 Servlet 容器（ Tomcat ）发出 Http 请求Servlet 容器接收 Web Client 的请求
Servlet 容器创建一个 HttpServletRequest 对象，将 Web Client 请求的信息封装到这个对象中
Servlet 容器创建一个 HttpServletResponse 对象
Servlet 容器调 HttpServlet 对象 service 方法，把 Request 与 Response 作为参数，传给 HttpServlet
HttpServlet 调用 HttpServletRequest 对象的有关方法，获取 Http 请求信息
HttpServlet 调用 HttpServletResponse 对象的有关方法，生成响应数据
Servlet 容器把 HttpServlet 的响应结果传给 Web Client

【JavaEE 基础学习打卡 08】JSP 之初次认识 say hello！_jsp 执行流程-CSDN 博客

[Servlet 是什么？怎么使用？_什么是 servlet-CSDN 博客](

经验

使用 maven 打个 war 包，报了一连串的错误：

  1. IDEA maven 未配置好，配置一下就行
  2. 有依赖下载失败，换了新的版本解决了
  3. 测试用例有错误，打包时直接忽略掉测试用例就行
  4. Cannot access defaults field of Properties 问题，看下面

Cannot access defaults field of Properties 问题的解决-CSDN 博客

1
2
3
4
5
6
7
8
9
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.3.1</version>
        </plugin>
    </plugins>
</build>

有必要图文总结下这方面的经验了。

maven 打包、本地起 tomcat 服务器

image-20240326104155627

image-20240326104311608

像这样的报错，十有八九是项目使用的 Java 版本过低，提高到 JDK8 即可：

image-20240326104422888

最不想看到的就是 tomcat 服务起来之后，出现这样的情况：

image-20240326111338744

真是没有任何可以下手的地方

总结

有必要图文总结下这方面的经验了。

maven 打包、本地起 tomcat 服务器

image-20240327101230706

image-20240327101621140

程序包 javax.annotation 不存在？_百度知道 (baidu.com)

错误: 程序包 javax.annotation 不存在_mob64ca12e732bb 的技术博客_51CTO 博客

报错 java: 程序包 javax.servlet.http 不存在-CSDN 博客

程序包 javax.servlet 不存在 解决办法_helloservlet.java:4: 错误: 程序包 javax.servlet.http 不存在 -CSDN 博客

java: 程序包 javax.servlet 不存在、 java: 程序包 javax.servlet.http 不存在 java: 程序包 javax.servlet.annotation 不存在-CSDN 博客

跟着一通操作，还真打包成功了。

朔州市检察院可视化

后端

后端安装子模块出现问题：

关于 pom.xml 一直提示 Could not transfer artifact（无法搬运）+无法解析 maven 依赖的问题，我在学习 springboot 的过程中遇到的一些问题-CSDN 博客

这个问题我直接执行一键安装全部模块，然后单独安装每个子模块就可以

image-20240327113245582

前端

若依前端出现报错，解决方法：

若依报错解决_> ruoyi@3.8.6 dev > vue-cli-service serve info sta-CSDN 博客

1
$env:NODE_OPTIONS="--openssl-legacy-provider"

2024 年 9 月 4 日

补充：

这个错误 ERR_OSSL_EVP_UNSUPPORTED 通常与 Node.js 的 OpenSSL 加密库有关，特别是在 Node.js 17 及以上版本中更为常见。这个错误通常是因为 Node.js 试图使用 OpenSSL 的某些特性，但当前的系统环境或 OpenSSL 版本不支持这些特性。

解决方案

  1. 设置环境变量：
    你可以通过设置环境变量 NODE_OPTIONS 来告诉 Node.js 使用 OpenSSL 的旧版 API。这可以通过在你的命令行或 shell 脚本中添加以下命令来实现：

    1
    2
    3
    bash复制代码

    export NODE_OPTIONS=--openssl-legacy-provider

    如果你是在 Windows 系统中，可以使用：

    1
    2
    3
    cmd复制代码

    set NODE_OPTIONS=--openssl-legacy-provider

    或者，如果你使用的是 PowerShell，可以使用：

    1
    2
    3
    powershell复制代码

    $env:NODE_OPTIONS="--openssl-legacy-provider"

    注意：这个环境变量需要在启动 Node.js 进程之前设置。

  2. 更新或降级 Node.js：
    如果你正在使用的 Node.js 版本与你的操作系统或 OpenSSL 版本不兼容，考虑升级到最新版本的 Node.js 或降级到一个更稳定的版本。

  3. 更新 OpenSSL：
    确保你的系统上安装的 OpenSSL 是最新的，或者至少是与你的 Node.js 版本兼容的版本。

  4. 检查依赖：
    检查你的项目中是否有任何依赖项需要特定版本的 Node.js 或 OpenSSL。有时候，更新或降级这些依赖项可以解决问题。

  5. 清理和重建：
    删除 node_modules 文件夹和 package-lock.json 或 yarn.lock 文件，然后重新运行 npm install 或 yarn 来安装依赖项。这可以确保所有依赖项都是最新的，并且与你的 Node.js 版本兼容。

  6. 查看文档和社区：
    查看 Node.js 和相关库的官方文档，以及 Stack Overflow、GitHub Issues 等社区论坛，看看是否有其他人遇到并解决了类似的问题。

执行这条命令，确实百分百永久解决问题

image-20240327140712627

image-20240327105609337

image-20240327105629244

Java spring 注解 @PostConstruct 实战讲解-CSDN 博客

运行

很好，问题已解决：

这个错误日志显示了一个java.lang.NoClassDefFoundError异常，具体是找不到javax.xml.bind.DatatypeConverter类。DatatypeConverter是 Java 平台的一个类，用于在不同类型的 Java 数据类型和字符串之间进行转换，它属于 Java 的 JAXB（Java Architecture for XML Binding）API 的一部分。

这个异常通常发生在 Java 9 及以上版本的环境中，因为从 Java 9 开始，JAXB 不再作为 Java SE 的一部分，而是被标记为模块化的 JDK 中的可选部分。如果你的应用是基于 Java 9 或更高版本，并且你没有显式地将 JAXB 添加到你的项目依赖中，就可能会遇到这个问题。

要解决这个问题，你有以下几个选项：

  1. 添加 JAXB 依赖：
    在你的项目构建文件（如 Maven 的pom.xml或 Gradle 的build.gradle）中，添加 JAXB 的依赖。例如，如果你使用 Maven，可以添加如下依赖：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <dependency>
        <groupId>javax.xml.bind</groupId>
        <artifactId>jaxb-api</artifactId>
        <version>2.3.1</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
        <version>2.3.1</version>
    </dependency>

    确保使用与你项目兼容的 JAXB 版本。

  2. 使用 Java 8：
    如果你的项目没有特定的理由必须使用 Java 9 或更高版本，你可以考虑切换回 Java 8，因为 JAXB 在 Java 8 中是内置的。

  3. 添加 JVM 参数：
    如果你使用的是 Java 9 或更高版本，并且不想修改项目依赖，你可以尝试通过添加 JVM 参数来启用 JAXB 模块。例如，你可以添加如下 JVM 参数：

    1
    2
    3
    shell复制代码

    --add-modules java.se.ee

    然而，请注意，这种方法并不是官方推荐的，并且可能在未来的 Java 版本中不再有效。

  4. 检查代码库：
    如果DatatypeConverter是由某个库间接使用的，那么你可能需要更新这个库到支持 Java 9 及以上版本的版本，或者寻找一个替代库。

请根据你的具体情况选择最合适的解决方案。如果你正在使用 Spring Boot，确保你的 Spring Boot 版本与你的 Java 版本兼容，因为 Spring Boot 通常会处理这类依赖问题。如果问题依然存在，可能需要进一步检查你的项目配置和依赖关系。

入参：部门 id（belongDeptId），排名（sortNum），日期（time），指标等级（indexLevel）

根据时间（time）获取 newTime；根据部门 id（belongDeptId）获取父单位 id（parentId）；根据（newTime + parentId）更新指标等级（indexLevel）；根据指标等级（indexLevel）拿到字典类型（dictType）

联表查询指标库（bus_index_library）、指标数据（bus_index_value）、部门表（bus_dept）

朔州市查询，部门就为朔州市院；各县市查询，部门为对应县市院。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<select id="selectRankingDetails" resultType="com.zw.business.domain.vo.ResultVo">
    select d.index_value_id id, d.index_id indexId, belong_dept_id belongDeptId, sort_num sortNum, index_name indexName, index_until indexUntil,
        index_type indexType, index_value indexValue, index_parent_value indexParentValue,d.group_sort as groupSort,
        e.notification as notification ,e.index_order as indexOrder, e.index_logo as indexLogo
        from bus_index_value d left join bus_index_library e on d.index_id=e.index_id left join sys_dept f on belong_dept_id = dept_id
        where belong_dept_id = #{belongDeptId}
        <if test="indexIds != null and indexIds != ''"> and d.index_id in (${indexIds})</if>
        <if test="sortNum != null and sortNum != ''"> and d.sort_num = #{sortNum} </if>
        <if test="newTime != null and newTime != ''"> and d.index_time like concat(#{newTime},'%') </if>
        <if test="valueLevel != null and valueLevel != ''"> and d.value_level = #{valueLevel} </if>
        <if test="indexLevel != null and indexLevel != ''"> and e.index_level = #{indexLevel} </if>
        <if test="isCore != null and isCore != ''"> and e.is_core = #{isCore} </if>
        <if test="isSort != null and isSort != ''"> and e.is_sort = #{isSort} </if>
  </select>

根据字典类型（dictType）查询获取字典标签（dictLabel），给所有记录设置字典标签 / 业务类型。

默认指标等级（index_level）是 2，该指标等级对应的指标类型为：DICT_TYPE_INDEX_56，即字典类型。根据字典类型查询字典库（dict_library）获取到的字典标签列表，并按字典数据（dictValue）升序排序。

1
2
3
// 根据dict_type查询指标类型集合
    @Select("select dict_value as dictValue, dict_label dictLabel, remark as remark from sys_dict_data where dict_type = #{dictType} ORDER BY dict_value")
    public List<SysDictData> getIndexTypeList(String dictType);

根据字典数据（dictValue）升序排序获取的字典标签（dictLabel）。每个指标名称都有所属指标类型（即字典标签 dictLabel），用指标类型（index_type）关联（dictValue）。

1
2
Map<String, String> indexTypeMap = indexUtils.getIndexTypeMap(dictType);
list.forEach(data -> data.setDictLabel(indexTypeMap.get(data.getIndexType())));

一次三表联查 + 单表查询，我们查询到了完整的数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
{
  "id": "27777",
  "indexParentValue": 1.07,
  "sortNum": 1,
  "belongDeptId": 140600,
  "indexTime": "2023-09-02T00:00:00.000+0800",
  "indexId": "277",
  "indexName": "刑事“案-件比”",
  "indexUntil": "≤1.33",
  "indexShort": "刑事“案-件比”",
  "indexType": "0",
  "indexTypeSecond": "",
  "indexTypeThird": "",
  "dictLabel": "刑事检察",
  "deptId": 140600,
  "deptName": "朔州市院",
  "sortNumStr": "≤1.33",
  "notification": 1.33,
  "indexOrder": "1",
  "isCore": "0",
  "isSort": "0",
  "indexLogo": "0",
  "groupSort": "---",
  "showId": "1"
}

删除了认证授权校验，方便接口测试

废弃代码

serviceImpl 层：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
/**
     * 查询所有市院前三位指标数据(单项 + 组合)
     *
     * @param parentId   所属部门 id
     * @param time       日期
     * @param indexLevel 指标等级
     */
    @Override
    public ResponseVo selectFirstShanxiDetails(BigInteger parentId, String time, String indexLevel) {
        // 1.查询得到所有市院部门id
        List<BigInteger> depIdList = new ArrayList<>();
        depIdList = busIndexLibraryMapper.selectFirstShanxi(parentId);

        // 2.每个市院查询指标排名前三的指标数据
        List<Integer> singleResultList = null;
        List<ResultVo> multiResultList = null;
        for (BigInteger belongDeptId : depIdList) {
            // 2.1.单项分析排名前三指标数据
            singleResultList = this.getSingleFirstShanxi(belongDeptId, time, indexLevel);
            // 2.2.组合分析排名前三指标数据
            multiResultList = this.getMultiFirstShanxi(belongDeptId, time, indexLevel);
        }

        // 3.综合所有市院(全省)前三位指标数据

        // 4.返回结果
        return null;
    }

    /**
     * 市院单项分析排名前三位指标数据
     *
     * @param belongDeptId 所属部门 id
     * @param time         日期
     * @param indexLevel   指标等级
     */
    public List<ResultVo> getSingleFirstShanxiDetails(BigInteger belongDeptId, String time, String indexLevel) {
        String newTime = checkTime(time);
        String parentId = indexUtils.getParentId(belongDeptId);
        indexLevel = indexUtils.resetIndexLevel(parentId, newTime);
        String dictType = IndexUtils.getDictType(indexLevel);
        List<ResultVo> list;

        // 获取朔州市检察院前三名指标项详情
        list = busIndexLibraryMapper.getFirstXianDetails(null, belongDeptId, newTime, indexLevel, DictDataConstant.VALUE_LEVEL_ONE, DictDataConstant.IS_CORE_FALSE, DictDataConstant.IS_SORT_FALSE);
        List<ResultVo> list1 = busIndexLibraryMapper.getFirstXianDetails(null, belongDeptId, newTime, indexLevel, DictDataConstant.VALUE_LEVEL_THREE, DictDataConstant.IS_CORE_FALSE, DictDataConstant.IS_SORT_FALSE);
        if (list1.size() > 0) {
            String indexIds = IndexUtils.getIndexIds(list1);
            List<ResultVo> list2 = busIndexLibraryMapper.selectRankingDetails(indexIds, belongDeptId, "", newTime, indexLevel, DictDataConstant.VALUE_LEVEL_TWO, DictDataConstant.IS_CORE_FALSE, DictDataConstant.IS_SORT_FALSE);
            if (list2.size() > 0) {
                list.addAll(list2);
            }
        }
        // 设置指标列表序号
        this.setShowIdNormal(list);
        // 设置业务类型标签
        this.setDictLabelByLevel(list, dictType);
        if (!indexUtils.checkIndexNumber(newTime)) {
            this.resetIndexValue(list);
        }

        return list;
    }

    /**
     * 市院组合分析排名前三位指标数据
     *
     * @param belongDeptId 所属部门 id
     * @param time         日期
     * @param indexLevel   指标等级
     */
    public List<ResultVo> getMultiFirstShanxiDetails(BigInteger belongDeptId, String time, String indexLevel) {
        String newTime = checkTime(time);
        String parentId = indexUtils.getParentId(belongDeptId);
        indexLevel = indexUtils.resetIndexLevel(parentId, newTime);
        String dictType = IndexUtils.getDictType(indexLevel);
        List<ResultVo> list;

        // 获取朔州市检察院前三名指标项详情
        list = busIndexLibraryMapper.getFirstXianDetails(null, belongDeptId, newTime, indexLevel, DictDataConstant.VALUE_LEVEL_ONE, DictDataConstant.IS_CORE_FALSE, DictDataConstant.IS_SORT_FALSE);
        List<ResultVo> list1 = busIndexLibraryMapper.getFirstXianDetails(null, belongDeptId, newTime, indexLevel, DictDataConstant.VALUE_LEVEL_THREE, DictDataConstant.IS_CORE_FALSE, DictDataConstant.IS_SORT_FALSE);
        if (list1.size() > 0) {
            String indexIds = IndexUtils.getIndexIds(list1);
            List<ResultVo> list2 = busIndexLibraryMapper.selectRankingDetails(indexIds, belongDeptId, "", newTime, indexLevel, DictDataConstant.VALUE_LEVEL_TWO, DictDataConstant.IS_CORE_FALSE, DictDataConstant.IS_SORT_FALSE);
            if (list2.size() > 0) {
                list.addAll(list2);
            }
        }
        // 设置指标列表序号
        this.setShowIdNormal(list);
        // 设置业务类型标签
        this.setDictLabelByLevel(list, dictType);
        if (!indexUtils.checkIndexNumber(newTime)) {
            this.resetIndexValue(list);
        }

        return list;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
/**
 * 查询所有市院前三位指标个数(单项 + 组合)
 *
 * @param parentId   所属部门 id
 * @param time       日期
 * @param indexLevel 指标等级
 */
@Override
public ResponseVo selectFirstShanxi(BigInteger parentId, String time, String indexLevel) {
    String newTime = checkTime(time);
    String parentIdStr = String.valueOf(parentId);
    indexLevel = indexUtils.resetIndexLevel(parentIdStr, newTime);

    // 1.查询得到所有市院部门id
    List<BigInteger> depIdList;
    depIdList = busIndexLibraryMapper.selectFirstShanxi(parentId);

    // 2.每个市院查询指标排名前三的个数
    List<Integer> singleList;
    List<List<Integer>> singleResultList = new ArrayList<>();
    for (BigInteger belongDeptId : depIdList) {
        // 2.1.单项分析排名前三指标个数
        singleList = this.getSingleFirstShanxi(belongDeptId, newTime, indexLevel);
        singleResultList.add(singleList);
    }

    // 2.2.组合分析排名前三指标个数(去重)
    List<ResultVo> multiResultList = this.getMultiFirstShanxi(parentId, newTime, indexLevel);

    // 3.综合所有市院(全省)前三位指标个数

    // 4.返回结果
    return null;
}

/**
 * 市院单项分析排名前三位指标个数
 *
 * @param belongDeptId 所属部门 id
 * @param time         日期
 * @param indexLevel   指标等级
 */
public List<Integer> getSingleFirstShanxi(BigInteger belongDeptId, String time, String indexLevel) {
    List<String> sortNumList = new ArrayList<>();

    // 各级指标数量
    List<ResultVo> indexNumList;
    // 区间指标数量
    List<Integer> resultVoList = new ArrayList<>();
    // 山西省
    // 靠前方阵 1 - 3
    for (int i = 1; i <= 3; i++) {
        sortNumList.add(String.valueOf(i));
    }
    // 根据sortNum获取各排名指标个数
    for (String sortNum : sortNumList) {
        indexNumList = busIndexLibraryMapper.selectRankBySortNum(belongDeptId, time, indexLevel, sortNum,
                DictDataConstant.VALUE_LEVEL_FALSE, DictDataConstant.IS_CORE_FALSE, DictDataConstant.IS_SORT_FALSE);
        resultVoList.add(indexNumList.size());
    }

    return resultVoList;
}

/**
 * 市院组合分析排名前三位指标个数
 *
 * @param belongDeptId 所属部门 id
 * @param time         日期
 * @param indexLevel   指标等级
 */
public List<ResultVo> getMultiFirstShanxi(BigInteger belongDeptId, String time, String indexLevel) {
    String newTime = checkTime(time);
    List<ResultVo> resultList;

    List<Integer> sortRankList = new ArrayList<>();
    sortRankList.add(0, 1);
    sortRankList.add(1, 2);
    sortRankList.add(2, 3);

    Map<String, Map> allDeptSortMap = this.getAllDeptSortMap(newTime, belongDeptId.toString());
    Map<BigInteger, Map<Integer, List<ResultVo>>> singleDeptSortMap = allDeptSortMap.get("single");
    Map<BigInteger, Map<String, List<ResultVo>>> groupDeptSortMap = allDeptSortMap.get("disGroup");

    List<IndexFraction> sortList = this.getSortNumSum(newTime, belongDeptId);
    sortList.sort((o1, o2) -> o2.getFraction().compareTo(o1.getFraction()));

    // 装配属性
    resultList = this.transIndexFractionToResultVo(sortList);
    resultList.forEach(data -> {
        Map<Integer, List<ResultVo>> singleMap = singleDeptSortMap.get(data.getDeptId());
        Map<String, List<ResultVo>> groupMap = groupDeptSortMap.get(data.getDeptId());

        Integer first = sortRankList.get(0);
        Integer second = sortRankList.get(1);
        data.setFirst((singleMap.containsKey(first) ? singleMap.get(first).size() : 0)
                + (groupMap.containsKey(first.toString()) ? groupMap.get(first.toString()).size() : 0));
        data.setSecond((singleMap.containsKey(second) ? singleMap.get(second).size() : 0)
                + (groupMap.containsKey(second.toString()) ? groupMap.get(second.toString()).size() : 0));

        if (!indexUtils.checkDept(belongDeptId.toString())) {
            Integer thild = sortRankList.get(2);
            data.setThird((singleMap.containsKey(thild) ? singleMap.get(thild).size() : 0)
                    + (groupMap.containsKey(thild.toString()) ? groupMap.get(thild.toString()).size() : 0));
        }
    });

    // 根据 sortNum, 使用Stream API 和 Lambda 表达式对列表进行排序
    return resultList.stream()
            .sorted(Comparator.comparing(ResultVo::getSortNum)) // 根据fieldName字段进行升序排序
            .collect(Collectors.toList());
}

service 层：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
    * 查询所有市院前三位指标个数(单项 + 组合)
    *
    * @return com.zw.business.domain.vo.ResponseVo
    * @Param parentId 部门Id
    * @Param time 查询年月
    */
   ResponseVo selectFirstShanxi(BigInteger parentId, String time, String indexLevel);

   /**
    * 查询所有市院前三位指标数据(单项 + 组合)
    *
    * @return com.zw.business.domain.vo.ResponseVo
    * @Param belongDeptId 部门Id
    * @Param time 查询年月
    */
   ResponseVo selectFirstShanxiDetails(BigInteger parentId, String time, String indexLevel);

Controller 层：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * @return com.zw.business.domain.vo.ResponseVo
 * @description: 查询所有市院前三位指标个数(单项 + 组合)
 * 1
 * @Param: parentId 父部门Id
 * @Param: time 查询年月
 */
@RequestMapping("/selectFirstShanxi")
public ResponseVo selectFirstShanxi(@RequestParam BigInteger parentId, @RequestParam(required = false, defaultValue = "") String time,
                                    @RequestParam String indexLevel) {
    return busIndexLibraryService.selectFirstShanxi(parentId, time, indexLevel);
}

/**
 * @return com.zw.business.domain.vo.ResponseVo
 * @description: 查询所有市院前三位指标详情(单项 + 组合)
 * 1
 * @Param: parentId 父部门Id
 * @Param: time 查询年月
 */
@RequestMapping("/selectFirstShanxiDetails")
public ResponseVo selectFirstShanxiDetails(@RequestParam BigInteger parentId, @RequestParam(required = false, defaultValue = "") String time,
                                           @RequestParam String indexLevel) {
    return busIndexLibraryService.selectFirstShanxiDetails(parentId, time, indexLevel);
}

serviceImpl 层：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/**
 * 查询全省前三指标数量(1, 2, 3)
 *
 * @return ResponseVo
 * @Param parentId 父部门Id
 * @Param time 查询年月
 */
@Override
public ResponseVo selectSumSortNumQian(BigInteger parentId, String time, String indexLevel) {
    String newTime = checkTime(time);
    indexLevel = indexUtils.resetIndexLevel(parentId.toString(), newTime);

    List<IndexFraction> resultList;
    if (checkFiftySixOrFortyEight(indexLevel)) {
        // 全省前三指标数量(1, 2, 3) 计算组合指标排名 （组合指标 单项指标排名不做计算）
        resultList = this.getSortNumSumQian(newTime, parentId);
    } else {
        // 设置单项排名之和
        // 市/区县院指标排名之和排序
        String dictType = IndexUtils.getDictType(indexLevel);
        resultList = busIndexLibraryMapper.selectSortSumFraction(dictType, newTime, parentId, indexLevel, DictDataConstant.VALUE_LEVEL_ONE + "," + DictDataConstant.VALUE_LEVEL_TWO, DictDataConstant.IS_CORE_FALSE, DictDataConstant.IS_SORT_FALSE);
        resultList.sort(Comparator.comparing(IndexFraction::getFraction));
    }

    return ResponseVo.returnResponse(200, "成功", resultList);
}

   private List<IndexFraction> getSortNumSumQian(String monthId, BigInteger parentId) {
        List<IndexFraction> resultList = new ArrayList<>();
        // 1.列举所有市院/区县院
        List<SysDept> deptTree = deptMapper.getDeptTree(Long.valueOf(parentId.toString()));
        // 2.获取全省（11地市）/全市（12区县）(1, 2, 3) 指标数据集合 （含未测算、未排名）
        List<ResultVo> resultVos = indexUtils.selectQianMultipleValues(monthId, parentId.toString());

        // 3.单项指标 不含未测算 未排名
        List<ResultVo> logoZeroStream = resultVos.stream()
                .filter(s -> DictDataConstant.DEFAULT_GROUP_SORT.equals(s.getGroupSort())
                        && DictDataConstant.IS_CORE_FALSE.equals(s.getIsCore())
                        && DictDataConstant.IS_SORT_FALSE.equals(s.getIsSort()))
                .collect(Collectors.toList());

        // 单项指标 按照 deptId分组
        // key: deptId.toString()    value: list
        Map<BigInteger, List<ResultVo>> logoZeroDeptSortMap = logoZeroStream.stream()
                .collect(Collectors.groupingBy(ResultVo::getDeptId));

        // 4.组合指标集合
        List<ResultVo> logoGroupStream = resultVos.stream()
                .filter(s -> !DictDataConstant.DEFAULT_GROUP_SORT.equals(s.getGroupSort()))
                .collect(Collectors.toList())
                .stream().sorted(Comparator.comparing(ResultVo::getIndexId)).collect(Collectors.toList());
        // 组合指标 按照deptId分组
        Map<BigInteger, List<ResultVo>> groupDeptMap = logoGroupStream.stream().collect(Collectors.groupingBy(ResultVo::getDeptId));
        // 组合指标排名集合  去重
        HashMap<BigInteger, List<Integer>> groupSortMap = new HashMap<>();
        groupDeptMap.forEach((key, value) -> {
            // key 为 deptId
            // 组合指标 按照标识分组  *** 此处未按照indexType分组
            Map<String, List<ResultVo>> oneDeptGroupMap = value.stream().collect(Collectors.groupingBy(ResultVo::getIndexLogo));
            // deptId key  value:list<Integer>
            List<Integer> sortNumList = new ArrayList<>();
            oneDeptGroupMap.forEach((key1, value1) -> {
                // key: deptId.toString()+indexLogo    value: groupSort   deptId:11 * groupSort:14 = 154
                // groupSortMap.put(data.getKey().toString()+s.getKey(),s.getValue().get(0).getGroupSort());
                sortNumList.add(Integer.valueOf(value1.get(0).getGroupSort()));
            });
            groupSortMap.put(key, sortNumList);
        });

        // 5.排名之和累加 装填
        deptTree.forEach(data -> {
            int num = 0;
            List<ResultVo> sigList = logoZeroDeptSortMap.get(new BigInteger(data.getDeptId().toString()));
            for (ResultVo resultVo : sigList) {
                num = num + (null == resultVo.getSortNum() ? 0 : resultVo.getSortNum());
            }

            if (groupSortMap.containsKey(new BigInteger(data.getDeptId().toString()))) {
                List<Integer> grouplist = groupSortMap.get(new BigInteger(data.getDeptId().toString()));
                for (Integer integer : grouplist) {
                    num = num + integer;
                }
            }

            resultList.add(new IndexFraction(num, data.getDeptName(), Integer.valueOf(data.getDeptId().toString()), 0));
        });

        resultList.sort(Comparator.comparing(IndexFraction::getFraction));

        // 等值等排名
        if (CollectionUtils.isNotEmpty(resultList)) {
            int sort = 1;
            for (int j = 0; j < resultList.size(); j++) {
                if (j == 0) {
                    resultList.get(j).setSortNum(sort);
                } else {
                    if (resultList.get(j - 1).getFraction().equals(resultList.get(j).getFraction())) {
                        resultList.get(j).setSortNum(resultList.get(j - 1).getSortNum());
                    } else {
                        resultList.get(j).setSortNum(sort);
                    }
                }
                sort++;
            }
        }

        // 返回全省排名前三
        return resultList.stream()
                .limit(3)
                .collect(Collectors.toList());
    }

/**
 * 查询全省前三指标数据(1, 2, 3)
 *
 * @return ResponseVo
 * @Param parentId 父部门Id
 * @Param time 查询年月
 */
@Override
public ResponseVo selectSumSortNumQianDetails(BigInteger parentId, String time, String indexLevel) {
    String newTime = checkTime(time);
    indexLevel = indexUtils.resetIndexLevel(parentId.toString(), newTime);

    List<IndexFraction> resultList;
    if (checkFiftySixOrFortyEight(indexLevel)) {
        // 全省前三指标数据(1, 2, 3) 计算组合指标排名 （组合指标 单项指标排名不做计算）
        resultList = this.getSortNumSumQian(newTime, parentId);
    } else {
        // 设置单项排名之和
        // 市/区县院指标排名之和排序
        String dictType = IndexUtils.getDictType(indexLevel);
        resultList = busIndexLibraryMapper.selectSortSumFraction(dictType, newTime, parentId, indexLevel, DictDataConstant.VALUE_LEVEL_ONE + "," + DictDataConstant.VALUE_LEVEL_TWO, DictDataConstant.IS_CORE_FALSE, DictDataConstant.IS_SORT_FALSE);
        resultList.sort(Comparator.comparing(IndexFraction::getFraction));
    }

    return ResponseVo.returnResponse(200, "成功", resultList);
}

service 层：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 查询全省前三指标数量(1, 2, 3)
 * 0
 *
 * @return ResponseVo
 * @Param parentId 父部门Id
 * @Param time 查询年月
 */
ResponseVo selectSumSortNumQian(BigInteger parentId, String time, String indexLevel);

/**
 * 查询全省前三指标数据(1, 2, 3)
 * 0
 *
 * @return ResponseVo
 * @Param parentId 父部门Id
 * @Param time 查询年月
 */
ResponseVo selectSumSortNumQianDetails(BigInteger parentId, String time, String indexLevel);

controller 层：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * @return com.zw.business.domain.vo.ResponseVo
 * @description: 查询全省前三指标数量(1, 2, 3)
 * 0
 * @Param: parentId 父部门Id
 * @Param: time 查询年月
 */
// @RequestMapping("/selectSumSortNumQian")
public ResponseVo selectSumSortNumQian(@RequestParam BigInteger parentId, @RequestParam(required = false, defaultValue = "") String time,
                                       @RequestParam String indexLevel) {
    return busIndexLibraryService.selectSumSortNumQian(parentId, time, indexLevel);
}

/**
 * @return com.zw.business.domain.vo.ResponseVo
 * @description: 查询全省前三指标数据(1, 2, 3)
 * 0
 * @Param: parentId 父部门Id
 * @Param: time 查询年月
 */
// @RequestMapping("/selectSumSortNumQianDetails")
public ResponseVo selectSumSortNumQianDetails(@RequestParam BigInteger parentId, @RequestParam(required = false, defaultValue = "") String time,
                                              @RequestParam String indexLevel) {
    return busIndexLibraryService.selectSumSortNumQianDetails(parentId, time, indexLevel);
}

大同检察院

后端

模板路径，后续从配置文件读取

image-20240401105053573

前端

同样的，修改请求的后端地址为本地的 8090 端口

若依前端出现报错，解决方法：

若依报错解决_> ruoyi@3.8.6 dev > vue-cli-service serve info sta-CSDN 博客

1
$env:NODE_OPTIONS="--openssl-legacy-provider"

执行这条命令，确实百分百永久解决问题

检察院可视化

丰子恺经典语录 34 句，精辟走心，句句看透人生，让你受益一生！ (baidu.com)

导入数据

IDEA 书签

【效率提升】IDEA 中书签功能的妙用_idea 书签-CSDN 博客

Spring MySQL 配置：

MySQL 之 InvalidConnectionAttributeException，SQLNonTransientConnectionException_sqlnontransientconnectionexception: server shutdow-CSDN 博客

MySQL 的这行配置还有点门道：

1
url: jdbc:mysql://122.9.51.171:3306/test_shuozhou?serverTimezone=UTC&allowMultiQueries=true&autoReconnect=true&useUnicode=true&failOverReadOnly=false&useSSL=false&characterEncoding=utf-8

Postman 测试文件上传接口：

Postman 上传文件 返回 500 报错 “Current request is not a multipart request” 解决_postman current request is not a multipart request-CSDN 博客

Excel 表格修改后缀：

The supplied data appears to be in the OLE2 Format.-CSDN 博客

推送代码

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name ‘his-CSDN 博客

部署项目 Failure obtaining db row lock: Table ‘XXX.qrtz_LOCKS‘ doesn‘t exist-CSDN 博客

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name ‘his-CSDN 博客

部署项目 Failure obtaining db row lock: Table ‘XXX.qrtz_LOCKS‘ doesn‘t exist-CSDN 博客

3.解决方法：

  • (1)win+R，打开命令提示符框，输入 cmd，进入命令提示符
  • (2)输入 netstat -aon | findstr 1099，找到占用 1099 端口的进程 ID：PID
  • (3)输入 taskkill -f -pid PID
  • (4)重启 Tomcat

持续学习

2024 年 5 月 31 日

JSP 运行原理_jsp 网页运行原理-CSDN 博客

JavaWeb > 经验
#经验 #JavaWeb
从零开始的 JavaWeb 之旅
https://test.atomgit.net/blog/2023/06/03/从零开始的 JavaWeb 之旅/
作者
Memory
发布于
2023年6月3日
更新于
2024年9月4日
许可协议