认证授权示例——JWT及Shiro

最新推荐文章于 2025-07-16 14:58:13 发布

qqxhb

最新推荐文章于 2025-07-16 14:58:13 发布

阅读量3k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： Java SpringBoot 文章标签：认证授权 JWT Shiro Springboot

本文链接：https://blog.csdn.net/qq_43792385/article/details/99310970

Java 同时被 2 个专栏收录

63 篇文章

订阅专栏

SpringBoot

35 篇文章

订阅专栏

本文介绍了常见的认证机制，包括HTTP Basic Auth、Cookie Auth、OAuth和Token Auth，重点讲解了JWT（JSON Web Token）的原理和实现，包括JWT的组成部分、快速入门、自定义claims以及签名过程。此外，还阐述了Shiro安全框架的基本概念，包括其功能模块、内部结构以及如何在应用程序中使用Shiro进行认证授权。文中提供了详细的JWT和Shiro的示例，包括登录、鉴权和自定义Realm的实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、常见的认证机制

1.1 HTTP Basic Auth

HTTP Basic Auth简单点说明就是每次请求API时都提供用户的usernamepassword，简言之，Basic Auth是配合RESTful API 使用的最简单的认证方式，只需提供用户名密码即可，但由于有把用户名密码暴露给第三方客户端的风险，在生产环境下被使用的越来越少。因此，在开发对外开放的RESTful API时，尽量避免采用HTTP Basic Auth

1.2 Cookie Auth

Cookie认证机制就是为一次请求认证在服务端创建一个Session对象，同时在客户端的浏览器端创建了一个Cookie对象；通过客户端带上来Cookie对象来与服务器端session对象匹配来实现状态管理的。默认的，当我们关闭浏览器的时候，cookie会被删除但可以通过修改cookie 的expire time使cookie在一定时间内有效。

1.3 OAuth

OAuth（开放授权）是一个开放的授权标准，允许用户让第三方应用访问该用户在某一web服务上存储的私密的资源（如照片，视频，联系人列表），而无需将用户名和密码提供给第三方应用。 OAuth允许用户提供一个令牌，而不是用户名和密码来访问他们存放在特定服务提供者的数据。每一个令牌授权一个特定的第三方系统（例如，视频编辑网站)在特定的时段（例如，接下来的2小时内）内访问特定的资源（例如仅仅是某一相册中的视频）。这样，OAuth让用户可以授权第三方网站访问他们存储在另外服务提供者的某些特定信息，而非所有内容。这种基于OAuth的认证机制适用于个人消费者类的互联网产品，如社交类APP等应用，但是不太适合拥有自有认证权限管理的企业应用。
在这里插入图片描述

1.4 Token Auth

使用基于 Token 的身份验证方法，在服务端不需要存储用户的登录记录。大概的流程是这样的：

客户端使用用户名跟密码请求登录
服务端收到请求，去验证用户名与密码
验证成功后，服务端会签发一个 Token，再把这个 Token 发送给客户端
客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里
客户端每次向服务端请求资源的时候需要带着服务端签发的 Token
服务端收到请求，然后去验证客户端请求里面带着的 Token，如果验证成功，就向客户端返回请求的数据

Token Auth的优点：
支持跨域访问: Cookie是不允许垮域访问的，这一点对Token机制是不存在的，前提是传输的用户认证信息通过HTTP头传输；
无状态(也称：服务端可扩展行):Token机制在服务端不需要存储session信息，因为Token 自身包含了所有登录用户的信息，只需要在客户端的cookie或本地介质存储状态信息；
更适用CDN: 可以通过内容分发网络请求你服务端的所有资料（如：javascript，HTML,图片等），而你的服务端只要提供API即可；
去耦: 不需要绑定到一个特定的身份验证方案。Token可以在任何地方生成，只要在你的API被调用的时候，你可以进行Token生成调用即可；
更适用于移动应用: 当你的客户端是一个原生平台（iOS, Android，Windows 8等）时，Cookie是不被支持的（你需要通过Cookie容器进行处理），这时采用Token认证机制就会简单得多；
CSRF:因为不再依赖于Cookie，所以你就不需要考虑对CSRF（跨站请求伪造）的防范；
性能: 一次网络往返时间（通过数据库查询session信息）总比做一次HMACSHA256计算的Token验证和解析要费时得多；
不需要为登录页面做特殊处理: 如果你使用Protractor 做功能测试的时候，不再需要为登录页面做特殊处理；
基于标准化:你的API可以采用标准化的 JSON Web Token (JWT). 这个标准已经存在多个后端库（.NET, Ruby,Java,Python, PHP）和多家公司的支持（如：Firebase,Google, Microsoft）。

2、 JWT实现认证授权

2.1 什么是JWT

JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。在Java世界中通过JJWT实现JWT创建和验证。
JWT令牌由三部分组成，每部分中间使用点（.）分隔，比如：aa.bb.cc

Header
头部包括令牌的类型（即JWT）及使用的哈希算法（如HMAC SHA256或RSA）

{
  "alg": "HS256",
  "typ": "JWT"
}

将上边的内容使用Base64Url编码，得到一个字符串就是JWT令牌的第一部分(aa)。

Payload
第二部分是负载，内容也是一个json对象，它是存放有效信息的地方，它可以存放jwt提供的现成字段，比如：iss（签发者）,exp（过期时间戳）, sub（面向的用户）等，也可自定义字段。此部分不建议存放敏感信息，因为此部分可以解码还原原始内容。最后将第二部分负载使用Base64Url编码，得到一个字符串就是JWT令牌的第二部分(bb)。

{
  "sub": "1234567890",
  "name": "456",
  "admin": true
}

Signature
第三部分是签名，此部分用于防止jwt内容被篡改。这个部分使用base64url将前两部分进行编码，编码后使用点（.）连接组成字符串，最后使用header中声明签名算法进行签名。HMACSHA256(aa+ “.” +bb, secret)其中secret签名所使用的密钥或者说盐。

2.2 JWT的快速入门

2.2.1 token的创建

（1）引入依赖

<dependency>
  <groupId>io.jsonwebtoken</groupId>
  <artifactId>jjwt</artifactId>
  <version>0.6.0</version>
</dependency>

（2）创建类JWTAuthApplicationTest,测试生成token

public static void createJwt() {
		JwtBuilder builder = Jwts.builder().setId("666").setSubject("君莫笑").setIssuedAt(new Date())
				.signWith(SignatureAlgorithm.HS256, "qqxhb");
		System.out.println(builder.compact());
	}

token:

eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI2NjYiLCJzdWIiOiLlkJvojqvnrJEiLCJpYXQiOjE1NjU2MDA0NTR9.gnq6RX6FRj748f9voVPgc81wBuWRyvKl1gODMPqU9S8

2.2.2 token的解析

我们刚才已经创建了token ，在web应用中这个操作是由服务端进行然后发给客户端，客户端在下次向服务端发送请求时需要携带这个token（这就好像是拿着一张门票一样），那服务端接到这个token 应该解析出token中的信息（例如用户id）,根据这些信息查询数据库返回相应的结果。

public static void parseJwt(String token) {
		Claims claims = Jwts.parser().setSigningKey("qqxhb").parseClaimsJws(token).getBody();
		System.out.println("id:" + claims.getId());
		System.out.println("subject:" + claims.getSubject());
		System.out.println("IssuedAt:" + claims.getIssuedAt());
	}

parseResult:

id:666
subject:君莫笑
IssuedAt:Mon Aug 12 17:06:24 CST 2019

2.2.3 自定义claims

我们刚才的例子只是存储了id和subject两个信息，如果你想存储更多的信息（例如角色）可以定义自定义claims
（1）修改createJwt，并存储角色头像内容
java

 public static String createJwt() {
		long exp = System.currentTimeMillis() + 60 * 1000;// 过期时间一分钟
		JwtBuilder builder = Jwts.builder().setId("666").setSubject("君莫笑").setIssuedAt(new Date())
				.signWith(SignatureAlgorithm.HS256, "qqxhb")
				.setExpiration(new Date(exp))
				.claim("role", "admin")
				.claim("logo", "logo.png");
		return builder.compact();
	}

（2）修改parseJwt，获取角色头像内容

public static void parseJwt(String token) {
		Claims claims = Jwts.parser().setSigningKey("qqxhb").parseClaimsJws(token).getBody();
		System.out.println("id:" + claims.getId());
		System.out.println("subject:" + claims.getSubject());
		System.out.println("role:" + claims.get("role"));
		System.out.println("logo:" + claims.get("logo"));
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		System.out.println("签发时间:"+sdf.format(claims.getIssuedAt()));
        System.out.println("过期时间:"+sdf.format(claims.getExpiration()));
        System.out.println("当前时间:"+sdf.format(new Date()) );
	}

parseResult:

id:666
subject:君莫笑
role:admin
logo:logo.png
签发时间:2019-08-12 05:15:48
过期时间:2019-08-12 05:16:48
当前时间:2019-08-12 05:15:49

2.3 抽取JWT工具类

import java.util.Date;
import java.util.Map;

import org.springframework.boot.context.properties.ConfigurationProperties;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

@ConfigurationProperties("jwt.config")
public class JwtUtil {
	private String key;
	private long ttl;

	public String getKey() {
		return key;
	}

	public void setKey(String key) {
		this.key = key;
	}

	public long getTtl() {
		return ttl;
	}

	public void setTtl(long ttl) {
		this.ttl = ttl;
	}

	/**
	 * 创建Token
	 */
	public String createJWT(String id, String subject, Map<String, Object> map) {
		long now = System.currentTimeMillis();
		long exp = now + ttl;
		JwtBuilder jwtBuilder = Jwts.builder().setId(id).setSubject(subject).setIssuedAt(new Date())
				.signWith(SignatureAlgorithm.HS256, key);
		for (Map.Entry<String, Object> entry : map.entrySet()) {
			jwtBuilder.claim(entry.getKey(), entry.getValue());
		}
		if (ttl > 0) {
			jwtBuilder.setExpiration(new Date(exp));
		}
		String token = jwtBuilder.compact();
		return token;
	}

	/*
	 * 解析JWT
	 * 
	 * @param token
	 * 
	 * @return
	 */
	public Claims parseJWT(String token) {
		Claims claims = null;
		try {
			claims = Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody();
		} catch (Exception e) {
		}
		return claims;
	}
}

修改工程的application.yml, 添加配置

jwt:
 config:
    key: auth-jwt
    ttl: 360000

2.4 登录成功签发token

（1）配置JwtUtil，交给spring容器管理。

	@Bean
	public JwtUtil jwtUtil() {
		return new JwtUtil();
	}

（2）添加登录方法

@RequestMapping(value = "/login", method = RequestMethod.POST)
	public Result login(@RequestBody Map<String, String> loginMap) {
		String userName = loginMap.get("userName");
		String password = loginMap.get("password");
		User user = userService.findByUserName(userName);
		// 登录失败
		if (user == null || !user.getPassword().equals(password)) {
			return new Result(ResultCode.MOBILEORPASSWORDERROR);
		} else {// 登录成功
			Map<String, Object> map = new HashMap<>();
			map.put("companyName", user.getCompany());
			String token = jwtUtil.createJWT(user.getId(), user.getUserName(), map);
			return new Result(ResultCode.SUCCESS, token);
		}
	}

2.5 获取用户信息鉴权

需求：用户登录成功之后，会发送一个新的请求到服务端，获取用户的详细信息。获取用户信息的过程中必须登录才能，否则不能获取。
前后端约定：前端请求微服务时需要添加头信息Authorization ,内容为Bearer+空格+token
（1）添加响应值对象

@Setter
@Getter
public class ProfileResult {
	private String userName;
	private String company;
	// 角色权限信息
	private Map<String, Object> roles = new HashMap<>();

	public ProfileResult(User user) {
		this.userName = user.getUserName();
		this.company = user.getCompany();

		Set<String> menus = new HashSet<>();
		Set<String> points = new HashSet<>();
		Set<String> apis = new HashSet<>();
		//根据用户去获取角色权限信息：菜单，按钮，接口
		this.roles.put("menus", menus);
		this.roles.put("points", points);
		this.roles.put("apis", apis);
	}
}

（2）添加profile接口方法

/**
	 * 用户登录成功之后，获取用户信息 
	 */
	@RequestMapping(value = "/profile", method = RequestMethod.POST)
	public Result profile(HttpServletRequest request) throws Exception {

		String userid = claims.getId();
		// 获取用户信息
		User user = userService.findById(userid);
		// 根据不同的用户级别获取用户权限
		ProfileResult result = new ProfileResult(user);
		return new Result(ResultCode.SUCCESS, result);
	}

（3）验证token
思路：从请求中获取key为Authorization的token信息，并使用jwt验证，验证成功后获取隐藏信息。提取公用Controller

import io.jsonwebtoken.Claims;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.ModelAttribute;

import com.qqxhb.auth.jwt.utils.JwtUtil;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class BaseController {

	protected HttpServletRequest request;
	protected HttpServletResponse response;
	protected String company;
	protected Claims claims;

	@Autowired
	JwtUtil jwtUtil;

	@ModelAttribute
	public void setResAnReq(HttpServletRequest request, HttpServletResponse response) {
		this.request = request;
		this.response = response;
		String authorization = request.getHeader("Authorization");
		if (StringUtils.isEmpty(authorization)) {
			return;
		}
		// 前后端约定头信息内容以 Bearer+空格+token 形式组成
		String token = authorization.replace("Bearer ", "");
		// 比较并获取claims
		Claims claims = jwtUtil.parseJWT(token);
		Object obj = request.getAttribute("user_claims");

		if (obj != null) {
			this.claims = (Claims) obj;
			this.company = (String) claims.get("company");
		}
	}

}

2.6 通过拦截器鉴权

@Component
public class JwtInterceptor extends HandlerInterceptorAdapter {

    /**
     * 简化获取token数据的代码编写（判断是否登录）
     *  1.通过request获取请求token信息
     *  2.从token中解析获取claims
     *  3.将claims绑定到request域中
     */

    @Autowired
    private JwtUtil jwtUtils;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.通过request获取请求token信息
        String authorization = request.getHeader("Authorization");
        //判断请求头信息是否为空，或者是否已Bearer开头
        if(!StringUtils.isEmpty(authorization) && authorization.startsWith("Bearer")) {
            //获取token数据
            String token = authorization.replace("Bearer ","");
            //解析token获取claims
            Claims claims = jwtUtils.parseJWT(token);
            if(claims != null) {
                //通过claims获取到当前用户的可访问API权限字符串
                String apis = (String) claims.get("apis");  //api-user-delete,api-user-update
                //通过handler
                HandlerMethod h = (HandlerMethod) handler;
                //获取接口上的reqeustmapping注解
                RequestMapping annotation = h.getMethodAnnotation(RequestMapping.class);
                //获取当前请求接口中的name属性
                String name = annotation.name();
                //判断当前用户是否具有响应的请求权限
                if(apis.contains(name)) {
                    request.setAttribute("user_claims",claims);
                    return true;
                }else {
                    throw new CommonException(ResultCode.UNAUTHORISE);
                }
            }
        }
        throw new CommonException(ResultCode.UNAUTHENTICATED);
    }
}

注册配置拦截器

@Configuration
public class JwtMvcConfig extends WebMvcConfigurationSupport {

    @Autowired
    private JwtInterceptor jwtInterceptor;

    /**
     * 添加JWT鉴权拦截器
     */
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor).
                addPathPatterns("/**").//指定拦截器的url地址
                excludePathPatterns("/login","/register/**");//指定不拦截的url地址
    }
}

修改BaseController

@Component
public class BaseController {

	protected HttpServletRequest request;
	protected HttpServletResponse response;
	protected String company;
	protected Claims claims;

	@ModelAttribute
	public void setResAnReq(HttpServletRequest request, HttpServletResponse response) {
		this.request = request;
		this.response = response;
		Object obj = request.getAttribute("user_claims");

		if (obj != null) {
			this.claims = (Claims) obj;
			this.company = (String) claims.get("company");
		}
	}

}

3、Shiro安全框架实现认证授权

3.1 什么是Shiro

3.1.1 什么是Shiro

Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
Apache Shiro 的首要目标是易于使用和理解。安全有时候是很复杂的，甚至是痛苦的，但它没有必要这样。框架应该尽可能掩盖复杂的地方，露出一个干净而直观的 API，来简化开发人员在使他们的应用程序安全上的努力。以下是你可以用 Apache Shiro 所做的事情：

验证用户来核实他们的身份
对用户执行访问控制，如：判断用户是否被分配了一个确定的安全角色；判断用户是否被允许做某事
在任何环境下使用 Session API，即使没有 Web 或 EJB 容器。
在身份验证，访问控制期间或在会话的生命周期，对事件作出反应。
聚集一个或多个用户安全数据的数据源，并作为一个单一的复合用户“视图”。
启用单点登录（SSO）功能。
为没有关联到登录的用户启用"Remember Me"服务

3.1.2 与Spring Security的对比

Spring Security：
除了不能脱离Spring，shiro的功能它都有。而且Spring Security对Oauth、OpenID也有支持,Shiro则需要自己手动实现。Spring Security的权限细粒度更高。
Shiro：
Shiro较之 Spring Security，Shiro在保持强大功能的同时，还在简单性和灵活性方面拥有巨大优势。

易于理解的 Java Security API；
简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）；
对角色的简单的签权（访问控制），支持细粒度的签权；
支持一级缓存，以提升应用程序的性能；
内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境；
异构客户端会话访问；
非常简单的加密 API；
不跟任何的框架或者容器捆绑，可以独立运行

3.1.3 Shiro的功能模块

Shiro可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环境。Shiro可以帮助我们完成：认证、授权、加密、会话管理、与Web集成、缓存等。而且Shiro的API也是非常简单；其基本功能点如下图所示：
在这里插入图片描述
Authentication：身份认证/登录，验证用户是不是拥有相应的身份。
Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情。
Session Management：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的。
Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储。
Web Support：Shiro 的 web 支持的 API 能够轻松地帮助保护 Web 应用程序。
Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率。
Concurrency：Apache Shiro 利用它的并发特性来支持多线程应用程序。
Testing：测试支持的存在来帮助你编写单元测试和集成测试，并确保你的能够如预期的一样安全。
“Run As”：一个允许用户假设为另一个用户身份（如果允许）的功能，有时候在管理脚本很有用。
“Remember Me”：记住我。

3.2 Shiro的内部结构

在这里插入图片描述
Subject：主体，可以看到主体可以是任何可以与应用交互的“用户”；
SecurityManager：相当于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher；是Shiro的心脏；所有具体的交互都通过SecurityManager进行控制；它管理着所有Subject、且负责进行认证和授权、及会话、缓存的管理。
Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得Shiro默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了；
Authrizer：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；
Realm：可以有1个或多个Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是JDBC实现，也可以是LDAP实现，或者内存实现等等；由用户提供；注意：Shiro不知道你的用户/权限存储在哪及以何种格式存储；所以我们一般在应用中都需要实现自己的Realm；
SessionManager：如果写过Servlet就应该知道Session的概念，Session呢需要有人去管理它的生命周期，这个组件就是SessionManager；而Shiro并不仅仅可以用在Web环境，也可以用在如普通的JavaSE环境、EJB等环境；所有呢，Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据；
SessionDAO：DAO大家都用过，数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的SessionDAO，通过如JDBC写到数据库；比如想把Session放到Memcached中，可以实现自己的Memcached SessionDAO；另外SessionDAO中可以使用Cache进行缓存，以提高性能；
CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能
Cryptography：密码模块，Shiro提高了一些常见的加密组件用于如密码加密/解密的。

3.3 应用程序使用Shiro

在这里插入图片描述
也就是说对于我们而言，最简单的一个Shiro应用：
1、应用代码通过Subject来进行认证和授权，而Subject又委托给SecurityManager；
2、我们需要给Shiro的SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限进行判断。从以上也可以看出，Shiro不提供维护用户/权限，而是通过Realm让开发人员自己注入。

3.4 Shiro的入门

3.4.1 搭建基于ini的运行环境

（1）创建工程导入shiro坐标

<dependencies>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-core</artifactId>
      <version>1.3.2</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

3.4.2 用户认证

认证：身份认证/登录，验证用户是不是拥有相应的身份。基于shiro的认证，是通过subject的login方法完成用户认证工作的
（1）在resource目录下创建shiro的ini配置文件构造模拟数据（shiro-auth.ini）

[users]
#模拟从数据库查询的用户
#数据格式  用户名=密码
zhangsan=123456
lisi=654321

（2）测试用户认证

@Test
	public void testLogin() {
		// 1.根据配置文件创建SecurityManagerFactory
		Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-test-1.ini");
		// 2.通过工厂获取SecurityManager
		SecurityManager securityManager = factory.getInstance();
		// 3.将SecurityManager绑定到当前运行环境
		SecurityUtils.setSecurityManager(securityManager);
		// 4.从当前运行环境中构造subject
		Subject subject = SecurityUtils.getSubject();
		// 5.构造shiro登录的数据
		String username = "zhangsan";
		String password = "1234561";
		UsernamePasswordToken token = new UsernamePasswordToken(username, password);
		// 6.主体登陆
		subject.login(token);
		// 7.验证用户是否登录成功
		System.out.println("用户是否登录成功=" + subject.isAuthenticated());
		// 8.获取登录成功的数据
		System.out.println(subject.getPrincipal());
	}

3.4.3 用户授权

授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限
（1）在resource目录下创建shiro的ini配置文件构造模拟数据（shiro-prem.ini）

[users]
#模拟从数据库查询的用户
#数据格式  用户名=密码,角色1,角色2..
zhangsan=123456,role1,role2
lisi=654321,role2
[roles]
#模拟从数据库查询的角色和权限列表
#数据格式  角色名=权限1，权限2
role1=user:save,user:update
role2=user:update,user.delete
role3=user.find

（2）完成用户授权

private SecurityManager securityManager;

    @Before
    public void init() {
        //1.根据配置文件创建SecurityManagerFactory
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-test-2.ini");
        //2.通过工厂获取SecurityManager
        SecurityManager securityManager = factory.getInstance();
        //3.将SecurityManager绑定到当前运行环境
        SecurityUtils.setSecurityManager(securityManager);
    }

    @Test
    public void testLogin() {
        Subject subject = SecurityUtils.getSubject();
        String username = "lisi";
        String password = "123456";
        UsernamePasswordToken token = new UsernamePasswordToken(username,password);
        subject.login(token);

        //登录成功之后，完成授权
        //授权：检验当前登录用户是否具有操作权限，是否具有某个角色
        System.out.println(subject.hasRole("role1"));
        System.out.println(subject.isPermitted("user:save"));

    }

3.4.4 自定义Realm

Realm域：Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源
（1）自定义Realm

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 java.util.ArrayList;
import java.util.List;

/**
 * 自定义realms对象 继承AuthorizingRealm 重写方法 doGetAuthorizationInfo：授权
 * 获取到用户的授权数据（用户的权限数据） doGetAuthenticationInfo：认证 根据用户名密码登录，将用户数据保存（安全数据）
 *
 */
public class PermissionRealm extends AuthorizingRealm {

	/**
	 * 自定义realm名称
	 */
	public void setName(String name) {
		super.setName("permissionRealm");
	}

	// 授权:授权的主要目的就是根据认证数据获取到用户的权限信息

	/**
	 * principalCollection：包含了所有已认证的安全数据 AuthorizationInfoInfo：授权数据
	 */
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
		System.out.println("执行授权方法");
		// 1.获取安全数据 username，用户id
		String username = (String) principalCollection.getPrimaryPrincipal();
		// 2.根据id或者名称查询用户
		// 3.查询用户的角色和权限信息
		List<String> perms = new ArrayList<>();
		perms.add("user:save");
		perms.add("user:update");
		List<String> roles = new ArrayList<>();
		roles.add("role1");
		roles.add("role2");
		// 4.构造返回
		SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
		// 设置权限集合
		info.addStringPermissions(perms);
		// 设置角色集合
		info.addRoles(roles);
		return info;
	}

	// 认证：认证的主要目的，比较用户名和密码是否与数据库中的一致
	// 将安全数据存入到shiro进行保管
	// 参数：authenticationToken登录构造的usernamepasswordtoken
	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken)
			throws AuthenticationException {
		System.out.println("执行认证方法");
		// 1.构造uptoken
		UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
		// 2.获取输入的用户名密码
		String username = upToken.getUsername();
		String password = new String(upToken.getPassword());
		// 3.根据用户名查询数据库，正式系统查询
		// 4.比较密码和数据库中的密码是否一致（密码可能需要加密）
		if ("123456".equals(password)) {
			// 5.如果成功，向shiro存入安全数据
			SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username, password, getName());// 1.安全数据，2.密码。3。当前realm域名称
			return info;
		} else {
			// 6.失败，抛出异常或返回null
			throw new RuntimeException("用户名或密码错误");
		}
	}
}

（2）配置shiro的ini配置文件（shiro-realm.ini）

[main]
#声明realm
permReam=com.qqxhb.auth.shiro.PermissionRealm
#注册realm到securityManager中
securityManager.realms=$permReam

（3）验证

	@Before
	public void init() {
		// 1.根据配置文件创建SecurityManagerFactory
		Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-test-3.ini");
		// 2.通过工厂获取SecurityManager
		SecurityManager securityManager = factory.getInstance();
		// 3.将SecurityManager绑定到当前运行环境
		SecurityUtils.setSecurityManager(securityManager);
	}
	
@Test
	public void testLogin3() {
		Subject subject = SecurityUtils.getSubject();
		String username = "zhangsan";
		String password = "123456";
		UsernamePasswordToken token = new UsernamePasswordToken(username, password);

		// 执行login-->realm域中的认证方法
		subject.login(token);

		// 授权：-->realm域中的授权方法
		System.out.println(subject.hasRole("role1"));
		System.out.println(subject.isPermitted("user:save"));

	}

3.4.5 认证与授权的执行流程分析

（1）认证流程
在这里插入图片描述

首先调用Subject.login(token)进行登录，其会自动委托给Security Manager，调用之前必须通过SecurityUtils.setSecurityManager()设置；
SecurityManager负责真正的身份验证逻辑；它会委托给Authenticator进行身份验证；
Authenticator才是真正的身份验证者，Shiro API中核心的身份认证入口点，此处可以自定义插入自己的实现；
Authenticator可能会委托给相应的AuthenticationStrategy进行多Realm身份验证，默认ModularRealmAuthenticator会调用AuthenticationStrategy进行多Realm身份验证；
Authenticator会把相应的token传入Realm，从Realm获取身份验证信息，如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个Realm，将按照相应的顺序及策略进行访问。

（2）授权流程
在这里插入图片描述
6. 首先调用Subject.isPermitted/hasRole接口，其会委托给SecurityManager，而SecurityManager接着会委托给Authorizer；
7. Authorizer是真正的授权者，如果我们调用如isPermitted(“user:view”)，其首先会通过PermissionResolver把字符串转换成相应的Permission实例；
8. 在进行授权之前，其会调用相应的Realm获取Subject相应的角色/权限用于匹配传入的角色/权限；
9. Authorizer会判断Realm的角色/权限是否和传入的匹配，如果有多个Realm，会委托给ModularRealmAuthorizer进行循环判断，如果匹配如isPermitted/hasRole会返回true，否则返回false表示授权失败。