devbox
思考机器
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot+vue+springsecurity前后端权限管理系统_springboot + springboot - security 用户管理

作者：思考机器 | 2024-02-01 13:38:33

赞

踩

springboot + springboot - security 用户管理

由于字数限制，请阅读原文，原文附源码和sql以及项目演示地址和项目资料。

环境：

win10、idea22023.2、vscode1.7、maven3.5、jdk8、Redis

技术：

  • springboot2.5.9

  • springsecurity

  • Redis

  • mybatis plus

  • mysql5.7.38

  • swagger

  • jwt

  • vue2

  • element ui

  • vuex

  • vue-router

  • axios

  • mockjs

  • echarts

  • less

模块：

  1. 登录页面

  2. 首页

  3. 权限管理

    1.用户管理

    2.角色管理

    3.菜单管理

功能要点：

  1. 从0到1实现项目前后端搭建

  2. vuex实现面包屑和Tag功能

  3. vuex+localStorage动态路由和菜单（重点）

  4. 封装一个ECharts组件

  5. 封装Table表格

  6. 树形表格和CheckBox的使用

  7. 封装统一返回类

  8. 两种方式实现代码生成，解放双手

  9. jwt、swagger、Redis封装

  10. 权限管理（重点）

项目截图

1、登录页面

d906325f5d7942401a06d8708517e85a.png

2、首页

3210e95481c9812f41fa647b07c48555.png

3、用户管理

c8f8ec1c6c509c9b4853818304530bea.png

4、角色管理

cc103c9863b97a10a64cf8f17cf4fb60.png

5、分配权限

34958a307f40a99bbcb655337eacdcc0.png

6、菜单管理

3d2ce369feeba22966c3a26d5747871d.png

7、根据权限动态加载菜单和按钮

e631043bc330c156d8fbc681c0a6455f.png

8、部分主要代码

登录

  1. <template>
  2.   <el-form
  3.     ref="form"
  4.     label-width="70px"
  5.     :inline="true"
  6.     class="login-container"
  7.     :model="form"
  8.     :rules="rules"
  9.   >
  10.     <h3 class="login_title">系统登录</h3>
  11.     <el-form-item label="用户名" prop="username">
  12.       <el-input v-model="form.username" placeholder="请输入账号"></el-input>
  13.     </el-form-item>
  14.     <el-form-item label="密码" prop="password">
  15.       <el-input
  16.         type="password"
  17.         v-model="form.password"
  18.         placeholder="请输入密码"
  19.       ></el-input>
  20.     </el-form-item>
  21.     <el-form-item label="验证码" prop="code">
  22.       <el-input v-model="form.code" maxlength="6"></el-input>
  23.     </el-form-item>
  24.     <el-form-item>
  25.       <el-image
  26.         :src="captchaImg"
  27.         class="captchaImg"
  28.         style="margin-left: 15px"
  29.         @click="getCaptcha"
  30.       ></el-image>
  31.     </el-form-item>
  32.     <el-form-item>
  33.       <el-button
  34.         @click="submit"
  35.         style="margin-left: 105px; margin-top: 10px"
  36.         type="primary"
  37.         :loading="loading"
  38.         >登录</el-button
  39.       >
  40.       <!-- <el-button
  41.         @click="submit1"
  42.         style="margin-left: 105px; margin-top: 10px"
  43.         type="primary"
  44.         :loading="loading"
  45.         >登录1</el-button
  46.       > -->
  47.     </el-form-item>
  48.   </el-form>
  49. </template>
  50. <script>
  51. // import Mock from 'mockjs'
  52. // import Cookie from 'js-cookie'
  53. // import { getMenu } from '../api'
  54. import qs from "qs";
  55. import http from "@/utils/request";
  56. export default {
  57.   data() {
  58.     return {
  59.       captchaImg: "",
  60.       loading: false,
  61.       form: {
  62.         username: "admin",
  63.         password: "111111",
  64.         token: "aaaaa",
  65.         code: "",
  66.       },
  67.       rules: {
  68.         username: [
  69.           { required: true, trigger: "blur", message: "请输入用户名" },
  70.         ],
  71.         password: [{ required: true, trigger: "blur", message: "请输入密码" }],
  72.       },
  73.     };
  74.   },
  75.  
  76.  
  77.   created() {
  78.     this.getCaptcha();
  79.   },
  80.   methods: {
  81.     submit1() {},
  82.     getCaptcha() {
  83.       http.get("/captcha").then((res) => {
  84.         if(res.code === 20000){
  85.           console.log("/captcha");
  86.           console.log(res);
  87.           this.form.token = res.data.data.token;
  88.           this.captchaImg = res.data.data.captchaImg;
  89.           //this.form.code = "";
  90.         }
  91.  
  92.  
  93.       });
  94.     },
  95.     // 登录
  96.     submit() {
  97.       let that = this;
  98.       that.$refs.form.validate((valid) => {
  99.         if (valid) {
  100.           this.loading = true;
  101.           this.$store
  102.             .dispatch("Login", this.form)
  103.             .then((res) => {
  104.            
  105.               if (res.code != 20000) {
  106.                 that.$message({
  107.                   type: "warning",
  108.                   message: res.message,
  109.                 });
  110.                 this.loading = false;
  111.                 return false;
  112.               }
  113.               this.loading = false;
  114.               this.$router.push({ path: "/home" });
  115.             })
  116.             .catch(() => {
  117.               this.loading = false;
  118.             });
  119.           // http
  120.           //   .post("/login?" + qs.stringify(this.form))
  121.           //   .then((res) => {
  122.           //     if (res.code != 20000) {
  123.           //       that.$message({
  124.           //         type: "warning",
  125.           //         message: res.message,
  126.           //       });
  127.           //     }
  128.           //     console.log(res);
  129.  
  130.  
  131.           //       const jwt = res.data.authorization;
  132.  
  133.  
  134.           //      this.$store.commit("SET_TOKEN", jwt);
  135.           //     //
  136.           //     this.$router.push("/home");
  137.           //   })
  138.           //   .catch((e) => {});
  139.  
  140.  
  141.           //this.loading = true;
  142.           // that.$store
  143.           //   .dispatch("Login", that.form)
  144.           //   .then(() => {
  145.           //     //this.loading = false;
  146.           //     that.$router.push({ path: "/" });
  147.           //   })
  148.           //   .catch(() => {
  149.           //     //this.loading = false;
  150.           //   });
  151.         } else {
  152.           console.log("error submit!!");
  153.           return false;
  154.         }
  155.       });
  156.  
  157.  
  158.       // // token信息
  159.       // const token = Mock.Random.guid()
  160.  
  161.  
  162.       // 校验通过
  163.       // this.$refs.form.validate((valid) => {
  164.       //     if (valid) {
  165.       //         getMenu(this.form).then(({ data }) => {
  166.       //             console.log(data)
  167.       //             if (data.code === 20000) {
  168.       //                 // token信息存入cookie用于不同页面间的通信
  169.       //                 Cookie.set('token', data.data.token)
  170.  
  171.  
  172.       //                 // 获取菜单的数据，存入store中
  173.       //                 this.$store.commit('setMenu', data.data.menu)
  174.       //                 this.$store.commit('addMenu', this.$router)
  175.       //                 // 跳转到首页
  176.       //                 this.$router.push('/home')
  177.       //             } else {
  178.       //                 this.$message.error(data.data.message);
  179.       //             }
  180.       //         })
  181.       //     }
  182.       // })
  183.     },
  184.   },
  185. };
  186. </script>
  187. <style lang="less" scoped>
  188. .login-container {
  189.   width: 650px;
  190.   border: 1px solid #eaeaea;
  191.   margin: 180px auto;
  192.   padding: 35px 35px 15px 35px;
  193.   background-color: #fff;
  194.   border-radius: 15px;
  195.   box-shadow: 0 0 25px #cac6c6;
  196.   box-sizing: border-box;
  197.   .login_title {
  198.     text-align: center;
  199.     margin-bottom: 40px;
  200.     color: #505458;
  201.   }
  202.   .el-input {
  203.     width: 198px;
  204.   }
  205. }
  206. </style>

菜单

  1. <template>
  2.   <div>
  3.     <el-table
  4.       :data="tableData"
  5.       style="width: 100%; margin-bottom: 20px"
  6.       row-key="id"
  7.       border
  8.       default-expand-all
  9.       :tree-props="{ children: 'children', hasChildren: 'hasChildren' }"
  10.     >
  11.       <el-table-column prop="name" label="名称" sortable min-width="20%">
  12.       </el-table-column>
  13.       <el-table-column prop="path" label="访问路径" sortable min-width="15%">
  14.       </el-table-column>
  15.  
  16.  
  17.       <el-table-column
  18.         prop="component"
  19.         label="组件路径"
  20.         sortable
  21.         min-width="15%"
  22.       >
  23.       </el-table-column>
  24.       <el-table-column
  25.         prop="permissionValue"
  26.         label="权限值"
  27.         sortable
  28.         min-width="15%"
  29.       >
  30.       </el-table-column>
  31.       <el-table-column prop="status" label="状态" sortable min-width="10%">
  32.       </el-table-column>
  33.       <el-table-column prop="icon" label="图标" sortable min-width="10%">
  34.       </el-table-column>
  35.  
  36.  
  37.       <el-table-column label="操作" min-width="15%">
  38.         <template slot-scope="scope">
  39.           <!-- 第一层和第二层可以添加菜单，第三层添加功能，第四层修改功能 -->
  40.           <el-button
  41.             v-if="scope.row.level === 1 || scope.row.level === 2"
  42.             type="text"
  43.             size="mini"
  44.             @click="addOrEditMenuDialog(scope.row, 'add')"
  45.             >添加菜单</el-button
  46.           >
  47.           <el-button
  48.             v-if="scope.row.level === 3"
  49.             type="text"
  50.             size="mini"
  51.             @click="
  52.               () => {
  53.                 dialogPermissionFormVisible = true;
  54.                 permissionForm = { ...PERMISSION_FORM };
  55.                 permissionForm.pid = scope.row.id;
  56.                 permissionTitle = '添加功能';
  57.               }
  58.             "
  59.           >
  60.             添加功能</el-button
  61.           >
  62.           <el-button
  63.             v-if="scope.row.level === 4"
  64.             type="text"
  65.             size="mini"
  66.             @click="updatePermissionDialog(scope.row)"
  67.             >修改功能</el-button
  68.           >
  69.           <el-button
  70.             v-if="scope.row.level !== 1 && scope.row.level !== 4"
  71.             type="text"
  72.             size="mini"
  73.             @click="addOrEditMenuDialog(scope.row, 'edit')"
  74.             >修改</el-button
  75.           >
  76.           <el-button
  77.             v-if="scope.row.level !== 1"
  78.             @click="deleteSubmit(scope.row)"
  79.             type="text"
  80.             size="mini"
  81.             >删除</el-button
  82.           >
  83.         </template>
  84.       </el-table-column>
  85.     </el-table>
  86.     <!-- 添加菜单的窗口 -->
  87.     <el-dialog
  88.       :title="title"
  89.       :label-position="labelPosition"
  90.       :visible.sync="dialogFormVisible"
  91.     >
  92.       <el-form
  93.         ref="menuForm"
  94.         :model="menuForm"
  95.         :rules="menuFormRules"
  96.         label-width="120px"
  97.       >
  98.         <el-form-item label="菜单名称" prop="name">
  99.           <el-input v-model="menuForm.name"></el-input>
  100.         </el-form-item>
  101.         <el-form-item label="访问路径" prop="path" v-if="showFlag">
  102.           <el-input v-model="menuForm.path"></el-input>
  103.         </el-form-item>
  104.         <el-form-item label="组件路径" prop="component" v-if="showFlag">
  105.           <el-input v-model="menuForm.component"></el-input>
  106.         </el-form-item>
  107.         <!-- <el-form-item label="权限值" prop="permissionValue">
  108.           <el-input v-model="menuForm.permissionValue"></el-input>
  109.         </el-form-item> -->
  110.         <el-form-item label="图标" prop="icon">
  111.           <el-input v-model="menuForm.icon"></el-input>
  112.         </el-form-item>
  113.       </el-form>
  114.       <div slot="footer" class="dialog-footer">
  115.         <el-button @click="resetMenu()">取 消</el-button>
  116.         <el-button type="primary" @click="addMenuFormSubmit()">确 定</el-button>
  117.       </div>
  118.     </el-dialog>
  119.  
  120.  
  121.     <!-- 添加功能的窗口 -->
  122.     <el-dialog
  123.       :title="permissionTitle"
  124.       :label-position="labelPosition"
  125.       :visible.sync="dialogPermissionFormVisible"
  126.     >
  127.       <el-form
  128.         ref="permissionForm"
  129.         :model="permissionForm"
  130.         :rules="permissionFormRules"
  131.         label-width="120px"
  132.       >
  133.         <el-form-item label="功能名称" prop="name">
  134.           <el-input v-model="permissionForm.name"></el-input>
  135.         </el-form-item>
  136.         <el-form-item label="访问路径" prop="path">
  137.           <el-input v-model="permissionForm.path"></el-input>
  138.         </el-form-item>
  139.         <el-form-item label="组件路径" prop="component">
  140.           <el-input v-model="permissionForm.component"></el-input>
  141.         </el-form-item>
  142.         <el-form-item label="功能权限值" prop="permissionValue">
  143.           <el-input v-model="permissionForm.permissionValue"></el-input>
  144.         </el-form-item>
  145.         <el-form-item label="图标" prop="icon">
  146.           <el-input v-model="permissionForm.icon"></el-input>
  147.         </el-form-item>
  148.       </el-form>
  149.       <div slot="footer" class="dialog-footer">
  150.         <el-button @click="resetPermission()">取 消</el-button>
  151.         <el-button type="primary" @click="addPermissonFormSubmit()"
  152.           >确 定</el-button
  153.         >
  154.       </div>
  155.     </el-dialog>
  156.   </div>
  157. </template>
  158. <script>
  159. import { getData, updateMenuSubmit, deleteSubmit } from "@/api/permission.js";
  160. import http from "@/utils/request";
  161. const MENU_FORM = {
  162.   name: "",
  163.   path: "",
  164.   component: "",
  165.   // status: 0,
  166.   icon: "setting",
  167.   pid: 0,
  168.   type: "1",
  169.   id: "",
  170. };
  171. const PERMISSION_FORM = {
  172.   name: "",
  173.   path: "",
  174.   component: "",
  175.   permissionValue: "",
  176.   // status: 0,
  177.   icon: "setting",
  178.   pid: 0,
  179.   type: "2",
  180.   id: "",
  181. };
  182. export default {
  183.   data() {
  184.     return {
  185.       showFlag: true,
  186.       labelPosition: "left",
  187.       tableData: [], //获取递归取得的全部菜单
  188.       dialogFormVisible: false, //添加修改菜单窗口开关
  189.       dialogPermissionFormVisible: false, //添加修改功能窗口开关
  190.       title: "添加菜单", //添加修改菜单标题
  191.       permissionTitle: "添加功能", //添加修改菜单标题
  192.       menuForm: MENU_FORM, //添加修改菜单内容
  193.       permissionForm: PERMISSION_FORM, //添加修改功能内容
  194.       //表单验证
  195.       menuFormRules: {
  196.         name: [
  197.           { required: true, message: "请输入菜单名称", trigger: "blur" },
  198.           {
  199.             min: 3,
  200.             max: 30,
  201.             message: "长度在 3 到 30 个字符",
  202.             trigger: "blur",
  203.           },
  204.         ],
  205.         path: [
  206.           { message: "请输入访问路径", trigger: "blur" },
  207.           {
  208.             min: 3,
  209.             max: 18,
  210.             message: "长度在 3 到 18 个字符",
  211.             trigger: "blur",
  212.           },
  213.         ],
  214.         component: [
  215.           { message: "请输入组件路径", trigger: "blur" },
  216.           {
  217.             min: 3,
  218.             max: 18,
  219.             message: "长度在 3 到 18 个字符",
  220.             trigger: "blur",
  221.           },
  222.         ],
  223.       },
  224.       //功能表单验证
  225.       permissionFormRules: {
  226.         name: [
  227.           { required: true, message: "请输入菜单名称", trigger: "blur" },
  228.           { min: 3, max: 8, message: "长度在 3 到 8 个字符", trigger: "blur" },
  229.         ],
  230.  
  231.  
  232.         permissionValue: [
  233.           { required: true, message: "请输入权限值", trigger: "blur" },
  234.           {
  235.             min: 3,
  236.             max: 18,
  237.             message: "长度在 3 到 18 个字符",
  238.             trigger: "blur",
  239.           },
  240.         ],
  241.       },
  242.     };
  243.   },
  244.  
  245.  
  246.   created() {
  247.     //获取递归取得的全部菜单
  248.     this.getAllMenuList();
  249.   },
  250.   methods: {
  251.     //修改功能
  252.     updatePermissionDialog(val) {
  253.       this.dialogPermissionFormVisible = true;
  254.       this.permissionForm = val;
  255.       this.permissionTitle = "修改功能";
  256.     },
  257.     //取消菜单添加或修改
  258.     resetMenu() {
  259.       this.dialogFormVisible = false;
  260.       this.menuForm = {};
  261.     },
  262.  
  263.  
  264.     //取消功能添加或修改
  265.     resetPermission() {
  266.       this.dialogPermissionFormVisible = false;
  267.       this.permissionForm = {};
  268.     },
  269.     //添加修改下级功能
  270.     addPermissonFormSubmit() {
  271.       let that = this;
  272.       this.$refs.permissionForm.validate((valid) => {
  273.         if (valid) {
  274.           if (that.permissionForm.id) {
  275.             //修改
  276.             updateMenuSubmit(that.permissionForm).then((res) => {
  277.               if (res.code === 20000) {
  278.                 that.$message({
  279.                   type: "success",
  280.                   message: "修改功能成功",
  281.                 });
  282.                 //刷新页面
  283.                 that.getAllMenuList();
  284.                 that.dialogPermissionFormVisible = false;
  285.                 that.permissionForm = { ...PERMISSION_FORM };
  286.               }
  287.             });
  288.           } else {
  289.             //新增
  290.  
  291.  
  292.             //let permission = that.menuForm;
  293.             http({
  294.               url: "/permission/save",
  295.               method: "post",
  296.               data: that.permissionForm,
  297.             }).then((res) => {
  298.               if (res.code === 20000) {
  299.                 that.$message({
  300.                   type: "success",
  301.                   message: "添加功能成功",
  302.                 });
  303.                 //刷新页面
  304.                 that.getAllMenuList();
  305.                 that.dialogPermissionFormVisible = false;
  306.                 that.permissionForm = { ...PERMISSION_FORM };
  307.               }
  308.             });
  309.           }
  310.         } else {
  311.           return false;
  312.         }
  313.       });
  314.     },
  315.     //删除
  316.     deleteSubmit(val) {
  317.       let that = this;
  318.       this.$confirm("此操作将永久删除该记录，是否继续?", "提升", {
  319.         distinguishCancelAndClose: true,
  320.         confirmButtonText: "确定",
  321.         cancelButtonText: "取消",
  322.       })
  323.         .then(() => {
  324.           deleteSubmit(val.id).then((res) => {
  325.             if (res.code === 20000) {
  326.               that.$message({
  327.                 type: "success",
  328.                 message: "删除成功",
  329.               });
  330.               //刷新页面
  331.               that.getAllMenuList();
  332.             }
  333.           });
  334.           this.$message({
  335.             type: "info",
  336.             message: "保存修改",
  337.           });
  338.         })
  339.         .catch((action) => {
  340.           this.$message({
  341.             type: "info",
  342.             message:
  343.               action === "cancel" ? "放弃保存并离开页面" : "停留在当前页面",
  344.           });
  345.         });
  346.       // let that = this;
  347.       // this.$confirm("此操作将永久删除该记录，是否继续?", "提升", {
  348.       //   cofirmButtonText: "确定",
  349.       //   cancelButtonText: "取消",
  350.       //   type: "warning",
  351.       // }).then(() => {
  352.       //   deleteSubmit(val.id).then((res) => {
  353.       //     if (res.code === 20000) {
  354.       //       that.$message({
  355.       //         type: "success",
  356.       //         message: "删除成功",
  357.       //       });
  358.       //       //刷新页面
  359.       //       that.getAllMenuList();
  360.       //     }
  361.       //   });
  362.       // });
  363.     },
  364.     //修改
  365.     updateMenuSubmit() {
  366.       let that = this;
  367.       updateMenuSubmit(that.menuForm).then((res) => {
  368.         if (res.code === 20000) {
  369.           that.$message({
  370.             type: "success",
  371.             message: "修改菜单成功",
  372.           });
  373.           //刷新页面
  374.           that.getAllMenuList();
  375.           that.dialogFormVisible = false;
  376.         }
  377.       });
  378.     },
  379.     //新增
  380.     addMenuSubmit() {
  381.       let that = this;
  382.       //let permission = that.menuForm;
  383.       http({
  384.         url: "/admin/sys/permission/save",
  385.         method: "post",
  386.         data: that.menuForm,
  387.       }).then((res) => {
  388.         if (res.code === 20000) {
  389.           that.$message({
  390.             type: "success",
  391.             message: "添加菜单成功",
  392.           });
  393.           //刷新页面
  394.           that.getAllMenuList();
  395.           that.dialogFormVisible = false;
  396.         }
  397.       });
  398.     },
  399.     //提交添加菜单的数据
  400.     addMenuFormSubmit() {
  401.       let that = this;
  402.       this.$refs.menuForm.validate((valid) => {
  403.         if (valid) {
  404.           if (that.menuForm.id) {
  405.             that.title = "修改菜单";
  406.             //修改
  407.             that.updateMenuSubmit();
  408.           } else {
  409.             that.title = "添加菜单";
  410.             //新增
  411.             that.addMenuSubmit();
  412.           }
  413.         } else {
  414.           return false;
  415.         }
  416.       });
  417.     },
  418.     //显示添加菜单
  419.     addOrEditMenuDialog(val, flag) {
  420.       if (val.level === 1) {
  421.         this.showFlag = false;
  422.       } else {
  423.         this.showFlag = true;
  424.       }
  425.  
  426.  
  427.       if ("add" === flag) {
  428.         //新增的话，页面的值初始化为定义好的常量
  429.         this.menuForm = { ...MENU_FORM };
  430.         //新增的话，新增的菜单的pid为当前选中的行的id
  431.         this.menuForm.pid = val.id;
  432.         this.title = "添加菜单";
  433.       } else {
  434.         this.title = "修改菜单";
  435.         //修改的话，页面的值初始化为列表的具体的内容
  436.         Object.assign(this.menuForm, val);
  437.         //修改
  438.         if (val.level === 2) {
  439.           this.showFlag = false;
  440.         }
  441.       }
  442.  
  443.  
  444.       this.dialogFormVisible = true;
  445.     },
  446.     //获取递归取得的全部菜单
  447.     getAllMenuList() {
  448.       getData().then((res) => {
  449.         if (res.code === 20000 && res.data) {
  450.           this.tableData = res.data.data;
  451.           //console.log('JSON.stringify(this.tableData) ==='+JSON.stringify(this.tableData))
  452.         }
  453.       });
  454.     },
  455.   },
  456. };
  457. </script>

分配权限

  1. <template>
  2.   <div style="margin: 29px">
  3.     <el-tree
  4.       ref="tree"
  5.       :data="data"
  6.       show-checkbox
  7.       default-expand-all
  8.       node-key="id"
  9.       highlight-current
  10.       :props="defaultProps"
  11.     />
  12.     <el-button :disabled="saveBtnDisabled" type="primary" @click="save"
  13.       >保存</el-button
  14.     >
  15.   </div>
  16. </template>
  17.  
  18.  
  19. <script>
  20. import {
  21.   toAssign,
  22.   doAssign,
  23. } from "@/api/permission";
  24. export default {
  25.   data() {
  26.     return {
  27.       saveBtnDisabled: false,
  28.       data: [],
  29.       roleId: "",
  30.       defaultProps: {
  31.         children: "children",
  32.         label: "name",
  33.       },
  34.     };
  35.   },
  36.   watch: {
  37.     $route(to, from) {
  38.       this.init();
  39.     },
  40.   },
  41.   created() {
  42.     this.init();
  43.   },
  44.   methods: {
  45.     init() {
  46.       if (this.$route.params && this.$route.params.id) {
  47.         this.roleId = this.$route.params.id;
  48.         this.getDataList(this.roleId);
  49.       }
  50.     },
  51.     getDataList(roleId) {
  52.       toAssign(roleId).then((res) => {
  53.         if (res.code === 20000 && res.data.data) {
  54.           this.data = res.data.data;
  55.           var list = [];
  56.           var jsonList = JSON.parse(JSON.stringify(this.data));
  57.           var llll = JSON.stringify(this.data);
  58.           console.log("this.data=========================  " + this.data);
  59.           console.log("jsonList=========================  " + jsonList);
  60.           console.log(
  61.             "JSON.stringify(this.data)=========================  " +
  62.               JSON.stringify(this.data)
  63.           );
  64.           this.getJsonList(list, jsonList[0]["children"]);
  65.           this.$refs.tree.setCheckedKeys(list);
  66.         }
  67.       });
  68.     },
  69.     //获取所有的角色的权限
  70.     getJsonList(list, jsonList) {
  71.       for (var i = 0; i < jsonList.length; i++) {
  72.         if (
  73.           jsonList[i]["hasSelect"] == true &&
  74.           jsonList[i]["children"].length === 0
  75.         ) {
  76.           list.push(jsonList[i]["id"]);
  77.         }
  78.         if (jsonList[i]["children"].length > 0) {
  79.           this.getJsonList(list, jsonList[i]["children"]);
  80.         }
  81.       }
  82.     },
  83.     save() {
  84.       this.saveBtnDisabled = true;
  85.       var beforeIds = this.$refs.tree.getHalfCheckedKeys().join(",");
  86.       var afterIds = this.$refs.tree.getCheckedKeys().join(",");
  87.       var ids = beforeIds + "," + afterIds;
  88.       if (ids === ",") {
  89.         ids = [];
  90.       }
  91.       console.log(ids);
  92.       doAssign(this.roleId, ids).then((res) => {
  93.         if (res.code === 20000 && res.success) {
  94.           this.$message({
  95.             type: "info",
  96.             message: "保存成功！",
  97.           });
  98.           this.$router.push({ path: "/role" });
  99.         } else {
  100.           this.$message({
  101.             type: "info",
  102.             message: "保存失败！",
  103.           });
  104.         }
  105.       });
  106.     },
  107.   },
  108. };
  109. </script>
  110.  
  111.  
  112. <style>
  113. </style>

路由

  1. import Vue from 'vue'
  2. import VueRouter from 'vue-router'
  3. import Home from '@/views/Home.vue'
  4. import User from '@/views/sys/user/User.vue'
  5. import Main from '@/views/Main.vue'
  6. import store from '@/store'
  7. import { getToken } from '@/utils/auth'
  8. import { login, logout, getInfo } from '@/api/login'
  9. Vue.use(VueRouter)
  10.  
  11.  
  12. // 0. 如果使用模块化机制编程，导入Vue和VueRouter，要调用 Vue.use(VueRouter)
  13. // 1. 定义 (路由) 组件。
  14. // 可以从其他文件 import 进来
  15. // 2. 定义路由
  16. // 每个路由应该映射一个组件。 其中"component" 可以是
  17. // 通过 Vue.extend() 创建的组件构造器，
  18. // 或者，只是一个组件配置对象。
  19. // 我们晚点再讨论嵌套路由。
  20. const routes = [
  21.   {
  22.     path: '/login',
  23.     name: 'Login',
  24.     component: () => import('@/views/Login.vue')
  25.   },
  26.   //主路由
  27.   // {
  28.   //   path: '/',
  29.   //   component: Main,
  30.   //   redirect: '/home',
  31.   //   children: [
  32.   //     //子路由
  33.   //     { path: 'home', name: "home", component: Home },//首页
  34.   //     // { path: 'user', name: "user", component: User },//用户管理
  35.   //     // { path: 'role', name: "role", component: () => import("@/views/sys/Role.vue") },//角色管理
  36.   //     // { path: 'menu', name: "menu", component: () => import("@/views/sys/Menu.vue") },//菜单管理管理
  37.   //   ]
  38.   // },
  39.   // {
  40.   //   path: '/user',
  41.   //   name: 'User',
  42.   //   component: User
  43.   // },
  44. ]
  45.  
  46.  
  47. // 3. 创建 router 实例，然后传 `routes` 配置
  48. // 你还可以传别的配置参数, 不过先这么简单着吧。
  49. const router = new VueRouter({
  50.   mode: 'history', // 去掉url中的#
  51.   routes // (缩写) 相当于 routes: routes
  52. })
  53.  
  54.  
  55. // 4. 创建和挂载根实例。挂载到main.js的根节点
  56. // 记得要通过 router 配置参数注入路由，
  57. // 从而让整个应用都有路由功能
  58. // const app = new Vue({
  59. //   router
  60. // }).$mount('#app')
  61.  
  62.  
  63. // 防止连续点击多次路由报错
  64. // 获取原型对象push函数
  65. const originalPush = VueRouter.prototype.push
  66. // 获取原型对象replace函数
  67. const originalReplace = VueRouter.prototype.replace
  68. // 修改原型对象中的push函数
  69. VueRouter.prototype.push = function push(location) {
  70.   return originalPush.call(this, location).catch(err => err)
  71. }
  72. // 修改原型对象中的replace函数
  73. VueRouter.prototype.replace = function replace(location) {
  74.   return originalReplace.call(this, location).catch(err => err)
  75. }
  76.  
  77.  
  78. //模拟菜单数据
  79. //const authoritys = ['sys:user:list', "sys:user:save", "sys:user:delete"]
  80.  
  81.  
  82. const menuData1 = [
  83.   // {
  84.   //   path: "/",
  85.   //   name: "home",
  86.   //   label: "首页",
  87.   //   icon: "s-home",
  88.   //   url: "Home/Home",
  89.   // },
  90.   {
  91.     label: "权限管理",
  92.     name: "system",
  93.     icon: "location",
  94.     children: [
  95.       {
  96.         path: "/user",
  97.         name: "user",
  98.         label: "用户管理",
  99.         icon: "setting",
  100.         component: "sys/user/User",
  101.       },
  102.       {
  103.         path: '/sys/role/distribution/:id',
  104.         name: '角色权限',
  105.         component: 'sys/role/roleForm',
  106.         meta: { title: '角色权限', icon: 'table' },
  107.         hidden: true
  108.       },
  109.       {
  110.         path: '/userForm/:id',
  111.         name: '角色权限',
  112.         component: 'sys/user/userForm',
  113.         meta: { title: '角色权限', icon: 'table' },
  114.         hidden: true
  115.       },
  116.       {
  117.         path: "/role",
  118.         name: "role",
  119.         label: "角色管理",
  120.         icon: "setting",
  121.         component: "sys/role/Role",
  122.       },
  123.       {
  124.         path: "/menu",
  125.         name: "menu",
  126.         label: "菜单管理",
  127.         icon: "setting",
  128.         component: "sys/menu/Menu",
  129.       },
  130.     ],
  131.   },
  132. ]
  133. // 拼装动态路由
  134. const manageRoute = {
  135.   path: '/',
  136.   component: Main,
  137.   redirect: '/login',
  138.   children: [
  139.     //子路由
  140.     { path: 'home', name: "home", component: Home },//首页
  141.  
  142.  
  143.   ]
  144. }
  145. //获取数据
  146. //菜单
  147. // store.commit('setMenuList', menuData1)
  148.  
  149.  
  150. //权限用户
  151. //localStorage.setItem("menus1", JSON.stringify(menuData1))
  152. // 注意：刷新页面会导致页面路由重置
  153. const setRoutes = () => {
  154.  
  155.  
  156.   //const storeMenus = localStorage.getItem("menus");
  157.   const storeMenus = localStorage.getItem("menus");
  158.  
  159.  
  160.   if (storeMenus) {
  161.  
  162.  
  163.     // 获取当前的路由对象名称数组
  164.     const currentRouteNames = router.getRoutes().map(v => v.name)
  165.     if (!currentRouteNames.includes('home')) {
  166.       
  167.       const menus = JSON.parse(storeMenus)
  168.       menus.forEach(item => {
  169.         
  170.         if (item.path) {  // 当且仅当path不为空的时候才去设置路由
  171.           
  172.           let flag = false;
  173.           if (item.hidden) {
  174.  
  175.  
  176.             flag = true;
  177.           }
  178.           let itemMenu = {
  179.             path: item.path,
  180.             name: item.name,
  181.             hidden: flag,
  182.             component: () => import('../views/' + item.component + '.vue')
  183.           }
  184.  
  185.           manageRoute.children.push(itemMenu)
  186.         } else if (item.children.length) {
  187.           item.children.forEach(item => {
  188.             let flag = false;
  189.             if (item.hidden) {
  190.  
  191.  
  192.               flag = true;
  193.             }
  194.             if (item.path) {
  195.               let itemMenu = {
  196.                 path: item.path,
  197.                 name: item.name,
  198.                 hidden: flag,
  199.                 component: () => import('../views/' + item.component + '.vue')
  200.               }
  201.  
  202.  
  203.               manageRoute.children.push(itemMenu)
  204.             }
  205.           })
  206.         }
  207.       })
  208.       
  209.       // 动态添加到现在的路由对象中去
  210.       router.addRoute(manageRoute)
  211.     }
  212.  
  213.  
  214.   }
  215. }
  216.  
  217.  
  218. // 重置我就再set一次路由
  219. setRoutes()
  220.  
  221.  
  222. //转成路由
  223. // const menuToRoute = (item) => {
  224.  
  225.  
  226. //   if (!item.component) {
  227. //     return null
  228. //   }
  229. //   // let route = {
  230. //   //   name: item.name,
  231. //   //   path: item.path.replace("/", ""),
  232.  
  233.  
  234. //   //   meta: {
  235. //   //     icon: item.icon,
  236. //   //     title: item.title,
  237.  
  238.  
  239. //   //   }
  240. //   // }
  241. //   // route.component= () => import('../views/' + item.component + '.vue')
  242. //   // route.component=()=>import('@/views/'+item.component+'.vue');
  243. //   // route.component = () => import('@/views/' + item.component + '.vue')
  244. //   let route = { path: item.path.replace("/", ""), name: item.name, component: () => import('../views/' + item.component + '.vue') }
  245. //   return route
  246. // }
  247.  
  248.  
  249.  
  250.  
  251.  
  252.  
  253. // router.beforeEach((to, from, next) => {
  254.  
  255.  
  256. //   let that = this
  257.  
  258.  
  259. //   getInfo(store.state.token).then(response => {
  260.     
  261. //     const data = response.data
  262. //     if (data.roles && data.roles.length > 0) { // 验证返回的roles是否是一个非空数组
  263. //       store.commit('SET_ROLES', data.roles)
  264. //     }
  265.  
  266.  
  267. //     const buttonAuthList = []
  268. //     menuData = data.permissionList
  269. //     
  270. //     data.permissionValueList.forEach(button => {
  271. //       if (button) {
  272. //         buttonAuthList.push(button)
  273. //       }
  274.  
  275.  
  276. //     })
  277.  
  278.  
  279. //     store.commit('SET_NAME', data.name)
  280. //     //commit('SET_AVATAR', data.avatar)
  281. //     store.commit('SET_BUTTONS', buttonAuthList)
  282.  
  283.  
  284. //   }).catch(error => {
  285.  
  286.  
  287. //   })
  288. //   next()
  289. // })
  290.  
  291.  
  292.  
  293.  
  294. export default router

权限

  1. import router from './router'
  2. import { login, logout, getInfo } from '@/api/login'
  3. import { getToken, setToken, removeToken } from '@/utils/auth'
  4. import http from "@/utils/request";
  5. import qs from "qs";
  6. import store from './store'
  7. router.beforeEach(async (to, from, next) => {
  8.  
  9.  
  10.  
  11.  
  12.   const hasToken = getToken()
  13.  
  14.  
  15.   if (hasToken) {
  16.     if (to.path === '/login') {
  17.       // if is logged in, redirect to the home page
  18.       next()
  19.  
  20.  
  21.     } else {
  22.       // determine whether the user has obtained his permission roles through getInfo
  23.       const hasRoles = store.getters.roles && store.getters.roles.length > 0
  24.       if (hasRoles) {
  25.         next()
  26.       } else {
  27.         // get user info
  28.         // note: roles must be a object array! such as: ['admin'] or ,['developer','editor']
  29.         const response = await store.dispatch('GetInfo')
  30.         if (response.code === 20000) {
  31.           const data = response.data
  32.           if (data.roles && data.roles.length > 0) { // 验证返回的roles是否是一个非空数组
  33.             store.commit('SET_ROLES', data.roles)
  34.           }
  35.  
  36.  
  37.           const buttonAuthList = []
  38.           const menuData = data.permissionList
  39.           store.commit('setMenuList', menuData)
  40.  
  41.  
  42.           //权限用户
  43.           localStorage.setItem("menus", JSON.stringify(menuData))
  44.           data.permissionValueList.forEach(button => {
  45.             if (button) {
  46.               buttonAuthList.push(button)
  47.             }
  48.  
  49.  
  50.           })
  51.  
  52.  
  53.           store.commit('SET_NAME', data.name)
  54.           //commit('SET_AVATAR', data.avatar)
  55.           store.commit('SET_BUTTONS', buttonAuthList)
  56.  
  57.  
  58.  
  59.  
  60.         }
  61.  
  62.  
  63.       }
  64.     }
  65.   }
  66.   next()
  67. })

mixin

  1. import Vue from "vue"
  2.  
  3.  
  4. Vue.mixin({
  5.   methods: {
  6.     hasAuth(perm) {
  7.       var authority = this.$store.state.user.buttons
  8.       return authority.indexOf(perm) > -1
  9.     }
  10.   }
  11. })

security配置

  1. package com.stu.myserver.config;
  2.  
  3.  
  4.  
  5.  
  6. import com.stu.myserver.security.*;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
  11. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
  12. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  13. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  14. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  15. import org.springframework.security.config.http.SessionCreationPolicy;
  16. import org.springframework.security.core.userdetails.UserDetailsService;
  17. import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
  18.  
  19.  
  20. /******************************
  21.  * 用途说明: Security配置
  22.  * 作者姓名: 公众号:小明的学习圈子  https://www.stucoding.com/
  23.  * 创建时间: 2022-07-27 23:16
  24.  ******************************/
  25. @Configuration
  26. @EnableWebSecurity
  27. @EnableGlobalMethodSecurity(prePostEnabled = true)
  28. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  29.     @Autowired
  30.     LoginFailureHandler loginFailureHandler;
  31.  
  32.  
  33.     @Autowired
  34.     LoginSuccessHandler loginSuccessHandler;
  35.  
  36.  
  37.     @Autowired
  38.     CaptchaFilter captchaFilter;
  39.     
  40.     @Autowired
  41.     JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
  42.  
  43.  
  44.     @Autowired
  45.     JwtAccessDeniedHandler jwtAccessDeniedHandler;
  46.  
  47.  
  48.     @Autowired
  49.     private UserDetailsService userDetailsService;
  50.  
  51.  
  52.     @Autowired
  53.     JwtLogoutSuccessHandler jwtLogoutSuccessHandler;
  54.  
  55.  
  56.     @Bean
  57.     JwtAuthenticationFilter jwtAuthenticationFilter() throws Exception {
  58.         JwtAuthenticationFilter jwtAuthenticationFilter = new JwtAuthenticationFilter(authenticationManager());
  59.         return jwtAuthenticationFilter;
  60.     }
  61.  
  62.  
  63.     //    @Bean
  64. //    BCryptPasswordEncoder bCryptPasswordEncoder() {
  65. //        return new BCryptPasswordEncoder();
  66. //    }
  67.     private static final String[] URL_WHITELIST = {
  68.  
  69.  
  70.             "/user/register",
  71.             "/js/**",
  72.             "/login",
  73.             "/logout",
  74.             "/captcha",
  75.             "/favicon.ico",
  76.             "/login**",
  77.             "/login#/login",
  78.             "/home/getData",
  79.             "captcha/getUserInfo"
  80.  
  81.  
  82.     };
  83.  
  84.  
  85.     protected void configure(HttpSecurity http) throws Exception {
  86.  
  87.  
  88.         http.cors().and().csrf().disable()                // 登录配置
  89.                 .formLogin()
  90.                 .successHandler(loginSuccessHandler)
  91.                 .failureHandler(loginFailureHandler)
  92.  
  93.  
  94.                 .and()
  95.                 .logout()
  96.                 .logoutSuccessHandler(jwtLogoutSuccessHandler)
  97.  
  98.  
  99.                 // 禁用session
  100.                 .and()
  101.                 .sessionManagement()
  102.                 .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
  103.  
  104.  
  105.                 // 配置拦截规则
  106.                 .and()
  107.                 .authorizeRequests()
  108.                 .antMatchers(URL_WHITELIST).permitAll()
  109.                 .anyRequest().authenticated()
  110.  
  111.  
  112.                 // 异常处理器
  113.                 .and()
  114.                 .exceptionHandling()
  115.                 .authenticationEntryPoint(jwtAuthenticationEntryPoint)
  116.                 .accessDeniedHandler(jwtAccessDeniedHandler)
  117.  
  118.  
  119.                 // 配置自定义的过滤器
  120.                 .and()
  121.                 .addFilter(jwtAuthenticationFilter())
  122.                 .addFilterBefore(captchaFilter, UsernamePasswordAuthenticationFilter.class);
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.     }
  130.  
  131.  
  132.     @Override
  133.     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  134.         auth.userDetailsService(userDetailsService);
  135.     }
  136. }

Redis配置

  1. package com.stu.myserver.config;
  2.  
  3.  
  4.  
  5.  
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.data.redis.connection.RedisConnectionFactory;
  10. import org.springframework.data.redis.core.RedisTemplate;
  11. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  12. import org.springframework.data.redis.serializer.StringRedisSerializer;
  13.  
  14.  
  15. /******************************
  16.  * 用途说明: redis配置
  17.  * 作者姓名: 公众号:小明的学习圈子  https://www.stucoding.com/
  18.  * 创建时间: 2022-07-27 23:16
  19.  ******************************/
  20. @Configuration
  21. public class RedisConfig {
  22.  
  23.  
  24.     @Bean
  25.     RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  26.  
  27.  
  28.         RedisTemplate redisTemplate = new RedisTemplate();
  29.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  30.  
  31.  
  32.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  33.         jackson2JsonRedisSerializer.setObjectMapper(new ObjectMapper());
  34.  
  35.  
  36.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  37.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  38.  
  39.  
  40.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  41.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  42.  
  43.  
  44.         return redisTemplate;
  45.  
  46.  
  47.     }
  48.  
  49.  
  50. }

跨域配置

  1. package com.stu.myserver.config;
  2.  
  3.  
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.web.cors.CorsConfiguration;
  7. import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
  8. import org.springframework.web.filter.CorsFilter;
  9. import org.springframework.web.servlet.config.annotation.CorsRegistry;
  10. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  11.  
  12.  
  13.  
  14.  
  15. /******************************
  16.  * 用途说明: 跨域
  17.  * 作者姓名: 公众号:小明的学习圈子  https://www.stucoding.com/
  18.  * 创建时间: 2022-07-27 23:16
  19.  ******************************/
  20. @Configuration
  21. public class CorsConfig implements WebMvcConfigurer {
  22.     private CorsConfiguration buildConfig() {
  23.         CorsConfiguration corsConfiguration = new CorsConfiguration();
  24.         corsConfiguration.addAllowedOrigin("*");
  25.         corsConfiguration.addAllowedHeader("*");
  26.         corsConfiguration.addAllowedMethod("*");
  27.         corsConfiguration.addExposedHeader("Authorization");
  28.         return corsConfiguration;
  29.     }
  30.  
  31.  
  32.     @Bean
  33.     public CorsFilter corsFilter() {
  34.         UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
  35.         source.registerCorsConfiguration("/**", buildConfig());
  36.         return new CorsFilter(source);
  37.     }
  38.  
  39.  
  40.     @Override
  41.     public void addCorsMappings(CorsRegistry registry) {
  42.         registry.addMapping("/**")
  43.                 .allowedOrigins("*")
  44. //          .allowCredentials(true)
  45.                 .allowedMethods("GET", "POST", "DELETE", "PUT")
  46.                 .maxAge(3600);
  47.     }
  48. }
PermissionServiceImpl
  1. package com.stu.myserver.service.impl;
  2.  
  3.  
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  6. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  7. import com.stu.myserver.entity.Permission;
  8. import com.stu.myserver.entity.RolePermission;
  9. import com.stu.myserver.mapper.PermissionMapper;
  10. import com.stu.myserver.service.IPermissionService;
  11. import com.stu.myserver.service.IRolePermissionService;
  12. import com.stu.myserver.service.IUserService;
  13. import org.apache.commons.lang.StringUtils;
  14. import org.springframework.beans.factory.annotation.Autowired;
  15. import org.springframework.stereotype.Service;
  16. import com.stu.myserver.entity.User;
  17. import org.springframework.util.CollectionUtils;
  18.  
  19.  
  20. import java.util.ArrayList;
  21. import java.util.List;
  22. import java.util.stream.Collectors;
  23.  
  24.  
  25. /**
  26.  * <p>
  27.  * 权限 服务实现类
  28.  * </p>
  29.  *
  30.  * @author 程序员小明1024
  31.  * @since 2023-08-07
  32.  */
  33. @Service
  34. public class PermissionServiceImpl extends ServiceImpl<PermissionMapper, Permission> implements IPermissionService {
  35.  
  36.  
  37.     @Autowired
  38.     private IRolePermissionService rolePermissionService;
  39.  
  40.  
  41.     @Autowired
  42.     private IUserService userService;
  43.  
  44.  
  45.     /***********************************
  46.      * 用途说明:获取全部菜单
  47.      * 返回值说明:
  48.      * @return List<Permission>
  49.      ***********************************/
  50.     @Override
  51.     public List<Permission> listPermissions() {
  52.         QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
  53.         queryWrapper.orderByDesc("id");
  54.  
  55.  
  56.         //把查询的所有菜单用递归的方式生成结构化菜单
  57.         return buildPermissions(baseMapper.selectList(queryWrapper));
  58.     }
  59.  
  60.  
  61.     /***********************************
  62.      * 用途说明:获取全部菜单
  63.      * 返回值说明:
  64.      * @return List<Permission>
  65.      ***********************************/
  66.     private List<Permission> buildPermissions(List<Permission> list) {
  67.         //创建rootList集合，最终数据封装
  68.         List<Permission> rootList = new ArrayList<>();
  69.  
  70.  
  71.         //遍历所有菜单，得到顶层菜单 pid==0，设置leve =1
  72.         for (Permission permission : list) {
  73.             //获取顶层菜单，pid=0
  74.             if ("0".equals(permission.getPid())) {
  75.                 //设置level = 1
  76.                 permission.setLevel(1);
  77.                 //根据顶层菜单，添加子菜单，封装到rootList
  78.                 rootList.add(selectChildrenMenu(permission, list));
  79.  
  80.  
  81.             }
  82.         }
  83.  
  84.  
  85.         return rootList;
  86.     }
  87.  
  88.  
  89.     /***********************************
  90.      * 用途说明:递归查询下级菜单
  91.      * @param root
  92.      * @param list
  93.      * 返回值说明:
  94.      * @return com.stu.myserver.entity.Permission
  95.      ***********************************/
  96.     private Permission selectChildrenMenu(Permission root, List<Permission> list) {
  97.         //因为要往下级菜单房新的菜单，需要初始化
  98.         root.setChildren(new ArrayList<Permission>());
  99.         //遍历所有菜单，比较当前对象的id和遍历的子菜单的pid是否相同
  100.         for (Permission permission : list) {
  101.             if (root.getId().equals(permission.getPid())) {
  102.                 permission.setLevel(root.getLevel() + 1);
  103.                 //递归，查询出来的子菜单放到父菜单里
  104.                 root.getChildren().add(selectChildrenMenu(permission, list));
  105.             }
  106.         }
  107.         return root;
  108.     }
  109.  
  110.  
  111.     /***********************************
  112.      * 用途说明:查询所有权限菜单
  113.      * 返回值说明:
  114.      * @return java.util.List<com.stu.service.acl.entity.Permission>
  115.      ***********************************/
  116.     @Override
  117.     public List<Permission> ListAllPermissions() {
  118.         QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
  119.         queryWrapper.orderByDesc("id");
  120.         return bulidPermission(baseMapper.selectList(queryWrapper));
  121.     }
  122.  
  123.  
  124.     /***********************************
  125.      * 用途说明:把返回所有菜单list集合进行封装的方法
  126.      * @param list
  127.      * 返回值说明:
  128.      * @return java.util.List<com.stu.service.acl.entity.Permission>
  129.      ***********************************/
  130.     private List<Permission> bulidPermission(List<Permission> list) {
  131.         //创建list集合，用于数据最终封装
  132.         List<Permission> finalNode = new ArrayList<>();
  133.  
  134.  
  135.         //把所有菜单list集合遍历，得到顶层菜单 pid=0菜单，设置level是1
  136.         for (Permission permission : list) {
  137.             //得到顶层菜单 pid=0菜单
  138.             if ("0".equals(permission.getPid())) {
  139.                 permission.setLevel(1);
  140.                 //根据顶层菜单，向里面进行查询子菜单，封装到finalNode里面
  141.                 finalNode.add(selectChildren(permission, list));
  142.             }
  143.         }
  144.  
  145.  
  146.         return finalNode;
  147.     }
  148.  
  149.  
  150.     /***********************************
  151.      * 用途说明:递归查询下级菜单
  152.      * @param permission
  153.      * @param list
  154.      * 返回值说明:
  155.      * @return com.stu.service.acl.entity.Permission
  156.      ***********************************/
  157.     private Permission selectChildren(Permission permission, List<Permission> list) {
  158.         //1 因为向一层菜单里面放二层菜单，二层里面还要放三层，把对象初始化
  159.         permission.setChildren(new ArrayList<Permission>());
  160.         //2 遍历所有菜单list集合，进行判断比较，比较id和pid值是否相同
  161.         for (Permission child : list) {
  162.             if (permission.getId().equals(child.getPid())) {
  163.                 child.setLevel(permission.getLevel() + 1);
  164.                 if (child.getChildren() == null) {
  165.                     child.setChildren(new ArrayList<>());
  166.                 }
  167. //                permission.getChildren().add(child);
  168. //                selectChildren(child,list);
  169.                 permission.getChildren().add(selectChildren(child, list));
  170.             }
  171.         }
  172.         return permission;
  173.  
  174.  
  175.     }
  176.  
  177.  
  178.     /***********************************
  179.      * 用途说明:递归删除菜单
  180.      * @param id
  181.      * 返回值说明:
  182.      * @return boolean
  183.      ***********************************/
  184.     @Override
  185.     public boolean removeChildById(String id) {
  186.         List<String> idList = new ArrayList<>();
  187.         selectChildListById(id, idList);
  188.         idList.add(id);
  189.         return baseMapper.deleteBatchIds(idList) > 0;
  190.     }
  191.  
  192.  
  193.     /***********************************
  194.      * 用途说明:根據角色獲取菜單
  195.      * @param id
  196.      * 返回值说明:
  197.      * @return java.util.List<com.stu.service.acl.entity.Permission>
  198.      ***********************************/
  199.     @Override
  200.     public List<Permission> listAllMenu(String id) {
  201.         //获取所有菜单
  202.         List<Permission> allPermissionList = baseMapper.selectList(new QueryWrapper<>());
  203.         //根据角色id呼气角色权限列表
  204.         List<RolePermission> rolePermissionsList = rolePermissionService
  205.                 .list(new QueryWrapper<RolePermission>().eq("role_id", id));
  206.         //遍历所有菜单，获取每一项，看是否在权限列表，如果在，就标记
  207.         List<String> permissionIdList = rolePermissionsList.stream().map(e -> e.getPermissionId()).collect(Collectors.toList());
  208.         allPermissionList.forEach(permission -> {
  209.             if (permissionIdList.contains(permission.getId())) {
  210.                 permission.setHasSelect(true);
  211.             } else {
  212.                 permission.setHasSelect(false);
  213.             }
  214.         });
  215.         /*for (int i = 0; i < allPermissionList.size(); i++) {
  216.             Permission permission = allPermissionList.get(i);
  217.             for (int m = 0; m < rolePermissionList.size(); m++) {
  218.                 RolePermission rolePermission = rolePermissionList.get(m);
  219.                 if(rolePermission.getPermissionId().equals(permission.getId())) {
  220.                     permission.setSelect(true);
  221.                 }
  222.             }
  223.         }*/
  224.         return bulidPermission(allPermissionList);
  225.     }
  226.  
  227.  
  228.     /***********************************
  229.      * 用途说明:给角色分配菜单权限
  230.      * @param roleId
  231.      * @param permissionId
  232.      * 返回值说明:
  233.      * @return boolean
  234.      ***********************************/
  235.     @Override
  236.     public boolean saveRolePermissionrelationShip(String roleId, String[] permissionId) {
  237.  
  238.  
  239.         //删除旧的权限
  240.        boolean ttt =  rolePermissionService.remove(new QueryWrapper<RolePermission>().eq("role_id", roleId));
  241.         if (null != permissionId && permissionId.length > 0) {
  242.             List<RolePermission> list = new ArrayList<>();
  243.             for (String id : permissionId) {
  244.                 RolePermission rolePermission = new RolePermission();
  245.                 rolePermission.setRoleId(roleId);
  246.                 rolePermission.setPermissionId(id);
  247.                 list.add(rolePermission);
  248.             }
  249.  
  250.  
  251.             return rolePermissionService.saveBatch(list);
  252.         }
  253.         return true;
  254.     }
  255.  
  256.  
  257.     /***********************************
  258.      * 用途说明:根据用户id查询有权限的菜单
  259.      * @param id
  260.      * 返回值说明:
  261.      * @return java.util.List<java.lang.String>
  262.      ***********************************/
  263.     @Override
  264.     public List<String> selectPermissionValueListByUserId(String id) {
  265.         List<String> list;
  266.         if (checkAdmin(id)) {
  267.             //如果是超级管理员获取所有权限
  268.             list = baseMapper.selectAllPermissionValue();
  269.         } else {
  270.             //根据用户id查询所有权限
  271.             list = baseMapper.selectPermissionValueByUserId(id);
  272.         }
  273.         return list;
  274.     }
  275.  
  276.  
  277.     /***********************************
  278.      * 用途说明:根据用户id查询所有权限的菜单详细列表
  279.      * @param userId
  280.      * 返回值说明:
  281.      * @return java.util.List<org.json.JSONObject>
  282.      ***********************************/
  283.     @Override
  284.     public List<JSONObject> selectPermissionByUserId(String userId) {
  285.         List<Permission> selectPermissionList = null;
  286.         if (checkAdmin(userId)) {
  287.             //如果是超级管理员获取所有权限
  288.             selectPermissionList = baseMapper.selectList(null);
  289.         } else {
  290.             //根据用户id查询所有权限
  291.             selectPermissionList = baseMapper.selectPermissionByUserId(userId);
  292.         }
  293.         //先转换成树状
  294.         List<Permission> permissionList = bulidPermission(selectPermissionList);
  295.         //然后转化成前端需要的格式
  296.         List<JSONObject> result = bulidJson(permissionList);
  297.  
  298.  
  299.         return result;
  300.     }
  301.  
  302.  
  303.     /***********************************
  304.      * 用途说明:转化成前端需要的格式
  305.      * @param permissionList
  306.      * 返回值说明:
  307.      * @return java.util.List<org.json.JSONObject>
  308.      ***********************************/
  309.     private List<JSONObject> bulidJson(List<Permission> permissionList) {
  310.         List<JSONObject> menus = new ArrayList<>();
  311.         if (permissionList.size() == 1) {
  312.             Permission topNode = permissionList.get(0);
  313.             //组建左侧一级菜单
  314.             List<Permission> oneMenuList = topNode.getChildren();
  315.             for (Permission one : oneMenuList) {
  316.                 JSONObject oneMenu = new JSONObject();
  317.                 oneMenu.put("path", one.getPath());
  318.                 oneMenu.put("component", one.getComponent());
  319.                 oneMenu.put("redirect", "noredirect");//第一级不需要重定向
  320.                 oneMenu.put("name", "name_" + one.getId());
  321.                 oneMenu.put("title", one.getName());
  322.                 oneMenu.put("label", one.getName());
  323.                 oneMenu.put("icon", one.getIcon());
  324.                 oneMenu.put("hidden", false);//一级不需要因此，3级需要
  325.                 JSONObject oneMeta = new JSONObject();
  326.                 oneMeta.put("title", one.getName());
  327.                 oneMeta.put("icon", one.getIcon());
  328.                 oneMenu.put("meta", oneMeta);
  329.  
  330.  
  331.                 List<JSONObject> children = new ArrayList<>();
  332.                 List<Permission> twoMenuList = one.getChildren();//二级菜单
  333.                 for (Permission two : twoMenuList) {
  334.                     JSONObject twoMenu = new JSONObject();
  335.                     twoMenu.put("path", two.getPath());
  336.                     twoMenu.put("component", two.getComponent());
  337.                     twoMenu.put("title", two.getName());
  338.                     twoMenu.put("label", two.getName());
  339.                     twoMenu.put("icon", two.getIcon());
  340. //                    twoMenu.put("redirect", "noredirect");//第一级不需要重定向
  341.                     twoMenu.put("name", "name_" + two.getId());
  342.                     twoMenu.put("hidden", false);//一级不需要因此，3级需要
  343.                     JSONObject twoMeta = new JSONObject();
  344.                     twoMeta.put("title", two.getName());
  345.                     twoMeta.put("icon", two.getIcon());
  346.                     twoMenu.put("meta", twoMeta);
  347.                     children.add(twoMenu);
  348.  
  349.  
  350.                     //功能按钮
  351.                     List<Permission> threeMenuList = two.getChildren();
  352.                     for (Permission three : threeMenuList) {
  353.                         if (StringUtils.isEmpty(three.getPath())) {
  354.                             continue;
  355.                         }
  356.                         JSONObject threeMenu = new JSONObject();
  357.                         threeMenu.put("path", three.getPath());
  358.                         threeMenu.put("component", three.getComponent());
  359. //                        threeMenu.put("redirect", "noredirect");//第一级不需要重定向
  360.                         threeMenu.put("name", "name_" + three.getId());
  361.                         threeMenu.put("title", three.getName());
  362.                         threeMenu.put("label", three.getName());
  363.                         threeMenu.put("icon", three.getIcon());
  364.                         threeMenu.put("hidden", true);//一级不需要因此，3级需要
  365.                         JSONObject threeMeta = new JSONObject();
  366.                         threeMeta.put("title", three.getName());
  367.                         threeMeta.put("icon", three.getIcon());
  368.                         threeMenu.put("meta", threeMeta);
  369.  
  370.  
  371.                         children.add(threeMenu);
  372.                     }
  373.  
  374.  
  375.                 }
  376.                 oneMenu.put("children", children);
  377.                 menus.add(oneMenu);
  378.  
  379.  
  380.             }
  381.         }
  382.         return menus;
  383.     }
  384.  
  385.  
  386.     /***********************************
  387.      * 用途说明:判断是否管理员
  388.      * @param id
  389.      * 返回值说明:
  390.      * @return boolean
  391.      ***********************************/
  392.     private boolean checkAdmin(String id) {
  393.         User user = userService.getById(id);
  394.         if (user != null && "admin".equals(user.getUsername())) {
  395.             return true;
  396.         }
  397.         return false;
  398.     }
  399.  
  400.  
  401.     /***********************************
  402.      * 用途说明:根据当前菜单id查询他的子子孙孙id，封装到list集合
  403.      * @param id
  404.      * @param idList
  405.      * 返回值说明:
  406.      ***********************************/
  407.     private void selectChildListById(String id, List<String> idList) {
  408.         //查询当前菜单的下级
  409.         QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
  410.         queryWrapper.eq("pid", id);
  411.         queryWrapper.select("id");
  412.         List<Permission> childList = baseMapper.selectList(queryWrapper);
  413.         //把childIdList里面菜单id值获取出来，封装idList里面，做递归查询
  414.         childList.forEach(item -> {
  415.             idList.add(item.getId());
  416.             selectChildListById(item.getId(), idList);
  417.         });
  418.  
  419.  
  420.     }
  421. }

IndexServiceImpl

  1. package com.stu.myserver.service.impl;
  2.  
  3.  
  4. import com.alibaba.fastjson.JSONObject;
  5.  
  6.  
  7. import com.stu.myserver.entity.Role;
  8. import com.stu.myserver.entity.User;
  9. import com.stu.myserver.exception.CustomException;
  10. import com.stu.myserver.service.IPermissionService;
  11. import com.stu.myserver.service.IRoleService;
  12. import com.stu.myserver.service.IUserService;
  13. import com.stu.myserver.service.IndexService;
  14. import com.stu.myserver.utils.ResultCodeEnum;
  15. import org.springframework.beans.factory.annotation.Autowired;
  16. import org.springframework.data.redis.core.RedisTemplate;
  17. import org.springframework.stereotype.Service;
  18.  
  19.  
  20. import java.util.HashMap;
  21. import java.util.List;
  22. import java.util.Map;
  23. import java.util.stream.Collectors;
  24.  
  25.  
  26. /******************************
  27.  * 用途说明:
  28.  * 作者姓名: Administrator
  29.  * 创建时间: 2022-09-01 22:34
  30.  ******************************/
  31. @Service
  32. public class IndexServiceImpl implements IndexService {
  33.  
  34.  
  35.     @Autowired
  36.     private IUserService userService;
  37.  
  38.  
  39.     @Autowired
  40.     private IRoleService roleService;
  41.  
  42.  
  43.     @Autowired
  44.     private IPermissionService permissionService;
  45.  
  46.  
  47.     @Autowired
  48.     private RedisTemplate redisTemplate;
  49.  
  50.  
  51.     /***********************************
  52.      * 用途说明:根据用户明获取用户登录信息
  53.      * @param userName
  54.      * 返回值说明:
  55.      * @return java.util.Map<java.lang.String, java.lang.Object>
  56.      ***********************************/
  57.     @Override
  58.     public Map<String, Object> getUserInfo(String userName) {
  59.         Map<String, Object> result = new HashMap<>();
  60.         User user = userService.selectByUserName(userName);
  61.         if (user == null) {
  62.             throw new CustomException(ResultCodeEnum.FETCH_USERINFO_ERROR);
  63.         }
  64.         //根据用户id获取角色
  65.         List<Role> roleList = roleService.selectRoleByUserId(user.getId());
  66.         //转换成角色名称列表
  67.         List<String> roleNameList = roleList.stream()
  68.                 .map(item -> item.getRoleName()).collect(Collectors.toList());
  69.  
  70.  
  71.         //前端框架必须返回一个角色，否则报错，如果没有角色，返回一个空角色
  72.         if (roleNameList.size() == 0) {
  73.             roleNameList.add("");
  74.         }
  75.  
  76.  
  77.         List<String> permissionValueList = permissionService.selectPermissionValueListByUserId(user.getId());
  78.         redisTemplate.opsForValue().set(userName, permissionValueList);
  79.         List<String> permissionValueLisst = (List<String>) redisTemplate.opsForValue().get(userName);
  80.         result.put("name", user.getUsername());
  81.         result.put("roles", roleNameList);
  82.         result.put("permissionValueList", permissionValueList);
  83.         return result;
  84.     }
  85.  
  86.  
  87.     /***********************************
  88.      * 用途说明:根据用户动态获取菜单
  89.      * @param userName
  90.      * 返回值说明:
  91.      * @return java.util.List<org.json.JSONObject>
  92.      ***********************************/
  93.     @Override
  94.     public List<JSONObject> getMenu(String userName) {
  95.         User user = userService.selectByUserName(userName);
  96.         if (user == null) {
  97.             throw new CustomException(ResultCodeEnum.FETCH_USERINFO_ERROR);
  98.         }
  99.         //根据用户动态获取菜单
  100.         return permissionService.selectPermissionByUserId(user.getId());
  101.     }
  102. }

RoleServiceImpl

  1. package com.stu.myserver.service.impl;
  2.  
  3.  
  4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  5. import com.stu.myserver.entity.Role;
  6. import com.stu.myserver.entity.UserRole;
  7. import com.stu.myserver.mapper.RoleMapper;
  8. import com.stu.myserver.service.IRoleService;
  9. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  10. import com.stu.myserver.service.IUserRoleService;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.stereotype.Service;
  13.  
  14.  
  15. import java.util.ArrayList;
  16. import java.util.HashMap;
  17. import java.util.List;
  18. import java.util.Map;
  19. import java.util.stream.Collectors;
  20.  
  21.  
  22. /**
  23.  * <p>
  24.  *  服务实现类
  25.  * </p>
  26.  *
  27.  * @author 程序员小明1024
  28.  * @since 2023-06-28
  29.  */
  30. @Service
  31. public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements IRoleService {
  32.     @Autowired
  33.     private IUserRoleService userRoleService;
  34.  
  35.  
  36.     /***********************************
  37.      * 用途说明:根据用户获取角色
  38.      * @param userId
  39.      * 返回值说明:
  40.      * @return java.util.List<com.stu.service.acl.entity.Permission>
  41.      ***********************************/
  42.     @Override
  43.     public Map<String, Object> findRoleByUserId(String userId) {
  44.         //获取所有角色
  45.         List<Role> allRoleList = baseMapper.selectList(new QueryWrapper<>());
  46.         //根据用户id获取角色列表
  47.         List<UserRole> existUserRoleList = userRoleService
  48.                 .list(new QueryWrapper<UserRole>().eq("user_id", userId).select("role_id"));
  49.         //遍历所有菜单，获取每一项，看是否在权限列表，如果在，就标记
  50.         List<String> existRoleLists = existUserRoleList.stream().map(e -> e.getRoleId()).collect(Collectors.toList());
  51.  
  52.  
  53.         List<Role> assignRoles = new ArrayList<>();
  54.         allRoleList.forEach(role -> {
  55.             if (existRoleLists.contains(role.getId())) {
  56.                 assignRoles.add(role);
  57.             }
  58.         });
  59.  
  60.  
  61.         Map<String, Object> roleMap = new HashMap<>();
  62.         roleMap.put("assignRoles", assignRoles);
  63.         roleMap.put("allRoleList", allRoleList);
  64.         return roleMap;
  65.     }
  66.  
  67.  
  68.     /***********************************
  69.      * 用途说明:给用户分配角色权限
  70.      * @param userId
  71.      * @param roleIds
  72.      * 返回值说明:
  73.      * @return boolean
  74.      ***********************************/
  75.     @Override
  76.     public boolean saveUserRelationShip(String userId, String[] roleIds) {
  77.         //删除旧的所有角色权限
  78.         userRoleService.remove(new QueryWrapper<UserRole>().eq("user_id", userId));
  79.         List<UserRole> list = new ArrayList<>();
  80.         for (String id : roleIds) {
  81.             UserRole rolePermission = new UserRole();
  82.             rolePermission.setRoleId(id);
  83.             rolePermission.setUserId(userId);
  84.             list.add(rolePermission);
  85.         }
  86.  
  87.  
  88.         return userRoleService.saveBatch(list);
  89.     }
  90.  
  91.  
  92.     /***********************************
  93.      * 用途说明:根据userid获取用户信息
  94.      * @param userId
  95.      * 返回值说明:
  96.      * @return java.util.List<com.stu.service.acl.entity.Role>
  97.      ***********************************/
  98.     @Override
  99.     public List<Role> selectRoleByUserId(String userId) {
  100.         //根据用户id获取角色列表
  101.         List<UserRole> userRoleList = userRoleService
  102.                 .list(new QueryWrapper<UserRole>().eq("user_id", userId).select("role_id"));
  103.         //遍历所有菜单，获取每一项，看是否在权限列表，如果在，就标记
  104.         List<String> roleIdLists = userRoleList.stream().map(e -> e.getRoleId()).collect(Collectors.toList());
  105.         List<Role> roleList = new ArrayList<>();
  106.         if (roleIdLists.size() > 0) {
  107.             roleList = baseMapper.selectBatchIds(roleIdLists);
  108.         }
  109.  
  110.  
  111.         return roleList;
  112.     }
  113. }

CodeGenerator

  1. package com.stu.myserver.utils;
  2.  
  3.  
  4. import com.baomidou.mybatisplus.annotation.FieldFill;
  5. import com.baomidou.mybatisplus.generator.FastAutoGenerator;
  6. import com.baomidou.mybatisplus.generator.config.OutputFile;
  7. import com.baomidou.mybatisplus.generator.fill.Column;
  8.  
  9.  
  10. import java.util.Collections;
  11.  
  12.  
  13. /******************************
  14.  * 用途说明:
  15.  * 作者姓名:公众号:程序员小明1024
  16.  * 创建时间: 2023-06-23 14:52
  17.  ******************************/
  18. public class CodeGenerator {
  19.  
  20.  
  21.     public static void main(String[] args) {
  22.         generate();
  23.     }
  24.  
  25.  
  26.     private static void generate() {
  27.         String projectPath = System.getProperty("user.dir");
  28.         FastAutoGenerator.create("jdbc:mysql://localhost:3306/2023Java?serverTimezone=Asia/Shanghai", "root", "study")
  29.                 .globalConfig(builder -> {
  30.                     builder.author("公众号 小明的学习圈子") // 设置作者
  31.                             .enableSwagger() // 开启 swagger 模式
  32.                             .fileOverride() // 覆盖已生成文件
  33.                             .outputDir(projectPath + "/src/main/java"); // 指定输出目录
  34.                 })
  35.                 .packageConfig(builder -> {
  36.                     builder.parent("com.stu.myserver") // 设置父包名
  37.                             .moduleName(null) // 设置父包模块名
  38.                             .pathInfo(Collections.singletonMap(OutputFile.mapperXml, projectPath + "/src/main/resources/mapper")); // 设置mapperXml生成路径
  39.                 })
  40.                 .strategyConfig(builder -> {
  41.                     builder.entityBuilder().enableLombok()
  42.                             .addTableFills(new Column("gmt_create", FieldFill.INSERT))
  43.                             .addTableFills(new Column("gmt_modified", FieldFill.INSERT_UPDATE));;
  44. //                    builder.mapperBuilder().enableMapperAnnotation().build();
  45.                     builder.controllerBuilder().enableHyphenStyle()  // 开启驼峰转连字符
  46.                             .enableRestStyle();  // 开启生成@RestController 控制器
  47.                     builder.addInclude("acl_user_role") // 设置需要生成的表名
  48.                             .addTablePrefix("acl_", "sys_"); // 设置过滤表前缀
  49.                 })
  50. //                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
  51.                 .execute();
  52.  
  53.  
  54.     }
  55.  
  56.  
  57.  
  58.  
  59. }
ResponseUtil
  1. package com.stu.myserver.utils;
  2.  
  3.  
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import org.springframework.http.HttpStatus;
  6. import org.springframework.http.MediaType;
  7.  
  8.  
  9. import javax.servlet.http.HttpServletResponse;
  10. import java.io.IOException;
  11.  
  12.  
  13. /******************************
  14.  * 用途说明:需要寫入response的數據
  15.  * 作者姓名: Administrator
  16.  * 创建时间: 2022-09-01 20:44
  17.  ******************************/
  18. public class ResponseUtil {
  19.  
  20.  
  21.  
  22.  
  23.     /*这段代码是一个用于在Java Web应用中向客户端发送JSON响应的方法。让我逐行解释其功能：
  24.             1. `public static void out(HttpServletResponse response, R r)`：
  25.             这是一个公共静态方法，它接受两个参数，一个是`HttpServletResponse`对象，
  26.             另一个是泛型`R`的对象`r`。`HttpServletResponse`对象用于设置HTTP响应的状态码、内容类型和写入响应数据。
  27.             2. `ObjectMapper mapper = new ObjectMapper();`：在方法内部创建了一个Jackson库
  28.             的`ObjectMapper`对象。Jackson库是用于在Java对象和JSON之间进行序列化和反序列化的流行库。
  29.             这个`ObjectMapper`对象将用于将`r`对象转换为JSON格式。
  30.             3. `response.setStatus(HttpStatus.OK.value());`：设置HTTP响应的状态码为200 OK。这表示请求已成功处理。
  31.             4. `response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);`：
  32.             设置HTTP响应的内容类型为"application/json;charset=UTF-8"，表示响应体将包含JSON数据，并且使用UTF-8字符编码。
  33.             5. `mapper.writeValue(response.getWriter(), r);`：使用`ObjectMapper`
  34.             将`r`对象序列化为JSON格式，并将其写入`HttpServletResponse`的输出流（通过`response.getWriter()`
  35.             获得的输出流）。这样，JSON数据将作为HTTP响应的内容发送给客户端。
  36.     总之，这段代码的目的是将一个Java对象`r`序列化为JSON格式，并将其作为HTTP响应的内容发送给客户端，
  37.     同时设置响应的状态码和内容类型。这通常用于Web应用程序中的API端点，以便向客户端提供结构化的数据响应。
  38. */    public static void out(HttpServletResponse response, R r) {
  39.         ObjectMapper mapper = new ObjectMapper();
  40.         response.setStatus(HttpStatus.OK.value());
  41.         response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
  42.         try {
  43.             mapper.writeValue(response.getWriter(), r);
  44.         } catch (IOException e) {
  45.             e.printStackTrace();
  46.         }
  47.     }
  48. }

更多内容阅读原文

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/53918
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号