Spring Security表达式语言（SpEL）应用

Spring Security SpEL：权限控制的文艺复兴，让你的代码更有范儿！

大家好！我是你们的老朋友，江湖人称“码界诗人”的那个。今天，我们要聊点儿高级货——Spring Security 的 SpEL 表达式语言。 啥？你一听“表达式语言”就头大？别怕！今天这堂课，保证让你听得津津有味，学得轻松愉快，从此以后，你的权限控制代码，也能像诗歌一样优雅！ 😎

一、开场白：权限控制，一场永恒的战争

在软件开发的世界里，权限控制就像一场永恒的战争。我们要守住数据的安全，防止“熊孩子”乱动我们的宝贝，又要确保“好孩子”能方便地使用。传统的权限控制方式，比如硬编码、角色权限表等等，就像是原始部落的武器，简单粗暴，但缺乏灵活性，维护起来更是噩梦。

想象一下，你的代码里到处都是 if (user.getRole().equals("ADMIN")) { ... }，或者臃肿的角色权限表，每次需求变更都要改动大量的代码，简直就是一场灾难！😱

而 Spring Security SpEL，就像是文艺复兴时期的火枪，为我们提供了更强大、更灵活、更优雅的权限控制手段。它能让我们像诗人一样，用简洁的表达式来定义复杂的权限规则，让代码更具可读性和可维护性，从此告别“屎山”代码！

二、SpEL 是啥？它和 Spring Security 之间又有什么“奸情”？

SpEL (Spring Expression Language) 是 Spring 框架提供的一种强大的表达式语言，它允许你在运行时查询和操作对象图。你可以把它想象成一个微型的编程语言，专门用来计算值。

那 SpEL 怎么和 Spring Security 搞到一起了呢？ 简单来说，Spring Security 借用了 SpEL 的强大功能，让我们可以用表达式来定义访问控制规则。 就像古代将军拿到了威力强大的火枪，可以更加精准地打击敌人，保护自己的领土。

三、SpEL 的基本语法：让你的权限规则像绕口令一样有趣！

SpEL 的语法其实很简单，我们可以把它想象成一个绕口令游戏，只要掌握了一些基本规则，就能玩得飞起。

• 字面量表达式: 这是最简单的一种，直接写值，比如 true、false、123、'hello'。
• 属性引用: 通过 .来访问对象的属性，比如 user.username、product.price。
• 方法调用: 调用对象的方法，比如 user.isAdmin()、product.calculateDiscount()。
• 运算符: 支持各种运算符，比如 +、-、*、/、==、!=、&&、||。
• 集合操作: 访问 List、Map 等集合的元素，比如 users[0]、products['name']。
• 三元运算符: condition ? value1 : value2，根据条件选择不同的值。
• 安全导航运算符: ?.，防止空指针异常，比如 user?.address?.city。
• SpEL 上下文: SpEL 可以访问 Spring Security 提供的上下文信息，比如 authentication (当前认证的用户信息)、principal (用户主体)、hasRole() (判断用户是否拥有某个角色)。

举几个栗子：

SpEL 表达式	含义
true	永远允许访问
false	永远拒绝访问
authentication.name == 'admin'	只有用户名为 "admin" 的用户才能访问
hasRole('ADMIN')	只有拥有 "ADMIN" 角色的用户才能访问
hasAuthority('permission:read')	只有拥有 "permission:read" 权限的用户才能访问
hasAnyRole('ADMIN', 'MANAGER')	只要拥有 "ADMIN" 或 "MANAGER" 角色之一的用户就能访问
hasAnyAuthority('permission:read', 'permission:write')	只要拥有 "permission:read" 或 "permission:write" 权限之一的用户就能访问
principal.id == #productId	只有用户 ID 等于产品 ID 的用户才能访问 (假设 #productId 是一个方法参数)
@myService.canAccess(#productId, authentication.name)	调用一个自定义的 Spring Bean (名为 myService) 的 canAccess 方法来判断用户是否有权限访问 (假设 #productId 是一个方法参数，authentication.name 是用户名)

是不是感觉像在玩文字游戏？ 只要掌握了这些基本规则，你就可以像诗人一样，用 SpEL 写出各种各样的权限规则，让你的代码充满艺术感！ 🎨

四、Spring Security 中 SpEL 的应用场景：让你的权限控制无处不在！

Spring Security 中，SpEL 就像一位百变魔术师，可以应用在各种不同的场景，让你的权限控制无处不在。

• 方法级别的权限控制 (Method Security): 这是最常用的场景之一。你可以在方法上使用 @PreAuthorize、@PostAuthorize、@PreFilter、@PostFilter 等注解，用 SpEL 表达式来定义方法的访问权限。

  • @PreAuthorize: 在方法执行之前进行权限检查，如果不满足条件，就抛出异常。
  • @PostAuthorize: 在方法执行之后进行权限检查，可以根据方法的返回值来决定是否允许访问。
  • @PreFilter: 对方法的参数进行过滤，只允许符合条件的值传递给方法。
  • @PostFilter: 对方法的返回值进行过滤，只返回符合条件的值。

  举个栗子：

  @PreAuthorize("hasRole('ADMIN')")
  public void deleteProduct(Long productId) {
      // 只有拥有 ADMIN 角色的用户才能删除产品
  }
  
  @PostAuthorize("returnObject.owner == authentication.name")
  public Product getProduct(Long productId) {
      // 只有产品的 owner 是当前用户才能访问
      return productRepository.findById(productId).orElse(null);
  }
  
  @PreFilter("filterObject.price > 100")
  public void updateProducts(@Param("products") List<Product> products) {
      // 只允许价格大于 100 的产品被更新
  }
  
  @PostFilter("filterObject.price > 100")
  public List<Product> getProducts() {
      // 只返回价格大于 100 的产品
      return productRepository.findAll();
  }

• Web 级别的权限控制 (Web Security): 你可以在 Spring Security 的配置类中使用 HttpSecurity 对象，用 antMatchers()、mvcMatchers() 等方法来配置 URL 的访问权限，也可以使用 SpEL 表达式来定义更复杂的访问规则。

  举个栗子：

  @Configuration
  @EnableWebSecurity
  @EnableMethodSecurity(prePostEnabled = true)
  public class SecurityConfig {
  
      @Bean
      public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
          http
              .authorizeHttpRequests((authz) -> authz
                  .antMatchers("/admin/**").hasRole("ADMIN")
                  .antMatchers("/products/{productId}").access("hasRole('ADMIN') or @productService.isProductOwner(#productId, authentication.name)") // 使用 SpEL
                  .anyRequest().permitAll()
              )
              .formLogin()
                  .permitAll()
              .and()
              .logout()
                  .permitAll();
  
          return http.build();
      }
  
      @Bean
      public PasswordEncoder passwordEncoder() {
          return new BCryptPasswordEncoder();
      }
  }

  在这个例子中，我们使用 SpEL 表达式 @productService.isProductOwner(#productId, authentication.name) 来判断用户是否有权限访问 /products/{productId} 这个 URL。 只有拥有 "ADMIN" 角色的用户，或者产品的 owner 是当前用户才能访问。

• 表达式访问决策管理器 (Expression-Based Access Decision Manager): 你可以自定义 AccessDecisionVoter，使用 SpEL 表达式来判断用户是否有权限访问某个资源。 这种方式更加灵活，可以满足各种复杂的权限控制需求。

  总而言之，只要你想得到，SpEL 就能做到！ 它就像一位全能选手，可以胜任各种不同的权限控制任务，让你的代码更加简洁、优雅、易于维护。

五、SpEL 的高级用法：让你的权限控制更上一层楼！

掌握了 SpEL 的基本语法和应用场景，你已经可以写出很多复杂的权限规则了。但是，SpEL 的潜力远不止于此。 接下来，我们来探索 SpEL 的一些高级用法，让你的权限控制更上一层楼！

• 自定义 SpEL 函数: 你可以自定义 SpEL 函数，在表达式中调用自己的代码。 这可以让你封装一些常用的权限判断逻辑，提高代码的复用性。

  举个栗子：

  @Component("mySpelFunctions")
  public class MySpelFunctions {
  
      public boolean isProductOwner(Long productId, String username) {
          // 你的判断逻辑
          return productService.isProductOwner(productId, username);
      }
  }

  然后在 Spring Security 的配置类中，将 MySpelFunctions 注册为 SpEL 函数：

  @Configuration
  @EnableMethodSecurity(prePostEnabled = true)
  public class SecurityConfig {
  
      @Autowired
      private MySpelFunctions mySpelFunctions;
  
      @Bean
      public DefaultMethodSecurityExpressionHandler expressionHandler() {
          DefaultMethodSecurityExpressionHandler handler = new DefaultMethodSecurityExpressionHandler();
          handler.setPermissionEvaluator(new MyPermissionEvaluator()); // 可选，如果需要自定义权限评估器
          handler.setTrustResolver(new AuthenticationTrustResolverImpl());
          handler.setRoleHierarchy(roleHierarchy()); // 可选，如果使用角色层级
  
          StandardEvaluationContext context = new StandardEvaluationContext();
          context.setVariable("mySpelFunctions", mySpelFunctions); // 注册 SpEL 函数
  
          handler.setExpressionParser(new SpelExpressionParser(new SpelParserConfiguration(true, true))); // 允许 null 属性访问
          handler.setEvaluationContext(context);
          return handler;
      }
  
      // ... 其他配置
  }

  现在，你就可以在 SpEL 表达式中调用 isProductOwner 函数了：

  @PreAuthorize("@mySpelFunctions.isProductOwner(#productId, authentication.name)")
  public void updateProduct(Long productId) {
      // 只有产品 owner 才能更新产品
  }

• 自定义 PermissionEvaluator: 你可以自定义 PermissionEvaluator，实现更复杂的权限评估逻辑。 PermissionEvaluator 允许你根据各种不同的条件来判断用户是否有权限访问某个资源，比如资源的类型、资源的属性、用户的角色等等。

  举个栗子：

  @Component
  public class MyPermissionEvaluator implements PermissionEvaluator {
  
      @Override
      public boolean hasPermission(Authentication authentication, Object targetDomainObject, Object permission) {
          if (targetDomainObject == null) {
              return false;
          }
  
          if (targetDomainObject instanceof Product) {
              Product product = (Product) targetDomainObject;
              if (permission.equals("read")) {
                  // 判断用户是否有权限读取产品
                  return product.getOwner().equals(authentication.getName()) || authentication.getAuthorities().stream().anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
              } else if (permission.equals("write")) {
                  // 判断用户是否有权限更新产品
                  return product.getOwner().equals(authentication.getName());
              }
          }
  
          return false;
      }
  
      @Override
      public boolean hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission) {
          // 根据 targetId 和 targetType 加载资源，然后调用上面的 hasPermission 方法
          return false;
      }
  }

  然后在 Spring Security 的配置类中，将 MyPermissionEvaluator 注册到 MethodSecurityExpressionHandler 中：

  @Configuration
  @EnableMethodSecurity(prePostEnabled = true)
  public class SecurityConfig {
  
      @Autowired
      private MyPermissionEvaluator myPermissionEvaluator;
  
      @Bean
      public DefaultMethodSecurityExpressionHandler expressionHandler() {
          DefaultMethodSecurityExpressionHandler handler = new DefaultMethodSecurityExpressionHandler();
          handler.setPermissionEvaluator(myPermissionEvaluator); // 注册 PermissionEvaluator
          return handler;
      }
  
      // ... 其他配置
  }

  现在，你就可以在 SpEL 表达式中使用 hasPermission 函数了：

  @PreAuthorize("hasPermission(#productId, 'Product', 'write')")
  public void updateProduct(Long productId) {
      // 只有拥有写权限的用户才能更新产品
  }

• 角色层级 (Role Hierarchy): 你可以配置角色层级，让拥有更高角色的用户自动拥有更低角色的权限。 比如，你可以配置 "ADMIN" 角色拥有 "MANAGER" 角色的权限，那么拥有 "ADMIN" 角色的用户就可以访问需要 "MANAGER" 角色才能访问的资源。

  举个栗子：

  @Bean
  public RoleHierarchy roleHierarchy() {
      RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();
      roleHierarchy.setHierarchy("ROLE_ADMIN > ROLE_MANAGER > ROLE_USER");
      return roleHierarchy;
  }

  然后在 Spring Security 的配置类中，将 RoleHierarchy 注册到 MethodSecurityExpressionHandler 中：

  @Configuration
  @EnableMethodSecurity(prePostEnabled = true)
  public class SecurityConfig {
  
      @Autowired
      private RoleHierarchy roleHierarchy;
  
      @Bean
      public DefaultMethodSecurityExpressionHandler expressionHandler() {
          DefaultMethodSecurityExpressionHandler handler = new DefaultMethodSecurityExpressionHandler();
          handler.setRoleHierarchy(roleHierarchy); // 注册 RoleHierarchy
          return handler;
      }
  
      // ... 其他配置
  }

  现在，拥有 "ADMIN" 角色的用户就可以访问需要 "MANAGER" 或 "USER" 角色才能访问的资源了。

六、SpEL 的最佳实践：让你的权限控制更安全、更可靠！

• 保持 SpEL 表达式的简洁性: 尽量避免在 SpEL 表达式中写过于复杂的逻辑，可以将复杂的逻辑封装到自定义函数或 PermissionEvaluator 中。
• 使用安全导航运算符 (?.): 防止空指针异常，特别是当访问嵌套对象的属性时。
• 避免在 SpEL 表达式中使用高危函数: 比如 T(java.lang.Runtime).getRuntime().exec('evil command')，这可能会导致安全漏洞。
• 对 SpEL 表达式进行单元测试: 确保你的权限规则能够正确地工作。
• 使用 Spring Security 提供的内置函数: 比如 hasRole()、hasAuthority()、permitAll()、denyAll() 等，这些函数经过了严格的测试，可以保证安全性。
• 使用参数化查询: 如果 SpEL 表达式中需要使用用户输入的数据，一定要使用参数化查询，防止 SQL 注入攻击。

七、总结：SpEL，权限控制的艺术！

Spring Security SpEL 就像一把锋利的宝剑，可以帮助你构建更安全、更灵活、更优雅的权限控制系统。 掌握了 SpEL 的基本语法和应用场景，你就可以像艺术家一样，用简洁的表达式来定义复杂的权限规则，让你的代码充满艺术感！

记住，权限控制不仅仅是技术，更是一门艺术。 只有不断学习、不断实践，才能真正掌握这门艺术，让你的代码更加安全、可靠、易于维护！

希望今天的分享对大家有所帮助。 下次有机会，我们再聊聊 Spring Security 的其他高级特性！ 祝大家编码愉快！ 🚀