【毕业设计】基于SSM的大学生健康档案管理系统

迈不过友情╰ 2024-03-30 11:39 197阅读 0赞

#### 文章目录 ####

*  前言
 *  1 项目介绍
 *  2 相关技术
 *  3 系统功能设计
 *   *  3.1 前台功能
     *  3.2 后台功能
     *  3.3 数据库设计
     *  3.4 系统实体联系图
 *  4 实现效果-项目展示
 *  5 项目代码实现
 *   *  5.1 项目说明
     *  5.2 权限相关
     *  5.3 其他
     *  5.4 跨域配置
 *  6 最后

## 前言 ##

Hi，同学们好呀，学长今天带大家复盘一个学长帮往届同学做的一个毕业作品

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

## 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 数据库设计 ###

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

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_30_color_FFFFFF_t_70_g_se_x_16]

**系统信息表**

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_30_color_FFFFFF_t_70_g_se_x_16 1]

**报告信息表**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_30_color_FFFFFF_t_70_g_se_x_16 2]

**权限表**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16]

**权限资源表**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 1]

**资源表**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 2]

**健康阅读表**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 3]

**检查报告表**

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 4]

### 3.4 系统实体联系图 ###

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 5]

## 4 实现效果-项目展示 ##

**登录页**

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 6]  
**首页**

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 7]

**健康建议**

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 8]  
**添加文章**

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 9]  
**健康档案管理**

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 10]

**查看档案**

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 11]  
**角色管理**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 12]

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 13]

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

在创建实体时，首先定义了一个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);
    
    }

同时创建接口实现类时需要继承自定义的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);
        }
    }

**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("删除成功");
        }
    
    
    }

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

在使用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() {
        
    
        }
    }

使用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);
        }
    }

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

### 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);
        }

## 6 最后 ##

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_30_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/bd9fd370c02f48a0a5cbc9ca02430810.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_30_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b0e425fbf12e48bbabefb025cef9830d.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_30_color_FFFFFF_t_70_g_se_x_16 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9aebb23a76cb480d942cbcfab3129ad6.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/995bbf5fab894271a0e5a9e605fb7c97.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2db7611142f849ee9bf12c461bcd447c.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e40f8e17bfaf4cc9ba7e3904acda0225.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f8e68195ec2d4118b66bb525bf3f2eb2.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4def7f6bb9e249e2b68f9bc0f83d37bb.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/58cc2180041342229c7aec30be09bf67.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d364dcabd36d406882418551b2bb5766.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/75bc61f63904496fbf075faa1e7cd167.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f73b72f7e0fe4d578f08a6f2788e38c4.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/0c486a2748854c6a9d369ffc2f0b78b0.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1b9c5463742e42b1a08569a7bffef5fe.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d805486b8f65416eb3c5adc157ae0bad.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c0757bb238b547c0bf26ad8d996d863e.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbWF0aG9yLXNpbm9y_size_35_color_FFFFFF_t_70_g_se_x_16 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/19bc527861f547aca02dce58fa3136ca.png