得当才最美：Shiro安全框架使专心得

大家好，我是 V 哥。Apache Shiro 是一个强大且灵活的 Java 安全框架，专注于提供认证、授权、会话管理和加密功能。它常用于掩护 Java 应用的访问控制，特别是在 Web 应用中。相比于 Spring Security，Shiro 的设计更简洁，得当轻量级应用，并且在很多方面具有更好的易用性和扩展性，今天 V 哥就来聊聊 Shiro 安全框架。

Shiro 的核心概念

按照惯例，和 V 哥一起来了解一下 Shiro 的核心概念：

• Subject
  Subject 是 Shiro 框架中一个核心的接口，表示应用中的“用户”或“实体”，用于交互和存储认证状态。通常通过 SecurityUtils.getSubject() 获取当前的 Subject。它代表了用户的身份信息和权限数据。
  
• SecurityManager
  SecurityManager 是 Shiro 的核心控制器，负责管理所有的安全操作和认证。通过配置 SecurityManager，可以控制用户的认证、授权、会话等管理。
  
• Realm
  Realm 是 Shiro 从数据源获取用户、角色和权限信息的途径。通过实现自界说的 Realm，可以将 Shiro 与数据库、LDAP、文件等数据源整合。Shiro 会把用户的认证和授权数据从 Realm 中获取。
  
• Session
  Shiro 自带会话管理，不依赖于 Servlet 容器提供的会话。即使在非 Web 环境下，也可以使用 Shiro 的会话管理。Shiro 的会话管理提供了更过细的控制，比如会话超时、存储和共享等功能。
  
• Authentication（认证）
  认证是指验证用户身份的过程。Shiro 提供了简朴的 API 来实现认证过程，比如 subject.login(token)。在现实应用中，通常通过用户名和密码的组合进行认证，但 Shiro 也支持其他方式（如 OAuth2、JWT 等）。
  
• Authorization（授权）
  授权是指验证用户是否具备某些权限或角色的过程。Shiro 支持基于角色和基于权限的授权，允许更精细的权限控制。通过 subject.hasRole 或 subject.isPermitted 方法，开发者可以查抄用户的角色和权限。
  
• Cryptography（加密）
  Shiro 内置了加密功能，提供对密码和敏感信息的加密和解密支持。它支持多种加密算法，并且在密码存储时支持散列和盐值。
  

Shiro 的重要功能和优势

V 哥总结几点Shiro 的重要功能和优势，这个在口试时吹牛逼用得到。

• 易于集成
  Shiro 的 API 设计简朴，易于集成到各种 Java 应用中。开发者可以基于 Shiro 提供的默认实现快速搭建一个基本的安全架构，也可以根据需要自界说各种功能。
  
• 独立的会话管理
  与基于 Web 容器的会话管理不同，Shiro 提供了跨环境的会话管理，可以应用于 Web 和非 Web 的环境，增加了应用的灵活性。
  
• 权限控制简朴而灵活
  Shiro 的权限管理可以通过配置文件、注解或代码实现，提供了细粒度的访问控制。通过权限和角色的组合，开发者可以非常灵活地控制访问权限。
  
• 支持多种数据源
  Shiro 可以从多种数据源（如数据库、LDAP、文件等）获取用户和权限信息，方便与各种现有系统整合。
  
• 支持 Web 和非 Web 环境
  Shiro 不仅可以在 Web 应用中使用，也支持在桌面应用或微服务等环境中使用。
  

Shiro 的基本使用示例

光讲概念不是 V 哥风格，接下来，通过一个典型的 Shiro 应用来了解一下如何使用，包含配置 SecurityManager、配置 Realm、进行认证和授权等步调。

• 配置 Shiro 环境
  可以通过 shiro.ini 文件配置 Shiro，也可以通过代码进行配置。
  

1.    [main]
2.    # 配置 SecurityManager
3.    securityManager = org.apache.shiro.mgt.DefaultSecurityManager
5.    # 配置 Realm
6.    myRealm = com.wg.MyCustomRealm
7.    securityManager.realms = $myRealm

复制代码

• 创建自界说 Realm
  自界说 Realm 通过继承 AuthorizingRealm 并实现 doGetAuthenticationInfo 和 doGetAuthorizationInfo 方法来提供用户和权限数据。
  

1.    public class MyCustomRealm extends AuthorizingRealm {
2.        @Override
3.        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
4.            // 获取用户名和密码等信息，查询数据库进行认证
5.            return new SimpleAuthenticationInfo(username, password, getName());
6.        }
8.        @Override
9.        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
10.            // 获取用户角色和权限信息
11.            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
12.            info.addRole("admin");
13.            info.addStringPermission("user:read");
14.            return info;
15.        }
16.    }

复制代码

• 使用 Shiro 进行认证和授权
  

1.    Subject currentUser = SecurityUtils.getSubject();
2.    if (!currentUser.isAuthenticated()) {
3.        UsernamePasswordToken token = new UsernamePasswordToken("username", "password");
4.        try {
5.            currentUser.login(token);
6.            System.out.println("认证成功");
7.        } catch (AuthenticationException ae) {
8.            System.out.println("认证失败");
9.        }
10.    }
12.    // 检查权限
13.    if (currentUser.hasRole("admin")) {
14.        //用输出模拟一下哈
15.        System.out.println("用户拥有 admin 角色");
16.    }
17.    if (currentUser.isPermitted("user:read")) {
18.        //用输出模拟一下哈
19.        System.out.println("用户具有 user:read 权限");
20.    }

复制代码

通过这个简朴的案例学习，咱们可以了解 Shiro 的基本使用，但这不是全部，听V哥继续慢慢道来。
场景案例

这点很紧张，强调一下哈，Shiro 得当需要简洁易用、安全控制要求灵活的 Java 应用，如中小型 Web 应用、桌面应用、分布式微服务等。对于大型企业应用或需要集成多种认证方式（如 OAuth2、JWT 等）的项目，Spring Security 可能会更符合。
要在微服务架构中实现基于 Apache Shiro 的安全认证和授权，比如一个订单管理系统为例。这个系统包含两个重要服务：

• 用户服务：负责用户的注册、登录、认证等操作。
  
• 订单服务：允许用户创建、查看、删除订单，并限制访问权限。
  

咱们来看一下，这个应该怎么设计呢？
微服务案例设计

在这个场景中，我们需要以下几项核心功能：

• 用户认证：用户通过用户名和密码登录。
  
• 权限控制：仅管理员能删除订单，普通用户只能查看和创建订单。
  
• Token机制：使用 JWT Token（JSON Web Token）来管理用户的登录状态，实现无状态认证，使得在分布式环境下不依赖于单一会话。
  
• 跨服务认证：订单服务在接收到哀求时，查抄并验证用户的身份和权限。
  

架构和技能选型

• Spring Boot：用于快速搭建微服务。
  
• Shiro：实现认证、授权。
  
• JWT：生成和验证 Token，保持无状态认证。
  
• Spring Data JPA：访问数据库存储用户和订单数据。
  

系统结构

1. +------------------+      +---------------------+
2. |   用户服务        |      |     订单服务        |
3. |                  |      |                     |
4. | 用户注册、登录    |      |   查看、创建、删除订单|
5. +------------------+      +---------------------+
6.             |                    |
7.             |----用户 Token ------|

复制代码

步调：实现微服务中的认证和授权

1. 引入须要的依赖

在 pom.xml 文件中，添加 Shiro、JWT 和 Spring Data JPA 等依赖：

1. <dependency>
2.     <groupId>org.apache.shiro</groupId>
3.     <artifactId>shiro-spring</artifactId>
4.     <version>1.8.0</version>
5. </dependency>
7. <dependency>
8.     <groupId>io.jsonwebtoken</groupId>
9.     <artifactId>jjwt</artifactId>
10.     <version>0.9.1</version>
11. </dependency>
13. <dependency>
14.     <groupId>org.springframework.boot</groupId>
15.     <artifactId>spring-boot-starter-data-jpa</artifactId>
16. </dependency>
17. <dependency>
18.     <groupId>org.springframework.boot</groupId>
19.     <artifactId>spring-boot-starter-web</artifactId>
20. </dependency>
21. <dependency>
22.     <groupId>com.h2database</groupId>
23.     <artifactId>h2</artifactId>
24. </dependency>

复制代码

2. 配置 Shiro 与 JWT 过滤器

使用 Shiro 的自界说 JWT 过滤器实现无状态认证，通过 Token 验证用户。

1. public class JwtFilter extends BasicHttpAuthenticationFilter {
3.     @Override
4.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
5.         HttpServletRequest httpServletRequest = (HttpServletRequest) request;
6.         String token = httpServletRequest.getHeader("Authorization");
8.         if (StringUtils.isBlank(token)) {
9.             return false;
10.         }
12.         try {
13.             // 解析 JWT token
14.             JwtToken jwtToken = new JwtToken(token);
15.             getSubject(request, response).login(jwtToken);
16.             return true;
17.         } catch (Exception e) {
18.             return false;
19.         }
20.     }
21. }

复制代码

3. 实现自界说 Realm

自界说 Realm，从数据库获取用户和角色信息，并使用 JWT Token 进行无状态认证。

1. public class JwtRealm extends AuthorizingRealm {
3.     @Override
4.     public boolean supports(AuthenticationToken token) {
5.         return token instanceof JwtToken;
6.     }
8.     @Override
9.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
10.         String jwtToken = (String) token.getPrincipal();
12.         // 验证 Token
13.         String username = JwtUtil.getUsernameFromToken(jwtToken);
14.         if (username == null) {
15.             throw new AuthenticationException("Token 无效");
16.         }
18.         // 查询用户
19.         User user = userService.findByUsername(username);
20.         if (user == null) {
21.             throw new AuthenticationException("用户不存在");
22.         }
24.         return new SimpleAuthenticationInfo(jwtToken, jwtToken, getName());
25.     }
27.     @Override
28.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
29.         String username = JwtUtil.getUsernameFromToken(principals.toString());
31.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
32.         User user = userService.findByUsername(username);
34.         // 添加角色和权限
35.         authorizationInfo.addRole(user.getRole());
36.         authorizationInfo.addStringPermission(user.getPermission());
38.         return authorizationInfo;
39.     }
40. }

复制代码

4. 创建 JWT 工具类

编写一个工具类，用于生成和解析 JWT Token。

1. public class JwtUtil {
3.     //这里替换一下你自己的secret_key
4.     private static final String SECRET_KEY = "这里打码了";
6.     public static String generateToken(String username) {
7.         return Jwts.builder()
8.                 .setSubject(username)
9.                 .setIssuedAt(new Date())
10.                 .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 1 hour
11.                 .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
12.                 .compact();
13.     }
15.     public static String getUsernameFromToken(String token) {
16.         Claims claims = Jwts.parser()
17.                 .setSigningKey(SECRET_KEY)
18.                 .parseClaimsJws(token)
19.                 .getBody();
20.         return claims.getSubject();
21.     }
23.     public static boolean isTokenExpired(String token) {
24.         Claims claims = Jwts.parser()
25.                 .setSigningKey(SECRET_KEY)
26.                 .parseClaimsJws(token)
27.                 .getBody();
28.         return claims.getExpiration().before(new Date());
29.     }
30. }

复制代码

5. 编写用户服务和订单服务接口

用户服务接口

用户服务提供注册和登录 API。

1. @RestController
2. @RequestMapping("/user")
3. public class UserController {
5.     @PostMapping("/register")
6.     public ResponseEntity<?> register(@RequestBody User user) {
7.         userService.save(user);
8.         return ResponseEntity.ok("用户注册成功");
9.     }
11.     @PostMapping("/login")
12.     public ResponseEntity<?> login(@RequestBody User user) {
13.         User dbUser = userService.findByUsername(user.getUsername());
14.         if (dbUser != null && dbUser.getPassword().equals(user.getPassword())) {
15.             String token = JwtUtil.generateToken(user.getUsername());
16.             return ResponseEntity.ok(token);
17.         }
18.         return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("登录失败");
19.     }
20. }

复制代码

订单服务接口

订单服务在操作订单时会验证用户的角色和权限。

1. @RestController
2. @RequestMapping("/order")
3. public class OrderController {
5.     @GetMapping("/{orderId}")
6.     public ResponseEntity<?> getOrder(@PathVariable Long orderId) {
7.         Subject currentUser = SecurityUtils.getSubject();
8.         if (currentUser.isPermitted("order:read")) {
9.             // 查询订单
10.             return ResponseEntity.ok("订单详情");
11.         }
12.         return ResponseEntity.status(HttpStatus.FORBIDDEN).body("无权限查看订单");
13.     }
15.     @DeleteMapping("/{orderId}")
16.     public ResponseEntity<?> deleteOrder(@PathVariable Long orderId) {
17.         Subject currentUser = SecurityUtils.getSubject();
18.         if (currentUser.hasRole("admin")) {
19.             // 删除订单
20.             return ResponseEntity.ok("订单已删除");
21.         }
22.         return ResponseEntity.status(HttpStatus.FORBIDDEN).body("无权限删除订单");
23.     }
24. }

复制代码

最后

这个案例中咱们通过如何使用 Shiro、JWT 和 Spring Boot 来构建一个无状态的微服务认证授权机制。通过 Shiro 实现用户认证和权限控制，使用 JWT 实现无状态 Token 验证。在轻量级的分布式微服务应用中，是不是使用 Shiro 感觉更加清新呢，欢迎批评区一起讨论，关注威哥爱编程，爱上Java，一辈子。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。