spring boot+iview 前后端分离架构之角色管理的实现（二十八）

最新推荐文章于 2023-06-04 21:42:57 发布
最新推荐文章于 2023-06-04 21:42:57 发布
阅读量1w 收藏 3
点赞数
分类专栏： spring boot 与 iview实现前后端分离架构 文章标签： iview vue spring boot 前后端分离 权限架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linzhefeng89/article/details/95108001
版权
spring boot 同时被 3 个专栏收录
84 篇文章 2 订阅
订阅专栏
java
65 篇文章 5 订阅
订阅专栏
vue
42 篇文章 2 订阅
订阅专栏

spring boot 与 iview 前后端分离架构之角色管理的实现（二十八）

公众号

在这里插入图片描述
大家可以直接微信扫描上面的二维码关注我的公众号，然后回复【bg28】 里面就会给到源代码的下载地址同时会附上相应的视频教程，并定期在我的公众号上给大家推送相应的技术文章，欢迎大家关注我的公众号。

角色管理

在第二十七章我们已经实现了我们的菜单管理的整个的功能，那么在第二十八章我们将实现我们的角色管理的功能。

补前端权限拦截

由于在前面几章的时候我们还没涉及到鉴权因此当时是把前端的权限都放开了，但是到本章实际上我们已经对整个系统进行了鉴权了，因此在此处前端需要改造router目录底下的index.js，改造完成以后的代码如下：

import Vue from 'vue';
import iView from 'iview';
import Util from '../lib/util';
import VueRouter from 'vue-router';
import routers from './router';

Vue.use(VueRouter);

// 路由配置
const RouterConfig = {
  //mode: 'history',
  routes: routers
};

export const router = new VueRouter(RouterConfig);

router.beforeEach((to, from, next) => {
  iView.LoadingBar.start();
  Util.title(to.meta.title);
  if (to.meta.requireAuth) {
    if (localStorage.getItem('token') != '' && localStorage.getItem('token') != null) {
      next();
    } else {
      next({
        path: '/login',
        query: {redirect: to.fullPath}//登录成功以后跳转到该路由
      });
    }
  } else {
    next();
  }
});

router.afterEach((to) => {
  iView.LoadingBar.finish();
  window.scrollTo(0, 0);
});

相关工具类的实现

在我们开始编写角色管理的时候我们首先需要实现一些相关工具类。

Role实体改造

@Table(name = "t_role")
public class Role {
    /**
     * 角色流水ID
     */
    @Id
    @Column(name = "roleId")
    @KeySql(genId = UuidGenId.class)
    private String roleId;

    /**
     * 角色名字
     */
    @Column(name = "roleName")
    private String roleName;

    /**
     * 角色编码
     */
    @Column(name = "roleCode")
    private String roleCode;

    /**
     * 创建时间
     */
    @Column(name = "crtDate")
    private Date crtDate;

    /**
     * 角色数据集合
     */
    @Transient
    private String roleTrees;

    /**
     * 空的构造函数
     */
    public Role(){
        super();
    }
  // 省略set和get方法
 }

RoleTree实体改造

 @Table(name = "t_role_tree")
public class RoleTree {
    /**
     * 角色菜单关联流水ID
     */
    @Id
    @Column(name = "roleTreeId")
    @KeySql(genId = UuidGenId.class)
    private String roleTreeId;

    /**
     * 角色ID
     */
    @Column(name = "roleId")
    private String roleId;

    /**
     * 菜单ID
     */
    @Column(name = "treeId")
    private Integer treeId;

    /**
     *
     * @param roleId 角色ID
     * @param treeId 菜单ID
     */
    public RoleTree(String roleId,Integer treeId){
        this.roleId = roleId;
        this.treeId = treeId;
    }
    // 省略set和get方法
}

角色管理的实现

由于角色是与菜单是有关联关系的，因此在我们删除角色的时候，我们需要删除角色与菜单之间的中间表的关联关系的数据，因此我们需要根据角色ID来删除角色菜单关联数据。

RoleTreeDao.xml添加以下的实现

<!-- 根据角色ID来删除关联的角色数据 -->
  <delete id="deleteRoleTreeByRoleId">
    delete from t_role_tree where roleId = #{roleId}
  </delete>

RoleTreeDao添加以下的实现

/**
     * 功能描述：根据角色ID来删除角色菜单关联数据
     * @param roleId 角色ID
     * @return 返回删除结果
     */
    int deleteRoleTreeByRoleId(@Param("roleId")String roleId);

RoleDao.xml的实现

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.github.bg.admin.core.dao.RoleDao">
  <resultMap id="BaseResultMap" type="com.github.bg.admin.core.entity.Role">
    <id column="roleId" jdbcType="VARCHAR" property="roleId" />
    <result column="roleName" jdbcType="VARCHAR" property="roleName" />
    <result column="roleCode" jdbcType="VARCHAR" property="roleCode" />
    <result column="crtDate" jdbcType="TIMESTAMP" property="crtDate" />
  </resultMap>

  <!-- 根据用户ID来获取该用户的相应的绑定的数据 -->
  <select id="getUserRoleListByUserId" resultMap="BaseResultMap">
        select tr.* from t_role tr inner join t_user_role tur on tr.roleId = tur.roleId where tur.userId = #{userId}
    </select>

  <!-- 更新角色信息 -->
  <update id="updateRole">
    update t_role set roleName = #{roleName},roleCode=#{roleCode} where roleId = #{roleId}
    </update>

  <!-- 验证角色编码和角色名字是否重复 -->
  <select id="checkRoleCodeAndName" resultType="java.lang.Integer">
    select count(*) from t_role where 1=1
    <if test="roleName!=null and roleName !=''">
      and roleName = #{roleName}
    </if>
    <if test="roleCode!=null and roleCode !=''">
      and roleCode = #{roleCode}
    </if>
    <if test="roleId != null and roleId != ''">
      and roleId != #{roleId}
    </if>
  </select>

  <!-- 获取角色管理列表 -->
  <select id="queryRoleList" resultMap="BaseResultMap">
    select * from t_role where 1=1
    <if test="search!=null and search!=''">
      and (
      roleName  like concat('%',#{search},'%') or
      roleCode  like concat('%',#{search},'%')
      )
    </if>
  </select>

</mapper>

RoleDao的实现

package com.github.bg.admin.core.dao;

import com.github.bg.admin.core.entity.Role;
import org.apache.ibatis.annotations.Param;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;

/**
 * @author linzf
 * @since 2019-07-05
 * 类描述：角色的dao
 */
public interface RoleDao extends Mapper<Role> {

    /**
     * 功能描述：根据用户ID来获取该用户的相应的绑定的数据
     * @param userId 用户ID
     * @return 返回角色的集合
     */
    List<Role> getUserRoleListByUserId(@Param("userId") String userId);

    /**
     * 功能描述：更新角色信息
     *
     * @param roleId   角色流水ID
     * @param roleName 角色名字
     * @param roleCode 角色编码
     * @return 返回操作结果
     */
    int updateRole(@Param("roleId") String roleId, @Param("roleName") String roleName, @Param("roleCode") String roleCode);

    /**
     * 功能描述：验证角色编码和角色名字是否重复
     *
     * @param roleId   角色ID
     * @param roleName 角色名字
     * @param roleCode 角色编码
     * @return 返回验证结果
     */
    int checkRoleCodeAndName(@Param("roleId") String roleId, @Param("roleName") String roleName, @Param("roleCode") String roleCode);

    /**
     * 功能描述：获取角色列表数据
     *
     * @param search 模糊匹配角色的roleName和roleCode
     * @return 返回查询结果
     */
    List<Role> queryRoleList(@Param("search") String search);
}

RoleService的实现

package com.github.bg.admin.core.service;


import com.github.bg.admin.core.constant.RoleStaticConstant;
import com.github.bg.admin.core.constant.SystemStaticConst;
import com.github.bg.admin.core.constant.TreeStaticConstant;
import com.github.bg.admin.core.dao.RoleDao;
import com.github.bg.admin.core.dao.RoleTreeDao;
import com.github.bg.admin.core.dao.TreeDao;
import com.github.bg.admin.core.dto.TreeDto;
import com.github.bg.admin.core.entity.*;
import com.github.bg.admin.core.mapper.TreeMapper;
import com.github.bg.admin.core.util.JsonUtils;
import com.github.bg.admin.core.util.PageUtil;
import com.github.bg.admin.core.util.TreeInstall;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author linzf
 * @since 2019/4/30
 * 类描述：角色管理的service
 */
@Service
@Transactional(rollbackFor = {IllegalArgumentException.class})
public class RoleService {

    @Autowired
    private RoleDao roleDao;
    @Autowired
    private TreeDao treeDao;
    @Autowired
    private RoleTreeDao roleTreeDao;
    @Autowired
    private TreeMapper treeMapper;




    /**
     * 功能描述：加载菜单节点的数据
     * @return 返回加载结果
     */
    public ReturnInfo loadTree(){
        Tree tree = new Tree();
        tree.setTreeState(TreeStaticConstant.TREE_STATE_NORMAL);
        return new ReturnInfo(SystemStaticConst.SUCCESS, "加载菜单数据成功", TreeInstall.installTree(treeMapper.treesToTreeDTO(treeDao.select(tree))));
    }

    /**
     * 功能描述：删除角色数据
     *
     * @param roleId 角色流水ID
     * @return 返回删除结果
     */
    public ReturnInfo deleteRole(String roleId) {
        try {
            if (roleDao.deleteByPrimaryKey(roleId) > 0) {
                // 删除角色的关联数据
                roleTreeDao.deleteRoleTreeByRoleId(roleId);
                return new ReturnInfo(SystemStaticConst.SUCCESS, "删除角色数据成功");
            }
            return new ReturnInfo(SystemStaticConst.FAIL, "删除角色数据失败！失败原因：该角色数据不存在");
        } catch (Exception e) {
            return new ReturnInfo(SystemStaticConst.FAIL, "删除角色数据失败！失败原因：" + e.getMessage());
        }
    }

    /**
     * 功能描述：更新角色数据
     *
     * @param roleId   角色流水ID
     * @param roleName 角色名字
     * @param roleCode 角色编码
     * @param roleTrees 角色菜单关联的数据
     * @return 返回操作结果
     */
    public ReturnInfo updateRole(String roleId, String roleName, String roleCode,String roleTrees) {
        try {
            if (roleDao.checkRoleCodeAndName(roleId, roleName, "") > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "角色名字已经存在，请修改以后再提交！");
            }
            if (roleDao.checkRoleCodeAndName(roleId, "", roleCode) > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "角色编码已经存在，请修改以后再提交！");
            }
            if (roleDao.updateRole(roleId, roleName, roleCode) > 0) {
                if(roleTrees!=null){
                    // 删除关联表的数据
                    roleTreeDao.deleteRoleTreeByRoleId(roleId);
                    // 重新插入新的关联数据
                    saveRoleAssociateTree(JsonUtils.jsonToList(roleTrees, TreeDto.class),new Role(roleId));
                }
                return new ReturnInfo(SystemStaticConst.SUCCESS, "更新角色数据成功");
            }
            return new ReturnInfo(SystemStaticConst.FAIL, "更新角色数据失败！失败原因：查无此角色数据");
        } catch (Exception e) {
            return new ReturnInfo(SystemStaticConst.FAIL, "更新角色数据失败！失败原因：" + e.getMessage());
        }
    }

    /**
     * 功能描述：获取角色信息
     *
     * @param roleId 角色流水ID
     * @return 返回操作结果
     */
    public ReturnInfo getRoleByRoleId(String roleId) {
        try {
            Role role = roleDao.selectByPrimaryKey(roleId);
            if (role != null) {
                List<Tree> treeList = treeDao.queryTreeByRoleId(role.getRoleId());
                List<Tree> allTree = treeDao.selectAll();
                Map<String,Object> treeMap = new HashMap<>(3);
                for(Tree tree:treeList){
                    treeMap.put(tree.getTreeId().toString(),tree);
                }
                Map<String,Object>  result = JsonUtils.objToMap(role);
                result.put(RoleStaticConstant.ROLE_TREE_LIST_NAME,TreeInstall.installCheckTree(treeMapper.treesToTreeDTO(allTree),treeMap));
                return new ReturnInfo(SystemStaticConst.SUCCESS, "获取角色数据成功", result);
            }
        } catch (Exception e) {
            return new ReturnInfo(SystemStaticConst.FAIL, "获取角色数据失败！失败原因：" + e.getMessage());
        }
        return new ReturnInfo(SystemStaticConst.FAIL, "获取角色数据失败！失败原因：查无此角色数据");
    }

    /**
     * 功能描述：实现增加角色数据
     *
     * @param role 角色实体数据
     * @return 返回操作结果
     */
    public ReturnInfo addRole(Role role) {
        role.setCrtDate(new Date());
        try {
            if (roleDao.checkRoleCodeAndName("", role.getRoleName(), "") > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "角色名字已经存在，请修改以后再提交！");
            }
            if (roleDao.checkRoleCodeAndName("", "", role.getRoleCode()) > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "角色编码已经存在，请修改以后再提交！");
            }
            roleDao.insert(role);
            saveRoleAssociateTree(JsonUtils.jsonToList(role.getRoleTrees(),TreeDto.class),role);
        } catch (Exception e) {
            return new ReturnInfo(SystemStaticConst.FAIL, "增加角色失败，失败原因：" + e.getMessage());
        }
        return new ReturnInfo(SystemStaticConst.SUCCESS, "增加加角色成功", role);
    }

    /**
     * 功能描述：验证角色编码和角色名字是否重复
     *
     * @param roleId   角色流水ID
     * @param roleName 角色名字
     * @param roleCode 角色编码
     * @return 返回处理结果
     */
    public ReturnInfo checkRoleCodeAndName(String roleId, String roleName, String roleCode) {
        Map<String, Object> result = new HashMap<>(1);
        try {
            // 查询的结果大于0表示数据库已经存在该数据了，反之则不存在
            if (roleDao.checkRoleCodeAndName(roleId, roleName, roleCode) > 0) {
                result.put("success", "unPass");
            } else {
                result.put("success", "pass");
            }
        } catch (Exception e) {
            return new ReturnInfo(SystemStaticConst.FAIL, "验证请求处理失败，失败原因：" + e.getMessage());
        }
        return new ReturnInfo(SystemStaticConst.SUCCESS, "验证请求处理成功", result);
    }

    /**
     * 功能描述：获取角色列表数据
     *
     * @param search       模糊匹配角色的roleName和roleCode
     * @param pageSize     每页显示的记录的条数
     * @param current      当前访问第几页
     * @param orderKey     排序字段
     * @param orderByValue 排序方式，降序还是升序
     * @return 返回查询结果
     */
    public ReturnInfo queryRoleList(String search, int pageSize, int current, String orderKey, String orderByValue) {
        PageHelper.startPage(current, (pageSize > 0 && pageSize <= 500) ? pageSize : 20, (orderKey != null && !"".equals(orderKey)) ? ((orderByValue != null && !"".equals(orderByValue)) ? (orderKey + " " + orderByValue) : orderKey) : "");
        HashMap<String, Object> res = PageUtil.getResult(roleDao.queryRoleList(search));
        return new ReturnInfo(SystemStaticConst.SUCCESS, "获取角色列表数据成功！", new Page(pageSize, current, (long) res.get("total"), (List) res.get("rows")));
    }

    /**
     * 功能描述：保存角色和菜单的关联关系的数据
     * @param treeDtoList 菜单节点数据
     * @param entity 角色实体
     * @return 返回是否有子节点被选中
     */
    private boolean saveRoleAssociateTree(List<TreeDto> treeDtoList,Role entity){
        boolean hasChildrenChecked = false;
        for(TreeDto treeDto:treeDtoList){
            if(treeDto.getChildren()!=null&&treeDto.getChildren().size()>0){
                if(saveRoleAssociateTree(treeDto.getChildren(),entity)||treeDto.isChecked()){
                    roleTreeDao.insert(new RoleTree(entity.getRoleId(),treeDto.getTreeId()));
                    hasChildrenChecked = true;
                }
            }else{
                if(treeDto.isChecked()){
                    roleTreeDao.insert(new RoleTree(entity.getRoleId(),treeDto.getTreeId()));
                    hasChildrenChecked = true;
                }
            }
        }
        return hasChildrenChecked;
    }

}

RoleController的实现

package com.github.bg.admin.core.controller;

import com.github.bg.admin.core.entity.ReturnInfo;
import com.github.bg.admin.core.entity.Role;
import com.github.bg.admin.core.service.RoleService;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author linzf
 * @since 2019/4/30
 * 类描述：角色管理的controller
 */
@RestController
@RequestMapping("/role")
public class RoleController {

    @Autowired
    private RoleService roleService;

    /**
     * 功能描述：加载菜单节点的数据
     * @return
     */
    @ApiOperation(value = "加载菜单节点的数据")
    @PostMapping("loadTree")
    public ReturnInfo loadTree(){
        return roleService.loadTree();
    }

    /**
     * 功能描述：删除角色数据
     * @param roleId 角色流水ID
     * @return 返回删除结果
     */
    @ApiOperation(value = "删除角色数据")
    @PostMapping("deleteRole")
    public ReturnInfo deleteRole(@RequestParam(name = "roleId")String roleId){
        return roleService.deleteRole(roleId);
    }

    /**
     * 功能描述：更新角色数据
     * @param roleId 角色流水ID
     * @param roleName 角色名字
     * @param roleCode 角色编码
     * @param roleTrees 角色关联的菜单数据
     * @return 返回操作结果
     */
    @ApiOperation(value = "更新角色数据")
    @PostMapping("updateRole")
    public ReturnInfo updateRole(@RequestParam(name = "roleId") String roleId, @RequestParam(name = "roleName") String roleName, @RequestParam(name = "roleCode") String roleCode,@RequestParam(name = "roleTrees" ,required = false) String roleTrees){
        return roleService.updateRole(roleId, roleName, roleCode,roleTrees);
    }

    /**
     * 功能描述：获取角色信息
     * @param roleId 角色流水ID
     * @return 返回操作结果
     */
    @ApiOperation(value = "获取角色信息")
    @PostMapping("getRoleByRoleId")
    public ReturnInfo getRoleByRoleId(@RequestParam(name = "roleId") String roleId){
        return roleService.getRoleByRoleId(roleId);
    }

    /**
     * 功能描述：实现增加角色
     * @param role 角色实体数据
     * @return 返回操作结果
     */
    @ApiOperation(value = "增加角色")
    @PostMapping("addRole")
    public ReturnInfo addRole(Role role){
        return roleService.addRole(role);
    }

    /**
     * 功能描述：验证角色编码和角色名字是否重复
     *
     * @param roleId   角色流水ID
     * @param roleName 角色名字
     * @param roleCode 角色编码
     * @return 返回处理结果
     */
    @ApiOperation(value = "验证角色编码和角色名字是否重复")
    @PostMapping("checkRoleCodeAndName")
    public ReturnInfo checkRoleCodeAndName(@RequestParam(name = "roleId", required = false) String roleId, @RequestParam(name = "roleName", required = false) String roleName, @RequestParam(name = "roleCode", required = false) String roleCode) {
        return roleService.checkRoleCodeAndName(roleId, roleName, roleCode);
    }

    /**
     * 功能描述：获取角色列表数据
     *
     * @param search   模糊匹配角色的roleName和roleCode
     * @param pageSize 每页显示的记录的条数
     * @param current  当前访问第几页
     * @param orderKey 排序字段
     * @param orderByValue 排序方式，降序还是升序
     * @return 返回查询结果
     */
    @ApiOperation(value = "获取角色列表数据")
    @PostMapping("queryRoleList")
    public ReturnInfo queryRoleList(@RequestParam(name = "search", required = false) String search, @RequestParam(name = "pageSize") int pageSize, @RequestParam(name = "current") int current, @RequestParam(name = "orderKey",required = false) String orderKey, @RequestParam(name = "orderByValue",required = false) String orderByValue) {
        return roleService.queryRoleList(search, pageSize, current,orderKey,orderByValue);
    }

}

运行项目

最后我们重新编译我们的项目，记得一定要重新编译，因为我们引入了mapper，不重新编译是会报错的，然后我们使用账号：admin密码：123456登录系统操作我们的角色模块，可以正常的对整个角色模块进行相应的操作，这样我们就完成了角色的整合。
在这里插入图片描述
上一篇文章地址：spring boot+iview 前后端分离架构之菜单管理的实现（二十七）
下一篇文章地址：spring boot+iview 前后端分离架构之组织管理的实现（二十九）

笨_鸟_不_会_飞
关注
专栏目录
Spring Boot + Vue.js 实现前后端分离（附源码），看完记得收藏！
weixin_46898270的博客
05-05 655
Spring Boot + Vue.js 前后端涉及基本概念介绍，搭建记录，本文会列举出用到环境和工具，并且提供源码。 前端工具和环境： Node.js V10.15.0 Vue.js V2.5.21 yarn: V1.13.0 IDE: VScode 后端工具和环境： Maven: 3.52 jdk: 1.8 MySql: 14.14 IDE: IDEA Spring Boot: 2.0+ Zo...
iview-admin + spring boot + mysql 项目管理系统毕业设计源码
07-05
学习这个项目，你不仅可以掌握前端框架的使用，还能深入了解Spring Boot的微服务架构和数据库操作，对于提升Web开发技能，特别是前后端分离的项目开发经验，具有极大的帮助。如果你对这个项目感兴趣，不妨下载源码，...
基于vueiview的人员管理系统
08-09
一款基于vue2.0的人员管理系统，样式使用iviewui框架。 数据库语言：mongoose 后台接口语言：node.js
利用 Vue.js 实现前后端分离的RBAC角色权限管理
weixin_33958366的博客
09-13 902
项目背景：物业管理后台，不同角色拥有不同权限 采用技术：Vue.js + Vuex + Element UI 实现 RBAC 权限管理需要后端接口支持，这里仅提供前端解决方案。因代码篇幅较大，对代码进行了删减，文中 “...” 即为省略的一部分代码。 大致思路： 首先登录成功后，从后台拉取用户当前可显示的菜单和可用权限列表，分别将其存入 ...
spring boot+iview 前后端分离架构之角色管理布局和列表的实现（十六）
热门推荐
笨鸟不会飞
06-30 1万+
spring boot 与 iview 前后端分离架构之角色管理布局和列表的实现（十六）角色管理 角色管理 通过上一章我们已经完成了我们的菜单管理模块的开发了，那么这章我们将开始讲解如何开发我们的角色模块，首先会给大家讲解角色管理的布局和列表，在下一章将会给大家讲解如何实现角色与菜单的权限的关联。 打开我们的基于第十六章的工程然后在sys目录底下创建一个role目录如下： 由于我们的角色列表有需...
管理后台项目-06-用户管理角色管理模块
ycmy2017的博客
04-25 1594
用户管理（列表-新增|修改-删除-分配角色）-角色管理（列表-新增|修改-删除-分配权限）
web后端开发的中验证码和角色添加功能的实现的一个逻辑思维
Beautifullyday的博客
01-08 333
web后端开发的中验证码和角色添加功能的实现的一个逻辑思维 做web后端开发中的部分功能，其中包括验证码的使用、文件的上传、角色权限的添加、删除、修改等功能，在实现这些功能的过程中重新梳理了一下思绪，做以下总结: 一、做验证码功能的时候，要有一个逻辑思维，在servlet中实现时 1、第一步需要创建一个图片，其中要设置图片的背景眼色和字体 2、第二步要生成验证码，需要使用Random来产生随机数，将字母数字装在定义的字符串中，通过循环来随机生成验证码 3、第三步要设置干扰线，增加验证码的辨识难度，通过循
spring boot 与 iview 前后端分离架构.zip
最新发布
03-01
《Spring Boot与iView前后端分离架构详解》 在当今的Web开发领域，前后端分离已经成为了一种主流架构模式，它极大地提高了开发效率和代码的可维护性。本专题将深入探讨Spring Boot作为后端框架，搭配前端UI库iView...
基于Spring Boot 2.x的前后端分离架构X-Boot 后台.zip
10-10
基于Spring Boot 2.x的前后端分离架构X-Boot 后台。.zip,基于Spring Boot 2.x的前后端分离开发平台X-Boot 前端：Vue+iView Admin 后端：Spring Boot 2.x/Spring Security/JWT/Spring Data JPA+Mybatis-Plus/Redis/...
前后端分离小项目(员工管理).zip
08-04
1、技术选型： 前端: vue + axios 后端: springboot + mybatis + mysql + tomcat + Redis 2、需求分析： 用户模块 a.用户登录 b.用户注册 c.验证码实现 d.欢迎xx用户展示 e.安全退出 f.员工列表展示 员工模块 g.员工添加 h.员工删除 i.员工修改 j.员工列表加入redis缓存实现 只能当作前后端分离的基础入门项目，因为这里并没有使用组件，只是演示下前后端分离项目的开发过程。
iviewadmin是基于iview的后台管理系统
08-09
iview-admin 是基于vue2 iview3 axios webpack3 为前端主要技术，后端采用express mysql开发的一个后台管理系统。
建立前后端分离小项目之员工管理
liulang68的博客
11-03 262
建表的时候最后一个字段就不要加逗号了
spring boot+iview 前后端分离架构之角色管理增删改的实现（十七）
笨鸟不会飞
07-02 1万+
spring boot 与 iview 前后端分离架构之角色管理增删改的实现（十七）角色管理新增角色修改角色删除角色 角色管理 通过上一章我们已经完成了角色管理的列表的编写，接着上一章的代码，我们本章将实现角色的增删改的功能，同时在增删改的时候同步实现角色与菜单之间的关联关系。 新增角色 首先打开我们的前端工程，接着在role目录底下创建一个addRole.vue文件，该文件实现新增角色的功能，该...
若依前端后端框架 分离切换用户问题解决！学不会得找我！！！
qq_41895699的博客
08-03 1526
若依前端后端框架 分离切换用户问题解决！学不会得找我！！！
企业员工角色权限管理平台（SpringBoot2.0+Mybatis+Shiro+Vue）
08-07
课程简介：历经半个多月的时间，Debug亲自撸的 “企业员工角色权限管理平台” 终于完成了。正如字面意思，本课程讲解的是一个真正意义上的、企业级的项目实战，主要介绍了企业级应用系统中后端应用权限的管理，其中主要涵盖了六大核心业务模块、十几张数据库表。 其中的核心业务模块主要包括用户模块、部门模块、岗位模块、角色模块、菜单模块和系统日志模块；与此同时，Debug还亲自撸了额外的附属模块，包括字典管理模块、商品分类模块以及考勤管理模块等等，主要是为了更好地巩固相应的技术栈以及企业应用系统业务模块的开发流程！ 核心技术栈列表： 值得介绍的是，本课程在技术栈层面涵盖了前端和后端的大部分常用技术，包括Spring Boot、Spring MVC、Mybatis、Mybatis-Plus、Shiro(身份认证与资源授权跟会话等等)、Spring AOP、防止XSS攻击、防止SQL注入攻击、过滤器Filter、验证码Kaptcha、热部署插件Devtools、POI、Vue、LayUI、ElementUI、JQuery、HTML、Bootstrap、Freemarker、一键打包部署运行工具Wagon等等，如下图所示： 课程内容与收益： 总的来说，本课程是一门具有很强实践性质的“项目实战”课程，即“企业应用员工角色权限管理平台”，主要介绍了当前企业级应用系统中员工、部门、岗位、角色、权限、菜单以及其他实体模块的管理；其中，还重点讲解了如何基于Shiro的资源授权实现员工-角色-操作权限、员工-角色-数据权限的管理；在课程的最后，还介绍了如何实现一键打包上传部署运行项目等等。如下图所示为本权限管理平台的数据库设计图： 以下为项目整体的运行效果截图： 值得一提的是，在本课程中，Debug也向各位小伙伴介绍了如何在企业级应用系统业务模块的开发中，前端到后端再到数据库，最后再到服务器的上线部署运行等流程，如下图所示：
Java初学实践03-使用spring boot进行简单的用户管理
draper-crypto的博客
06-04 1111
使用spring boot进行简单的用户管理
springBoot项目搭建包含RBAC模块 -- 角色管理模块开发（七）
weixin_43470322的博客
07-05 517
上一章讲了资源管理开发，这一章讲角色管理开发，角色管理不仅角色自己还包含和资源关联关系的开发。主要功能有 新增角色、修改角色、删除角色、分页查询角色、获取用户对应角色（用户角色关联关系在用户管理模块开发）。1. 角色管理开发创建 角色实体 id、roleName、roleDesc、createTime、updateTime 创建角色管理controller层AdminRoleController 创建角色管理 service 和 serviceImplAdminRoleService Admin
springboot整合shiro实现基础的用户角色权限管理
begefefsef的博客
04-26 1163
文章目录 1. 用户角色权限需要解决的问题及shiro的解决方案 2. 过滤器 3. 登录并获取菜单权限 4. shiro授权 5. 总结 项目地址 1. 用户角色权限需要解决的问题及shiro的解决方案 灵活配置需要和不需要拦截的页面 shiro提供了过滤器可以灵活配置需要和不需要拦截的页面 实现用户认证 shiro整合了HttpSession（web应用）可以保存用户登录的信息。 根据当前认证用户加载不同的菜单权限 这个和shiro无关，直接展示用户具有的菜单权
4. Spring Boot Security角色管理持久化实现
qq_21047625的博客
12-03 1072
1.概述,在第三章里大家学会了怎么初步使用Spring Boot 结合Spring Security来实现权限控制和角色管理, 但是我们发现无论是使用那种方式角色管理和权限控制全部是在 xml中或则 配置类中写的, 没有实现持久化, 本次就为大家讲解怎么实现.本小结为大家讲 用户角色管理的实现, 至于权限控制来下一个小结会讲. 2.表和数据 PDM文件路径: https://github.co
Spring Boot + Vue快速构建前后端分离后台管理系统指南
本文将详细介绍如何基于Spring Boot快速搭建一个前后端分离的后台管理系统。前后端分离是一种现代Web开发模式，它将前端和后端功能分离，使得两者可以独立开发和维护。这种架构的优势包括： 1. **优点**: - **业务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

笨_鸟_不_会_飞

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

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

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

打赏作者

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

抵扣说明：

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

余额充值