基于javaweb+mysql的springboot社区养老医疗综合服务(java+springboot+html+bootstrap+ztree+mysql)

最新推荐文章于 2025-06-11 16:04:38 发布
最新推荐文章于 2025-06-11 16:04:38 发布
阅读量52 收藏
点赞数
文章标签： java html mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_71017137/article/details/132415312
版权

基于javaweb+mysql的springboot社区养老医疗综合服务(java+springboot+html+bootstrap+ztree+mysql)

运行环境

Java≥8、MySQL≥5.7

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SpringBoot社区养老医疗综合服务(java+springboot+html+bootstrap+ztree+mysql)

项目介绍

本项目分为管理员、医生、病人三种角色， 管理员的功能包含如下： 个人信息：个人资料、修改密码 系统管理：用户管理、角色管理、部门管理、菜单管理、字典管理 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息

医生的功能包含如下： 个人信息：个人资料、修改密码 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息

病人的功能包含如下： 个人信息：个人资料、修改密码 居民医保信息 居民健康信息 居民就诊历史 我的预约信息

环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。 2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA; 3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可 4.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS； 5.数据库：MySql 5.7或8.0版本； 6.是否Maven项目：是；

技术栈

  1. 后端：SpringBoot+mybatis-plus 2. 前端：HTML+CSS+javascript+jQuery+bootstrap+ztree

使用说明

  1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件； 2. 使用IDEA/Eclipse/MyEclipse导入项目，导入成功后请执行maven clean;maven install命令，然后运行； 3. 将项目中application.yml配置文件中的数据库配置改为自己的配置; 4. 运行项目，在浏览器中输入http://localhost:8080/ 登录 管理员账号/密码：admin/111111 医生账号/密码：doctor/111111 病人账号/密码：doctor/111111

/**
 * 通知控制器
 *
 */
@Controller
@RequestMapping("/notice")
public class NoticeController extends BaseController {

    private String PREFIX = "/system/notice/";

    @Autowired
    private INoticeService noticeService;

    /**
     * 跳转到通知列表首页

        }
        User user = this.userService.selectOne(new EntityWrapper<User>().eq("id", userId));
        model.addAttribute("userId", userId);
        model.addAttribute("userAccount", user.getAccount());
        return PREFIX + "user_roleassign.html";
    }

    /**
     * 跳转到编辑管理员页面
     */
    @Permission
    @RequestMapping("/user_edit/{userId}")
    public String userEdit(@PathVariable Integer userId, Model model) {
        if (ToolUtil.isEmpty(userId)) {
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        assertAuth(userId);
        User user = this.userService.selectById(userId);
        model.addAttribute(user);
        model.addAttribute("roleName", ConstantFactory.me().getRoleName(user.getRoleid()));
        model.addAttribute("deptName", ConstantFactory.me().getDeptName(user.getDeptid()));
        LogObjectHolder.me().set(user);
        return PREFIX + "user_edit.html";
    }

    /**
     * 跳转到查看用户详情页面
     */
    @RequestMapping("/user_info")
    public String userInfo(Model model) {
        Integer userId = ShiroKit.getUser().getId();
        if (ToolUtil.isEmpty(userId)) {
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        User user = this.userService.selectById(userId);
        model.addAttribute(user);
        model.addAttribute("roleName", ConstantFactory.me().getRoleName(user.getRoleid()));
        model.addAttribute("deptName", ConstantFactory.me().getDeptName(user.getDeptid()));
        LogObjectHolder.me().set(user);
        return PREFIX + "user_view.html";
    }

    /**
     * 跳转到修改密码界面
     */
    @RequestMapping("/user_chpwd")
    public String chPwd() {
        return PREFIX + "user_chpwd.html";
    }

    /**
     * 修改当前用户的密码
     */
    @RequestMapping("/changePwd")

        model.addAttribute(user);
        model.addAttribute("roleName", ConstantFactory.me().getRoleName(user.getRoleid()));
        model.addAttribute("deptName", ConstantFactory.me().getDeptName(user.getDeptid()));
        LogObjectHolder.me().set(user);
        return PREFIX + "user_view.html";
    }

    /**
     * 跳转到修改密码界面
     */
    @RequestMapping("/user_chpwd")
    public String chPwd() {
        return PREFIX + "user_chpwd.html";
    }

    /**
     * 修改当前用户的密码
     */
    @RequestMapping("/changePwd")
    @ResponseBody
    public Object changePwd(@RequestParam String oldPwd, @RequestParam String newPwd, @RequestParam String rePwd) {
        if (!newPwd.equals(rePwd)) {
            throw new ServiceException(BizExceptionEnum.TWO_PWD_NOT_MATCH);
        }
        Integer userId = ShiroKit.getUser().getId();
        User user = userService.selectById(userId);
        String oldMd5 = ShiroKit.md5(oldPwd, user.getSalt());
        if (user.getPassword().equals(oldMd5)) {
            String newMd5 = ShiroKit.md5(newPwd, user.getSalt());
            user.setPassword(newMd5);
            user.updateById();
            return SUCCESS_TIP;
        } else {
            throw new ServiceException(BizExceptionEnum.OLD_PWD_NOT_RIGHT);
        }
    }

    /**
     * 查询管理员列表
     */
    @RequestMapping("/list")
    @Permission
    @ResponseBody
    public Object list(@RequestParam(required = false) String name, @RequestParam(required = false) String beginTime, @RequestParam(required = false) String endTime, @RequestParam(required = false) Integer deptid) {
        if (ShiroKit.isAdmin()) {
            List<Map<String, Object>> users = userService.selectUsers(null, name, beginTime, endTime, deptid);
            return new UserWarpper(users).wrap();
        } else {
            DataScope dataScope = new DataScope(ShiroKit.getDeptDataScope());
            List<Map<String, Object>> users = userService.selectUsers(dataScope, name, beginTime, endTime, deptid);

/**
 * 日志管理的控制器
 *
 */
@Controller
@RequestMapping("/log")
public class LogController extends BaseController {

    private static String PREFIX = "/system/log/";

    @Autowired
    private IOperationLogService operationLogService;

    /**
     * 跳转到日志管理的首页
     */
    @RequestMapping("")
    public String index() {
        return PREFIX + "log.html";
    }

    /**
     * 查询操作日志列表
     */
    @RequestMapping("/list")
    @Permission(Const.ADMIN_NAME)
    @ResponseBody
    public Object list(@RequestParam(required = false) String beginTime, @RequestParam(required = false) String endTime, @RequestParam(required = false) String logName, @RequestParam(required = false) Integer logType) {
        Page<OperationLog> page = new PageFactory<OperationLog>().defaultPage();
        List<Map<String, Object>> result = operationLogService.getOperationLogs(page, beginTime, endTime, logName, BizLogType.valueOf(logType), page.getOrderByField(), page.isAsc());
        page.setRecords(new LogWarpper(result).wrap());
        return new PageInfoBT<>(page);
    }

    /**
     * 查询操作日志详情
     */
    @RequestMapping("/detail/{id}")
    @Permission(Const.ADMIN_NAME)
    @ResponseBody
    public Object detail(@PathVariable Integer id) {
        OperationLog operationLog = operationLogService.selectById(id);
        Map<String, Object> stringObjectMap = BeanUtil.beanToMap(operationLog);
        return super.warpObject(new LogWarpper(stringObjectMap));
    }



/**
 * 全局的的异常拦截器（拦截所有的控制器）（带有@RequestMapping注解的方法上都会拦截）
 *
 */
@ControllerAdvice
@Order(-1)
public class GlobalExceptionHandler {

    private Logger log = LoggerFactory.getLogger(this.getClass());

    /**
     * 拦截业务异常
     */
    @ExceptionHandler(ServiceException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ResponseBody
    public ErrorResponseData bussiness(ServiceException e) {
        LogManager.me().executeLog(LogTaskFactory.exceptionLog(ShiroKit.getUser().getId(), e));
        getRequest().setAttribute("tip", e.getMessage());
        log.error("业务异常:", e);
        return new ErrorResponseData(e.getCode(), e.getMessage());
    }

    /**
     * 用户未登录异常

    }

    /**
     * 新增部门
     */
    @BussinessLog(value = "添加部门", key = "simplename", dict = DeptDict.class)
    @RequestMapping(value = "/add")
    @Permission
    @ResponseBody
    public Object add(Dept dept) {
        if (ToolUtil.isOneEmpty(dept, dept.getSimplename())) {
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        //完善pids,根据pid拿到pid的pids
        deptSetPids(dept);
        return this.deptService.insert(dept);
    }

    /**
     * 获取所有部门列表
     */
    @RequestMapping(value = "/list")
    @Permission
    @ResponseBody
    public Object list(String condition) {
        List<Map<String, Object>> list = this.deptService.list(condition);
        return super.warpObject(new DeptWarpper(list));
    }

    /**
     * 部门详情
     */
    @RequestMapping(value = "/detail/{deptId}")
    @Permission
    @ResponseBody
    public Object detail(@PathVariable("deptId") Integer deptId) {
        return deptService.selectById(deptId);
    }

    /**
     * 修改部门

    @RequestMapping("")
    public String index() {
        return PREFIX + "menu.html";
    }

    /**
     * 跳转到菜单列表列表页面
     */
    @RequestMapping(value = "/menu_add")
    public String menuAdd() {
        return PREFIX + "menu_add.html";
    }

    /**
     * 跳转到菜单详情列表页面
     */
    @Permission(Const.ADMIN_NAME)
    @RequestMapping(value = "/menu_edit/{menuId}")
    public String menuEdit(@PathVariable Long menuId, Model model) {
        if (ToolUtil.isEmpty(menuId)) {
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        Menu menu = this.menuService.selectById(menuId);

        //获取父级菜单的id
        Menu temp = new Menu();
        temp.setCode(menu.getPcode());
        Menu pMenu = this.menuService.selectOne(new EntityWrapper<>(temp));

        //如果父级是顶级菜单
        if (pMenu == null) {
            menu.setPcode("0");
        } else {
            //设置父级菜单的code为父级菜单的id
            menu.setPcode(String.valueOf(pMenu.getId()));
        }

        Map<String, Object> menuMap = BeanUtil.beanToMap(menu);
        menuMap.put("pcodeName", ConstantFactory.me().getMenuNameByCode(temp.getCode()));
        model.addAttribute("menu", menuMap);
        LogObjectHolder.me().set(menu);
        return PREFIX + "menu_edit.html";
    }

    }

    /**
     * 无权访问该资源异常
     */
    @ExceptionHandler(UndeclaredThrowableException.class)
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    @ResponseBody
    public ErrorResponseData credentials(UndeclaredThrowableException e) {
        getRequest().setAttribute("tip", "权限异常");
        log.error("权限异常!", e);
        return new ErrorResponseData(BizExceptionEnum.NO_PERMITION.getCode(), BizExceptionEnum.NO_PERMITION.getMessage());
    }

    /**
     * 拦截未知的运行时异常
     */
    @ExceptionHandler(RuntimeException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ResponseBody
    public ErrorResponseData notFount(RuntimeException e) {
        LogManager.me().executeLog(LogTaskFactory.exceptionLog(ShiroKit.getUser().getId(), e));
        getRequest().setAttribute("tip", "服务器未知运行时异常");
        log.error("运行时异常:", e);
        return new ErrorResponseData(BizExceptionEnum.SERVER_ERROR.getCode(), BizExceptionEnum.SERVER_ERROR.getMessage());
    }
}
/**
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


    }

    /**
     * 新增通知
     */
    @RequestMapping(value = "/add")
    @ResponseBody
    @BussinessLog(value = "新增通知", key = "title", dict = NoticeMap.class)
    public Object add(Notice notice) {
        if (ToolUtil.isOneEmpty(notice, notice.getTitle(), notice.getContent())) {
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        notice.setCreater(ShiroKit.getUser().getId());
        notice.setCreatetime(new Date());
        notice.insert();
        return SUCCESS_TIP;
    }

    /**
     * 删除通知
     */
    @RequestMapping(value = "/delete")
    @ResponseBody
    @BussinessLog(value = "删除通知", key = "noticeId", dict = NoticeMap.class)
    public Object delete(@RequestParam Integer noticeId) {

        //缓存通知名称
        LogObjectHolder.me().set(ConstantFactory.me().getNoticeTitle(noticeId));

        this.noticeService.deleteById(noticeId);

        return SUCCESS_TIP;
    }

    /**
     * 修改通知
     */
    @RequestMapping(value = "/update")
    @ResponseBody
    @BussinessLog(value = "修改通知", key = "title", dict = NoticeMap.class)
    public Object update(Notice notice) {
        if (ToolUtil.isOneEmpty(notice, notice.getId(), notice.getTitle(), notice.getContent())) {
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        Notice old = this.noticeService.selectById(notice.getId());
        old.setTitle(notice.getTitle());
        old.setContent(notice.getContent());
        old.updateById();
        return SUCCESS_TIP;
    }


    /**
     * 获取角色列表
     */
    @RequestMapping(value = "/roleTreeList")
    @ResponseBody
    public List<ZTreeNode> roleTreeList() {
        List<ZTreeNode> roleTreeList = this.roleService.roleTreeList();
        roleTreeList.add(ZTreeNode.createParent());
        return roleTreeList;
    }

    /**
     * 获取角色列表
     */
    @RequestMapping(value = "/roleTreeListByUserId/{userId}")
    @ResponseBody
    public List<ZTreeNode> roleTreeListByUserId(@PathVariable Integer userId) {
        User theUser = this.userService.selectById(userId);
        String roleid = theUser.getRoleid();
        if (ToolUtil.isEmpty(roleid)) {
            return this.roleService.roleTreeList();
        } else {
            String[] strArray = roleid.split(",");
            return this.roleService.roleTreeListByRoleId(strArray);
        }
    }

}
/**
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and

    @RequestMapping(value = "/view/{menuId}")
    @ResponseBody
    public ResponseData view(@PathVariable Long menuId) {
        if (ToolUtil.isEmpty(menuId)) {
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        this.menuService.selectById(menuId);
        return SUCCESS_TIP;
    }

    /**
     * 获取菜单列表(首页用)
     */
    @RequestMapping(value = "/menuTreeList")
    @ResponseBody
    public List<ZTreeNode> menuTreeList() {
        return this.menuService.menuTreeList();
    }

    /**
     * 获取菜单列表(选择父级菜单用)
     */
    @RequestMapping(value = "/selectMenuTreeList")
    @ResponseBody
    public List<ZTreeNode> selectMenuTreeList() {
        List<ZTreeNode> roleTreeList = this.menuService.menuTreeList();
        roleTreeList.add(ZTreeNode.createParent());
        return roleTreeList;
    }

    /**
     * 获取角色列表
     */
    @RequestMapping(value = "/menuTreeListByRoleId/{roleId}")
    @ResponseBody
    public List<ZTreeNode> menuTreeListByRoleId(@PathVariable Integer roleId) {
        List<Long> menuIds = this.menuService.getMenuIdsByRoleId(roleId);
        if (ToolUtil.isEmpty(menuIds)) {
            return this.menuService.menuTreeList();
        } else {
            return this.menuService.menuTreeListByMenuIds(menuIds);
        }
    }

    /**
     * 根据请求的父级菜单编号设置pcode和层级
     */
    private void menuSetPcode(@Valid Menu menu) {
        if (ToolUtil.isEmpty(menu.getPcode()) || menu.getPcode().equals("0")) {
            menu.setPcode("0");


/**
 * 登录控制器
 *
 */
@Controller
public class LoginController extends BaseController {

    @Autowired
    private IMenuService menuService;

    @Autowired
    private IUserService userService;

    /**
     * 跳转到主页
     */
    @RequestMapping(value = "/", method = RequestMethod.GET)
    public String index(Model model) {
        //获取菜单列表
        List<Integer> roleList = ShiroKit.getUser().getRoleList();
        if (roleList == null || roleList.size() == 0) {
            ShiroKit.getSubject().logout();

        patientHistoryService.insert(patientHistory);
        return SUCCESS_TIP;
    }

    /**
     * 删除居民就诊历史管理
     */
    @RequestMapping(value = "/delete")
    @ResponseBody
    public Object delete(@RequestParam Integer patientHistoryId) {
        patientHistoryService.deleteById(patientHistoryId);
        return SUCCESS_TIP;
    }

    /**
     * 修改居民就诊历史管理
     */
    @RequestMapping(value = "/update")
    @ResponseBody
    public Object update(PatientHistory patientHistory) {
        patientHistoryService.updateById(patientHistory);
        return SUCCESS_TIP;
    }

    /**
     * 居民就诊历史管理详情
     */
    @RequestMapping(value = "/detail/{patientHistoryId}")
    @ResponseBody
    public Object detail(@PathVariable("patientHistoryId") Integer patientHistoryId) {
        return patientHistoryService.selectById(patientHistoryId);
    }
}


        model.addAttribute("roleName", ConstantFactory.me().getSingleRoleName(roleId));
        return PREFIX + "/role_assign.html";
    }

    /**
     * 获取角色列表
     */
    @Permission
    @RequestMapping(value = "/list")
    @ResponseBody
    public Object list(@RequestParam(required = false) String roleName) {
        List<Map<String, Object>> roles = this.roleService.selectRoles(super.getPara("roleName"));
        return super.warpObject(new RoleWarpper(roles));
    }

    /**
     * 角色新增
     */
    @RequestMapping(value = "/add")
    @BussinessLog(value = "添加角色", key = "name", dict = RoleDict.class)
    @Permission(Const.ADMIN_NAME)
    @ResponseBody
    public ResponseData add(@Valid Role role, BindingResult result) {
        if (result.hasErrors()) {
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        role.setId(null);
        this.roleService.insert(role);
        return SUCCESS_TIP;
    }

    /**
     * 角色修改
     */
    @RequestMapping(value = "/edit")
    @BussinessLog(value = "修改角色", key = "name", dict = RoleDict.class)
    @Permission(Const.ADMIN_NAME)
    @ResponseBody
    public ResponseData edit(@Valid Role role, BindingResult result) {
        if (result.hasErrors()) {
            throw new ServiceException(BizExceptionEnum.REQUEST_NULL);
        }
        this.roleService.updateById(role);

         * 如果是ajax请求则不进行跳转
         */
        if (httpServletRequest.getHeader("x-requested-with") != null
                && httpServletRequest.getHeader("x-requested-with").equalsIgnoreCase("XMLHttpRequest")) {
            httpServletResponse.setHeader("sessionstatus", "timeout");
            return false;
        } else {

            /**
             * 第一次点击页面
             */
            String referer = httpServletRequest.getHeader("Referer");
            if (referer == null) {
                saveRequestAndRedirectToLogin(request, response);
                return false;
            } else {

                /**
                 * 从别的页面跳转过来的
                 */
                if (ShiroKit.getSession().getAttribute("sessionFlag") == null) {
                    httpServletRequest.setAttribute("tips", "session超时");
                    httpServletRequest.getRequestDispatcher("/login").forward(request, response);
                    return false;
                } else {
                    saveRequestAndRedirectToLogin(request, response);
                    return false;
                }
            }
        }
    }
}
/**
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>

     * 查询操作日志详情
     */
    @RequestMapping("/detail/{id}")
    @Permission(Const.ADMIN_NAME)
    @ResponseBody
    public Object detail(@PathVariable Integer id) {
        OperationLog operationLog = operationLogService.selectById(id);
        Map<String, Object> stringObjectMap = BeanUtil.beanToMap(operationLog);
        return super.warpObject(new LogWarpper(stringObjectMap));
    }

    /**
     * 清空日志
     */
    @BussinessLog(value = "清空业务日志")
    @RequestMapping("/delLog")
    @Permission(Const.ADMIN_NAME)
    @ResponseBody
    public Object delLog() {
        SqlRunner.db().delete("delete from sys_operation_log");
        return SUCCESS_TIP;
    }
}
/**
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


    public Object list(String condition) {
        if (StringUtils.isEmpty(condition)){
            return doctorPointService.selectList(null);
        }else {
            Map<String,Object> map = new HashMap<String, Object>();
            map.put("patient_name",condition);
            List<DoctorPoint> doctorPointList = doctorPointMapper.selectByMap(map);
            return doctorPointList;
        }
    }

    /**
     * 新增医生预约
     */
    @RequestMapping(value = "/add")
    @ResponseBody
    public Object add(DoctorPoint doctorPoint) {
        doctorPointService.insert(doctorPoint);
        return SUCCESS_TIP;
    }

    /**
     * 删除医生预约
     */
    @RequestMapping(value = "/delete")
    @ResponseBody
    public Object delete(@RequestParam Integer doctorPointId) {
        doctorPointService.deleteById(doctorPointId);
        return SUCCESS_TIP;
    }

    /**
     * 修改医生预约
     */
    @RequestMapping(value = "/update")
    @ResponseBody
    public Object update(DoctorPoint doctorPoint) {
        doctorPointService.updateById(doctorPoint);
        return SUCCESS_TIP;
    }

    /**
     * 医生预约详情
     */
    @RequestMapping(value = "/detail/{doctorPointId}")
    @ResponseBody
    public Object detail(@PathVariable("doctorPointId") Integer doctorPointId) {
        return doctorPointService.selectById(doctorPointId);
    }

    public Object add(PatientHistory patientHistory) {
        patientHistoryService.insert(patientHistory);
        return SUCCESS_TIP;
    }

    /**
     * 删除居民就诊历史管理
     */
    @RequestMapping(value = "/delete")
    @ResponseBody
    public Object delete(@RequestParam Integer patientHistoryId) {
        patientHistoryService.deleteById(patientHistoryId);
        return SUCCESS_TIP;
    }

    /**
     * 修改居民就诊历史管理
     */
    @RequestMapping(value = "/update")
    @ResponseBody
    public Object update(PatientHistory patientHistory) {
        patientHistoryService.updateById(patientHistory);
        return SUCCESS_TIP;
    }

    /**
     * 居民就诊历史管理详情
     */
    @RequestMapping(value = "/detail/{patientHistoryId}")
    @ResponseBody
    public Object detail(@PathVariable("patientHistoryId") Integer patientHistoryId) {
        return patientHistoryService.selectById(patientHistoryId);
    }
}

请添加图片描述

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

m0_71017137
关注
基于javaweb+mysql的springboot社区养老医疗综合服务(java+springboot+html+bootstrap+ztree+mysql+maven)
欢迎私信，一直在线
02-19 358
本项目分为管理员、医生、病人三种角色， 管理员的功能包含如下： 个人信息：个人资料、修改密码 系统管理：用户管理、角色管理、部门管理、菜单管理、字典管理 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息。医生的功能包含如下： 个人信息：个人资料、修改密码 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息。病人的功能包含如下： 个人信息：个人资料、修改密码 居民医保信息 居民健康信息 居民就诊历史 我的预约信息。病人账号/密码：patient/123456。
基于javaweb+SpringBoot的社区养老医疗综合服务系统(java+SpringBoot+bootstrap+HTML+mysql)
m0_71046928的博客
05-17 1052
项目介绍 本项目分为管理员、医生、病人三种角色， 管理员的功能包含如下： 个人信息：个人资料、修改密码 系统管理：用户管理、角色管理、部门管理、菜单管理、字典管理 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息 医生的功能包含如下： 个人信息：个人资料、修改密码 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息 病人的功能包含如下： 个人信息：个人资料、修改密码 居民医保信息 居民健康信息 居民就诊历史 我的预约信息 环境需要 1.运行环境：最好是java jdk
基于javaweb+mysql的社区养老医疗综合服务系统(java+SpringBoot+bootstrap+HTML+mysql)
m0_71414071的博客
05-26 120
项目介绍 本项目分为管理员、医生、病人三种角色， 管理员的功能包含如下： 个人信息：个人资料、修改密码 系统管理：用户管理、角色管理、部门管理、菜单管理、字典管理 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息 医生的功能包含如下： 个人信息：个人资料、修改密码 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息 病人的功能包含如下： 个人信息：个人资料、修改密码 居民医保信息 居民健康信息 居民就诊历史 我的预约信息 环境需要 1.运行环境：最好是java jdk
基于javaweb+mysql的springboot社区养老医疗综合服务系统(java+springboot+bootstrap+html+mysql)
m0_71015455的博客
08-11 149
本项目分为管理员、医生、病人三种角色， 管理员的功能包含如下： 个人信息：个人资料、修改密码 系统管理：用户管理、角色管理、部门管理、菜单管理、字典管理 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息 医生的功能包含如下： 个人信息：个人资料、修改密码 药物信息管理 居民健康信息 居民就诊历史 我的预约信息 居民医保信息 病人的功能包含如下： 个人信息：个人资料、修改密码 居民医保信息 居民健康信息 居民就诊历史。1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。
基于javaweb的社区养老医疗综合服务系统(java+springboot+bootstrap+html+mysql)
m0_69593263的博客
10-26 672
基于javaweb的社区养老医疗综合服务系统(java+springboot+bootstrap+html+mysql) 运行环境 Java≥8、MySQL≥5.7 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
基于javaweb的社区养老医疗综合服务(java+springboot+html+bootstrap+ztree+mysql)
m0_68551656的博客
10-28 269
基于javaweb的社区养老医疗综合服务(java+springboot+html+bootstrap+ztree+mysql) 运行环境 Java≥8、MySQL≥5.7 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
基于javaweb+mysql的springboot图书管理系统(java+springboot+jsp+bootstrap+maven+mysql)
m0_71481516的博客
08-03 177
3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可 4.硬件环境：windows 7/8/10 1G内存以上；管理员角色包含以下功能： 借书管理,图书信息管理,图书分类管理,用户管理,角色管理,还书管理,登录页面等功能。基于javaweb+mysql的springboot图书管理系统(java+springboot+jsp+bootstrap+maven+mysql)借阅管理,图书检索,查看借还记录,查看图书详情,还书管理,登录页面等功能。课程设计，大作业，毕业设计，项目练习，学习演示等。
基于javaweb+mysql的springboot图书馆借阅管理系统(java+springboot+bootstrap+html+maven+mysql)
欢迎私信
12-24 434
基于javaweb+mysql的springboot图书馆借阅管理系统(java+springboot+bootstrap+html+maven+mysql)本项目分为管理员与学生两种角色， 管理员角色包含以下功能： 登录,图书查询,加入购物车,用户管理,添加用户,角色管理,管理权限,图书管理,进行还书等功能。学生角色包含以下功能： 登录页面,查看图书列表,好看要预定的图书,开始借阅等功能。2.IDE环境：IDEA，Eclipse,Myeclipse都可以。4.数据库：MySql 5.7版本；
基于javaweb的快递物流管理系统(java+springboot+shiro+bootstrap+ssm+mysql)
m0_68415979的博客
10-27 862
基于javaweb的快递物流管理系统(java+springboot+shiro+bootstrap+ssm+mysql) 运行环境 Java≥8、MySQL≥5.7 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
基于SpringBoot 的CMS系统，拿去开发企业官网真香（附源码）
m0_68850571的博客
05-30 708
前言 ： 推荐这个项目是因为使用手册部署手册非常完善，项目也有开发教程视频对小白非常贴心，接私活可以直接拿去二开非常舒服 开源说明 系统100%开源 模块化开发模式，铭飞所开发的模块都发布到了maven中央库。可以通过pom.xml文件的方式拉取源代码 <dependency> <groupId>net.mingsoft</groupId> <artifactId>模块</artifactId> <vers..
Java循环编程常见错误与优化实践
静水深流
06-10 64
值得注意的是，基础的静态分析诊断（如"变量未使用"）无法检测此类问题，因为循环变量。该实现完全封装了索引操作，消除了客户端代码中显式使用索引的风险。建议在代码审查时特别关注循环体内索引变量的使用一致性，并针对边界情况（如空数组、单元素数组、多元素同值数组）设计专项测试用例。），将导致严重的无限循环问题。在需要逆向遍历集合时，开发者常犯的关键错误是修改循环条件后忘记调整递增/递减操作。开发者在循环结构中常犯的一个典型错误是：虽然正确编写了循环结构，但在循环体内错误地使用常量索引（如。停止更新，引发无限循环。
11《Java 类加载机制：从动态加载到热修复的底层秘密》
qq_62682600的博客
06-08 810
Java 类加载机制在运行期完成类的加载、连接与初始化，牺牲部分性能换灵活性，支持热修复、插件化等。其生命周期含 7 阶段，初始化有 5 种强制触发场景，动态性是热修复等技术的底层基础。
什么是闭包，JavaScript闭包详解
qq_44136882的博客
06-09 818
JavaScript闭包详解：闭包是函数与可访问的外部变量的组合，具有记忆词法作用域的特性。核心特征在于函数能访问定义时的作用域变量，即使在其他位置执行。常见用途包括封装私有变量、创建函数工厂和处理回调。但需注意内存泄漏风险及循环中的变量共享问题。React Hooks也依赖闭包机制保存状态。理解闭包有助于编写高效灵活的代码，但需正确处理变量引用和生命周期。
springCloud2025+springBoot3.5.0+Nacos集成redis从nacos拉配置起服务
zwrlj527的专栏
06-07 495
本文探讨了在搭建最新SpringCloud+SpringBoot3+Nacos微服务框架时，网关(Gateway)选择WebFlux响应式编程模型的原因及Redis集成的方案。作者对比了WebFlux与传统Servlet栈的性能优势，包括非阻塞I/O、高并发处理能力等技术特点。针对Redis集成问题，提出了两种解决方案：一种是自定义配置类RedisAfterNacosAutoConfiguration，确保在Nacos配置加载后初始化Redis连接；另一种是直接使用SpringBoot自动配置。文章还提供了
Java 语言特性(面试系列1)
myy2012的专栏
06-10 967
JVM 为节省内存，相同字面量的字符串共享同一个实例。：线程安全，分段锁实现（JDK8 采用 CAS+之间的对象，超出范围时创建新对象。
软件工程职业实践第一节课（6.9）
m0_73776435的博客
06-10 278
新建项目打开IDEA → 点击 New Project → 选择左侧的 ‌Spring Initializr‌。 配置项目信息： ‌Name‌：项目名称（如 demo） ‌Location‌：项目存储路径 ‌Type‌：Maven 或 Gradle（本文以Maven为例） ‌Language‌：Java ‌Group‌：包名前缀（如 com.example） ‌Artifact‌：项目标识（自动填充） ‌Java Version‌：选择JDK 17或24 ‌Spring Boot‌：选择最新稳定版本（如 3
Java异步编程难题拆解：从基础到高阶实践
学海无涯苦作舟的博客
06-09 447
随着Project Loom的成熟，Java异步编程正走向结构化并发的新阶段。但技术选型仍需平衡复杂度与收益，简单场景用CompletableFuture足够，高吞吐系统建议采用反应式编程。未来ZGC与虚拟线程的结合，有望实现纳秒级延迟的异步处理能力。
Java NIO 面试全解析：9大核心考点与深度剖析
最新发布
真实的菜的博客
06-11 620
NIO的学习关键在于动手实践！建议通过实现简单的RPC框架或代理服务器来加深理解，这将成为你面试中最有力的证明。💻。
基于SSH+MySQL的JavaWeb用户管理系统
4. **JavaWeb:** JavaWeb指的是使用Java语言来开发的动态网页技术，涉及到的技术包括Servlet、JSP、JavaBean等，可以实现基于B/S架构的应用。 #### 压缩包子文件的文件名称列表: UserManagement **知识点:** 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值