基于javaweb+mysql的ssm+mavenoa办公管理系统(java+layui+ssm+maven+mysql+jsp)

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量318 收藏 12
点赞数 6
文章标签： java mysql layui
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70122726/article/details/136063295
版权

基于javaweb+mysql的ssm+mavenoa办公管理系统(java+layui+ssm+maven+mysql+jsp)

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

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

适用

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

功能说明

基于javaweb的SSM+Mavenoa办公管理系统(java+layui+ssm+maven+mysql+jsp)

一、项目运行 环境配置：

Jdk1.8 + Tomcat8.5 + mysql + Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）

项目技术：

JSP +Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQuery + Ajax + layui+ maven等等

    }

    @Override
    public JSONObject historicTaskInstanceQuery(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            /** 从SecurityUtils中获取自身的工号*/
            String number = SecurityUtils.getSubject().getPrincipal().toString();
            if (number == null) {
                json.put("type", "error");
                json.put("msg", MessageError.SYSTEM_ERROR);
                return json;
            }
            /** 获取进程引擎*/
            ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
            List<ProcessTask> processTaskList = new ArrayList<>();

            /** 得到历史的服务*/
            HistoryService historyService = processEngine.getHistoryService();
            List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery().taskAssignee(number).finished().list();
            for (HistoricTaskInstance hti : list) {
                ProcessTask processTask = new ProcessTask();
                processTask.setProcessTaskId(hti.getId());
                processTask.setProcessTaskName(hti.getName());
                processTask.setProcessTaskExecutionId(hti.getExecutionId());
                processTask.setCreateTime(hti.getCreateTime());
                processTask.setProcessTaskAssignee(hti.getAssignee());
                processTask.setProcessTaskTenantId(hti.getTenantId());
                Leave leave = leaveDao.selectLeaveByProcessInstanceId(hti.getExecutionId());
                if (leave != null) processTask.setLeave(leave);
                processTaskList.add(processTask);
            }
            json.put("type", "success");
            json.put("msg", "获取数据成功！");
            json.put("code", 0);
            json.put("count", processTaskList.size());
            json.put("data", processTaskList);
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        return json;
    }
}


                json.put("msg", "删除菜单成功！");
                return json;
            }
        } catch (Exception e) {
            json.put("tpe", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type", "error");
        json.put("msg", "删除菜单失败！");
        return json;
    }

    /**
     * 获取全部菜单树型信息
     * @param request
     * @return
     */
    @RequestMapping("/getMenuAllTree")
    @ResponseBody
    public List<Menu> getMenuAllTree(HttpServletRequest request){
        List<Menu> menuList = new ArrayList<>();

        int roleId = Integer.parseInt(request.getParameter("roleId"));
        List<Menu> menuByRoleId = menuService.getMenuByRoleId(roleId);

        List<Menu> menuAll = menuService.getMenuAll(0, 999);
        for(Menu menu : menuAll){
            menu.setDisabled(!menu.isStart());   //是否禁用
            for(Menu menu1: menuByRoleId){
                if(menu.getId().equals(menu1.getId())){
                    //如果相等
                    menu.setSpread(true);       //展开
                    menu.setChecked(true);      //选中
                    //是否是一级
                    for(Menu menu2 : menuAll){
                        if(menu.getId().equals(menu2.getPid())){
                            menu.setChecked(false); //取消勾选
                        }
                    }
                }
            }
        }
        //整理成树型
        for(Menu menu : menuAll){
            if(menu.getPid().equals(-1)){
                List<Menu> menuList1 = new ArrayList<>();


@Transactional
@Service("/processService")
public class ProcessServiceImpl implements ProcessService {

    @Autowired
    private LeaveDao leaveDao;

    @Override
    public JSONObject getHistoricProcessInstanceAll(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            /**
             * 分页处理
             */
            String page = request.getParameter("page");
            String limit = request.getParameter("limit");
            if (page == null || limit == null) {
                json.put("type", "error");
                json.put("msg", "获取分页数据失败！");
                return json;
            }
            int pageInt = Integer.parseInt(page);
            int limitInt = Integer.parseInt(limit);

            /**
             * 流程处理
             */
            /** 1.创建进程引擎*/
            ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
            /** 2.获取进程历史服务*/
            HistoryService historyService = processEngine.getHistoryService();
            /** 3.创建历史流程实例查询，按进程定义Id排序，降序排列，集合分页*/
            List<HistoricProcessInstance> list = historyService.createHistoricProcessInstanceQuery().orderByProcessDefinitionId().desc().listPage((pageInt - 1) * limitInt, limitInt);

            /**
             * json封装
             */

     * @return
     */
    @RequestMapping("/addNotice")
    @ResponseBody
    public JSONObject addNotice(HttpServletRequest request) {
        return noticeService.addNotice(request);
    }

    /**
     * 删除系统公告信息
     *
     * @param request
     * @return
     */
    @RequestMapping("/deleteNotice")
    @ResponseBody
    public JSONObject deleteNotice(HttpServletRequest request) {
        return noticeService.deleteNotice(request);
    }

    /**
     * 修改系统公告信息
     *
     * @param request
     * @return
     */
    @RequestMapping("/updateNotice")
    @ResponseBody
    public JSONObject updateNotice(HttpServletRequest request) {
        return noticeService.updateNotice(request);
    }

    /**
     * 已阅读系统公告
     *
     * @param request
     * @return
     */
    @RequestMapping("/flagNotice")
    @ResponseBody
    public JSONObject flagNotice(HttpServletRequest request) {
        return noticeService.flagNotice(request);
    }

    /**
     * 批量发布系统公告
     *
     * @param request
     * @return
     */
    @RequestMapping("/bulkReleaseNotice")
    @ResponseBody
    public JSONObject bulkReleaseNotice(HttpServletRequest request) {
        return noticeService.bulkReleaseNotice(request);

     * @return
     */
    @RequestMapping("/updateMenu")
    @ResponseBody
    public JSONObject updateMenu(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            Menu menu = JSONObject.parseObject(request.getParameter("menu"), Menu.class);
            if (menuService.updateMenu(menu) > 0) {
                json.put("type", "success");
                json.put("msg", "修改菜单成功！");
                return json;
            }
        } catch (Exception e) {
            json.put("tpe", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type", "error");
        json.put("msg", "修改菜单失败！");
        return json;
    }

    /**
     * 删除菜单
     *
     * @param request
     * @return
     */
    @RequestMapping("/deleteMenu")
    @ResponseBody
    public JSONObject deleteMenu(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            int menuId = Integer.parseInt(request.getParameter("menuId"));
            if (menuService.deleteMenu(menuId) > 0) {
                json.put("type", "success");
                json.put("msg", "删除菜单成功！");
                return json;
            }
        } catch (Exception e) {
            json.put("tpe", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type", "error");
        json.put("msg", "删除菜单失败！");

            if (employeeDao.verifyEmployeeNumber(employee) > 0) {
                json.put("type", "error");
                json.put("msg", "该工号已被使用，请使用别的工号");
                return json;
            }
            if (employeeDao.verifyEmployeePhone(employee) > 0) {
                json.put("type", "error");
                json.put("msg", "该手机号已被使用，请使用别的手机号");
                return json;
            }
            if (employeeDao.updateEmployeeAdmin(employee) > 0) {
                json.put("type", "success");
                json.put("msg", "修改雇员成功");
                return json;
            }
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type", "error");
        json.put("msg", "修改雇员失败");
        return json;
    }

    @Override
    public JSONObject deleteEmployee(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            String employeeId = request.getParameter("employeeId");
            if (employeeDao.deleteEmployee(Integer.parseInt(employeeId)) > 0) {
                json.put("type", "success");
                json.put("msg", "删除雇员成功");
                return json;
            }
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type", "error");
        json.put("msg", "删除雇员失败");
        return json;
    }


            int limit = Integer.parseInt(request.getParameter("limit"));
            List<Leave> leaves = leaveDao.selectLeaveAllApproval(approved, (page - 1) * limit, limit);
            json.put("type", "success");
            json.put("msg", "获取数据成功！");
            json.put("code", 0);
            json.put("count", leaveDao.selectLeaveAllApprovalCount(approved));
            json.put("data", leaves);
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        return json;
    }

    @Override
    public JSONObject updateLeaveApproval(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            String leaveStr = request.getParameter("leave");
            if (leaveStr == null) {
                json.put("type", "error");
                json.put("msg", "数据获取失败！");
                return json;
            }
            Leave leave = JSONObject.parseObject(leaveStr, Leave.class);
            if (leaveDao.updateLeaveApproval(leave) > 0) {
                json.put("type", "success");
                json.put("msg", "审批成功！");
                return json;
            }
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type", "error");
        json.put("msg", "审批失败！");
        return json;
    }
}


     * @param request
     * @return
     */
    @RequestMapping("/getHistoricProcessInstanceAll")
    @ResponseBody
    public JSONObject getHistoricProcessInstanceAll(HttpServletRequest request) {
        return processService.getHistoricProcessInstanceAll(request);
    }

    /**
     * 查看流程状态
     *
     * @param request
     * @return
     */
    @RequestMapping("/checkProcessStatus")
    @ResponseBody
    public JSONObject checkProcessStatus(HttpServletRequest request) {
        return processService.checkProcessStatus(request);
    }

    /**
     * 流程实例开关
     *
     * @param request
     * @return
     */
    @RequestMapping("/switchProcessInstance")
    @ResponseBody
    public JSONObject switchProcessInstance(HttpServletRequest request) {
        return processService.switchProcessInstance(request);
    }

    /**
     * 历史任务实例查询
     *
     * @param request
     * @return
     */
    @RequestMapping("/historicTaskInstanceQuery")
    @ResponseBody

        //整理成树型
        for(Menu menu : menuAll){
            if(menu.getPid().equals(-1)){
                List<Menu> menuList1 = new ArrayList<>();
                for(Menu menu1 : menuAll){
                    if(menu.getId().equals(menu1.getPid())){
                        menuList1.add(menu1);
                    }
                }
                if(menuList1.size() > 0){
                    menu.setChildren(menuList1);
                }
                menuList.add(menu);
            }
        }
        return menuList;
    }

}

@Transactional
@Service("/permissionsService")
public class PermissionsServiceImpl implements PermissionsService {

    @Autowired
    private PermissionsDao permissionsDao;

    @Override

        return json;
    }

    @Override
    public JSONObject queryingSystemMessages(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            String employeeNumber = SecurityUtils.getSubject().getPrincipal().toString();   //得到自身工号
            if (employeeNumber == null) {
                json.put("type", "error");
                json.put("msg", "获取数据失败！");
                return json;
            }
            List<Notice> notices = noticeDao.queryingSystemMessages(employeeNumber);
            json.put("type", "success");
            json.put("msg", "获取数据成功！");
            json.put("code", 0);
            json.put("count", notices.size());
            json.put("data", notices);
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        return json;
    }

    @Override
    public JSONObject noticeRead(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try{
            int nerId;
            String nerIdStr = request.getParameter("nerId");
            if(nerIdStr == null){
                json.put("type","error");
                json.put("msg","获取数据失败！");
                return json;
            }
            nerId = Integer.parseInt(nerIdStr);
            if( noticeDao.noticeRead(nerId) > 0){
                json.put("type","success");
                json.put("msg","阅读成功！");
                return json;
            }
        }catch (Exception e){
            json.put("type","error");
            json.put("msg",MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type","error");

     */
    @RequestMapping("/getRoleAll")
    @ResponseBody
    public JSONObject getRoleAll() {
        JSONObject json = new JSONObject();
        List<Role> roles = roleService.selectRoleAll();
        json.put("code", 0);
        json.put("msg", "");
        json.put("count", roles.size());
        json.put("data", roles);
        return json;
    }

    /**
     * 设置角色菜单
     *
     * @param request
     * @return
     */
    @RequestMapping("/setRoleJurisdiction")
    @ResponseBody
    public JSONObject setRoleJurisdiction(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            /** 角色ID*/
            String roleId = request.getParameter("roleId");
            /** 菜单ID数组*/
            Integer[] menuIds = JSONObject.parseObject(request.getParameter("menuIdList"), Integer[].class);
            roleService.batchDeleteRoleByMenu(Integer.parseInt(roleId));    //先删除
            if (roleService.batchAddRoleByMenu(Integer.parseInt(roleId), menuIds) > 0) {    // 后添加
                json.put("type", "success");
                json.put("msg", "设置角色菜单成功");
                return json;
            }
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", "系统错误！请联系管理员");
            System.out.println(e.getMessage());
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();  //回滚
        }
        json.put("type", "error");
        json.put("msg", "设置角色菜单失败！");
        return json;
    }

    /**
     * 设置角色权限
     *
     * @param request
     * @return
     */
    @RequestMapping("/setRolePermissions")


@Transactional
@Service("/permissionsService")
public class PermissionsServiceImpl implements PermissionsService {

    @Autowired
    private PermissionsDao permissionsDao;

    @Override
    public JSONObject getPermissionsAll(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        int page = Integer.parseInt(request.getParameter("page"));
        int limit = Integer.parseInt(request.getParameter("limit"));
        List<Permissions> permissions = permissionsDao.selectPermissionsAll((page - 1) * limit, limit);
        json.put("code", 0);
        json.put("msg", "");
        json.put("count", permissionsDao.selectPermissionsAllCount());
        json.put("data", permissions);
        return json;
    }

    @Override
    public JSONObject updatePermissions(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            String permissionsJSON = request.getParameter("permissions");
            if (permissionsJSON == null) {
                json.put("type", "error");
                json.put("msg", "获取数据为空！");
                return json;
            }
            Permissions permissions = JSONObject.parseObject(permissionsJSON, Permissions.class);
            if (permissionsDao.updatePermissions(permissions) > 0) {
                json.put("type", "success");
                json.put("msg", "修改权限成功！");
                return json;
            }

                if (menuList2.size() > 0) menu.setChildren(menuList2);
                menuList.add(menu);
            }
        }
        return menuList;
    }
}

@Controller
@RequestMapping("/role")
public class RoleController {

    @Autowired
    private RoleService roleService;

    /**
     * 页面跳转
     *
     * @param request
     * @return
     */
    @RequestMapping("/toPage")
    public String toPage(HttpServletRequest request) {
        String url = "sys/role/role";
        String page = request.getParameter("page");
        if (page != null) {
            url = page;
        }
        return url;
    }

    /**
     * 添加角色

                json.put("msg", "修改权限成功！");
                return json;
            }
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type", "error");
        json.put("msg", "修改权限失败！");
        return json;
    }

    @Override
    public JSONObject addPermissions(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            String permissionsJSON = request.getParameter("permissions");
            if (permissionsJSON == null) {
                json.put("type", "error");
                json.put("msg", "获取数据为空！");
                return json;
            }
            Permissions permissions = JSONObject.parseObject(permissionsJSON, Permissions.class);
            if (permissionsDao.addPermissions(permissions) > 0) {
                json.put("type", "success");
                json.put("msg", "添加权限成功！");
                return json;
            }
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type", "error");
        json.put("msg", "添加权限失败！");
        return json;
    }

    @Override
    public JSONObject deletePermissions(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            String permissionsIdList = request.getParameter("permissionsIdList");
            if (permissionsIdList == null) {
                json.put("type", "error");
                json.put("msg", "获取数据为空！");
                return json;
            }
            Integer[] integers = JSONObject.parseObject(permissionsIdList, Integer[].class);
            if (permissionsDao.deletePermissions(integers) > 0) {
                json.put("type", "success");

            String limitStr = request.getParameter("limit");
            if (pageStr == null || limitStr == null) {
                json.put("type", "error");
                json.put("msg", "获取数据失败！");
                return json;
            }
            page = Integer.parseInt(pageStr);
            limit = Integer.parseInt(limitStr);
            List<Stationery> stationeries = stationeryDao.selectStationeryAll((page - 1) * limit, limit);
            json.put("type", "success");
            json.put("msg", "获取数据成功！");
            json.put("code", 0);
            json.put("count", stationeryDao.selectStationeryAllCount());
            json.put("data", stationeries);
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        return json;
    }

    @Override
    public JSONObject getHistoryOfOfficeSupplies(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            int page;
            int limit;
            String pageStr = request.getParameter("page");
            String limitStr = request.getParameter("limit");
            String employeeNumber = SecurityUtils.getSubject().getPrincipal().toString();   //得到自身工号
            if (pageStr == null || limitStr == null || employeeNumber == null) {
                json.put("type", "error");
                json.put("msg", "获取数据失败！");
                return json;
            }
            page = Integer.parseInt(pageStr);
            limit = Integer.parseInt(limitStr);

            List<StationeryProposer> stationeryProposers = stationeryDao.selectStationeryByEmployeeNumber(employeeNumber, (page - 1) * limit, limit);
            json.put("type", "success");
            json.put("msg", "获取数据成功！");

        return json;
    }

    @Override
    public JSONObject deleteEmployee(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            String employeeId = request.getParameter("employeeId");
            if (employeeDao.deleteEmployee(Integer.parseInt(employeeId)) > 0) {
                json.put("type", "success");
                json.put("msg", "删除雇员成功");
                return json;
            }
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;
        }
        json.put("type", "error");
        json.put("msg", "删除雇员失败");
        return json;
    }

    @Override
    public JSONObject updateRole(HttpServletRequest request) {
        JSONObject json = new JSONObject();
        try {
            String employeeIdList = request.getParameter("employeeIdList");
            String roleId = request.getParameter("roleId");
            if (employeeIdList == null || roleId == null) {
                json.put("type", "error");
                json.put("msg", "null");
                return json;
            }
            Integer[] employeeIdLists = JSONObject.parseObject(employeeIdList, Integer[].class);
            if (employeeDao.batchUpdateEmployeeByRoleId(employeeIdLists, Integer.parseInt(roleId)) > 0) {
                json.put("type", "success");
                json.put("msg", "修改角色成功！");
                return json;
            }
        } catch (Exception e) {
            json.put("type", "error");
            json.put("msg", MessageError.SYSTEM_ERROR);
            System.out.println(e.getMessage());
            return json;

    @ResponseBody
    public JSONObject addStationery(HttpServletRequest request) {
        return stationeryService.addStationery(request);
    }

    /**
     * 修改办公用品信息
     *
     * @param request
     * @return
     */
    @RequestMapping("/updateStationery")
    @ResponseBody
    public JSONObject updateStationery(HttpServletRequest request) {
        return stationeryService.updateStationery(request);
    }

    /**
     * 删除办公用品
     *
     * @param request
     * @return
     */
    @RequestMapping("/deleteStationery")
    @ResponseBody
    public JSONObject deleteStationery(HttpServletRequest request) {
        return stationeryService.deleteStationery(request);
    }

    /**
     * 添加新办公用品数量
     *
     * @param request
     * @return
     */
    @RequestMapping("/addStationeryAdd")
    @ResponseBody
    public JSONObject addStationeryAdd(HttpServletRequest request) {
        return stationeryService.addStationeryAdd(request);
    }

    /**
     * 获取添加新办公用品数量历史信息
     *
     * @param request
     * @return
     */
    @RequestMapping("/getStationeryAddHistory")
    @ResponseBody

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

java毕业
关注
  • 6
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java项目:轻语音乐网平台(java+Springboot+ssm+mysql+maven+jsp)
02-11
一、项目简述 ...进行收藏 我的音乐模块：收藏的歌曲会被添加到我的音乐列表中， 在我的音乐列表中也可以对...项目技术： JSP +SpringBoot + MyBatis + html+ css + JavaScript + JQuery + Ajax + Bootstrap+ maven 等等。
Java项目:图书管理系统(java+SSM+jsp+mysql+maven)
02-18
 功能包括(管理员和学生角色)： 管理员和学生登录，图书管理，图书添加删除修改，图书 借阅，图书归还，图书查看，学生管理，借还管理，读者 管理，密码管理，信息修改等等功能。 二、项目运行 环境配置： Jdk1.8 ...
基于javaweb的oa人事管理系统(java+springboot+jsp+layui+html+mysql)
m0_69592937的博客
10-24 784
基于javaweb的oa人事管理系统(java+springboot+jsp+layui+html+mysql) 运行环境 Java≥8、MySQL≥5.7 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等
Java基于WEB的OA办公信息管理系统(源码+mysql+文档)
天成程序设计
01-10 917
通过系统的统一管理和自动化处理，可以减少繁琐的手工操作，节省大量的时间和人力资源。系统可以对各种办公信息进行实时监控和分析，为企业决策提供科学依据，提高决策的准确性和及时性。此外，系统还可以实现信息的共享和协同工作，促进企业内部各部门之间的沟通和合作，提高工作效率和团队协作能力。该系统通过互联网技术，将企业内部的各种办公信息进行集中管理和共享，实现办公流程的自动化和信息化，提高企业的工作效率和管理水平。它不仅可以提高企业的工作效率和管理水平，还可以促进企业内部的协同工作和信息共享，提高企业的整体竞争力。
基于javaweb+mysql的springbootoa办公管理系统oa管理系统(java+springboot+vue+maven+mybatis+mysql)
欢迎私信
12-23 351
基于javaweb+mysql的springbootoa办公管理系统oa管理系统(java+springboot+vue+maven+mybatis+mysql)基于javaweb的SpringBootoa办公管理系统oa管理系统(java+springboot+vue+maven+mybatis+mysql)Spring + SpringBoot+ mybatis + Maven + Vue 等等组成，B/S模式 + Maven管理等等。课程设计，大作业，毕业设计，项目练习，学习演示等。
Java项目:公司企业OA管理系统(java+SSM+JSP+JavaScript+Mysql)
常年被追砍的博客
07-01 419
OA办公管理系统，这是一款由JSP+SSM（spring+springmvc+mybatis）+MySQL实现的简单的OA办公管理系统， 主要实现的功能有员工注册登录，自动计算当前月迟到、早退、加班、缺勤天数并根据图表展示， 任务管理（任务发布、更新、删除、进度条展示完成度），通知管理（通知发布、更新、删除）， 站内信发布、回复、删除等，发布公告和任务及站内信时可上传图片等。1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。 2.IDE环境：IDEA，Eclipse
基于javaweb+mysql的学生信息管理系统(java+SSM+jsp+mysql+maven)
m0_71480786的博客
05-28 731
一、项目简述 功能包括： 用户的登录注册，学生信息管理，教师信息管理，班级信 息管理，采用mvcx项目架构，覆盖增删改查，包括学生， 教币班级的信息导出上传导入等等功能。 二、项目运行 环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) 项目技术： JSP +Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQuery + Aj
基于javaweb+SSM的医院管理系统(java+SSM+layui+maven+mysql)
m0_71096470的博客
05-18 479
功能介绍： 基于ssm+layui框架的小型医院后台管理系统。简单实现了病人管理、病床管理、员工管理、部门管理、药品管理、仪器管理等基础功能。 整个项目通过maven方式搭建用到的jar包通过maven导入，前端使用搭建好的Layui框架，拿来即用。后端使用SSM+MySQL，后台逻辑实现了分页、级联、多表查询。目前项目基本完成，可重构与扩展 技术栈： SSM框架 Layui框架 MySQL 5.7 数据库 Maven搭建 MD5加密 实现功能： 管理员的登录、退出与切换 管理员、仪器、药品、部门、员
基于javaweb+jsp的图书管理系统(java+SSM+jsp+mysql+maven)
m0_71048928的博客
05-17 1151
一、项目简述 功能包括(管理员和学生角色)： 管理员和学生登录，图书管理，图书添加删除修改，图书 借阅，图书归还，图书查看，学生管理，借还管理，读者 管理，密码管理，信息修改等等功能。 二、项目运行 环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) 项目技术： JSP +Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQue
基于javaweb+jsp的在线点餐系统(java+SSM+jsp+mysql+maven+layui)
m0_71098312的博客
05-18 1107
一、项目简述 功能包括： 前台实现：用户浏览菜单、菜品分类筛选、查看菜单详 情、添加购物车、购物车结算、会员券、个人订单查询等 等。 后台实现：餐系管理、菜品管理、订单管理、系统管理、 酉己备员管理等。 系统分为：高或管理员、顾客、厨师、配送员等等。 二、项目运行 环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) 项目技术： JSP +Spring + SpringMVC + MyBati
基于javaweb+mysql的酒店管理系统(java+SSM+Maven+LayUI+mysql)
m0_71325892的博客
05-24 788
酒店管理系统-温情小筑后台管理系统 系统概要 项目主要功能包括： 住客管理：住客入住、住客列表； 房间管理：房间列表、添加房间、修改房间状态； 会员管理：新增会员、会员列表； 系统设置：网站信息、修改密码、清除缓存； 数据表：生成Excel并导出等功能，适合java新手学习； 技术选型 1.后台技术选型：SSM（Spring SpringMVC Mybatis） 2.前端技术选型：LayUI 开发环境 1.编程语言：Java 2.开发工具：IDEA/Eclipse、Navicat 3.项目构建：Maven
基于javaweb+mysql的仓库管理系统(SSM+jsp+mysql+maven)
m0_71285887的博客
05-23 651
一、项目简述 功能包括： 仓库管理，出入库管理，仓库人员管理，基本信息管理, 供应商信息，系统管理等等。 二、项目运行 环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) 项目技术： JSP +Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQuery + Ajax + layui+ maven等等。 适用 课程设计，大作
Java项目:车险理赔管理系统(java+SSM+JSP+echarts+jQuery+Mysql)
07-09
车险理赔管理系统源码，分为三个用户，一个管理员，一个工作人员，一个普通人员 管理员功能：登录、发放赔偿金、赔偿金发放列表、申请理赔列表、申请理赔通过、我的资料、用户列表 工作人员功能：勘察员-待调查事故...
Java项目:学生课堂考勤管理系统(java+SSM+JSP+layui+Mysql)
06-23
项目介绍 本项目包含辅导员、管理员、教师、学生四种角色； 辅导员包含以下功能： ... 管理员角色包含以下功能： ...2. 前端：JSP+CSS+JavaScript+layui 使用说明 1. 使用Navicat或者其它工具，在mys
Java项目:在线考试平台(java+Springboot+ssm+mysql+maven)
12-02
发布考试，考试列表，课程管理，题库管 理，成绩管理，成绩情况 /权限管理：学院管理，班级管理，用户管理，角色管 理，资源管理 4网站管理：基础信息，友链管理，评论管理，标签管理 /系统管理：在线用户 /上传管理...
JAVA进阶补充
2301_80150315的博客
08-15 744
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 888
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 528
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 264
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
Java SSM+Vue后勤管理系统实现与功能详解
"Java+SSM+Vue的公寓宿舍后勤管理系统是一个基于B/S架构和Web技术的JavaWeb项目，利用Spring、SpringMVC和MyBatis（SSM）框架进行开发，结合Vue.js前端框架，提供了全面的后勤管理功能。项目包含源代码、数据库、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

java毕业

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值