Spring boot整合shiro+jwt实现前后端分离

本文实例为大家分享了Spring boot整合shiro+jwt实现前后端分离的具体代码,供大家参考,具体内容如下

这里内容很少很多都为贴的代码,具体内容我经过了看源码和帖子加了注释。帖子就没用太多的内容

先下载shiro和jwt的jar包

<!-- shiro包 -->
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-spring</artifactId>
  <version>1.4.0</version>
</dependency>
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-ehcache</artifactId>
  <version>1.4.0</version>
</dependency>
<!--JWT依赖-->
<!--JWT-->
<dependency>
  <groupId>com.auth0</groupId>
  <artifactId>java-jwt</artifactId>
  <version>3.4.0</version>
</dependency>
<!--JJWT-->
<dependency>
   <groupId>io.jsonwebtoken</groupId>
   <artifactId>jjwt</artifactId>
   <version>0.9.0</version>
</dependency>

创建shiro的自定义的Realm

代码如下:

package com.serverprovider.config.shiro.userRealm;

import com.spring.common.auto.autoUser.AutoUserModel;
import com.spring.common.auto.autoUser.extend.AutoModelExtend;
import com.serverprovider.config.shiro.jwt.JWTCredentialsMatcher;
import com.serverprovider.config.shiro.jwt.JwtToken;
import com.serverprovider.service.loginService.LoginServiceImpl;
import com.util.Redis.RedisUtil;
import com.util.ReturnUtil.SecretKey;
import com.util.encryption.JWTDecodeUtil;
import io.jsonwebtoken.Claims;
import org.apache.log4j.Logger;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class UserRealm extends AuthorizingRealm {

  private Logger logger = Logger.getLogger(UserRealm.class);

  @Autowired private LoginServiceImpl loginService;

  public UserRealm(){
    //这里使用我们自定义的Matcher验证接口
    this.setCredentialsMatcher(new JWTCredentialsMatcher());
  }

  /**
   * 必须重写此方法,不然Shiro会报错
   */
  @Override
  public boolean supports(AuthenticationToken token) {
    return token instanceof JwtToken;
  }

  /**
   * shiro 身份验证
   * @param token
   * @return boolean
   * @throws AuthenticationException 抛出的异常将有统一的异常处理返回给前端
   *
   */
  @Override
  protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)throws AuthenticationException {
    /**
     * AuthenticationToken
     * JwtToken重写了AuthenticationToken接口 并创建了一个接口token的变量
     *  因为在filter我们将token存入了JwtToken的token变量中
     *  所以这里直接getToken()就可以获取前端传递的token值
     */
      String JWTtoken = ((JwtToken) token).getToken();
    /**
     * Claims对象它最终是一个JSON格式的对象,任何值都可以添加到其中
     * token解密 转换成Claims对象
     */
       Claims claims = JWTDecodeUtil.parseJWT(JWTtoken, SecretKey.JWTKey);

    /**
     *  根据JwtUtil加密方法加入的参数获取数据
     *  查询数据库获得对象
     *  如为空:抛出异常
     *  如验证失败抛出 AuthorizationException
     */
      String username = claims.getSubject();
      String password = (String) claims.get("password");
      AutoModelExtend principal = loginService.selectLoginModel(username,password);
      return new SimpleAuthenticationInfo(principal, JWTtoken,"userRealm");
  }

  @Override
  protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
    SimpleAuthorizationInfo info = null;
    /**
     * PrincipalCollection对象
     * 文档里面描述:返回从指定的Realm 仅作为Collection 返回的单个Subject的对象,如果没有来自该领域的任何对象,则返回空的Collection。
     * 在登录接口放入权限注解返回的错误信息:Subject.login(AuthenticationToken)或SecurityManager启用'Remember Me'功能后成功自动获取这些标识主体
     * 当调用Subject.login()方法成功后 PrincipalCollection会自动获得该对象 如没有认证过或认证失败则返回空的Collection并抛出异常
     * getPrimaryPrincipal():返回在应用程序范围内使用的主要对象,以唯一标识拥有帐户。
     */
    Object principal = principals.getPrimaryPrincipal();
    /**
     * 得到身份对象
     * 查询该用户的权限信息
     */
    AutoUserModel user = (AutoUserModel) principal;
    List<String> roleModels = loginService.selectRoleDetails(user.getId());
    try {
    /**
     * 创建一个Set,来放置用户拥有的权限
     * 创建 SimpleAuthorizationInfo, 并将办好权限列表的Set放入.
     */
    Set<String> rolesSet = new HashSet();
    for (String role : roleModels) {
      rolesSet.add(role);
    }
    info = new SimpleAuthorizationInfo();
    info.setStringPermissions(rolesSet);  // 放入权限信息
  }catch (Exception e){
    throw new AuthenticationException("授权失败!");
  }
    return info;
  }
}

这个授权方法遇到的坑比较少,就是在最终验证的时候网上很照抄过来的帖子一点都没有验证就粘贴赋值,在这里严重吐槽。

在使用jwt最为token而取消shiro传统的session时候,我们的需要重写shiro的验证接口   CredentialsMatcher,在 自定义的realm

中我们加入我们重写的验证方法,在调用SimpleAuthenticationInfo()方法进行验证的时候,shiro就会使用重写的验证接口。

此处为大坑。

贴上代码如下:

import com.spring.common.auto.autoUser.extend.AutoModelExtend;
import org.apache.log4j.Logger;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.credential.CredentialsMatcher;

/**
 * CredentialsMatcher
 * 接口由类实现,该类可以确定是否提供了AuthenticationToken凭证与系统中存储的相应帐户的凭证相匹配。
 * Shiro 加密匹配 重写匹配方法CredentialsMatcher 使用JWTUtil 匹配方式
 */
public class JWTCredentialsMatcher implements CredentialsMatcher {

  private Logger logger = Logger.getLogger(JWTCredentialsMatcher.class);

  /**
   * Matcher中直接调用工具包中的verify方法即可
   */
  @Override
  public boolean doCredentialsMatch(AuthenticationToken authenticationToken, AuthenticationInfo authenticationInfo) {
    String token = (String) ((JwtToken)authenticationToken).getToken();
    AutoModelExtend user = (AutoModelExtend)authenticationInfo.getPrincipals().getPrimaryPrincipal();
    //得到DefaultJwtParser
    Boolean verify = JwtUtil.isVerify(token, user);
    logger.info("JWT密码效验结果="+verify);
    return verify;
  }
}

shiro的配置项  ShiroConfiguration代码如下:

import com.serverprovider.config.shiro.shiroSysFile.JwtFilter;
import com.serverprovider.config.shiro.userRealm.UserRealm;
import org.apache.log4j.Logger;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.mgt.SessionStorageEvaluator;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.mgt.DefaultWebSessionStorageEvaluator;

import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;
import java.util.*;

@Configuration
public class ShiroConfiguration {

  private Logger logger = Logger.getLogger(ShiroConfiguration.class);

  @Bean("shiroFilter")
  public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    shiroFilterFactoryBean.setSecurityManager(securityManager);
    //拦截器
    Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
    // 配置不会被拦截的链接 顺序判断
    filterChainDefinitionMap.put("/login/**", "anon");
    // 添加自己的过滤器并且取名为jwt
    Map<String, Filter> filterMap = new HashMap<String, Filter>();
    filterMap.put("jwt", new JwtFilter());
    shiroFilterFactoryBean.setFilters(filterMap);
    //<!-- 过滤链定义,从上向下顺序执行,一般将/**放在最为下边
    filterChainDefinitionMap.put("/**", "jwt");
    shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

    return shiroFilterFactoryBean;
  }

  /**
   * 禁用session, 不保存用户登录状态。保证每次请求都重新认证。
   * 需要注意的是,如果用户代码里调用Subject.getSession()还是可以用session
   */
  @Bean
  protected SessionStorageEvaluator sessionStorageEvaluator(){
    DefaultWebSessionStorageEvaluator sessionStorageEvaluator = new DefaultWebSessionStorageEvaluator();
    sessionStorageEvaluator.setSessionStorageEnabled(false);
    return sessionStorageEvaluator;
  }

  @Bean("securityManager")
  public SecurityManager securityManager(UserRealm userRealm) {
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    securityManager.setRealm(userRealm);
    /*
     * 关闭shiro自带的session,详情见文档
     * http://shiro.apache.org/session-management.html#SessionManagement-StatelessApplications%28Sessionless%29
     */
    DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
    DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
    defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
    subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
    securityManager.setSubjectDAO(subjectDAO);

    return securityManager;
  }
  /**
   * 创建自定义的UserRealm @bean
   */
  @Bean("userRealm")
  public UserRealm shiroRealm() {
    UserRealm shiroRealm = new UserRealm();
    return shiroRealm;
  }

  //自动创建代理,没有这个鉴权可能会出错
  @Bean
  public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
    DefaultAdvisorAutoProxyCreator autoProxyCreator = new DefaultAdvisorAutoProxyCreator();
    autoProxyCreator.setProxyTargetClass(true);
    return autoProxyCreator;
  }
  /**
   * 开启shiro aop注解支持.
   * 使用代理方式;所以需要开启代码支持;
   *
   * @param
   * @return
   */
  @Bean
  public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
    AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
    authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
    return authorizationAttributeSourceAdvisor;
  }

到这里shiro配置就全部完成了

下面开始配置jwt:

首先我们需要重写  AuthenticationToken接口 此接口的作用

负责把shiro中username,password生成用于验证的token的封装类

所有我们需要去实现这个接口,封装我们自己生成的JWT生成的token

import org.apache.shiro.authc.AuthenticationToken;

/**
 * AuthenticationToken: shiro中负责把username,password生成用于验证的token的封装类
 * 我们需要自定义一个对象用来包装token。
 */
public class JwtToken implements AuthenticationToken {

  private String token;

  public JwtToken(String token) {
    this.token = token;
  }

  public String getToken() {
    return token;
  }

  public void setToken(String token) {
    this.token = token;
  }

  @Override
  public Object getPrincipal() {
    return null;
  }

  @Override
  public Object getCredentials() {
    return null;
  }
}

因为我们是前后端分离项目所有我们不存在session验证之类的 所有每次请求都需要携带token,所以每次请求我们都需要去验证token的真实性,所有我们需要去实现  BasicHttpAuthenticationFilter过滤器

BasicHttpAuthenticationFilter继承 AuthenticatingFilter 过滤器其能够自动地进行基于所述传入请求的认证尝试。此实现是每个基本HTTP身份验证规范的Java实现  , 通过此过滤器得到HTTP请求资源获取Authorization传递过来的token参数   获取subject对象进行身份验证

代码如下:

import com.alibaba.fastjson.JSONObject;
import com.serverprovider.config.shiro.jwt.JwtToken;
import com.util.Util.utilTime;
import org.apache.log4j.Logger;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestMethod;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.TimeUnit;

/**
 *
 * BasicHttpAuthenticationFilter继承 AuthenticatingFilter 过滤器
 * 其能够自动地进行基于所述传入请求的认证尝试。
 *    BasicHttpAuthenticationFilter 基本访问认证过滤器
 *   此实现是每个基本HTTP身份验证规范的Java实现
 *   通过此过滤器得到HTTP请求资源获取Authorization传递过来的token参数
 *   获取subject对象进行身份验证
 *
 *
 */
public class JwtFilter extends BasicHttpAuthenticationFilter {

  Logger logger = Logger.getLogger(JwtFilter.class);

  /**
   * 应用的HTTP方法列表配置基本身份验证筛选器。
   * 获取 request 请求 拒绝拦截登录请求
   * 执行登录认证方法
   *
   * @param request
   * @param response
   * @param mappedValue
   * @return
   */
  @Override
  protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
    HttpServletRequest httpServletRequest = (HttpServletRequest) request;
    String requestURI = httpServletRequest.getRequestURI();
    if (requestURI.equals("/user/login/verifyUser") || requestURI.equals("/user/register")) {
      return true;
    } else {
      try {
        executeLogin(request, response);
        return true;
      } catch (Exception e) {
        e.printStackTrace();
        return false;
      }
    }
  }

  /**
   * Authorization携带的参数为token
   * JwtToken实现了AuthenticationToken接口封装了token参数
   * 通过getSubject方法获取 subject对象
   * login()发送身份验证
   *
   * 为什么需要在Filter中调用login,不能在controller中调用login?
   * 由于Shiro默认的验证方式是基于session的,在基于token验证的方式中,不能依赖session做为登录的判断依据.
   * @param request
   * @param response
   */
  @Override
  protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
    HttpServletResponse httpServletResponse = (HttpServletResponse) response;
    try{
      HttpServletRequest httpServletRequest = (HttpServletRequest) request;
      String token = httpServletRequest.getHeader("Authorization");
      JwtToken jwtToken = new JwtToken(token);
      // 提交给realm进行登入,如果错误他会抛出异常并被捕获
      Subject subject = getSubject(request, response);
      subject.login(jwtToken);
      logger.info("JWT验证用户信息成功");
      // 如果没有抛出异常则代表登入成功,返回true
      return true;
      }catch (Exception e){
      /* *
       * 这个问题纠结了好久
       *   原生的shiro验证失败会进入全局异常 但是 和JWT结合以后却不进入了 之前一直想不通
       *   原因是 JWT直接在过滤器里验证 验证成功与否 都是直接返回到过滤器中 成功在进入controller
       *   失败直接返回进入springboot自定义异常处理页面
       */
      JSONObject responseJSONObject = new JSONObject();
      responseJSONObject.put("result","401");
      responseJSONObject.put("resultCode","token无效,请重新获取。");
      responseJSONObject.put("resultData","null");
      responseJSONObject.put("resultTime", utilTime.StringDate());
      PrintWriter out = null;
      httpServletResponse.setCharacterEncoding("UTF-8");
      httpServletResponse.setContentType("application/json; charset=utf-8");
      logger.info("返回是");
      logger.info(responseJSONObject.toString());
      out = httpServletResponse.getWriter();
      out.append(responseJSONObject.toString());
    }
  return false;
  }

  /**
   * 对跨域提供支持
   */
  @Override
  protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
    HttpServletRequest httpServletRequest = (HttpServletRequest) request;
    HttpServletResponse httpServletResponse = (HttpServletResponse) response;
    httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
    httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
    httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
    // 跨域时会首先发送一个option请求,这里我们给option请求直接返回正常状态
    if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
      httpServletResponse.setStatus(HttpStatus.OK.value());
      return false;
    }
    return super.preHandle(request, response);
  }

}

贴上 加密解密校验的工具类

import com.spring.common.auto.autoUser.extend.AutoModelExtend;
import com.util.ReturnUtil.SecretKey;
import io.jsonwebtoken.*;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;;

/* @author hw
 * @create 2019-04-16 10.12
 * @desc JWT工具类
 **/

public class JwtUtil {

  /**
   * 用户登录成功后生成Jwt
   * 使用Hs256算法 私匙使用用户密码
   *
   * @param ttlMillis jwt过期时间
   * @param user   登录成功的user对象
   * @return
   */
  public static String createJWT(long ttlMillis, AutoModelExtend user) {
    //指定签名的时候使用的签名算法,也就是header那部分,jjwt已经将这部分内容封装好了。
    SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
    //生成JWT的时间
    long nowMillis = System.currentTimeMillis();
    Date now = new Date(nowMillis);

    //创建payload的私有声明(根据特定的业务需要添加,如果要拿这个做验证,一般是需要和jwt的接收方提前沟通好验证方式的)
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("id", user.getId());
    map.put("username", user.getAuto_username());
    map.put("password", user.getAuto_password());

    //生成签名的时候使用的秘钥secret,这个方法本地封装了的,一般可以从本地配置文件中读取,
    // 切记这个秘钥不能外露哦。它就是你服务端的私钥,在任何场景都不应该流露出去。一旦客户端得知这个secret, 那就意味着客户端是可以自我签发jwt了。
    String key = SecretKey.JWTKey;
    //生成签发人
    String subject = user.getAuto_username();

    //下面就是在为payload添加各种标准声明和私有声明了
    //这里其实就是new一个JwtBuilder,设置jwt的body
    JwtBuilder builder = Jwts.builder()
        //如果有私有声明,一定要先设置这个自己创建的私有的声明,这个是给builder的claim赋值,一旦写在标准的声明赋值之后,就是覆盖了那些标准的声明的
        .setClaims(map)
        //设置jti(JWT ID):是JWT的唯一标识,根据业务需要,这个可以设置为一个不重复的值,主要用来作为一次性token,从而回避重放攻击。
        .setId(UUID.randomUUID().toString())
        //iat: jwt的签发时间
        .setIssuedAt(now)
        //代表这个JWT的主体,即它的所有人,这个是一个json格式的字符串,可以存放什么userid,roldid之类的,作为什么用户的唯一标志。
        .setSubject(subject)
        //设置签名使用的签名算法和签名使用的秘钥
        .signWith(signatureAlgorithm, key);
    if (ttlMillis >= 0) {
      long expMillis = nowMillis + ttlMillis;
      Date exp = new Date(expMillis);
      //设置过期时间
      builder.setExpiration(exp);
    }
    return builder.compact();
  }

  /**
   * 校验token
   * 在这里可以使用官方的校验,我这里校验的是token中携带的密码于数据库一致的话就校验通过
   *
   * @param token
   * @return
   */
  public static Boolean isVerify(String token, AutoModelExtend userModelExtend) {
    try {
      //得到DefaultJwtParser
      Claims claims = Jwts.parser()
          //设置签名的秘钥
          .setSigningKey(SecretKey.JWTKey)
          //设置需要解析的jwt
          .parseClaimsJws(token).getBody();

      if (claims.get("password").equals(userModelExtend.getAuto_password())) {
        return true;
      }
    } catch (Exception exception) {
      return false;
    }
    return null;

  }
 /**
   * Token的解密
   * @param token 加密后的token
   * @param secret 签名秘钥,和生成的签名的秘钥一模一样
   * @return
   */
  public static Claims parseJWT(String token, String secret) {
    //得到DefaultJwtParser
    Claims claims = Jwts.parser()
        //设置签名的秘钥
        .setSigningKey(secret)
        //设置需要解析的jwt
        .parseClaimsJws(token).getBody();
    return claims;
  }
}

到这里shiro jwt整合就完成了。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • SpringBoot + Shiro前后端分离权限

    shiro 验证通过后的信息保存在session 中,而ajax 每次传的都是不同的sessionid ,所以主要的区别就是需要修改shiro获取sessionid的方式.这里使用的是登录后将后台的sessionid 传到前端然后存放到 cookie(这个存放的地方视情况而定),然后每次请求后端时在Header中携带此信息,这里起名为Authorization shiro 中 默认获取Sessionid的类是 DefaultWebSessionManager 所以需要重写此类 import or

  • Shiro+Cas微服务化及前后端完全分离

    本文实例为大家分享了Shiro Cas微服务化及前后端完全分离,供大家参考,具体内容如下 shiro+cas微服务化笔记 1.Spring Boot 配置 有如下两个配置文件:ShiroBaseConfig.java import lombok.extern.log4j.Log4j; import org.apache.shiro.cache.CacheManager; import org.apache.shiro.cache.MemoryConstrainedCacheManager; im

  • shiro整合springboot前后端分离

    本文实例为大家分享了shiro整合springboot前后端分离的具体代码,供大家参考,具体内容如下 1.shiro整合springboot的配置 package com.hisi.config; import java.util.LinkedHashMap; import java.util.Map; import javax.servlet.Filter; import org.apache.shiro.session.mgt.eis.MemorySessionDAO; import org

  • Spring boot整合shiro+jwt实现前后端分离

    本文实例为大家分享了Spring boot整合shiro+jwt实现前后端分离的具体代码,供大家参考,具体内容如下 这里内容很少很多都为贴的代码,具体内容我经过了看源码和帖子加了注释.帖子就没用太多的内容 先下载shiro和jwt的jar包 <!-- shiro包 --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId

  • Spring Boot 整合 Shiro+Thymeleaf过程解析

    这篇文章主要介绍了Spring Boot 整合 Shiro+Thymeleaf过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.导包 <!-- springboot 与 shiro 的集成--> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <

  • spring boot整合shiro安全框架过程解析

    这篇文章主要介绍了spring boot整合shiro安全框架过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 题记:在学习了springboot和thymeleaf之后,想完成一个项目练练手,于是使用springboot+mybatis和thymeleaf完成一个博客系统,在完成的过程中出现的一些问题,将这些问题记录下来,作为自己的学习心得.在这先感谢群主TyCoding的Tumo项目,虽然本人实在太菜了,好些地方看不懂,但还是使我受益

  • Spring Boot2开发之Spring Boot整合Shiro两种详细方法

    在 Spring Boot 中做权限管理,一般来说,主流的方案是 Spring Security ,但是,仅仅从技术角度来说,也可以使用 Shiro. Spring Security 和 Shiro 的比较: Spring Security 是一个重量级的安全管理框架:Shiro 则是一个轻量级的安全管理框架 Spring Security 概念复杂,配置繁琐:Shiro 概念简单.配置简单 Spring Security 功能强大:Shiro 功能简单 等等 虽然 Shiro 功能简单,但是也

  • SpringBoot+Vue+JWT的前后端分离登录认证详细步骤

    前后端分离的概念在现在很火,最近也学习了一下前后端分离的登录认证. 创建后端springboot工程 这个很简单了,按照idea的一步一步创建就行 文件目录结构: pom文件依赖导入. <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </

  • SpringSecurity+JWT实现前后端分离的使用详解

    创建一个配置类 SecurityConfig 继承 WebSecurityConfigurerAdapter package top.ryzeyang.demo.common.config; import org.springframework.context.annotation.Bean; import org.springframework.security.access.hierarchicalroles.RoleHierarchy; import org.springframework

  • spring boot整合Shiro实现单点登录的示例代码

    Shiro是什么 Shiro是一个Java平台的开源权限框架,用于认证和访问授权.具体来说,满足对如下元素的支持: 用户,角色,权限(仅仅是操作权限,数据权限必须与业务需求紧密结合),资源(url). 用户分配角色,角色定义权限. 访问授权时支持角色或者权限,并且支持多级的权限定义. Q:对组的支持? A:shiro默认不支持对组设置权限. Q:是否可以满足对组进行角色分配的需求? A:扩展Realm,可以支持对组进行分配角色,其实就是给该组下的所有用户分配权限. Q:对数据权限的支持? 在业务

  • Spring Boot 集成JWT实现前后端认证的示例代码

    目录 前言 JWT简介 为什么要用JWT 传统session认证存在那些弊端? JWT认证的优势 JWT的数据结构 Header Payload Signature Spring Boot集成JWT 引入Jwt包 编写jwt工具类 Token认证拦截器 配置拦击器 登录验证流程 示例代码 总结 前言 小程序.H5应用的快速发展,使得前后端分离已经成为了趋势,然而系统认证却是系统的重要一部分,本文将讲解JWT如何实现前后端认证. JWT简介 JWT(全称:Json Web Token)是一个开放标

  • spring boot+vue 的前后端分离与合并方案实例详解

    springboot和vue结合的方案网络上的主要有以下两种: 1. [不推荐]在html中直接使用script标签引入vue和一些常用的组件,这种方式和以前传统的开发是一样的,只是可以很爽的使用vue的双向数据绑定,这种方式只适合于普通的全栈开发. 2.[推荐]使用vue官方的脚手架创建单独的前端工程项目,做到和后端完全独立开发和部署,后端单独部署一个纯restful的服务,而前端直接采用nginx来部署,这种称为完全的前后端分离架构开发模式,但是在分离中有很多api权限的问题需要解决,包括部

随机推荐