【SpringBoot+MySQL】后台管理系统——机构管理

最新推荐文章于 2024-04-08 16:46:26 发布
最新推荐文章于 2024-04-08 16:46:26 发布
阅读量561 收藏 2
点赞数
文章标签： restful java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42000631/article/details/120699312
版权

一、机构表

sql 建表语句
CREATE TABLE `t_organization`  (
  `id` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '主键',
  `parentId` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '上级部门Id',
  `code` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '部门编号',
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '部门名称',
  `levelCode` int(0) NULL DEFAULT NULL COMMENT '部门等级',
  `createdAt` date NULL DEFAULT NULL COMMENT '创建时间',
  `createdById` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '创建操作人',
  `deleted` tinyint(0) NULL DEFAULT NULL COMMENT '是否删除',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 22 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
数据库对应java 实体类
package com.management.entity;

import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
import lombok.Data;

import java.util.Date;
import java.io.Serializable;

/**
 * (Organization)实体类
 *
 */
@Data
@TableName(value = "t_organization")
public class Organization implements Serializable {
    private static final long serialVersionUID = 903679346923294871L;
    /**
     * 主键
     */
    @TableId(value = "id", type = IdType.INPUT)
    private String id;
    /**
     * 上级部门Id
     */
    private String parentId;
    /**
     * 部门编号
     */
    private String code;
    /**
     * 部门名称
     */
    private String name;
    /**
     * 部门等级
     */
    private int levelCode;
    /**
     * 创建时间
     */
    private Date createdAt;
    /**
     * 创建操作人
     */
    private String createdById;
    /**
     * 是否删除
     */
    private boolean deleted;

    public boolean getDeleted() {
        return deleted;
    }

    public void setDeleted(boolean deleted) {
        this.deleted = deleted;
    }
}
dao接口
package com.management.dao;

import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.management.entity.Organization;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;

import java.util.List;

/**
 * (Organization)表数据库访问层
 *
 */
@Mapper
public interface OrganizationDao extends BaseMapper<Organization> {

    @Update({"<script>" +
            "update organization set deleted= 1 " +
            "where"+
            "<foreach collection='organizations' item='item' index='index' open='(' separator='or' close=')'> " +
            " id = #{item} " +
            "</foreach>" +
            "</script>"})
    int updateBatchIds(@Param("organizations") List<String> organizations);

}
Organization 相关dto 类
package com.management.dto.organization;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

@Data
@ApiModel("新建机构")
public class CreateOrganizationDto {
    /**
     * 上级部门Id
     */
    @ApiModelProperty("父级机构id")
    private String parentId;

    /**
     * 部门名称
     */
    @ApiModelProperty("部门名称")
    private String name;

}


package com.management.dto.organization;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.Date;
import java.util.List;

@Data
@ApiModel("机构树")
public class OrgTreeDto {

    /**
     * 主键
     */
    @ApiModelProperty("主键")
    private String id;
    /**
     * 上级部门Id
     */
    @ApiModelProperty("上级部门Id")
    private String parentId;
    /**
     * 部门编号
     */
    @ApiModelProperty("部门编号")
    private String code;
    /**
     * 部门名称
     */
    @ApiModelProperty("部门名称")

    private String title;
    /**
     * 部门等级
     */
    @ApiModelProperty("部门等级")
    private int levelCode;
    /**
     * 创建时间
     */
    @ApiModelProperty("创建时间")

    private Date createdAt;
    /**
     * 创建操作人
     */
    @ApiModelProperty("创建操作人")
    private String createdById;
    /**
     * 是否删除
     */
    @ApiModelProperty("是否删除")
    private boolean deleted;
    /**
     * 子级机构
     */
    @ApiModelProperty("子级机构")

    private List<OrgTreeDto> children;
    /**
     * 前端要加的
     */
    private boolean contextmenu ;
}


package com.management.dto.organization;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;


@Data
@ApiModel("编辑机构")
public class UpdateOrgDto {

    /**
     * 主键
     */
    @ApiModelProperty("主键")
    private String id;

    /**
     * 部门名称
     */
    @ApiModelProperty("部门名称")
    private String name;

}
service 接口
package com.management.service;

import com.management.dto.organization.CreateOrganizationDto;
import com.management.dto.organization.OrgTreeDto;
import com.management.dto.organization.UpdateOrgDto;
import com.management.entity.Organization;

import java.util.List;

/**
 * (Organization)表服务接口
 */
public interface IOrganizationService {

    /**
     * 通过ID查询单条数据
     */
    Organization queryById(String id) throws Exception;

    /**
     * 查询机构树 根据id
     */
    OrgTreeDto queryOrgTree(String id) throws Exception;

    /**
     * 查询机构树 根据name
     */
    OrgTreeDto queryOrgTreeByName(String name, Boolean contextmenu) throws Exception;

    /**
     * 根据id 获取父级的id
     * @param orgId orgId
     * @return
     * @throws Exception
     */
    List<String> getParentId(String orgId) throws Exception;

    /**
     * 查询当前及以下机构的id
     */
    List<String> queryOrgList(String id) throws Exception;

    /**
     * 新建机构
     */
    Organization createOrg(CreateOrganizationDto organization) throws Exception;

    /**
     * 编辑机构
     */
    boolean updateOrg(UpdateOrgDto orgDto) throws Exception;

    /**
     * 删除当前部门以及下属部门
     */
    boolean deleteOrg(String id) throws Exception;

}
service 业务是实现类接口
package com.management.service.impl;

import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.management.common.enums.PrefixEnum;
import com.management.common.exception.LogicException;
import com.management.common.mapstruct.OrgCovert;
import com.management.common.primaryKey.PrimaryKeyGenerator;
import com.management.common.request.CurrentRequest;
import com.management.dao.OrganizationDao;
import com.management.dto.organization.CreateOrganizationDto;
import com.management.dto.organization.OrgTreeDto;
import com.management.dto.organization.UpdateOrgDto;
import com.management.entity.Organization;
import com.management.service.IOrganizationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * (Organization)表服务实现类
 */
@Service
@Slf4j
public class OrganizationService extends ServiceImpl<OrganizationDao, Organization> implements IOrganizationService {


    @Autowired
    private CurrentRequest currentRequest;

    @Autowired
    private OrgCovert orgCovert;

    @Autowired
    private PrimaryKeyGenerator primaryKeyGenerator;


    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public Organization queryById(String id) throws Exception {
        if (StringUtils.isEmpty(id)) {
            throw new LogicException("id为空！");
        }
        Organization organization = this.baseMapper.selectById(id);
        if (organization == null) {
            throw new LogicException("organization 查询失败！");
        }
        log.info("[组织机构]-[queryById]-organization: {} ", JSONUtil.toJsonStr(organization));
        return organization;
    }

    /**
     * 查询机构树 ,根据id
     *
     * @param id id
     * @return return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public OrgTreeDto queryOrgTree(String id) throws Exception {
        if (StringUtils.isEmpty(id)) {
            EntityWrapper<Organization> wrapper = new EntityWrapper<>();
            wrapper.eq("deleted", false).andNew().eq("parentId", "").or().isNull("parentId");
            List<Organization> organizations = baseMapper.selectList(wrapper);
            if (organizations != null && organizations.size() != 0) {
                id = organizations.get(0).getId();
            } else {
                throw new LogicException("id为空！");
            }
        }

        log.info("[组织机构]-[查询机构树]-id: {} ", id);

        List<OrgTreeDto> organizationList = new ArrayList<>();
        Organization organization = baseMapper.selectById(id);
        if (organization == null) {
            throw new LogicException("父级机构不存在");
        }
        OrgTreeDto result = orgCovert.daoTodto(organization);
        organizationList.add(result);

        while (true) {
            List<OrgTreeDto> temp = new ArrayList<>();
            for (OrgTreeDto orgTreeDto :
                    organizationList) {
                EntityWrapper<Organization> wrapper = new EntityWrapper<>();
                wrapper.eq("parentId", orgTreeDto.getId());
                wrapper.eq("deleted", 0);
                List<Organization> organizations = baseMapper.selectList(wrapper);
                if (organizations.size() != 0) {
                    List<OrgTreeDto> orgTreeDtos = orgCovert.daoTodto(organizations);
                    temp.addAll(orgTreeDtos);
                    orgTreeDto.setChildren(orgTreeDtos);
                }
            }
            if (temp.size() == 0) {
                break;
            }
            organizationList.clear();
            organizationList.addAll(temp);

        }
        log.info("[组织机构]-[查询机构树]-result: {} ", JSONUtil.toJsonStr(result));

        return result;
    }

    /**
     * 查询机构树 根据name
     *
     * @param name name
     * @return re
     * @throws Exception e
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public OrgTreeDto queryOrgTreeByName(String name, Boolean contextmenu) throws Exception {

        List<String> parentIds = new ArrayList<>();
        List<String> orgIds = new ArrayList<>();

        if (!StringUtils.isEmpty(name)) {

            EntityWrapper<Organization> wrapper = new EntityWrapper<>();
            wrapper.like("name", name);
            wrapper.eq("deleted", false);
            List<Organization> organizationList = baseMapper.selectList(wrapper);

            if (organizationList == null || organizationList.size() == 0) {
                return null;
            }

            List<String> parentIdAll = new ArrayList<>();
            for (Organization temp : organizationList) {
                List<String> parentId = getParentId(temp.getId());
                parentIdAll.add(temp.getId());
                parentIdAll.addAll(parentId);
                orgIds.add(temp.getId());
            }
            parentIds.addAll(parentIdAll.stream().distinct().collect(Collectors.toList()));
        }

        EntityWrapper<Organization> wrapperParent = new EntityWrapper<>();
        if (!parentIds.isEmpty()) {
            wrapperParent.in("id", parentIds);
        }
        wrapperParent.eq("deleted", false).andNew().eq("parentId", "").or().isNull("parentId");
        List<Organization> parentOrg = baseMapper.selectList(wrapperParent);


        List<OrgTreeDto> organizationList = new ArrayList<>();
        List<OrgTreeDto> orgTreeDtoList = new ArrayList<>();
        OrgTreeDto result = orgCovert.daoTodto(parentOrg.get(0));
        result.setContextmenu(contextmenu);
        organizationList.add(result);


        while (true) {
            List<OrgTreeDto> temp = new ArrayList<>();
            for (OrgTreeDto orgTreeDto :
                    organizationList) {
                EntityWrapper<Organization> wrapper = new EntityWrapper<>();
                wrapper.eq("parentId", orgTreeDto.getId());
                wrapper.eq("deleted", 0);
                if (!parentIds.isEmpty()) {
                    wrapper.in("id", parentIds);
                }
                List<Organization> organizations = baseMapper.selectList(wrapper);
                if (organizations.size() != 0) {
                    List<OrgTreeDto> orgTreeDtos = orgCovert.daoTodto(organizations);
                    for (OrgTreeDto temp1 : orgTreeDtos) {
                        temp1.setContextmenu(contextmenu);
                        if (orgIds.lastIndexOf(temp1.getId()) > -1) {
                            orgTreeDtoList.add(temp1);
                        }
                    }
                    temp.addAll(orgTreeDtos);
                    orgTreeDto.setChildren(orgTreeDtos);

                }
            }
            if (temp.size() == 0) {
                break;
            }
            organizationList.clear();
            organizationList.addAll(temp);

        }


        while (true) {
            List<OrgTreeDto> temp = new ArrayList<>();
            for (OrgTreeDto orgTreeDto :
                    orgTreeDtoList) {
                EntityWrapper<Organization> wrapper = new EntityWrapper<>();
                wrapper.eq("parentId", orgTreeDto.getId());
                wrapper.eq("deleted", 0);
                List<Organization> organizations = baseMapper.selectList(wrapper);
                if (organizations.size() != 0) {
                    List<OrgTreeDto> orgTreeDtos = orgCovert.daoTodto(organizations);
                    for (OrgTreeDto temp1 : orgTreeDtos) {
                        temp1.setContextmenu(contextmenu);
                    }
                    temp.addAll(orgTreeDtos);
                    orgTreeDto.setChildren(orgTreeDtos);
                }
            }
            if (temp.size() == 0) {
                break;
            }
            orgTreeDtoList.clear();
            orgTreeDtoList.addAll(temp);

        }
        log.info("[组织机构]-[查询机构树]-result: {} ", JSONUtil.toJsonStr(result));

        return result;
    }

    @Override
    public List<String> getParentId(String orgId) throws Exception {

        List<String> result = new ArrayList<>();

        if (StringUtils.isEmpty(orgId)) {
            throw new LogicException("orgId 为空！");
        }
        Organization organization = baseMapper.selectById(orgId);


        String parentId = organization.getParentId();
        while (true) {
            if (StringUtils.isEmpty(parentId)) {
                break;
            }
            EntityWrapper<Organization> wrapper = new EntityWrapper<>();
            wrapper.eq("id", parentId);
            wrapper.eq("deleted", 0);
            List<Organization> parentOrganizations = baseMapper.selectList(wrapper);

            if (parentOrganizations.isEmpty()) {
                throw new LogicException("查询父级机构失败！");
            }
            parentId = parentOrganizations.get(0).getParentId();
            result.add(parentOrganizations.get(0).getId());

        }
        return result;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public List<String> queryOrgList(String id) throws Exception {
        log.info("[组织机构]-[查询当前及以下机构的id]-id: {} ", id);

        List<Organization> organizationList = new ArrayList<>();
        Organization organization = baseMapper.selectById(id);
        if (organization == null) {
            throw new LogicException("父级机构不存在");
        }

        List<String> result = new ArrayList<>();
        result.add(organization.getId());

        organizationList.add(organization);

        while (true) {
            List<Organization> temp = new ArrayList<>();
            for (Organization org :
                    organizationList) {
                EntityWrapper<Organization> wrapper = new EntityWrapper<>();
                wrapper.eq("parentId", org.getId());
                wrapper.eq("deleted", 0);
                List<Organization> organizations = baseMapper.selectList(wrapper);
                if (organizations.size() != 0) {
                    List<String> idList = organizations.stream().map(Organization::getId).collect(Collectors.toList());
                    result.addAll(idList);
                    temp.addAll(organizations);
                }
            }
            if (temp.size() == 0) {
                break;
            }
            organizationList.clear();
            organizationList.addAll(temp);

        }
        log.info("[组织机构]-[查询当前及以下机构的id]-result: {} ", JSONUtil.toJsonStr(result));

        return result;
    }

    /**
     * 新建机构
     *
     * @param organization 实例对象
     * @return 实例对象
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public Organization createOrg(CreateOrganizationDto organization) throws Exception {
        log.info("[组织机构]-[新建机构]-organization: {} ", JSONUtil.toJsonStr(organization));

        Organization parentOrg = baseMapper.selectById(organization.getParentId());
        log.info("[组织机构]-[新建机构]-parentOrg: {} ", JSONUtil.toJsonStr(parentOrg));
        int newLevel = parentOrg.getLevelCode() + 1;

        Organization newOrg = new Organization();
        String primaryKey = primaryKeyGenerator.generateKey(PrefixEnum.t_organization.getPriFix(), PrefixEnum.t_organization);
        newOrg.setId(primaryKey);
        newOrg.setName(organization.getName());
        newOrg.setParentId(organization.getParentId());
        newOrg.setCreatedAt(new Date());
        newOrg.setCreatedById(currentRequest.getUserInfo().getId());
        newOrg.setDeleted(false);
        newOrg.setLevelCode(newLevel);
        log.info("[组织机构]-[新建机构]-newOrg: {} ", JSONUtil.toJsonStr(newOrg));

        Integer result = baseMapper.insert(newOrg);
        log.info("[组织机构]-[新建机构]-newOrg: {} ", JSONUtil.toJsonStr(newOrg));
        newOrg.setCode(String.valueOf(newOrg.getId()));
        int update = baseMapper.updateById(newOrg);
        log.info("[组织机构]-[新建机构]-result: {} ", result);
        log.info("[组织机构]-[新建机构]-update: {} ", update);

        if (result > 0 && update > 0) {
            return newOrg;
        }
        return null;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean updateOrg(UpdateOrgDto orgDto) throws Exception {
        log.info("[组织机构]-[编辑机构]-orgDto: {} ", JSONUtil.toJsonStr(orgDto));

        Organization organization = baseMapper.selectById(orgDto.getId());
        if (organization == null) {
            throw new LogicException("机构信息不存在");
        }

        log.info("[组织机构]-[编辑机构]-organization: {} ", JSONUtil.toJsonStr(organization));

        organization.setName(orgDto.getName());
        baseMapper.updateById(organization);

        return true;
    }


    /**
     * 删除当前部门以及下属部门
     *
     * @param id 主键
     * @return 是否成功
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean deleteOrg(String id) throws Exception {
        if (StringUtils.isEmpty(id)) {
            throw new LogicException("id为空！");
        }
        log.info("[组织机构]-[删除当前部门以及下属部门]-id: {} ", id);

        List<String> idList = new ArrayList<>();
        List<String> parentIdList = new ArrayList<>();
        idList.add(id);
        parentIdList.add(id);

        while (parentIdList.size() != 0) {
            EntityWrapper<Organization> wrapper = new EntityWrapper<>();
            wrapper.in("parentId", parentIdList);
            wrapper.eq("deleted", 0);
            List<Organization> organizations = baseMapper.selectList(wrapper);
            if (organizations.size() != 0) {
                idList.addAll(organizations.stream().map(Organization::getId).collect(Collectors.toList()));
                parentIdList.clear();
                parentIdList = organizations.stream().map(Organization::getId).collect(Collectors.toList());

            } else {
                parentIdList.clear();
            }


        }
        log.info("[组织机构]-[删除当前部门以及下属部门]-idList: {} ", idList);

        return baseMapper.updateBatchIds(idList) > 0;
    }
}
那时的样子_
关注
第4章 组织机构（部门）管理
通用权限管理系统
05-11 3335
通俗的讲，就是一个集团公司，划分几个区域，每个区域都有什么分公司，每个分公司都有哪些部门一样，哪些部门又有那些子部门等。当然也可以是外贸公司的全球性客户、合作伙伴的分布情况管理、或者是一个行政管理单位的按地区划分的行政机构的树型管理。一般使用信息化系统的公司，大多是人数众多、地域分布相对广有异地分支机构的更迫切使用信息化管理系统，关键商业数据都需要依靠信息化技术及时进行沟通协调，提
基于Spring Boot +Mysql 的后台管理系统——实现简单的用户登录
m0_65371061的博客
05-23 1379
Spring Boot是一个基于Java的开源框架，用于创建微服务。它由Pivotal Team开发，用于构建独立的生产就绪Spring应用。 Spring Boot为Java开发人员提供了一个很好的平台，可以开发一个可以运行的独立和生产级Spring应用程序。可以开始使用最少的配置，而无需进行整个Spring配置设置。 优点： Spring Boot为其开发人员提供以下优势 - 易于理解和开发Spring应用 提高生产力 缩短开发时间 目标： Spring Boot的设计目标如下 避免在S
【SpringBoot+MySQL】后台管理系统——新建项目
qq_42000631的博客
10-11 253
一、新建springboot 项目 步骤口诀： 建项目 改maven 建yml 改pom 主启动 1. 打开idea 选择新建项目 ，按照下图选择，不需要选择Create from archtype。 2. 按照下图先选择 3. 出现以下页面说明新建成功 4. 选择maven安装目录 安装maven 之后，建议添加阿里的中央仓库的坐标，因为国外的库下载特别慢。 5. 添加maven 坐标 第一步 ：将以下代码替换到pom.xml文件中。其中有很多常用坐标，暂时还用不到，提前加上，后期就不需要加了
精品微信小程序ssm培训机构管理系统+后台管理系统|前后分离VUE
weixin_60386968的博客
02-25 1365
《微信小程序培训机构管理系统+后台管理系统|前后分离VUE》该项目含有源码、论文等资料、配套开发软件、软件安装教程、项目发布教程等 本系统包含微信小程序前台和Java做的后台管理系统，该后台采用前后台前后分离的形式使用Java+VUE 微信小程序——前台涉及技术：WXML 和 WXSS、JavaScript、uniapp Java——后台涉及技术： 前端使用技术：JSP,HTML5,CSS3、JavaScript、VUE等 后端使用技术：Spring、SpringMvc、Mybatis（SSM）等
组织机构管理
字节叔叔
08-14 2183
最早的组织机构管理是用上面直线型的方式来做。把每个对象创建出来。 但是这种方式不大灵活，如果在部门中添加新的部门整个组织的架构都要变动。所以我们在下面定义了一种相对新一点的组织机构。 OrgType:组织机构类型，用来说明组织机构有哪些组织。 /** * 组织机构类型对象，用来设定系统中存在哪些组织类型 * 如：对于学校而言，可能存在：学校，分校，校长办，行政部门，教学部门，专业，班级
C#.NET通用管理系统后台管理组件中选择组织机构选择功能增加默认选择内部组织机构的功能...
weixin_33912638的博客
11-26 167
C#.NET通用管理系统后台管理组件中选择组织机构选择功能增加默认选择内部组织机构的功能 2011-02-25 18:28 by 通用信息化建设平台, 452 阅读, 0 评论, 收藏, 编辑 本文转自 jiri...
基于springboot的景区旅游信息管理系统：springboot+mybatis+mysql+html+layui.zip
03-04
本文将深入探讨一个典型的信息管理系统——基于SpringBoot的景区旅游信息管理系统，该系统集成了Mybatis、MySQL、HTML和Layui等技术，旨在实现高效、智能的旅游服务。 首先，SpringBoot作为Java领域的一种轻量级...
SpringBoot+mybatis-plus+VUE民宿管理系统后台-毕业设计
08-08
SpringBoot+mybatis-plus+VUE民宿管理系统后台-毕业设计 升级为mybatis-plus 加入启动页面类。 修改了一些VUE的其它问题。 本系列环境 环境 win11 工具 idea 2018 jdk 1.8 数据库 mysql5.5 maven 3.6.0 项目导入...
Java项目:游戏道具管理系统(java+springboot+maven+mysql)——计算机毕业设计
12-16 465
系统角色有后台管理员，前台玩家用户 ，各角色功能如下： 管理员：系统管理（角色、权限、菜单等）、玩家管理、游戏公告管理、道具管理、排行管理、奖惩管理、充值管理。 前台玩家会员：注册、登录、查看排行、搜索玩家、好友管理、公告查看、充值金币、个人信息管理、购买道具、查看奖惩等。 运行环境：windows/Linux均可、jdk1.8、mysql5.7、idea/eclipse均可。 特色功能：用户可以搜索查看好友、排行等。 个人中心 控制器： /** 个人中心 控制器 / @Cont
研究生调研管理系统 JAVA+Vue.js+SpringBoot+MySQL
最新发布
09-03
基于Vue.js和SpringBoot的研究生调研管理系统是一个为高校研究生教育和科研活动提供支持的综合性平台。该系统分为用户前台和管理后台两个主要部分，旨在为不同角色的用户——包括管理员和普通用户——提供定制化的...
一个炫酷的 springboot 后台模板,有菜单，权限，用户 管理的基本功能
09-21
一个后台管理系统，包含有菜单管理，比如新增、删除、修改菜单，同理有权限，用户多角色管理，多样报表，饼图，线形图，柱形图等 ，还有登录校验，当天登录次数过多限制，ip登录过多限制。等基本功能。后续可根据业务需求扩展。
利用AJAX+J2EE开发组织机构管理系统
陈建慧程序人生
03-02 2169
利用AJAX+J2EE开发组织机构管理系统
springboot 使用poi 导出组织机构树
weixin_40751469的博客
04-23 520
使用的springboot 直接访问端口号 http://dev.job.audit.cnooc:8099/test 上代码： 使用的jar包： <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>3.15</version> </dependency> <dep
AJAX+J2EE开发组织机构管理系统(5)
cuilongshi8706的博客
06-21 83
AJAX+J2EE开发组织机构管理系统(5)[@more@]五、数据接口的实现（见Org.jpg文件）Org.JSP文件用来在服务器上运行Java的类与前台web页之间架起一座桥。取到中间件的接口作用。这里分析部分代码：＜%@ ...
统一项目管理平台（UMPlatForm.NET）-4.7 组织机构管理模块
weixin_33966365的博客
08-29 195
统一项目管理平台（UMPlatForm.NET） 4.7 组织机构管理模块 统一项目管理平台（UMPlatForm.NET）,基于.NET的快速开发、整合框架。 4.7 组织机构管理模块 组织机构管理模块提供直观方便的组织机构管理，以树型结构显示单位和部门的机构体系，可根据需要进行添加、修改、删除或移动等机构调整处理。功能特点： ²树形目录结构使组织机构层次清晰明了。 ...
springboot+vue+elementUI springboot地方废物回收机构管理系统-#毕业设计
z459382737的博客
07-01 189
地方废物回收机构管理系统能够通过互联网得到广泛的、全面的宣传，让尽可能多的用户了解和熟知地方废物回收机构管理系统的便捷高效，不仅为用户提供了服务，而且也推广了自己，让更多的用户了解自己。对于地方废物回收机构而言，若拥有自己的系统，通过系统得到更好的管理，同时提升了形象。 考虑到实际生活中在地方废物回收机构管理方面的需要以及对该系统认真的分析，将系统权限按管理员和员工这两类涉及用户划分。 （1）管理员功能需求 管理员登陆后，主要模块包括首页、个人中心、员工管理、员工请假管理、销假申请管理、工作日志管理、员工工
Springboot+Mysql实现图书借阅管理系统及教务信息管理系统源码附带运行视频
weixin_45595607的博客
12-09 871
基于springboot脚手架的 ，主要实现了图书馆图书借阅管理的基本功能，除基础脚手架外，实现的功能有：学院管理、班级管理、学生管理、图书管理、图书分类管理、借阅管理、违规管理、借阅统计等. springboot+freemark+mysql实现的图书管理系统项目源码 猿来入此出品 ...
一二三应用开发平台使用手册——系统管理-组织机构-使用说明
学海无涯，行者无疆
04-08 892
平台文档是平台的重要组成部分，这块容易被忽视或不被重视。即使一个平台或系统架构优秀、设计合理、代码优雅，但文档缺失，对于平台的使用方而言，熟悉成本高、难度大。不可避免存在疑问，需要动手尝试验证或翻看源码才能确定系统的实际处理逻辑，效率低下。 此外，有些平台或系统虽然有文档，但文档流于形式化，为了写文档而写文档的产物。这样的文档质量堪忧，常见的问题主要有两个： 1.形式化与套路化，把功能模块和实体一列，然后增删改查，放几张截图，实际上都是些正确而无用的套话，提供的价值非常有限。 2.文档与系统实现不符，没有
系统管理之组织机构树形化结构
zhouzhiwengang的专栏
10-18 781
/* Navicat MySQL Data Transfer Source Server : 192.168.1.73 Source Server Type : MySQL Source Server Version : 80015 Source Host : 192.168.1.73:3306 Source Schema : ucas_zh_08 Target Server Type : MySQL Target Ser.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值