Shiro （Shiro + JWT + SpringBoot應用）

1.Shiro的簡介

2.Shiro + JWT + SpringBoot

1.導入依賴

2.配置JWT

3.配置Shiro

4.實作JWTToken

5.實作Realm

6.重寫Filter

ShiroConfig

8.登陸

9.@RequiresPermissions

Apache Shiro是一種功能強大且易于使用的Java安全架構，它執行身份驗證，授權，加密和會話管理，可用于保護從指令行應用程式，移動應用程式到Web和企業應用程式等應用的安全。

Authentication 身份認證/登入，驗證使用者是不是擁有相應的身份；

Authorization 授權，即權限驗證，驗證某個已認證的使用者是否擁有某個權限；即判斷使用者是否能做事情，常見的如：驗證某個使用者是否擁有某個角色。或者細粒度的驗證某個使用者對某個資源是否具有某個權限；

Cryptography 安全資料加密，保護資料的安全性，如密碼加密存儲到資料庫，而不是明文存儲；

Session Management 會話管理，即使用者登入後就是一次會話，在沒有退出之前，它的所有資訊都在會話中；

Web Integration web系統內建

Interations 內建其它應用，spring、緩存架構

從應用程式角度的來觀察如何使用Shiro完成工作：

Subject：主體，代表了目前“使用者”，這個使用者不一定是一個具體的人，與目前應用互動的任何東西都是Subject，如網絡爬蟲，機器人等；即一個抽象概念；所有Subject都綁定到SecurityManager，與Subject的所有互動都會委托給SecurityManager；可以把Subject認為是一個門面；SecurityManager才是實際的執行者；

SecurityManager：安全管理器；即所有與安全有關的操作都會與SecurityManager互動；且它管理着所有Subject；可以看出它是Shiro的核心，它負責與後邊介紹的其他元件進行互動，如果學習過SpringMVC，你可以把它看成DispatcherServlet前端控制器；

Realm：域，Shiro從從Realm擷取安全資料（如使用者、角色、權限），就是說SecurityManager要驗證使用者身份，那麼它需要從Realm擷取相應的使用者進行比較以确定使用者身份是否合法；也需要從Realm得到使用者相應的角色/權限進行驗證使用者是否能進行操作；可以把Realm看成DataSource，即安全資料源。

也就是說對于我們而言，最簡單的一個Shiro應用：

1、應用代碼通過Subject來進行認證和授權，而Subject又委托給SecurityManager；

2、我們需要給Shiro的SecurityManager注入Realm，進而讓SecurityManager能得到合法的使用者及其權限進行判斷。

<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.4.1</version>

<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.8.2</version>

public class JWTUtil {

/**
 * 校驗 token是否正确
 *
 * @param token  密鑰
 * @param secret 使用者的密碼
 * @return 是否正确
 */
public static boolean verify(String token, String username, String secret) {
    try {
        Algorithm algorithm = Algorithm.HMAC256(secret);
        JWTVerifier verifier = JWT.require(algorithm)
                .withClaim("username", username)
                .build();
        verifier.verify(token);
        return true;
    } catch (Exception e) {
        log.info("token is invalid{}", e.getMessage());
        return false;
    }
}

public static String getUsername(HttpServletRequest request) {
    // 取token
    String token = request.getHeader("Authorization");
    return getUsername(UofferUtil.decryptToken(token));
}
/**
 * 從 token中擷取使用者名
 * @return token中包含的使用者名
 */
public static String getUsername(String token) {
    try {
        DecodedJWT jwt = JWT.decode(token);
        return jwt.getClaim("username").asString();
    } catch (JWTDecodeException e) {
        log.error("error：{}", e.getMessage());
        return null;
    }
}

public static Integer getUserId(HttpServletRequest request) {
    // 取token
    String token = request.getHeader("Authorization");
    return getUserId(UofferUtil.decryptToken(token));
}
/**
 * 從 token中擷取使用者ID
 * @return token中包含的ID
 */
public static Integer getUserId(String token) {
    try {
        DecodedJWT jwt = JWT.decode(token);
        return Integer.valueOf(jwt.getSubject());
    } catch (JWTDecodeException e) {
        log.error("error：{}", e.getMessage());
        return null;
    }
}

/**
 * 生成 token
 * @param username 使用者名
 * @param secret   使用者的密碼
 * @return token 加密的token
 */
public static String sign(String username, String secret, Integer userId) {
    try {
        Map<String, Object> map = new HashMap<>();
        map.put("alg", "HS256");
        map.put("typ", "JWT");
        username = StringUtils.lowerCase(username);
        Algorithm algorithm = Algorithm.HMAC256(secret);
        return JWT.create()
                .withHeader(map)
                .withClaim("username", username)
                .withSubject(String.valueOf(userId))
                .withIssuedAt(new Date())

// .withExpiresAt(date)

.sign(algorithm);
    } catch (Exception e) {
        log.error("error：{}", e);
        return null;
    }
}

}

token自己已經包含了使用者名等資訊。

@Data

public class JWTToken implements AuthenticationToken {

private static final long serialVersionUID = 1282057025599826155L;

private String token;

private String exipreAt;

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

public JWTToken(String token, String exipreAt) {
    this.token = token;
    this.exipreAt = exipreAt;
}

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

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

自定義實作 ShiroRealm，包含認證和授權兩大子產品。

public class ShiroRealm extends AuthorizingRealm {

@Resource
private RedisUtil redisUtil;

@Autowired
private ISysUserService userService;

@Autowired
private ISysRoleService roleService;

@Autowired
private ISysMenuService menuService;

// 必須重寫此方法，不然Shiro會報錯
@Override
public boolean supports(AuthenticationToken token) {
    return token instanceof JWTToken;
}

/**
 * 隻有當需要檢測使用者權限的時候才會調用此方法
 * 授權子產品，擷取使用者角色和權限。
 * @param token token
 * @return AuthorizationInfo 權限資訊
 */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection token) {
    Integer userId = JWTUtil.getUserId(token.toString());

    SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();

    // 擷取使用者角色集
    Set<String> roleSet = roleService.selectRolePermissionByUserId(userId);
    simpleAuthorizationInfo.setRoles(roleSet);

    // 擷取使用者權限集
    Set<String> permissionSet = menuService.findUserPermissionsByUserId(userId);
    simpleAuthorizationInfo.setStringPermissions(permissionSet);
    return simpleAuthorizationInfo;
}

/**
 * 使用者認證:編寫shiro判斷邏輯，進行使用者認證
 * @param authenticationToken 身份認證 token
 * @return AuthenticationInfo 身份認證資訊
 * @throws AuthenticationException 認證相關異常
 */
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    // 這裡的 token是從 JWTFilter 的 executeLogin 方法傳遞過來的，已經經過了解密
    String token = (String) authenticationToken.getCredentials();
    String encryptToken = UofferUtil.encryptToken(token); //加密token
    String username = JWTUtil.getUsername(token); //從token中擷取username
    Integer userId = JWTUtil.getUserId(token);    //從token中擷取userId

    // 通過redis檢視token是否過期
    HttpServletRequest request = HttpContextUtil.getHttpServletRequest();
    String ip = IPUtil.getIpAddr(request);
    String encryptTokenInRedis = redisUtil.get(Constant.RM_TOKEN_CACHE + encryptToken + StringPool.UNDERSCORE + ip);
    if (!token.equalsIgnoreCase(UofferUtil.decryptToken(encryptTokenInRedis))) {
        throw new AuthenticationException("token已經過期");
    }

    // 如果找不到，說明已經失效
    if (StringUtils.isBlank(encryptTokenInRedis)) {
        throw new AuthenticationException("token已經過期");
    }

    if (StringUtils.isBlank(username)) {
        throw new AuthenticationException("token校驗不通過");
    }

    // 通過使用者id查詢使用者資訊
    SysUser user = userService.getById(userId);

    if (user == null) {
        throw new AuthenticationException("使用者名或密碼錯誤");
    }
    if (!JWTUtil.verify(token, username, user.getPassword())) {
        throw new AuthenticationException("token校驗不通過");
    }
    return new SimpleAuthenticationInfo(token, token, "febs_shiro_realm");
}

所有的請求都會先經過 Filter，是以我們繼承官方的 BasicHttpAuthenticationFilter ，并且重寫鑒權的方法。

代碼的執行流程 preHandle -> isAccessAllowed -> isLoginAttempt -> executeLogin 。

@Slf4j

public class JWTFilter extends BasicHttpAuthenticationFilter {

private static final String TOKEN = "Authorization";

private AntPathMatcher pathMatcher = new AntPathMatcher();

/**
 * 對跨域提供支援
 */
@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);
}

@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws UnauthorizedException {
    HttpServletRequest httpServletRequest = (HttpServletRequest) request;
    UofferProperties UofferProperties = SpringContextUtil.getBean(UofferProperties.class);
    // 擷取免認證接口 url 
    // 在application.yml中配置/adminApi/auth/doLogin/**,/adminApi/auth/register/**, ...
    String[] anonUrl = StringUtils.splitByWholeSeparatorPreserveAllTokens(UofferProperties.getShiro().getAnonUrl(), ",");

    boolean match = false;
    for (String u : anonUrl) {
        if (pathMatcher.match(u, httpServletRequest.getRequestURI())) {
            match = true;
        }
    }
    if (match) {
        return true;
    }
    if (isLoginAttempt(request, response)) {
        return executeLogin(request, response);
    }
    return false;
}

/**
 * 判斷使用者是否想要登入。
 * 檢測header裡面是否包含Authorization字段即可
 */
@Override
protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
    HttpServletRequest req = (HttpServletRequest) request;
    String token = req.getHeader(TOKEN);
    return token != null;
}

@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) {
    HttpServletRequest httpServletRequest = (HttpServletRequest) request;
    String token = httpServletRequest.getHeader(TOKEN); //得到token
    JWTToken jwtToken = new JWTToken(UofferUtil.decryptToken(token)); // 解密token
    try {
        // 送出給realm進行登入，如果錯誤他會抛出異常并被捕獲
        getSubject(request, response).login(jwtToken);
        // 如果沒有抛出異常則代表登入成功，傳回true
        return true;
    } catch (Exception e) {
        log.error(e.getMessage());
        return false;
    }
}

@Override
protected boolean sendChallenge(ServletRequest request, ServletResponse response) {
    log.debug("Authentication required: sending 401 Authentication challenge response.");
    HttpServletResponse httpResponse = WebUtils.toHttp(response);

// httpResponse.setStatus(HttpStatus.UNAUTHORIZED.value());

httpResponse.setCharacterEncoding("utf-8");
    httpResponse.setContentType("application/json; charset=utf-8");
    final String message = "未認證，請在前端系統進行認證";
    final Integer status = 401;
    try (PrintWriter out = httpResponse.getWriter()) {

// String responseJson = "{"message":"" + message + ""}";

JSONObject responseJson = new JSONObject();
        responseJson.put("msg", message);
        responseJson.put("status", status);
        out.print(responseJson);
    } catch (IOException e) {
        log.error("sendChallenge error：", e);
    }
    return false;
}

@Configuration

public class ShiroConfig {

@Bean
public ShiroRealm shiroRealm() {
    // 配置 Realm
    return new ShiroRealm();
}

// 建立DefaultWebSecurityManager
@Bean("securityManager")
public SecurityManager securityManager() {
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    // 配置 SecurityManager，并注入 shiroRealm
    securityManager.setRealm(shiroRealm());
    return securityManager;
}

// 建立ShiroFilterFactoryBean
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
    
    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    // 設定 securityManager
    shiroFilterFactoryBean.setSecurityManager(securityManager);

       //添加Shiro過濾器
    /**
     * Shiro内置過濾器，可以實作權限相關的攔截器
     *    常用的過濾器：
     *       anon: 無需認證（登入）可以通路
     *       authc: 必須認證才可以通路
     *       user: 如果使用rememberMe的功能可以直接通路
     *       perms： 該資源必須得到資源權限才可以通路
     *       role: 該資源必須得到角色權限才可以通路
     */
    
    // 在 Shiro過濾器鍊上加入 自定義過濾器JWTFilter 并取名為jwt
    LinkedHashMap<String, Filter> filters = new LinkedHashMap<>();
    filters.put("jwt", new JWTFilter());
    shiroFilterFactoryBean.setFilters(filters);

    // 自定義url規則
    LinkedHashMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
    // 所有請求都要經過 jwt過濾器
    filterChainDefinitionMap.put("/**", "jwt");
    shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
    return shiroFilterFactoryBean;
}

/**
 * 下面的代碼是添加注解支援
 */
@Bean
@DependsOn({"lifecycleBeanPostProcessor"})
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
    // 設定代理類
    DefaultAdvisorAutoProxyCreator creator = new DefaultAdvisorAutoProxyCreator();
    creator.setProxyTargetClass(true);

    return creator;
}

/**
 * 開啟aop注解支援
 *
 * @param securityManager
 * @return
 */
@Bean("authorizationAttributeSourceAdvisor")
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
    AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
    authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
    return authorizationAttributeSourceAdvisor;
}


// Shiro生命周期處理器
@Bean
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
    return new LifecycleBeanPostProcessor();
}

/**
 * 登入方法
 *
 * @param username 使用者名
 * @param password 密碼
 * @param code     驗證碼
 * @param uuid     唯一辨別
 * @return 結果
 */
@PostMapping("/doLogin")
public ResultVo login(String username, String password, String code, String uuid, HttpServletRequest request) throws UofferException {

    String verifyKey = Constant.RM_CAPTCHA_CODE_KEY + uuid;
    String captcha = redisUtil.getCacheObject(verifyKey);
    redisUtil.del(verifyKey);

    if (captcha == null) {
        return ResultVo.failed(201, "驗證碼失效");
    }
    if (!code.equalsIgnoreCase(captcha)) {
        return ResultVo.failed(201, "驗證碼錯誤");
    }

    username = StringUtils.lowerCase(username);
    password = MD5Util.encrypt(username, password);

    final String errorMessage = "使用者名或密碼錯誤";
    SysUser user = userManager.getUser(username);

    if (user == null) {
        return ResultVo.failed(201, errorMessage);
    }
    if (!StringUtils.equalsIgnoreCase(user.getPassword(), password)) {
        return ResultVo.failed(201, errorMessage);
    }
    if (Constant.STATUS_LOCK.equals(user.getStatus())) {
        return ResultVo.failed(201, "賬号已被鎖定,請聯系管理者！");
    }

Integer userId = user.getUserId();
    String ip = IPUtil.getIpAddr(request);
    String address = AddressUtil.getCityInfo(ip);
    // 更新使用者登入時間
    SysUser sysUser = new SysUser();
    sysUser.setUserId(userId);
    sysUser.setLastLoginTime(new Date());
    sysUser.setLastLoginIp(ip);
    userService.updateById(sysUser);

// 拿到token之後加密
    String sign = JWTUtil.sign(username, password, userId);
    String token = UofferUtil.encryptToken(sign);
    LocalDateTime expireTime = LocalDateTime.now().plusSeconds(properties.getShiro().getJwtTimeOut());
    String expireTimeStr = DateUtil.formatFullTime(expireTime);
    JWTToken jwtToken = new JWTToken(token, expireTimeStr);

    // 将登入日志存入日志表中
    SysLoginLog loginLog = new SysLoginLog();
    loginLog.setIp(ip);
    loginLog.setAddress(address);
    loginLog.setLoginTime(new Date());
    loginLog.setUsername(username);
    loginLog.setUserId(userId);
    loginLogService.save(loginLog);

    saveTokenToRedis(username, jwtToken, ip, address);
    JSONObject data = new JSONObject();
    data.put("Authorization", token);

    // 将使用者配置及權限存入redis中
    userManager.loadOneUserRedisCache(userId);
    return ResultVo.oK(data);
}

要求subject中必須含有bus:careerTalk:query的權限才能執行方法someMethod()。否則抛出異常AuthorizationException。

@RequiresPermissions("bus:careerTalk:query")

public void someMethod() {

引用：

https://www.iteye.com/blog/jinnianshilongnian-2018398 https://www.jianshu.com/p/f37f8c295057

原文位址

https://www.cnblogs.com/kuotian/p/13040682.html

Shiro （Shiro + JWT + SpringBoot應用）

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method