• springboot+springsecurity+jwt+elementui图书管理系统

    ​​图书管理系统​​

    关注公号：java大师，回复“图书”，获取源码

    一、springboot后台

    1、mybatis-plus整合

    1.1添加pom.xml

    1. <!--mp逆向工程 -->
    2.          <dependency>
    3.              <groupId>org.projectlombok</groupId>
    4.              <artifactId>lombok</artifactId>
    5.          </dependency>
    6.          <dependency>
    7.              <groupId>com.baomidou</groupId>
    8.              <artifactId>mybatis-plus-boot-starter</artifactId>
    9.              <version>3.4.3.1</version>
    10.          </dependency>
    11.          <dependency>
    12.              <groupId>com.baomidou</groupId>
    13.              <artifactId>mybatis-plus-generator</artifactId>
    14.              <version>3.1.0</version>
    15.          </dependency>
    16.          <dependency>
    17.              <groupId>org.freemarker</groupId>
    18.              <artifactId>freemarker</artifactId>
    19.              <version>2.3.31</version>
    20.          </dependency>
    21.          <dependency>
    22.              <groupId>mysql</groupId>
    23.              <artifactId>mysql-connector-java</artifactId>
    24.              <version>8.0.28</version>
    25.          </dependency>
    26.          <dependency>
    27.              <groupId>org.apache.commons</groupId>
    28.              <artifactId>commons-lang3</artifactId>
    29.              <version>3.7</version>
    30.          </dependency>

    1.2创建CodeGenerator代码生成类

    1. package com.ds.book.mp;
    2.  
    3.  import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
    4.  import com.baomidou.mybatisplus.core.toolkit.StringPool;
    5.  import com.baomidou.mybatisplus.generator.AutoGenerator;
    6.  import com.baomidou.mybatisplus.generator.InjectionConfig;
    7.  import com.baomidou.mybatisplus.generator.config.*;
    8.  import com.baomidou.mybatisplus.generator.config.po.TableInfo;
    9.  import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
    10.  import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
    11.  import org.apache.commons.lang3.StringUtils;
    12.  
    13.  import java.util.ArrayList;
    14.  import java.util.List;
    15.  import java.util.Scanner;
    16.  
    17.  public class CodeGenerator {
    18.  
    19.      /**
    20.       * 
    21.       * 读取控制台内容
    22.       * 
    23.       */
    24.      public static String scanner(String tip) {
    25.          Scanner scanner = new Scanner(System.in);
    26.          StringBuilder help = new StringBuilder();
    27.          help.append("请输入" + tip + "：");
    28.          System.out.println(help.toString());
    29.          if (scanner.hasNext()) {
    30.              String ipt = scanner.next();
    31.              if (StringUtils.isNotBlank(ipt)) {
    32.                  return ipt;
    33.              }
    34.          }
    35.          throw new MybatisPlusException("请输入正确的" + tip + "！");
    36.      }
    37.  
    38.      public static void main(String[] args) {
    39.          // 代码生成器
    40.          AutoGenerator mpg = new AutoGenerator();
    41.  
    42.          // 全局配置
    43.          GlobalConfig gc = new GlobalConfig();
    44.          String projectPath = System.getProperty("user.dir");
    45.          gc.setOutputDir(projectPath + "/src/main/java");
    46.          gc.setAuthor("java大师");
    47.          gc.setOpen(false);
    48.          // gc.setSwagger2(true); 实体属性 Swagger2 注解
    49.          mpg.setGlobalConfig(gc);
    50.  
    51.          // 数据源配置
    52.          DataSourceConfig dsc = new DataSourceConfig();
    53.          dsc.setUrl("jdbc:mysql://175.24.198.63:3306/book?useSSL=false&characterEncoding=utf8&serverTimezone=GMT%2B8");
    54.          // dsc.setSchemaName("public");
    55.          dsc.setDriverName("com.mysql.cj.jdbc.Driver");
    56.          dsc.setUsername("root");
    57.          dsc.setPassword("root@1234!@#");
    58.          mpg.setDataSource(dsc);
    59.  
    60.          // 包配置
    61.          PackageConfig pc = new PackageConfig();
    62.  //        pc.setModuleName(scanner("模块名"));
    63.          pc.setParent("com.ds.book");
    64.          mpg.setPackageInfo(pc);
    65.  
    66.          // 自定义配置
    67.          InjectionConfig cfg = new InjectionConfig() {
    68.              @Override
    69.              public void initMap() {
    70.                  // to do nothing
    71.              }
    72.          };
    73.  
    74.          // 如果模板引擎是 freemarker
    75.          String templatePath = "/templates/mapper.xml.ftl";
    76.          // 如果模板引擎是 velocity
    77.          // String templatePath = "/templates/mapper.xml.vm";
    78.  
    79.          // 自定义输出配置
    80.          List<FileOutConfig> focList = new ArrayList<>();
    81.          // 自定义配置会被优先输出
    82.          focList.add(new FileOutConfig(templatePath) {
    83.              @Override
    84.              public String outputFile(TableInfo tableInfo) {
    85.                  // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
    86.                  return projectPath + "/src/main/resources/mapper/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
    87.              }
    88.          });
    89.          /*
    90.          cfg.setFileCreate(new IFileCreate() {
    91.              @Override
    92.              public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
    93.                  // 判断自定义文件夹是否需要创建
    94.                  checkDir("调用默认方法创建的目录，自定义目录用");
    95.                  if (fileType == FileType.MAPPER) {
    96.                      // 已经生成 mapper 文件判断存在，不想重新生成返回 false
    97.                      return !new File(filePath).exists();
    98.                  }
    99.                  // 允许生成模板文件
    100.                  return true;
    101.              }
    102.          });
    103.          */
    104.          cfg.setFileOutConfigList(focList);
    105.          mpg.setCfg(cfg);
    106.  
    107.          // 配置模板
    108.          TemplateConfig templateConfig = new TemplateConfig();
    109.  
    110.          // 配置自定义输出模板
    111.          //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
    112.          // templateConfig.setEntity("templates/entity2.java");
    113.          // templateConfig.setService();
    114.          // templateConfig.setController();
    115.  
    116.          templateConfig.setXml(null);
    117.          mpg.setTemplate(templateConfig);
    118.  
    119.          // 策略配置
    120.          StrategyConfig strategy = new StrategyConfig();
    121.          strategy.setNaming(NamingStrategy.underline_to_camel);
    122.          strategy.setColumnNaming(NamingStrategy.underline_to_camel);
    123.          strategy.setTablePrefix("t_");
    124.  //        strategy.setInclude("t_user");
    125.  //        strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
    126.          strategy.setEntityLombokModel(true);
    127.          strategy.setRestControllerStyle(true);
    128.          // 公共父类
    129.  //        strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
    130.          // 写于父类中的公共字段
    131.          strategy.setSuperEntityColumns("id");
    132.          strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
    133.          strategy.setControllerMappingHyphenStyle(true);
    134.  //        strategy.setTablePrefix(pc.getModuleName() + "_");
    135.          mpg.setStrategy(strategy);
    136.          mpg.setTemplateEngine(new FreemarkerTemplateEngine());
    137.          mpg.execute();
    138.      }
    139.  
    140.  }

    1.3生成crontroller、service、mapper、entity等业务实体类

    运行CodeGenerator,生成业务实体类

    请输入表名，多个英文逗号分割： t_user,t_menu,t_role,t_user_role,t_role_menu

    2、springsecurity-jwt整合

    2.1整合springsecurity

    1）

    1. <dependency>
    2.              <groupId>org.springframework.boot</groupId>
    3.              <artifactId>spring-boot-starter-security</artifactId>
    4.  </dependency>

    2.2认证授权流程

    认证管理

    流程图解读：

    1、用户提交用户名、密码被SecurityFilterChain中的 UsernamePasswordAuthenticationFilter 过滤器获取到， 封装为请求Authentication，通常情况下是UsernamePasswordAuthenticationToken这个实现类。

    2、然后过滤器将Authentication提交至认证管理器（AuthenticationManager）进行认证 。

    3、认证成功后， AuthenticationManager 身份管理器返回一个被填充满了信息的（包括上面提到的权限信息， 身份信息，细节信息，但密码通常会被移除） Authentication 实例。

    4、SecurityContextHolder 安全上下文容器将第3步填充了信息的 Authentication ，通过 SecurityContextHolder.getContext().setAuthentication(…)方法，设置到其中。 可以看出AuthenticationManager接口（认证管理器）是认证相关的核心接口，也是发起认证的出发点，它 的实现类为ProviderManager。而Spring Security支持多种认证方式，因此ProviderManager维护着一个 List 列表，存放多种认证方式，最终实际的认证工作是由 AuthenticationProvider完成的。咱们知道web表单的对应的AuthenticationProvider实现类为 DaoAuthenticationProvider，它的内部又维护着一个UserDetailsService负责UserDetails的获取。最终 AuthenticationProvider将UserDetails填充至Authentication。

    授权管理

    访问资源（即授权管理），访问url时，会通过FilterSecurityInterceptor拦截器拦截，其中会调用SecurityMetadataSource的方法来获取被拦截url所需的全部权限，再调用授权管理器AccessDecisionManager，这个授权管理器会通过spring的全局缓存SecurityContextHolder获取用户的权限信息，还会获取被拦截的url和被拦截url所需的全部权限，然后根据所配的投票策略（有：一票决定，一票否定，少数服从多数等），如果权限足够，则决策通过，返回访问资源，请求放行，否则跳转到403页面、自定义页面。

    2.3编写自己的UserDetails和UserDetailService

    2.3.1UserDetails

    1. package com.ds.book.entity;
    2.  
    3.  import com.baomidou.mybatisplus.annotation.TableName;
    4.  import java.io.Serializable;
    5.  import java.util.Collection;
    6.  
    7.  import lombok.Data;
    8.  import lombok.EqualsAndHashCode;
    9.  import lombok.experimental.Accessors;
    10.  import org.springframework.security.core.GrantedAuthority;
    11.  import org.springframework.security.core.userdetails.UserDetails;
    12.  
    13.  /**
    14.   * 
    15.   * 
    16.   * 
    17.   *
    18.   * @author java大师
    19.   * @since 2023-03-17
    20.   */
    21.  @Data
    22.  @EqualsAndHashCode(callSuper = false)
    23.  @Accessors(chain = true)
    24.  @TableName("t_user")
    25.  public class User implements Serializable, UserDetails {
    26.  
    27.      private static final long serialVersionUID = 1L;
    28.      
    29.      private Integer id;
    30.  
    31.      /**
    32.       * 登录名
    33.       */
    34.      private String name;
    35.  
    36.      /**
    37.       * 用户名
    38.       */
    39.      private String username;
    40.  
    41.      /**
    42.       * 密码
    43.       */
    44.      private String password;
    45.  
    46.      /**
    47.       * 是否有效：1-有效；0-无效
    48.       */
    49.      private String status;
    50.  
    51.  
    52.      @Override
    53.      public Collectionextends GrantedAuthority> getAuthorities() {
    54.          return roles
    55.                  .stream()
    56.                  .map(role -> new SimpleGrantedAuthority(role.getRoleCode()))
    57.                  .collect(Collectors.toList());
    58.      }
    59.  
    60.      @Override
    61.      public boolean isAccountNonExpired() {
    62.          return true;
    63.      }
    64.  
    65.      @Override
    66.      public boolean isAccountNonLocked() {
    67.          return true;
    68.      }
    69.  
    70.      @Override
    71.      public boolean isCredentialsNonExpired() {
    72.          return true;
    73.      }
    74.  
    75.      @Override
    76.      public boolean isEnabled() {
    77.          return true;
    78.      }
    79.  }

    2.3.2userDetailService

    登录成功后，将UserDetails的roles设置到用户中

    1. package com.ds.book.service.impl;
    2.  
    3.  import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    4.  import com.ds.book.entity.User;
    5.  import com.ds.book.mapper.UserMapper;
    6.  import com.ds.book.service.IUserService;
    7.  import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    8.  import org.apache.commons.lang3.StringUtils;
    9.  import org.springframework.beans.factory.annotation.Autowired;
    10.  import org.springframework.security.core.userdetails.UserDetails;
    11.  import org.springframework.security.core.userdetails.UserDetailsService;
    12.  import org.springframework.security.core.userdetails.UsernameNotFoundException;
    13.  import org.springframework.stereotype.Service;
    14.  
    15.  /**
    16.   * 
    17.   *  服务实现类
    18.   * 
    19.   *
    20.   * @author java大师
    21.   * @since 2023-03-17
    22.   */
    23.  @Service
    24.  public class UserServiceImpl extends ServiceImpl, User> implements IUserService, UserDetailsService {
    25.  
    26.      @Autowired
    27.      private UserMapper userMapper;
    28.  
    29.      @Override
    30.      public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    31.          User loginUser = userMapper.selectOne(new QueryWrapper<User>().eq("username", username));
    32.          if (loginUser == null){
    33.              throw new UsernameNotFoundException("用户名或密码错误");
    34.          }
    35.          loginUser.setRoles(userMapper.getRolesByUserId(loginUser.getId()));
    36.          return loginUser;
    37.      }
    38.  }

    2.3.2加载userDetailService

    将我们自己的UserDetailService注入springsecurity

    1. package com.ds.book.config;
    2.  
    3.  import com.ds.book.filter.JwtTokenFilter;
    4.  import com.ds.book.service.impl.UserServiceImpl;
    5.  import org.springframework.beans.factory.annotation.Autowired;
    6.  import org.springframework.context.annotation.Bean;
    7.  import org.springframework.context.annotation.Configuration;
    8.  import org.springframework.security.config.annotation.ObjectPostProcessor;
    9.  import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    10.  import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    11.  import org.springframework.security.config.annotation.web.builders.WebSecurity;
    12.  import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    13.  import org.springframework.security.config.http.SessionCreationPolicy;
    14.  import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    15.  import org.springframework.security.crypto.password.PasswordEncoder;
    16.  import org.springframework.security.web.access.intercept.FilterSecurityInterceptor;
    17.  import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
    18.  
    19.  @Configuration
    20.  public class SecurityConfig extends WebSecurityConfigurerAdapter {
    21.  
    22.  
    23.      @Autowired
    24.      private UserServiceImpl userService;
    25.  
    26.      @Bean
    27.      public PasswordEncoder passwordEncoder(){
    28.          return new BCryptPasswordEncoder();
    29.      }
    30.  
    31.      //注入我们自己的UserDetailService
    32.      @Override
    33.      protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    34.          auth.userDetailsService(userService).passwordEncoder(passwordEncoder());
    35.      }
    36.  }

    问题：前后端分离项目，通常不会使用springsecurity自带的登录界面，登录界面由前端完成，后台只需要提供响应的服务即可，且目前主流不会采用session去存取用户，后端会返回响应的token，前端访问的时候，会在headers里面带入token.

    2.4JwtToken

    2.4.1 JWT描述

    Jwt token由Header、Payload、Signature三部分组成，这三部分之间以小数点”.”连接，JWT token长这样：

    eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.keH6T3x1z7mmhKL1T3r9sQdAxxdzB6siemGMr_6ZOwU

    token解析后长这样： header部分，有令牌的类型(JWT)和签名算法名称(HS256)： { "alg": "HS256", "typ": "JWT" } Payload部分，有效负载，这部分可以放任何你想放的数据：

    { "sub": "1234567890", "name": "John Doe", "iat": 1516239022 }

    Signature签名部分，由于这部分是使用header和payload部分计算的，所以还可以以此来验证payload部分有没有被篡改：

    HMACSHA256(

    base64UrlEncode(header) + "." +

    base64UrlEncode(payload),

    123456 //这里是密钥，只要够复杂，一般不会被破解

    )

    2.4.2 pom.xml

    1. <dependency>
    2.      <groupId>io.jsonwebtoken</groupId>
    3.      <artifactId>jjwt</artifactId>
    4.      <version>0.9.0</version>
    5.  </dependency>

    2.4.3 JwtToken工具类

    1. package com.ds.book.tool;
    2.  
    3.  
    4.  import io.jsonwebtoken.Claims;
    5.  import io.jsonwebtoken.JwtBuilder;
    6.  import io.jsonwebtoken.Jwts;
    7.  import io.jsonwebtoken.SignatureAlgorithm;
    8.  
    9.  import javax.crypto.SecretKey;
    10.  import javax.crypto.spec.SecretKeySpec;
    11.  import java.util.Base64;
    12.  import java.util.Date;
    13.  import java.util.UUID;
    14.  
    15.  /**
    16.   * JWT工具类
    17.   */
    18.  public class JwtUtil {
    19.  
    20.      //有效期为
    21.      public static final Long JWT_TTL = 60 * 60 *1000L;// 60 * 60 *1000  一个小时
    22.      //设置秘钥明文
    23.      public static final String JWT_KEY = "dashii";
    24.  
    25.      public static String getUUID(){
    26.          String token = UUID.randomUUID().toString().replaceAll("-", "");
    27.          return token;
    28.      }
    29.  
    30.      /**
    31.       * 生成jtw
    32.       * @param subject token中要存放的数据（json格式）
    33.       * @return
    34.       */
    35.      public static String createJWT(String subject) {
    36.          JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
    37.          return builder.compact();
    38.      }
    39.  
    40.      /**
    41.       * 生成jtw
    42.       * @param subject token中要存放的数据（json格式）
    43.       * @param ttlMillis token超时时间
    44.       * @return
    45.       */
    46.      public static String createJWT(String subject, Long ttlMillis) {
    47.          JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间
    48.          return builder.compact();
    49.      }
    50.  
    51.      private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
    52.          SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
    53.          SecretKey secretKey = generalKey();
    54.          long nowMillis = System.currentTimeMillis();
    55.          Date now = new Date(nowMillis);
    56.          if(ttlMillis==null){
    57.              ttlMillis= JwtUtil.JWT_TTL;
    58.          }
    59.          long expMillis = nowMillis + ttlMillis;
    60.          Date expDate = new Date(expMillis);
    61.          return Jwts.builder()
    62.                  .setId(uuid)              //唯一的ID
    63.                  .setSubject(subject)   // 主题  可以是JSON数据
    64.                  .setIssuer("dashi")     // 签发者
    65.                  .setIssuedAt(now)      // 签发时间
    66.                  .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
    67.                  .setExpiration(expDate);
    68.      }
    69.  
    70.      /**
    71.       * 创建token
    72.       * @param id
    73.       * @param subject
    74.       * @param ttlMillis
    75.       * @return
    76.       */
    77.      public static String createJWT(String id, String subject, Long ttlMillis) {
    78.          JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
    79.          return builder.compact();
    80.      }
    81.  
    82.      public static void main(String[] args) throws Exception {
    83.          String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJjYWM2ZDVhZi1mNjVlLTQ0MDAtYjcxMi0zYWEwOGIyOTIwYjQiLCJzdWIiOiJzZyIsImlzcyI6InNnIiwiaWF0IjoxNjM4MTA2NzEyLCJleHAiOjE2MzgxMTAzMTJ9.JVsSbkP94wuczb4QryQbAke3ysBDIL5ou8fWsbt_ebg";
    84.          Claims claims = parseJWT(token);
    85.          System.out.println(claims);
    86.      }
    87.  
    88.      /**
    89.       * 生成加密后的秘钥 secretKey
    90.       * @return
    91.       */
    92.      public static SecretKey generalKey() {
    93.          byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
    94.          SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
    95.          return key;
    96.      }
    97.  
    98.      /**
    99.       * 解析
    100.       *
    101.       * @param jwt
    102.       * @return
    103.       * @throws Exception
    104.       */
    105.      public static Claims parseJWT(String jwt) throws Exception {
    106.          SecretKey secretKey = generalKey();
    107.          return Jwts.parser()
    108.                  .setSigningKey(secretKey)
    109.                  .parseClaimsJws(jwt)
    110.                  .getBody();
    111.      }
    112.  }

    2.4.4 JwtTokenFilter

    1. package com.ds.book.filter;
    2.  
    3. import com.ds.book.entity.User;
    4. import com.ds.book.mapper.UserMapper;
    5. import com.ds.book.service.IMenuService;
    6. import com.ds.book.service.IUserService;
    7. import com.ds.book.tool.JwtUtil;
    8. import io.jsonwebtoken.Claims;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
    11. import org.springframework.security.core.context.SecurityContextHolder;
    12. import org.springframework.stereotype.Component;
    13. import org.springframework.util.StringUtils;
    14. import org.springframework.web.filter.OncePerRequestFilter;
    15.  
    16. import javax.servlet.FilterChain;
    17. import javax.servlet.ServletException;
    18. import javax.servlet.http.HttpServletRequest;
    19. import javax.servlet.http.HttpServletResponse;
    20. import java.io.IOException;
    21.  
    22. @Component
    23. public class JwtTokenFilter extends OncePerRequestFilter {
    24.  
    25.     @Autowired
    26.     private IUserService userService;
    27.     @Autowired
    28.     private UserMapper userMapper;
    29.  
    30.     @Override
    31.     protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
    32.         //1、获取token
    33.         String token = httpServletRequest.getHeader("token");
    34.         if (StringUtils.isEmpty(token)){
    35.             filterChain.doFilter(httpServletRequest,httpServletResponse);
    36.             return;
    37.         }
    38.         String userId;
    39.         try {
    40.             Claims claims = JwtUtil.parseJWT(token);
    41.             userId = claims.getSubject();
    42.         } catch (Exception exception) {
    43.             exception.printStackTrace();
    44.             throw new RuntimeException("token非法");
    45.         }
    46.         User user = userService.getUserById(Integer.parseInt(userId));
    47.         user.setRoles(userMapper.getRolesByUserId(Integer.parseInt(userId)));
    48.         UsernamePasswordAuthenticationToken authenticationToken =
    49.                 new UsernamePasswordAuthenticationToken(user,null,user.getAuthorities());
    50.         SecurityContextHolder.getContext().setAuthentication(authenticationToken);
    51.         filterChain.doFilter(httpServletRequest,httpServletResponse);
    52.     }
    53. }

    在springsecurity中，第一个经过的过滤器是UsernamePasswordAuthenticationFilter，所以前后端分离的项目，我们自己定义的过滤器要放在这个过滤器前面，具体配置如下

    1. @Override
    2.     protected void configure(HttpSecurity http) throws Exception {
    3.         http.csrf().disable()
    4.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
    5.                 .and()
    6.                 .authorizeRequests()
    7.                 .antMatchers("/login").permitAll()
    8.                 .anyRequest().authenticated();
    9.         http.addFilterBefore(jwtTokenFilter, UsernamePasswordAuthenticationFilter.class);
    10.         http.cors();
    11.     }

    2.4.5授权

    2.4.5.1 开启preAuthorize进行收取（Controller路径匹配）

    1）主启动类上添加EnableGlobalMethodSecurity注解

    1. @EnableGlobalMethodSecurity(prePostEnabled = true)
    2. @SpringBootApplication
    3. @MapperScan("com.ds.book.mapper")
    4. public class BookSysApplication {
    5.     public static void main(String[] args) {
    6.         SpringApplication.run(BookSysApplication.class,args);
    7.     }
    8. }

    2）Controller方法上添加@PreAuthorize注解

    1. @RestController
    2. public class HelloController {
    3.  
    4.     @GetMapping("/hello")
    5.     @PreAuthorize("hasRole('ROLE_ADMIN')")
    6.     public String hello(){
    7.         return "hello";
    8.     }
    9. }

    2.4.5.2 增强方式授权（数据库表配置）

    1）创建我们自己的FilterInvocationSecurityMetadataSource，实现getAttributes方法，获取请求url所需要的角色

    1. @Component
    2. public class MySecurtiMetaDataSource implements FilterInvocationSecurityMetadataSource {
    3.  
    4.     @Autowired
    5.     private IMenuService menuService;
    6.     AntPathMatcher antPathMatcher = new AntPathMatcher();
    7.  
    8.     //获取访问url需要的角色，例如：/sys/user需要ROLE_ADMIN角色，访问sys/user时获取到必须要有ROLE_ADMIN角色。返回		Collection<ConfigAttribute>
    9.     @Override
    10.     public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
    11.         String requestURI = ((FilterInvocation) object).getRequest().getRequestURI();
    12.         //获取所有的菜单及角色
    13.         List<Menu> menus = menuService.getMenus();
    14.         for (Menu menu : menus) {
    15.             if (antPathMatcher.match(menu.getUrl(),requestURI)){
    16.                 String[] roles = menu.getRoles().stream().map(role -> role.getRoleCode()).toArray(String[]::new);
    17.                 return SecurityConfig.createList(roles);
    18.             }
    19.         }
    20.         return null;
    21.     }
    22.  
    23.     @Override
    24.     public Collection<ConfigAttribute> getAllConfigAttributes() {
    25.         return null;
    26.     }
    27.  
    28.     @Override
    29.     public boolean supports(Class<?> clazz) {
    30.         return false;
    31.     }
    32. }

    2）创建我们自己的决策管理器AccessDecisionManager，实现decide方法，判断步骤1）中获取到的角色和我们目前登录的角色是否相同，相同则允许访问，不相同则不允许访问,

    1. @Component
    2. public class MyAccessDecisionManager implements AccessDecisionManager {
    3.     
    4.     //1、认证通过后，会往authentication中填充用户信息
    5.     //2、拿authentication中的权限与上一步获取到的角色信息进行比对，比对成功后，允许访问
    6.     @Override
    7.     public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes) throws AccessDeniedException, InsufficientAuthenticationException {
    8.         Collectionextends GrantedAuthority> authorities = authentication.getAuthorities();
    9.         for (ConfigAttribute configAttribute : configAttributes) {
    10.             for (GrantedAuthority authority : authorities) {
    11.                 if (authority.getAuthority().equals(configAttribute.getAttribute())){
    12.                     return;
    13.                 }
    14.             }
    15.         }
    16.         throw new AccessDeniedException("权限不足，请联系管理员");
    17.     }
    18.  
    19.     @Override
    20.     public boolean supports(ConfigAttribute attribute) {
    21.         return false;
    22.     }
    23.  
    24.     @Override
    25.     public boolean supports(Class clazz) {
    26.         return false;
    27.     }
    28. }

    3）在SecurityConfig中，添加后置处理器（增强器），让springsecurity使用我们自己的datametasource和decisionMananger

    1. @Configuration
    2. public class SecurityConfig extends WebSecurityConfigurerAdapter {
    3.  
    4.     @Autowired
    5.     private MySecurtiMetaDataSource mySecurtiMetaDataSource;
    6.     @Autowired
    7.     private MyAccessDecisionManager myAccessDecisionManager;
    8.     @Autowired
    9.     private MyAuthenticationEntryPoint myAuthenticationEntryPoint;
    10.     @Autowired
    11.     private MyAccessDeniedHandler myAccessDeniedHandler;
    12.  
    13.     @Autowired
    14.     private UserServiceImpl userService;
    15.  
    16.     @Autowired
    17.     private JwtTokenFilter jwtTokenFilter;
    18.  
    19.     @Bean
    20.     public PasswordEncoder passwordEncoder(){
    21.         return new BCryptPasswordEncoder();
    22.     }
    23.  
    24.     @Override
    25.     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    26.         auth.userDetailsService(userService).passwordEncoder(passwordEncoder());
    27.     }
    28.  
    29.     @Override
    30.     protected void configure(HttpSecurity http) throws Exception {
    31.         http.csrf().disable()
    32.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
    33.                 .and()
    34.                 .authorizeRequests()
    35.                 .antMatchers("/login").permitAll()
    36.                 .anyRequest().authenticated()
    37.             	//后置处理器，使用我们自己的FilterSecurityInterceptor拦截器配置
    38.                 .withObjectPostProcessor(new ObjectPostProcessor () {
    39.                     @Override
    40.                     public  O postProcess(O o) {
    41.                         o.setSecurityMetadataSource(mySecurtiMetaDataSource);
    42.                         o.setAccessDecisionManager(myAccessDecisionManager);
    43.                         return o;
    44.                     }
    45.                 })
    46.                 .and()
    47.                 .headers().cacheControl();
    48.         http.addFilterBefore(jwtTokenFilter, UsernamePasswordAuthenticationFilter.class);
    49.         http.cors();
    50.     }
    51. }

    2.4.6异常处理

    1）前端渲染工具类

    1. public class WebUtils
    2. {
    3.     /**
    4.      * 将字符串渲染到客户端
    5.      *
    6.      * @param response 渲染对象
    7.      * @param string 待渲染的字符串
    8.      * @return null
    9.      */
    10.     public static String renderString(HttpServletResponse response, String string) {
    11.         try
    12.         {
    13.             response.setStatus(200);
    14.             response.setContentType("application/json");
    15.             response.setCharacterEncoding("utf-8");
    16.             response.getWriter().print(string);
    17.         }
    18.         catch (IOException e)
    19.         {
    20.             e.printStackTrace();
    21.         }
    22.         return null;
    23.     }
    24. }

    2）未登录异常处理，实现commence方法

    1. @Component
    2. public class MyAuthenticationEntryPoint implements AuthenticationEntryPoint {
    3.     @Override
    4.     public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
    5.         Result result = new Result(401,"未登录，请先登录",null);
    6.         String json = JSON.toJSONString(result);
    7.         WebUtils.renderString(httpServletResponse,json);
    8.  
    9.     }
    10. }

    3）授权失败异常处理，实现Handle方法

    1. @Component
    2. public class MyAccessDeniedHandler implements AccessDeniedHandler {
    3.     @Override
    4.     public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
    5.         Result result = new Result(403,"权限不足请联系管理员",null);
    6.         String s = JSON.toJSONString(result);
    7.         WebUtils.renderString(httpServletResponse,s);
    8.     }
    9. }

    3、整合swagger2

    1）添加pom.xml依赖

    1. <dependency>
    2.     <groupId>io.springfox</groupId>
    3.     <artifactId>springfox-swagger2</artifactId>
    4.     <version>2.7.0</version>
    5. </dependency>
    6. <dependency>
    7.     <groupId>io.springfox</groupId>
    8.     <artifactId>springfox-swagger-ui</artifactId>
    9.     <version>2.7.0</version>
    10. </dependency>
    11. <dependency>
    12.     <groupId>com.github.xiaoymin</groupId>
    13.     <artifactId>knife4j-spring-boot-starter</artifactId>
    14.     <version>2.0.7</version>
    15. </dependency>

    2）创建swagger配置文件

    1. package com.ds.book.config;
    2.  
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5. import springfox.documentation.builders.ApiInfoBuilder;
    6. import springfox.documentation.builders.PathSelectors;
    7. import springfox.documentation.builders.RequestHandlerSelectors;
    8. import springfox.documentation.service.*;
    9. import springfox.documentation.spi.DocumentationType;
    10. import springfox.documentation.spi.service.contexts.SecurityContext;
    11. import springfox.documentation.spring.web.plugins.Docket;
    12. import springfox.documentation.swagger2.annotations.EnableSwagger2;
    13.  
    14. import java.util.ArrayList;
    15. import java.util.List;
    16.  
    17. @Configuration
    18. @EnableSwagger2
    19. public class Swagger2Config {
    20.     @Bean
    21.     public Docket createRestApi() {
    22.         return new Docket(DocumentationType.SWAGGER_2)
    23.                 .pathMapping("/")
    24.                 .apiInfo(apiInfo())
    25.                 .select()
    26.                 //swagger要扫描的包路径
    27.                 .apis(RequestHandlerSelectors.basePackage("com.ds.book.controller"))
    28.                 .paths(PathSelectors.any())
    29.                 .build()
    30.                 .securityContexts(securityContexts())
    31.                 .securitySchemes(securitySchemes());
    32.     }
    33.  
    34.     private ApiInfo apiInfo() {
    35.         return new ApiInfoBuilder().title("图书管理系统接口文档")
    36.             	//作者、路径和邮箱
    37.                 .contact(new Contact("java大师","http://localhost:8080/doc.html","fry000@qq.com"))
    38.                 .version("1.0").description("图书管理接口文档").build();
    39.     }
    40.  
    41.     private List<SecurityContext> securityContexts() {
    42.         //设置需要登录认证的路径
    43.         List<SecurityContext> result = new ArrayList<>();
    44.         result.add(getContextByPath("/.*"));
    45.         return result;
    46.     }
    47.  
    48.     //通过pathRegex获取SecurityContext对象
    49.     private SecurityContext getContextByPath(String pathRegex) {
    50.         return SecurityContext.builder()
    51.                 .securityReferences(defaultAuth())
    52.                 .forPaths(PathSelectors.regex(pathRegex))
    53.                 .build();
    54.     }
    55.  
    56.     //默认为全局的SecurityReference对象
    57.     private List<SecurityReference> defaultAuth() {
    58.         List<SecurityReference> result = new ArrayList<>();
    59.         AuthorizationScope authorizationScope = new AuthorizationScope("global",
    60.                 "accessEverything");
    61.         AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
    62.         authorizationScopes[0] = authorizationScope;
    63.         result.add(new SecurityReference("Authorization", authorizationScopes));
    64.         return result;
    65.     }
    66.  
    67.     private List<ApiKey> securitySchemes() {
    68.         //设置请求头信息
    69.         List<ApiKey> result = new ArrayList<>();
    70.         //设置header中的token
    71.         ApiKey apiKey = new ApiKey("token", "token", "header");
    72.         result.add(apiKey);
    73.         return result;
    74.     }
    75. }

    3）修改SecurityConfig配置类，允许访问swagger的地址

    1. //主要的配置文件，antMatchers匹配的路径，全部忽略，不进行JwtToken的认证
    2. @Override
    3. public void configure(WebSecurity web) throws Exception {
    4.     web.ignoring().antMatchers(
    5.             "/login",
    6.             "/logout",
    7.             "/css/**",
    8.             "/js/**",
    9.             "/index.html",
    10.             "favicon.ico",
    11.             "/doc.html",
    12.             "/webjars/**",
    13.             "/swagger-resources/**",
    14.             "/v2/api-docs/**"
    15.     );
    16. }

    4）编写LoginController接口，通过@Api和@ApiOperation注解使用swagger

    1. package com.ds.book.controller;
    2.  
    3. import com.ds.book.entity.Result;
    4. import com.ds.book.entity.User;
    5. import com.ds.book.service.IUserService;
    6. import io.swagger.annotations.Api;
    7. import io.swagger.annotations.ApiOperation;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.security.access.SecurityConfig;
    10. import org.springframework.security.access.prepost.PreAuthorize;
    11. import org.springframework.web.bind.annotation.GetMapping;
    12. import org.springframework.web.bind.annotation.PostMapping;
    13. import org.springframework.web.bind.annotation.RequestBody;
    14. import org.springframework.web.bind.annotation.RestController;
    15.  
    16. @RestController
    17. @Api(tags = "登录")
    18. public class LoginController {
    19.  
    20.     @Autowired
    21.     private IUserService userService;
    22.  
    23.     @ApiOperation("登录")
    24.     @PostMapping("/login")
    25.     public Result login(@RequestBody User user){
    26.         return userService.login(user);
    27.     }
    28. }

    5）输入地址 http://localhost:8080/doc.html，进入swagger

    6）点击登录进入登录接口，点击调试，发送

    测试成功！

    4、业务接口

    4.1 登录接口

    注意：前后端分离项目，退出的时候，由前端清除浏览器请求header中的token和sessionStorage或者LocalStorage，后端只要返回一个退出成功的消息。

    1. package com.ds.book.controller;
    2.  
    3. import com.ds.book.entity.Result;
    4. import com.ds.book.entity.User;
    5. import com.ds.book.service.IUserService;
    6. import io.swagger.annotations.Api;
    7. import io.swagger.annotations.ApiOperation;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.security.access.SecurityConfig;
    10. import org.springframework.security.access.prepost.PreAuthorize;
    11. import org.springframework.security.core.userdetails.UserDetails;
    12. import org.springframework.security.core.userdetails.UserDetailsService;
    13. import org.springframework.web.bind.annotation.GetMapping;
    14. import org.springframework.web.bind.annotation.PostMapping;
    15. import org.springframework.web.bind.annotation.RequestBody;
    16. import org.springframework.web.bind.annotation.RestController;
    17.  
    18. import java.security.Principal;
    19.  
    20. @RestController
    21. @Api(tags = "登录")
    22. public class LoginController {
    23.  
    24.     @Autowired
    25.     private IUserService userService;
    26.     @Autowired
    27.     private UserDetailsService userDetailsService;
    28.  
    29.     @ApiOperation("登录")
    30.     @PostMapping("/login")
    31.     public Result login(@RequestBody User user){
    32.         return userService.login(user);
    33.     }
    34.  
    35.     @ApiOperation("退出")
    36.     @PostMapping("/logout")
    37.     public Result logout(){
    38.         return Result.success("退出成功");
    39.     }
    40.  
    41.     @ApiOperation("获取当前登录用户信息")
    42.     @GetMapping("/user/info")
    43.     public User user(Principal principal){
    44.         if (principal == null){
    45.             return null;
    46.         }
    47.         String username = principal.getName();
    48.         User user = (User)userDetailsService.loadUserByUsername(username);
    49.         user.setPassword(null);
    50.         return user;
    51.     }
    52.  
    53. }

    4.2菜单接口

    1. package com.ds.book.controller;
    2.  
    3.  
    4. import com.ds.book.entity.Menu;
    5. import com.ds.book.entity.Result;
    6. import com.ds.book.service.IMenuService;
    7. import io.swagger.annotations.Api;
    8. import io.swagger.annotations.ApiOperation;
    9. import io.swagger.models.auth.In;
    10. import org.springframework.beans.factory.annotation.Autowired;
    11. import org.springframework.security.access.prepost.PreAuthorize;
    12. import org.springframework.web.bind.annotation.*;
    13.  
    14. import java.util.List;
    15.  
    16. /**
    17.  * 
    18.  *  前端控制器
    19.  * 
    20.  *
    21.  * @author java大师
    22.  * @since 2023-03-09
    23.  */
    24. @RestController
    25. @Api(tags = "菜单管理")
    26. public class MenuController {
    27.  
    28.     @Autowired
    29.     private IMenuService menuService;
    30.  
    31.     @GetMapping("/menus")
    32.     @ApiOperation("获取菜单树")
    33.     public Result getMenus(){
    34.         List allMenus = menuService.getMenuTree();
    35.         return Result.success("查询成功",allMenus);
    36.     }
    37.  
    38.     @PostMapping("/menu/add")
    39.     @ApiOperation("添加菜单")
    40.     public Result addMenu(@RequestBody Menu menu){
    41.         return menuService.addMenu(menu);
    42.     }
    43.  
    44.     @PostMapping("/menu/update")
    45.     @ApiOperation("修改菜单")
    46.     public Result updateMenu(@RequestBody Menu menu){
    47.         return menuService.updateMenu(menu);
    48.     }
    49.  
    50.     @PostMapping("/menu/delete/{id}")
    51.     @ApiOperation("删除菜单")
    52.     public Result deleteMenu(@PathVariable Integer id){
    53.         return menuService.deleteMenu(id);
    54.     }
    55. }

    4.3用户接口

    1. package com.ds.book.controller;
    2.  
    3.  
    4. import com.ds.book.entity.Result;
    5. import com.ds.book.entity.User;
    6. import com.ds.book.service.IUserService;
    7. import io.swagger.annotations.Api;
    8. import io.swagger.annotations.ApiOperation;
    9. import io.swagger.models.auth.In;
    10. import org.springframework.beans.factory.annotation.Autowired;
    11. import org.springframework.security.crypto.password.PasswordEncoder;
    12. import org.springframework.web.bind.annotation.*;
    13.  
    14. import javax.jws.soap.SOAPBinding;
    15. import java.util.List;
    16.  
    17. /**
    18.  * 
    19.  *  前端控制器
    20.  * 
    21.  *
    22.  * @author java大师
    23.  * @since 2023-03-09
    24.  */
    25. @RestController
    26. @Api(tags = "用户管理")
    27. public class UserController {
    28.     @Autowired
    29.     private IUserService userService;
    30.     @Autowired
    31.     private PasswordEncoder passwordEncoder;
    32.  
    33.     @GetMapping("/users")
    34.     @ApiOperation("查询用户列表")
    35.     public Result getUsers(){
    36.         List list = userService.getUsers();
    37.         if (list != null){
    38.             return Result.success("查询成功",list);
    39.         }
    40.         return Result.error("查询失败");
    41.     }
    42.  
    43.     @PostMapping("/user/add")
    44.     @ApiOperation("添加用户")
    45.     public Result addUser(@RequestBody User user){
    46.         user.setPassword(passwordEncoder.encode("123456"));
    47.         return userService.addUser(user);
    48.     }
    49.  
    50.     @PostMapping("/user/update")
    51.     @ApiOperation("修改用户")
    52.     public Result updateUser(@RequestBody User user){
    53.         return userService.updateUser(user);
    54.     }
    55.  
    56.     @PostMapping("/user/chooseRole/{userId}/{roleId}")
    57.     @ApiOperation("选择角色")
    58.     public Result chooseRole(@PathVariable Integer userId,@PathVariable Integer roleId){
    59.         return userService.chooseRole(userId,roleId);
    60.     }
    61.  
    62.     @PostMapping("/user/delete/{id}")
    63.     @ApiOperation("删除用户")
    64.     public Result deleteUser(@PathVariable Integer id){
    65.         return userService.deleteUser(id);
    66.     }
    67. }

    4.4角色接口

    1. package com.ds.book.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    4. import com.ds.book.entity.Menu;
    5. import com.ds.book.entity.Result;
    6. import com.ds.book.entity.Role;
    7. import com.ds.book.entity.RoleMenu;
    8. import com.ds.book.mapper.RoleMapper;
    9. import com.ds.book.mapper.RoleMenuMapper;
    10. import com.ds.book.service.IRoleService;
    11. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    12. import org.springframework.beans.factory.annotation.Autowired;
    13. import org.springframework.stereotype.Service;
    14.  
    15. import java.util.ArrayList;
    16. import java.util.List;
    17.  
    18. /**
    19.  * 
    20.  *  服务实现类
    21.  * 
    22.  *
    23.  * @author java大师
    24.  * @since 2023-03-09
    25.  */
    26. @Service
    27. public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements IRoleService {
    28.     @Autowired
    29.     private RoleMapper roleMapper;
    30.     @Autowired
    31.     private RoleMenuMapper roleMenuMapper;
    32.  
    33.     private List<Menu> buildMenuTree(List<Menu> menus, Integer parentId) {
    34.         List<Menu> treeMenus = new ArrayList<>();
    35.         for (Menu menu : menus) {
    36.             if (parentId==0 ? menu.getParentId()==0 : parentId.equals(menu.getParentId())) {
    37.                 List<Menu> children = buildMenuTree(menus, menu.getId());
    38.                 if (!children.isEmpty()) {
    39.                     menu.setChildren(children);
    40.                 }
    41.                 treeMenus.add(menu);
    42.             }
    43.         }
    44.         return treeMenus;
    45.     }
    46.  
    47.     @Override
    48.     public List getRoles() {
    49.         List<Role> roles = roleMapper.getRoles();
    50.         for (Role role : roles) {
    51.             role.setMenus(buildMenuTree(role.getMenus(),0));
    52.         }
    53.         return roles;
    54.     }
    55.  
    56.     @Override
    57.     public Result chooseMenus(Integer roleId, Integer[] menuIds) {
    58.         try {
    59.             roleMenuMapper.delete(new QueryWrapper<RoleMenu>().eq("role_id",roleId));
    60.             for (Integer menuId : menuIds) {
    61.                 RoleMenu roleMenu = new RoleMenu();
    62.                 roleMenu.setRoleId(roleId);
    63.                 roleMenu.setMenuId(menuId);
    64.                 roleMenuMapper.insert(roleMenu);
    65.             }
    66.             return Result.success("添加成功");
    67.         } catch (Exception exception) {
    68.             return Result.error("添加失败");
    69.         }
    70.     }
    71. }

    二、springboot前端

    1、vue-cli创建vue-book前端项目

    vue create vue-book

    选择Vue2，运行完毕，出现以下画面

    执行绿色的命令，出现下列界面代表脚手架创建项目成功

    2、整合elementui

    1. //命令行安装
    2. npm i element-ui -S
    3.  
    4. //main.js使用element-ui
    5. import Vue from 'vue';
    6. import ElementUI from 'element-ui';
    7. import 'element-ui/lib/theme-chalk/index.css';
    8. import App from './App.vue';
    9.  
    10. Vue.use(ElementUI);
    11.  
    12. new Vue({
    13.   el: '#app',
    14.   render: h => h(App)
    15. });

    3、安装vue-router

    2.1安装依赖

    npm install vue-router@3

    2.2创建路由文件

    1. import Vue from 'vue'
    2. import VueRouter from "vue-router";
    3.  
    4. Vue.use(VueRouter)
    5.  
    6. //配置localhost:8080/跳转为登录页
    7. const routes =[
    8.     {
    9.         path:'/',
    10.         name:'Login',
    11.         component:() => import('@/pages/Login.vue')
    12.     }
    13. ]
    14.  
    15. export default new VueRouter({
    16.     routes
    17. })

    4、整合json-server

    4.1安装json-server

    npm install -g json-server

    4.2创建mock文件夹，新建db.json

    1. {
    2.   "posts": [
    3.     {
    4.       "id": 1,
    5.       "title": "json-server",
    6.       "author": "typicode"
    7.     }
    8.   ],
    9.   "users": [
    10.     {
    11.       "id": 1,
    12.       "username": "admin",
    13.       "password": "123"
    14.     }
    15.   ],
    16.   "login":
    17.   {
    18.     "code": 200,
    19.     "message":"返回成功",
    20.     "data": {
    21.       "id": "1237361915165020161",
    22.       "username": "admin",
    23.       "phone": "111111111111",
    24.       "nickName": "javads",
    25.       "realName": "javads",
    26.       "sex": 1,
    27.       "deptId": "1237322421447561216",
    28.       "deptName": "测试部门",
    29.       "status": 1,
    30.       "email": "xxxx@qq.com",
    31.       "token":"ASDSADASDSW121DDSA",
    32.       "menus": [
    33.         {
    34.           "id": "1236916745927790564",
    35.           "title": "系统管理",
    36.           "icon": "el-icon-star-off",
    37.           "path": "/sys",
    38.           "name": "Sys",
    39.           "children": [
    40.             {
    41.               "id": "1236916745927790578",
    42.               "title": "角色管理",
    43.               "icon": "el-icon-s-promotion",
    44.               "path": "/sys/roles",
    45.               "name": "Roles",
    46.               "children": []
    47.             },
    48.             {
    49.               "id": "1236916745927790560",
    50.               "title": "菜单管理",
    51.               "icon": "el-icon-s-tools",
    52.               "path": "/sys/menus",
    53.               "name": "Menus",
    54.               "children": []
    55.             },
    56.             {
    57.               "id": "1236916745927790575",
    58.               "title": "用户管理",
    59.               "icon": "el-icon-s-custom",
    60.               "path": "/sys/users",
    61.               "name": "User",
    62.               "children": []
    63.             }
    64.           ],
    65.           "spread": true,
    66.           "checked": false
    67.         },
    68.         {
    69.           "id": "1236916745927790569",
    70.           "title": "账号管理",
    71.           "icon": "el-icon-s-data",
    72.           "path": "/account",
    73.           "name": "Account",
    74.           "children": []
    75.         }
    76.       ],
    77.       "permissions": [
    78.         "sys:log:delete",
    79.         "sys:user:add",
    80.         "sys:role:update",
    81.         "sys:dept:list"
    82.       ]
    83.     }
    84.   },
    85.   "comments": [
    86.     {
    87.       "id": 1,
    88.       "body": "some comment",
    89.       "postId": 1
    90.     }
    91.   ],
    92.   "profile": {
    93.     "name": "typicode"
    94.   }
    95. }

    4.3修改vue.config.js，json-server的默认端口为3000，将代理服务器的的端口改成3000

    1. const { defineConfig } = require('@vue/cli-service')
    2. module.exports = defineConfig({
    3.   transpileDependencies: true,
    4.   lintOnSave:false,
    5.   devServer:{
    6.     proxy:{
    7.       '/api':{
    8.         target:'http://localhost:3000',
    9.         pathRewrite:{'^/api':''},
    10.         ws:true, //不写为true，websocket
    11.         changeOrigin:true //不写为true
    12.       }
    13.     }
    14.   }
    15. })

    4.4修改package.json，在scripts添加以下代码

    "mock": "json-server src/mock/db.json --port 3000 --middlewares src/mock/middlewares.js"

    4.5 运行json-server，出现以下界面代表运行成功

    json-server.cmd --watch db.jso

    5、整合axios

    5.1配置axios请求拦截器，新建utils文件夹，新建api.js，输入以下内容

    1. import router from '../router'
    2. import axios from 'axios'
    3. import {Message} from 'element-ui'
    4. import {Loading} from 'element-ui'
    5.  
    6.  
    7. axios.defaults.baseURL = '/api'
    8.  
    9. //添加遮罩层代码
    10. let loading;
    11. let loadingNum = 0;
    12.  
    13. //弹出遮罩层
    14. function showLoading(){
    15.     if (loadingNum ===0){
    16.         loading = Loading.service({
    17.             lock:true,
    18.             text:'加载中，请稍后...',
    19.             background:'rgba(255,255,255,0.5)'
    20.         })
    21.     }
    22.     loadingNum++;
    23. }
    24.  
    25. //关闭遮罩层
    26. function hiddenLoading(){
    27.     loadingNum--;
    28.     if (loadingNum <=0){
    29.         loading.close();
    30.     }
    31.  
    32. }
    33.  
    34. /**
    35.  * 添加响应拦截器，在浏览器每次发请求之前，token放入http消息头当中
    36.  */
    37. axios.interceptors.request.use(config =>{
    38.     showLoading();
    39.     if(window.sessionStorage.getItem('token')){
    40.         config.headers.Authorization =window.sessionStorage.getItem('token')
    41.     }
    42.     console.log(config)
    43.     return config
    44. },error => {
    45.     console.log(error)
    46. })
    47.  
    48. /**
    49.  * 添加响应拦截器
    50.  */
    51. axios.interceptors.response.use(success => {
    52.     hiddenLoading();
    53.     if (success.status && success.status == 200){
    54.         if (success.data.code == 500 || success.data.code == 401 || success.data.code == 403) {
    55.             Message.error({
    56.                 offset:200,
    57.                 message:success.data.message
    58.             })
    59.             router.replace("/")
    60.         }
    61.         if (success.data.message){
    62.             Message.success({
    63.                 offset:200,
    64.                 message:success.data.message
    65.             })
    66.         }
    67.     }
    68.     return success.data
    69. },error => {
    70.     hiddenLoading();
    71.     if (error.response.code == 504 || error.response.code == 404) {
    72.         Message.error({
    73.             message: '服务器跑路了'
    74.         });
    75.     } else if (error.response.status == 403) {
    76.         Message.error({
    77.             message: '权限不足，请联系管理员'
    78.         });
    79.     } else if (error.response.code == 401) {
    80.         Message.error({
    81.             message: '尚未登录，请先登录'
    82.         })
    83.         router.replace('/');
    84.     } else {
    85.         if (error.response.data.message) {
    86.             Message.error({
    87.                 message: error.response.data.message
    88.             });
    89.         } else {
    90.             Message.error({
    91.                 message: '未知错误'
    92.             });
    93.         }
    94.     }
    95.     return;
    96. })
    97.  
    98. export default axios

    5.2创建请求接口，新建http.js

    1. import axios from './api'
    2.  
    3. export const login = (param) =>{
    4.     return axios.get(`/posts`, {param})
    5. }
    6.  
    7.  
    8. export const getUser = () =>{
    9.     return axios.get(`/users`, {})
    10. }

    6、业务功能

    6.1登录界面

    1. <template>
    2.   <div class="login-container">
    3.     <el-form ref="form" :model="form" label-width="100px" class="login-form">
    4.       <h1 style="margin-bottom: 20px;text-align: center">欢迎登录</h1>
    5.       <el-form-item label="用户名">
    6.         <el-input v-model="form.username"></el-input>
    7.       </el-form-item>
    8.       <el-form-item label="密码">
    9.         <el-input type="password" v-model="form.password"></el-input>
    10.       </el-form-item>
    11.       <el-form-item>
    12.         <el-button type="primary" @click="onSubmit">登录</el-button>
    13.         <el-button>取消</el-button>
    14.       </el-form-item>
    15.     </el-form>
    16.   </div>
    17. </template>
    18. <script>
    19. import {initRoutes} from "@/utils/routesUtil";
    20. import {login,getUser} from "@/utils/http";
    21. export default {
    22.   name:'Login',
    23.   data() {
    24.     return {
    25.       form: {
    26.         username: '',
    27.         password: '',
    28.       }
    29.     }
    30.   },
    31.   methods: {
    32.     onSubmit() {
    33.       login(this.form).then(res=>{
    34.         if(res){
    35.           //浏览器中存储token，以后每次调用后端接口，浏览器都会带入这个token
    36.           window.sessionStorage.setItem("token",res.data.token)
    37.           //初始化路由数据
    38.           let myRoutes = initRoutes(res.data.menus)
    39.           //将路由进行替换并添加到router中
    40.           this.$router.options.routes = [myRoutes]
    41.           this.$router.addRoute(myRoutes)
    42.           this.$router.replace("/home")
    43.         }else{
    44.           return false
    45.         }
    46.       })
    47.     },
    48.   }
    49. }
    50. </script>
    51. <style scoped>
    52.  
    53. .login-form {
    54.   border: 1px #DCDFE6 solid;
    55.   border-radius: 4px;
    56.   padding: 40px;
    57.   margin: 110px 400px;
    58.   box-shadow: 0 2px 4px rgba(0, 0, 0, .12), 0 0 6px rgba(0, 0, 0, .04);
    59.   width: 400px;
    60. }
    61.  
    62. .login-container {
    63.   /*background: url(../assets/image/login2.jpg) no-repeat;*/
    64.   height: 100%;
    65.   width: 100%;
    66.   overflow: hidden;
    67.   background-size: cover;
    68. }
    69. </style>

    6.2处理后台请求返回工具类

    1. export const initTmpRoutes = (menus) => {
    2.     let tmpRoutes = []
    3.     menus.forEach(menu => {
    4.         let {id,title,icon,path,name,children} = menu
    5.         if(children instanceof Array){
    6.             children = initTmpRoutes(children)
    7.         }
    8.         let tmpRoute = {
    9.             path:path,
    10.             meta:{icon:icon,title:title},
    11.             name:name,
    12.             children:children,
    13.             component:children.length?{render(c){return c('router-view')}}:()=>import(`@/pages${path}/${name}.vue`)
    14.         }
    15.         console.log('tmpRoute',tmpRoute.path)
    16.         tmpRoutes.push(tmpRoute)
    17.     })
    18.     return tmpRoutes
    19. }
    20.  
    21. export const initRoutes = (menus)=>{
    22.     const homeRoute = {
    23.         path:'/home',
    24.         name:'Home',
    25.         meta:{title:'首页',icon: 'el-icon-star-off'},
    26.         component:() => import('@/pages/Home.vue'),
    27.     }
    28.     homeRoute.children = initTmpRoutes(menus);
    29.     console.log('homeRoute',homeRoute)
    30.     return homeRoute;
    31. }

    6.3首页、导航页和主页

    home.vue

    1. <template>
    2.   <div class="box">
    3.     <el-container style="height: 100%;" direction="vertial">
    4.       <el-aside width="200px">
    5.         <Nav/>
    6.       </el-aside>
    7.       <el-container>
    8.         <el-header class="homeHeader">
    9.           <el-dropdown class="userInfo" @command="handlecommand">
    10.        <span class="el-dropdown-link">
    11.        </span>
    12.             <el-dropdown-menu slot="dropdown">
    13.               <el-dropdown-item command="userInfo">个人中心</el-dropdown-item>
    14.               <el-dropdown-item command="setting">设置</el-dropdown-item>
    15.               <el-dropdown-item command="logout">退出</el-dropdown-item>
    16.             </el-dropdown-menu>
    17.           </el-dropdown>
    18.         </el-header>
    19.         <el-main>
    20.           <Main/>
    21.         </el-main>
    22.         <el-footer>底部</el-footer>
    23.       </el-container>
    24.     </el-container>
    25.   </div>
    26. </template>
    27.  
    28. <script>
    29. import Nav from "@/components/Nav";
    30. import Main from "@/components/Main";
    31. import RecursiveMenu from "@/components/RecursiveMenu";
    32. export default{
    33.   data(){
    34.     return {
    35.       user:JSON.parse(window.sessionStorage.getItem('user'))
    36.     }
    37.   },
    38.   components:{
    39.     Nav,
    40.     RecursiveMenu,
    41.     Main
    42.   },
    43.   methods:{
    44.     handlecommand(command){
    45.       if(command=='logout'){
    46.         this.$confirm('确定退出?', '提示', {
    47.           confirmButtonText: '确定',
    48.           cancelButtonText: '取消',
    49.           type: 'warning'
    50.         }).then(()=>{
    51.           logout();
    52.           window.sessionStorage.removeItem('user');
    53.           window.sessionStorage.removeItem('token');
    54.           this.$store.commit('initRoutes',[]);
    55.           this.$router.replace('/');
    56.         }).catch(()=>{
    57.  
    58.         })
    59.       }
    60.     }
    61.   },
    62. }
    63.  
    64. </script>
    65.  
    66. <style>
    67. #app,
    68. html,
    69. body,
    70. .box,
    71. .el-container{
    72.   padding: 0px;
    73.   margin: 0px;
    74.   height: 100%;
    75. }
    76. .el-header,
    77. .el-footer {
    78.   background-color: #B3C0D1;
    79.   color: #333;
    80.   text-align: right;
    81.   line-height: 60px;
    82. }
    83.  
    84. .el-aside {
    85.   background-color: #545C64;
    86.   color: #333;
    87.   text-align: center;
    88.   line-height: 300px;
    89. }
    90.  
    91. .el-main {
    92.   background-color: #E9EEF3;
    93.   color: #333;
    94.   display: flex;
    95.   flex-direction: column;
    96. }
    97.  
    98. body>.el-container {
    99.   margin-bottom: 40px;
    100. }
    101.  
    102. .homeHeader .userInfo{
    103.   cursor: pointer;
    104. }
    105.  
    106. .el-dropdown-link img{
    107.   width: 36px;
    108.   height: 36px;
    109.   border-radius: 18px;
    110. }
    111. </style>

    Nav.vue

    1. <template>
    2.   <el-menu router>
    3.     <template v-for="item in routes">
    4.       <el-submenu v-if="item.children.length" :index="item.path">
    5.         <template slot="title">{{ item.meta.title }}</template>
    6.         <recursive-menu :menu="item.children"></recursive-menu>
    7.       </el-submenu>
    8.       <el-menu-item v-else :index="item.path">{{ item.meta.title }}</el-menu-item>
    9.     </template>
    10.   </el-menu>
    11. </template>
    12.  
    13. <script>
    14. import RecursiveMenu from "@/components/RecursiveMenu";
    15. export default {
    16.   name: 'Nav',
    17.   components:{
    18.     RecursiveMenu
    19.   },
    20.   computed:{
    21.     routes(){
    22.       console.log('Nav routes:',this.$router.options.routes.length)
    23.       // return this.$router.options.routes[1].children;
    24.       return this.$router.options.routes;
    25.     }
    26.   }
    27. }
    28. </script>

    RecursiveMenu.vue

    1. <template>
    2.   <div>
    3.     <el-menu router>
    4.       <template v-for="item in menu">
    5.         <el-submenu v-if="item.children.length" :index="item.path">
    6.           <template slot="title">{{ item.meta.title }}</template>
    7.           <recursive-menu :menu="item.children"></recursive-menu>
    8.         </el-submenu>
    9.         <el-menu-item v-else :index="item.path">{{ item.meta.title }}</el-menu-item>
    10.       </template>
    11.     </el-menu>
    12.   </div>
    13.  
    14. </template>
    15.  
    16. <script>
    17. export default {
    18.   name: 'RecursiveMenu',
    19.   props: {
    20.     menu: {
    21.       type: Array,
    22.       required: true
    23.     },
    24.   },
    25.   components: {
    26.     RecursiveMenu: () => import('./RecursiveMenu.vue')
    27.   }
    28. }
    29. </script>

    可以看到左边的菜单和路由已经展示在浏览器中

    注意：这里有一个坑，页面刷新以后，路由中的数据就会丢失，系统菜单会不显示

    原因：页面刷新后，页面会重新实例化路由数据，因为是动态路由，所以页面刷新后会将router置为router/index.js配置的原始路由数据，所以匹配路由地址的时候会报错。

    解决方法

    思路：因为目前login接口返回的时候，直接将菜单数据传回前端，所以我们需要将菜单缓存起来，因为每次页面刷新vuex数据都会重置，所以不适合存储在vuex中，可以将菜单数据存储在sessionStorage中，页面刷新在实例化vue的created生命周期函数之前初始化路由即可

    步骤

    1）安装vuex

    npm install vuex@3

    2）修改登录页Login.vue

    1. <template>
    2.   <div class="login-container">
    3.     <el-form ref="form" :model="form" label-width="100px" class="login-form">
    4.       <h1 style="margin-bottom: 20px;text-align: center">欢迎登录</h1>
    5.       <el-form-item label="用户名">
    6.         <el-input v-model="form.username"></el-input>
    7.       </el-form-item>
    8.       <el-form-item label="密码">
    9.         <el-input type="password" v-model="form.password"></el-input>
    10.       </el-form-item>
    11.       <el-form-item>
    12.         <el-button type="primary" @click="onSubmit">登录</el-button>
    13.         <el-button>取消</el-button>
    14.       </el-form-item>
    15.     </el-form>
    16.   </div>
    17. </template>
    18. <script>
    19. import {initRoutes} from "@/utils/routesUtil";
    20. import {login,getUser} from "@/utils/http";
    21. export default {
    22.   name:'Login',
    23.   data() {
    24.     return {
    25.       form: {
    26.         username: '',
    27.         password: '',
    28.       }
    29.     }
    30.   },
    31.   methods: {
    32.     onSubmit() {
    33.       login(this.form).then(res=>{
    34.         if(res){
    35. 		  //将token和menus保存在vuex中
    36.           this.$store.dispatch("UPDATETOKEN",res.data.token);
    37.           this.$store.dispatch("UPDATEUSERDATA",res.data.menus)
    38.           //登录的时候，初始化菜单放在vuex中，不在登录页进行处理
    39.           this.$store.commit('INITROUTES',res.data.menus)
    40.           // 以下代码为注释
    41.           // let myRoutes = initRoutes(res.data.menus)
    42.           // this.$router.options.routes = [myRoutes]
    43.           // this.$router.addRoute(myRoutes)
    44.           this.$router.replace("/home")
    45.         }else{
    46.           return false
    47.         }
    48.       })
    49.     },
    50.   }
    51. }
    52. </script>
    53. <style scoped>
    54.  
    55. .login-form {
    56.   border: 1px #DCDFE6 solid;
    57.   border-radius: 4px;
    58.   padding: 40px;
    59.   margin: 110px 400px;
    60.   box-shadow: 0 2px 4px rgba(0, 0, 0, .12), 0 0 6px rgba(0, 0, 0, .04);
    61.   width: 400px;
    62. }
    63.  
    64. .login-container {
    65.   /*background: url(../assets/image/login2.jpg) no-repeat;*/
    66.   height: 100%;
    67.   width: 100%;
    68.   overflow: hidden;
    69.   background-size: cover;
    70. }
    71. </style>

    3）创建store文件夹，创建index.js

    1. import Vuex from 'vuex'
    2. import Vue from "vue";
    3. import {initRoutes} from "@/utils/routesUtil";
    4. import Router from "@/router";
    5. Vue.use(Vuex)
    6.  
    7. const state = {
    8.     token:window.sessionStorage.getItem('token')||'',
    9.     userData:window.sessionStorage.getItem('userData')||{},
    10.     routes:{}
    11. }
    12. const mutations = {
    13.     SETTOKEN(state,token){
    14.         window.sessionStorage.setItem('token',token)
    15.         state.token = token
    16.     },
    17.     SETUSERDATA(state,userData){
    18.         window.sessionStorage.setItem('userData',JSON.stringify(userData))
    19.         state.userData = userData
    20.     },
    21.     INITROUTES(state,menus){
    22.         let myRoutes = initRoutes(menus)
    23.         Router.options.routes = [myRoutes]
    24.         Router.addRoute(myRoutes);
    25.         state.routes = myRoutes
    26.     }
    27. }
    28.  
    29. const actions = {
    30.     UPDATETOKEN(context,value){
    31.         context.commit('SETTOKEN',value)
    32.     },
    33.     UPDATEUSERDATA(context,value){
    34.         context.commit('SETUSERDATA',value)
    35.     }
    36. }
    37.  
    38.  
    39. const getters = {
    40.     userinfo(state){
    41.         return state.userData
    42.     },
    43.     menus(state){
    44.         return state.userData.menus
    45.     },
    46.     routes(state){
    47.         return state.routes.filter(item => {
    48.             return item.name==='Home'
    49.         })[0].children
    50.     }
    51. }
    52.  
    53. export default new Vuex.Store({
    54.     state,
    55.     mutations,
    56.     actions,
    57.     getters
    58. })

    4）main.js修改

    1. import Vue from 'vue'
    2. import App from './App.vue'
    3. import ElementUI from 'element-ui'
    4. import router from './router'
    5. import 'element-ui/lib/theme-chalk/index.css'
    6. import store from "@/store"
    7.  
    8. Vue.config.productionTip = false
    9. Vue.use(ElementUI)
    10.  
    11. //生成路由，由于没有获取菜单接口，所以直接从sessionStorage中直接去userData数据，进行路由的初始化
    12. const init = async ()=>{
    13.   if (sessionStorage.getItem('token')){
    14.     if (store.state.routes){
    15.       await store.commit('INITROUTES',JSON.parse(sessionStorage.getItem('userData')))
    16.     }
    17.   }
    18. }
    19.  
    20. //此处await不可缺少，需要等待路由数据先生成，才能进行vue实例的创建，否则会报错
    21. async function call(){
    22.   await init();
    23.   new Vue({
    24.     render: h => h(App),
    25.     router,
    26.     store
    27.   }).$mount('#app')
    28. }
    29. call()

    5）如果未登录，则跳转到login页处理，main.js添加如下内容

    1. //路由导航守卫，每次路由地址改变前出发
    2. router.beforeEach((to,from,next)=>{
    3.   if (sessionStorage.getItem('token')) {
    4.     next();
    5.   } else {
    6.     //如果是登录页面路径，就直接next()
    7.     if (to.path === '/login') {
    8.       next();
    9.     } else {
    10.       if(to.path === '/home'){
    11.         next();
    12.       }
    13.       next('/login');
    14.     }
    15.   }
    16. })

    安装e-icon-picker选择器

     

  • 相关阅读:
    线性二分类的实现
    2020年全国职业院校技能大赛改革试点赛样卷三
    Linux chmod命令——修改权限信息
    【数据结构】单链表基本操作的实现
    Javascript 基础知识学习
    23个react常见问题
    chrome调试秘籍，让你的开发速度飞起来
    Docker安装入门教程
    抛砖系列之redis监控命令
    mybatispuls 批处理 rewriteBatchedStatements=true
  • 原文地址：https://blog.csdn.net/weixin_44846436/article/details/130910626