前言

Hi，同学们好呀，被评为全网最细的丹成学长标签ヾ(•ω•`)o，今天带大家复盘一个学长帮往届同学做的一个毕业作品

基于java web的大学生健康档案管理系统

计算机毕设选题大全及项目分享:

https://blog.csdn.net/WEB_DC/article/details/125563252

1 项目介绍

通过电子健康档案管理系统这个平台，可以实现人员健康情况的信息化、网络化、系统化、规范化管理，从繁杂的数据查询和统计中解脱出来，更好的掌握人员健康状况。系统的主要功能包括：人员档案管理、体检管理与疾病信息管理。

学长设计的该系统前台主要使用Vue作为开发语言，后台使用mysql作为数据库管理系统，开发环境是Idea，开发出的一个基于Web技术的C/S结构的电子健康档案管理系统。

2 相关技术

• springboot
• mysql
• mybatis
• jpa
• swagger-ui
• lombok

3 系统功能设计

健康管理平台的总目标是：在计算机网络，数据库和先进的开发平台上，利用现有的软件，配置一定的硬件，开发一个具有开放体系结构的、易扩充的、易维护的、具有良好人机交互界面的大学生健康管理平台。

3.1 前台功能

在前台的功能实现上，可以分为以下几个部分：

• 1.大学生健康阅读：每日可以在首页进行健康资料阅读
• 2.大学生健康日志：用户可以记录自己健康日记，记录每一天的睡眠，饮酒，吸烟，血压，体重等情况。
• 3.大学生体检管理：大学生可通过该平台查询每次的体检结果，显示部分项目随时间变化的曲线。
• 4.疾病预测评估：针对糖尿病和高血压两种疾病，利用数学线性回归的方法，模拟计算出大学生患病概率。

3.2 后台功能

后台主要有四个功能：

• 1．管理员用户登录功能：通过编号登录系统。
• 2．管理员管理大学生功能：可以增删改查大学生基本信息。
• 3．管理员管理体检结果：可以增删改查大学生体检记录。
• 4．管理员对体检表，健康文档，体检数据图标展示等进行管理，以及权限管理，指定不同科室医生进行不同的操作。

3.3 数据库设计

健康管理平台主要涉及到真实姓名数据字典

系统信息表

报告信息表

权限表

权限资源表

资源表

健康阅读表

检查报告表

3.4 系统实体联系图

4 实现效果-项目展示

登录页

首页

健康建议

添加文章

健康档案管理

查看档案

角色管理

5 项目代码实现

5.1 项目说明

项目是采用SpringBoot + Mybatis + Shiro 的搭建的单体后台服务。同时通过引入通用mapper减少代码量，已达到重点关注业务的开发。

<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>${mapper-starter-version}</version>
    <exclusions>
        <exclusion>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
        </exclusion>
    </exclusions>
</dependency>
1
2
3
4
5
6
7
8
9
10
11

在创建实体时，首先定义了一个BaseEntity的类，所有的实体均集成该类，同时该类需要加上@MappedSuperclass注解。BaseEntity里面包含了所有实体的公共字段，如：id、createTime、updateTime。这样做是为了减少代码的冗余。
实体上配置了@Table注解，以及实体字段配置了 @Column注解是为了搭配jpa的自动建表，已达到添加字段时，重新运行项目，数据库表字段也会自动添加。

但是存在缺点: 更改字段类型或删除字段，数据库表不能自动修改或删除字段，需要手动去变更。
Dao层

再创建相关的dao层接口时，需要接口继承自定义的BaseDao接口，该接口集成了通用mapper相关的接口和注解，便于我们自定义一些通用接口。

Service层
所有的service接口需要继承自定义的BaseService接口，该接口定义了一些常用到的接口，例如增、删、改、查等等。

package com.cqjtu.studentdocument.service;

import com.cqjtu.studentdocument.utils.dto.Condition;
import com.github.pagehelper.PageInfo;
import tk.mybatis.mapper.entity.Example;

import java.io.Serializable;
import java.util.List;

/**
 * @author pengyangyan
 */
public interface BaseService<T> {

    /**
     * 查询所有数据
     * @return      结果List
     */
    List<T> selectAll();

    /**
     * 主键查询
     *
     * @param key   主键
     * @return      T
     */
    T selectByKey(Serializable key);

    /**
     * 插入数据
     * @param entity   传入实体
     * @return  受影响行数
     */
    int insert(T entity);

    /**
     * 主键删除
     * @param key   主键
     * @return   受影响行数
     */
    int deleteByKey(Serializable key);

    /**
     * 批量删除
     * @return      受影响行数
     */
    int deletes(List<String> keys);

    /**
     * 删除数据
     *
     * @param entity 实体
     * @return       受影响行数
     */
    int delete(T entity);

    /**
     * 更新数据
     *
     * @param  entity 实体
     * @return       受影响行数
     */
    int update(T entity);

    /**
     * mapper Example原生查询方式
     *
     * @param example  example
     * @return         结果List
     */
    List<T> selectByExample(Example example);

    /**
     * 条件排序查询
     * 1.查询条件clauses和排序条件sortMap都可以为空
     * 2.如果查询条件和排序map都为空，则返回所有数据
     * 3.pageSize和pageNum该方法无效
     * 4.clauses定义查询条件
     * 5.sortMap定义排序条件，key为属性字段，value="DESC" 为倒序，value="ASC"为正序。
     *
     * @param     condition 条件
     * @return    结果List
     */
    List<T> select(Condition condition);

    /**
     * 条件分页排序查询
     * 1.查询条件clauses和排序条件sortMap都可以为空
     * 2.如果查询条件和排序map都为空，则返回所有数据
     * 3.clauses定义匹查询条件
     * 4.sortMap定义排序条件，key为属性字段，value="DESC" 为倒序，value="ASC"为正序。
     *
     * @param condition   条件
     * @return         结果List
     */
    PageInfo<T> selectPage(Condition condition);

}
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

同时创建接口实现类时需要继承自定义的BaseServiceImpl类，该类实现了BaseService接口的所有方法，这样可以达到不用书写这些接口，就可在需要的时候
调用，如果需要自定义某个方法时，只需要实通过@Override重写某个方法即可。

package com.cqjtu.studentdocument.service.Impl;


import com.alibaba.fastjson.JSONObject;
import com.cqjtu.studentdocument.dao.BaseDao;
import com.cqjtu.studentdocument.service.BaseService;
import com.cqjtu.studentdocument.utils.dto.Clause;
import com.cqjtu.studentdocument.utils.dto.Condition;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import tk.mybatis.mapper.entity.EntityColumn;
import tk.mybatis.mapper.entity.Example;
import tk.mybatis.mapper.mapperhelper.EntityHelper;

import javax.persistence.Id;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @author pengyangyan
 */
@Slf4j
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true,rollbackFor = Exception.class)
public abstract class BaseServiceImpl<T, M extends BaseDao<T>> implements BaseService<T> {


    private Class<?> clazz = (Class<?>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];

    @Autowired
    protected M entityDao;


    @Override
    public List<T> selectAll() {
        return entityDao.selectAll();
    }

    @Override
    public T selectByKey(Serializable key) {
        log.info("执行筛选==>参数为【"+key+"】");
        return entityDao.selectByPrimaryKey(key);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int insert(T entity) {
        log.info("执行插入==>参数为【"+entity+"】");
        return entityDao.insertSelective(entity);
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public int deleteByKey(Serializable key) {
        log.info("执行删除==>参数为【"+key+"】");
        return entityDao.deleteByPrimaryKey(key);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int deletes(List<String> keys) {
        log.info("执行批量删除==>参数为【"+keys+"】");
        String keyName = null;
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Id.class)) {
                keyName = field.getName();
                break;
            }
        }
        Example example = new Example(clazz);
        example.createCriteria().andIn(keyName,keys);
        return entityDao.deleteByExample(example);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int delete(T entity) {
        log.info("执行删除==>参数为【"+entity+"】");
        if (entity != null){
            return entityDao.delete(entity);
        }
        return 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int update(T entity) {
        log.info("执行修改==>参数为【"+entity+"】");
        return entityDao.updateByPrimaryKeySelective(entity);
    }

    @Override
    public List<T> selectByExample(Example example) {
        return entityDao.selectByExample(example);
    }

    @Override
    public List<T> select(Condition condition) {
        log.info("执行条件查询===>参数为【"+JSONObject.toJSONString(condition) +"】");
        Map<String, EntityColumn> propertyMap = EntityHelper.getEntityTable(clazz).getPropertyMap();
        Example example = new Example(clazz);
        List<Clause> clauses = condition.getClauses();
        if (!CollectionUtils.isEmpty(clauses)) {
            Example.Criteria criteria = example.createCriteria();
            clauses.forEach(clause -> {
                if(!StringUtils.isEmpty(clause.getColumn())){
                    if("isNull".equalsIgnoreCase(clause.getOperation())){
                        criteria.andIsNull(clause.getColumn());
                    }
                    if("isNotNull".equalsIgnoreCase(clause.getOperation())) {
                        criteria.andIsNotNull(clause.getColumn());
                    }
                    else{
                        if (!StringUtils.isEmpty(clause.getValue())) {
                            if("between".equalsIgnoreCase(clause.getOperation())){
                                ArrayList<?> list= (ArrayList<?>) clause.getValue();
                                criteria.andBetween(clause.getColumn(),list.get(0),list.get(1));
                            }
                            if ("like".equalsIgnoreCase(clause.getOperation())) {
                                criteria.andLike(clause.getColumn(), "%" + clause.getValue() + "%");
                            }
                            if("=".equalsIgnoreCase(clause.getOperation())) {
                                criteria.andCondition(propertyMap.get(clause.getColumn()).getColumn() + clause.getOperation(), clause.getValue());
                            }
                        }
                    }
                }
            });
        }

        Map<String, Object> sortMap = condition.getSortMap();
        if (sortMap.size()>0) {
            StringBuffer sb = new StringBuffer();
            sortMap.forEach((k, v) -> {
                if (!StringUtils.isEmpty(k) && !StringUtils.isEmpty(v)) {
                    sb.append(propertyMap.get(k).getColumn());
                    sb.append(" ");
                    sb.append(v);
                    sb.append(",");
                }
            });
            if (sb.toString().endsWith(",")) {
                sb.deleteCharAt(sb.length() - 1);
            }
            example.setOrderByClause(sb.toString());
        }
        return selectByExample(example);
    }

    @Override
    public PageInfo<T> selectPage(Condition condition) {
        PageHelper.startPage(condition.getPageNum(), condition.getPageSize());
        List<T> list = select(condition);
        return new PageInfo<>(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
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

Web层

在web层，项目定义了一个BaseController的抽象类,里面实体了基本的增删改查的接口定义。再我们创建某个模块的Controller时只需要继承该类就
可达到不用在创建的类下面定义接口，也会自动拥有相关接口，如果需要对某个接口方法做定制时，只需要重新某个方法就可以了。

package com.cqjtu.studentdocument.controller;

import com.cqjtu.studentdocument.advice.ExceptionEnums;
import com.cqjtu.studentdocument.advice.MyException;
import com.cqjtu.studentdocument.service.BaseService;
import com.cqjtu.studentdocument.utils.dto.Condition;
import com.github.pagehelper.PageInfo;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import java.io.Serializable;
import java.util.List;


/**
 * @author pengyangyan
 */
@Slf4j
public abstract class BaseController<S extends BaseService<T>,T,ID extends Serializable> {

    @Autowired
    protected S service;

    @ApiOperation(value = "基础接口: 新增操作")
    @PostMapping(value = "add")
    public ResponseEntity<T> save(@RequestBody T entity){
        try {
            if ( service.insert(entity)<1){
                throw new MyException(ExceptionEnums.ADD_ERROR);
            }
        }catch (Exception e){
            log.error(e.getMessage());
            throw new MyException(ExceptionEnums.ADD_ERROR);
        }
        return ResponseEntity.ok(entity);
    }

    @ApiOperation(value = "基础接口: 返回指定ID的数据")
    @GetMapping(value = "get/{id}")
    public ResponseEntity<T> get(@PathVariable("id")ID id){
        T t = null;
        try {
            t = service.selectByKey(id);
        }catch (Exception e){
            log.error(e.getMessage());
            throw new MyException(ExceptionEnums.GET_ITEM);
        }
        return ResponseEntity.ok(t);
    }

    @ApiOperation(value = "基础接口: 返回所有数据")
    @GetMapping(value = "all")
    public ResponseEntity<List<T>> all(){
        List<T> list;
        try {
            list = service.selectAll();
        }catch (Exception e){
            log.error(e.getMessage());
            throw new MyException(ExceptionEnums.GET_LIST_ERROR);
        }
        return ResponseEntity.ok(list);
    }

    @ApiOperation(value = "基础接口: 分页返回数据")
    @PostMapping(value = "page")
    public ResponseEntity<PageInfo<T>> page(@RequestBody Condition condition){
        PageInfo<T> page ;
        try {
            page = service.selectPage(condition);
        }catch (Exception e){
            log.error(e.getMessage());
            throw new MyException(ExceptionEnums.GET_LIST_ERROR);
        }
        return ResponseEntity.ok(page);
    }

    @ApiOperation(value = "基础接口: 修改数据")
    @PostMapping(value = "update")
    public ResponseEntity<T> update(@RequestBody T entity){
        try {
            if (service.update(entity)<1){
                throw new MyException(ExceptionEnums.UPDATE_ERROR);
            }
        }catch (Exception e){
            log.error(e.getMessage());
            throw new MyException(ExceptionEnums.UPDATE_ERROR);
        }
        return ResponseEntity.ok(entity);
    }

    @ApiOperation(value = "基础接口: 删除指定ID的数据")
    @GetMapping(value = "delete/{id}")
    public ResponseEntity<String> delete(@PathVariable("id")ID id){
        try {
            if ( service.deleteByKey(id)<1){
                throw new MyException(ExceptionEnums.DELETE_ERROR);
            }
        } catch (Exception e){
            log.error(e.getMessage());
            throw new MyException(ExceptionEnums.DELETE_ERROR);
        }
        return ResponseEntity.ok("删除成功");
    }


}
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

5.2 权限相关

权限主要采用apache shiro,需要引入相关依赖

  <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.3.2</version>
    </dependency>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring</artifactId>
        <version>1.3.2</version>
    </dependency>
1
2
3
4
5
6
7
8
9
10

在使用shiro时，需要创建一个realm进行进行权限的授权和认证，同时需要创建一个自定义的凭证验证器来校验密码是否一致。

配置好这些后需要定义一个shiro的配置类ShiroConfiguration来配置shiro的权限过滤工厂beanShiroFilterFactoryBean,在里面引入自定义的AuthRealmbean以达到权限的校验。

因为项目采用的是前后端分离，会产生跨域请求等问题，所以需要开放所有来源对该服务的请求，所以需要配置相关过滤器CorsFilter。

package com.cqjtu.studentdocument.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


public class CorsFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse;
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
        //是否支持cookie跨域
        httpServletResponse.setHeader("Access-Control-Allow-Credentials","true");

        //指定允许其他域名访问

        httpServletResponse.setHeader("Access-Control-Allow-Origin", httpServletRequest.getHeader("Origin"));


        //响应头设置
        httpServletResponse.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept,client_id, uuid, Authorization,user-agent,X-XSRF-TOKEN");

        // 设置过期时间
        httpServletResponse.setHeader("Access-Control-Max-Age", "3600");

        //响应类型
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, DELETE");

        // 支持HTTP1.1.
        httpServletResponse.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");

        // 支持HTTP 1.0. 
        httpServletResponse.setHeader("Pragma", "no-cache");

        httpServletResponse.setHeader("Allow","GET, HEAD, POST, PUT, DELETE, TRACE, OPTIONS, PATCH");


        if ("OPTIONS".equals(httpServletRequest.getMethod())) {
            httpServletResponse.setStatus(204);
        }

        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

    }
}
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

使用shiro权限验证时，第一次请求为option方式，所以要配置shiro过滤掉option方式，不对此方式做权限拦截。故配置ShiroFilter

package com.cqjtu.studentdocument.filter;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;
import org.apache.shiro.web.util.WebUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;


@Slf4j
public class ShiroFiter extends FormAuthenticationFilter {

    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        boolean allowed = super.isAccessAllowed(request, response, mappedValue);
        if (!allowed) {
            // 判断请求是否是options请求
            String method = WebUtils.toHttp(request).getMethod();
            if (StringUtils.equalsIgnoreCase("OPTIONS", method)) {
                return true;
            }
        }
        return allowed;
    }

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        return super.onAccessDenied(request, response);
    }
}
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

5.3 其他

项目中定义了全局异常捕获，再项目中需要抛出异常时只需要抛出自定义的异常MyException,就可对该异常进行捕获，当用户请求某个接口如果出现异常时，

后台服务就会返回自定义的错误代码，不会出现乱码的情况,以便于前端对返回结果做统一处理或错误拦截。同时我们也可预先自定义需要抛出的错误，在前段可对错误code进行区别，采用不同的样式提示。

package com.cqjtu.studentdocument.advice;


import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;


@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum ExceptionEnums {

    /**
     * 错误返回信息
     */
    NO_CHECK_INFO(400,"暂无健康档案表，无法进行数据分析"),
    CHOOSE_FILE(400,"文件未上传"),
    IS_NOT_LOGIN(400,"用户未登录"),
    UPLOAD_FAIL(400,"上传失败"),
    RESOURCE_FOUNT_FAIL(400,"获取菜单权限失败！"),
    NOT_AUTHORIZED(403,"您暂无权限访问该资源！"),
    ACCOUNT_IS_EXIT(400,"用户名已存在"),
    PASSWORD_WRONG(400,"密码错误"),
    ACCOUNT_IS_NOT_EXIT(400,"用户名不存在"),
    UPDATE_ERROR(400,"更新失败"),
    ADD_ERROR(400,"新增失败"),
    DELETE_ERROR(400,"删除失败"),
    GET_LIST_ERROR(400,"获取列表失败"),
    GET_ITEM(400,"获取对象失败"),
    NO_WEIGHT_HEIGHT(400,"当前档案未完善身高体重信息")
    ;

    /**
     * 代码值
     */
    private int code;
    /**
     * 消息
     */
    private String msg;
}
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

5.4 跨域配置

@Configuration
public class CorsConfig {

    private CorsConfiguration buildConfig(){
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        return corsConfiguration;
    }

    @Bean
    public CorsFilter corsFilter(){
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**",buildConfig());
        return new CorsFilter(source);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

计算机毕设选题大全及项目分享:

https://blog.csdn.net/WEB_DC/article/details/125563252

文章版权说明：

该文章由丹成学长全网第一时间发布，CSDN: mathor-sinor，上述系统为丹成学长开发完成，违版必究，如有项目开发需求请联系 丹成学长.

6 最后