背景与初衷

在现代Web应用程序中，安全性是一个不可忽视的重要方面。除了对HTTP请求的控制之外，应用程序中的方法级别的安全性也至关重要。Spring Security 提供了强大的全局方法安全性功能，通过预授权（Pre-authorization）和后授权（Post-authorization）、预过滤（Pre-filtering）和后过滤（Post-filtering）等机制，确保应用程序在方法级别上的安全性。

目标

本文旨在详细介绍Spring Security中的全局方法安全性，包括预授权和后授权、预过滤和后过滤的实现和应用。通过这些机制，开发者可以在方法级别上实现细粒度的安全控制，确保应用程序的安全性和可靠性。

预授权和后授权

预授权（Pre-authorization）

预授权是指在方法调用之前对方法进行安全性检查。通过使用Spring Security的@PreAuthorize注解，可以在方法执行之前验证当前用户的权限。如果用户不具备所需的权限，方法调用将被阻止。

示例代码

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;
@Service
public class UserService {
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long userId) {
        // 删除用户的逻辑
    }
}

在上述示例中，deleteUser方法只有在当前用户具备ADMIN角色时才能执行。如果用户没有ADMIN角色，Spring Security将阻止该方法的调用。

后授权（Post-authorization）

后授权是指在方法调用之后对返回结果进行安全性检查。通过使用Spring Security的@PostAuthorize注解，可以在方法执行之后验证返回结果是否符合安全性要求。如果返回结果不符合要求，方法调用将被阻止。

示例代码

import org.springframework.security.access.prepost.PostAuthorize;
import org.springframework.stereotype.Service;
@Service
public class UserService {
    @PostAuthorize("returnObject.username == authentication.name")
    public User getUser(Long userId) {
        // 获取用户的逻辑
        return new User(userId, "username"); // 示例用户
    }
}

在上述示例中，getUser方法返回的User对象只有在其用户名与当前认证用户的用户名一致时才被允许返回。如果不一致，Spring Security将阻止该方法的调用。

预过滤和后过滤

预过滤（Pre-filtering）

预过滤是指在方法调用之前对方法参数进行过滤。通过使用Spring Security的@PreFilter注解，可以在方法执行之前过滤掉不符合条件的参数。

示例代码

import org.springframework.security.access.prepost.PreFilter;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserService {
    @PreFilter("filterObject.owner == authentication.name")
    public void updateUsers(List<User> users) {
        // 更新用户的逻辑
    }
}

在上述示例中，updateUsers方法中的用户列表users在方法执行之前将被过滤，只有当前用户是用户的所有者的对象才会被保留。

后过滤（Post-filtering）

后过滤是指在方法调用之后对返回结果进行过滤。通过使用Spring Security的@PostFilter注解，可以在方法执行之后过滤掉不符合条件的返回结果。

示例代码

import org.springframework.security.access.prepost.PostFilter;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserService {
    @PostFilter("filterObject.owner == authentication.name")
    public List<User> getUsers() {
        // 获取用户的逻辑
        return List.of(new User(1L, "username1"), new User(2L, "username2")); // 示例用户列表
    }
}

在上述示例中，getUsers方法返回的用户列表在方法执行之后将被过滤，只有当前用户是用户的所有者的对象才会被保留。

环境配置

项目结构

项目的结构如下：

method-security-demo
├── src
│   ├── main
│   │   ├── java
│   │   │   ├── com
│   │   │   │   ├── example
│   │   │   │   │   ├── MethodSecurityDemoApplication.java
│   │   │   │   │   ├── config
│   │   │   │   │   │   └── SecurityConfig.java
│   │   │   │   │   ├── controller
│   │   │   │   │   │   └── UserController.java
│   │   │   │   │   ├── model
│   │   │   │   │   │   └── User.java
│   │   │   │   │   ├── repository
│   │   │   │   │   │   └── UserRepository.java
│   │   │   │   │   ├── service
│   │   │   │   │   │   └── UserService.java
│   │   │   │   │   └── security
│   │   │   │   │       └── CustomUserDetailsService.java
│   │   ├── resources
│   │   │   └── application.properties
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── MethodSecurityDemoApplicationTests.java

代码实现

MethodSecurityDemoApplication.java

package com.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MethodSecurityDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(MethodSecurityDemoApplication.class, args);
    }
}

application.properties

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update

User.java

package com.example.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    private String roles;
    private String owner;
    // Constructors, getters, and setters
    public User() {
    }
    public User(Long id, String username) {
        this.id = id;
        this.username = username;
    }
    // ... other constructors, getters and setters
}

UserRepository.java

package com.example.repository;
import com.example.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}

CustomUserDetailsService.java

package com.example.security;
import com.example.model.User;
import com.example.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
@Service
public class CustomUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found");
        }
        return org.springframework.security.core.userdetails.User
                .withUsername(user.getUsername())
                .password(user.getPassword())
                .roles(user.getRoles().split(","))
                .build();
    }
}

UserService.java

package com.example.service;
import com.example.model.User;
import com.example.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.access.prepost.PostAuthorize;
import org.springframework.security.access.prepost.PreFilter;
import org.springframework.security.access.prepost.PostFilter;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long userId) {
        userRepository.deleteById(userId);
    }
    @PostAuthorize("returnObject.username == authentication.name")
    public User getUser(Long userId) {
        return userRepository.findById(userId).orElse(null);
    }
    @PreFilter("filterObject.owner == authentication.name")
    public void updateUsers(List<User> users) {
        userRepository.saveAll(users);
    }
    @PostFilter("filterObject.owner == authentication.name")
    public List<User> getUsers() {
        return userRepository.findAll();
    }
}

SecurityConfig.java

package com.example.config;
import com.example.security.CustomUserDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import
 org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private CustomUserDetailsService customUserDetailsService;
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(customUserDetailsService).passwordEncoder(passwordEncoder());
    }
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests().antMatchers("/login").permitAll()
            .anyRequest().authenticated()
            .and()
            .formLogin().permitAll()
            .and()
            .logout().permitAll();
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

UserController.java

package com.example.controller;
import com.example.model.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }
    @PostMapping("/update")
    public void updateUsers(@RequestBody List<User> users) {
        userService.updateUsers(users);
    }
    @GetMapping
    public List<User> getUsers() {
        return userService.getUsers();
    }
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

详细解读

在这个示例中，我们创建了一个简单的Spring Boot Web应用程序，并通过Spring Security实现了全局方法安全性。以下是关键组件的详细解读：

1. User 模型：定义了用户实体类，用户可以拥有多个角色，并且有一个所有者字段，用于预过滤和后过滤。
2. UserRepository：定义了用户的JPA仓库接口，用于数据库操作。
3. CustomUserDetailsService：实现Spring Security的UserDetailsService接口，用于从数据库中加载用户信息。
4. UserService：定义了用户相关的业务逻辑，包括使用@PreAuthorize、@PostAuthorize、@PreFilter和@PostFilter注解的方法。
5. SecurityConfig：配置Spring Security，包括启用全局方法安全性、配置用户详细信息服务、密码编码器等。
6. UserController：提供用户相关的API端点，通过调用UserService中的方法实现具体功能。

预授权和后授权

预授权的应用场景

预授权主要用于以下场景：

1. 访问控制：在调用关键方法之前验证用户的权限，确保只有具备相应权限的用户才能执行敏感操作。
2. 业务逻辑保护：在业务方法调用之前进行权限检查，防止非法操作。

示例代码：

@PreAuthorize("hasRole('ADMIN')")
public void createSensitiveData() {
    // 创建敏感数据的逻辑
}

后授权的应用场景

后授权主要用于以下场景：

1. 返回结果验证：在方法执行之后验证返回结果是否符合安全性要求，确保只有合法的数据可以返回给客户端。
2. 数据保护：在返回数据之前进行权限检查，防止敏感数据泄露。

示例代码：

@PostAuthorize("returnObject.owner == authentication.name")
public Data getSensitiveData(Long dataId) {
    // 获取敏感数据的逻辑
    return new Data(dataId, "data"); // 示例数据
}

预过滤和后过滤

预过滤的应用场景

预过滤主要用于以下场景：

1. 参数过滤：在方法调用之前过滤不符合条件的参数，确保只有合法的参数被传递给方法。
2. 数据验证：在方法执行之前对参数进行验证，确保数据的合法性和完整性。

示例代码：

@PreFilter("filterObject.owner == authentication.name")
public void processSensitiveData(List<Data> dataList) {
    // 处理敏感数据的逻辑
}

后过滤的应用场景

后过滤主要用于以下场景：

1. 返回结果过滤：在方法执行之后过滤不符合条件的返回结果，确保只有合法的数据可以返回给客户端。
2. 数据保护：在返回数据之前对结果进行过滤，防止敏感数据泄露。

示例代码：

@PostFilter("filterObject.owner == authentication.name")
public List<Data> getSensitiveDataList() {
    // 获取敏感数据的逻辑
    return List.of(new Data(1L, "data1"), new Data(2L, "data2")); // 示例数据列表
}

实际应用中的示例

为了更好地理解预授权、后授权、预过滤和后过滤的应用，我们将构建一个更加复杂的应用程序示例，包括用户注册、登录、权限管理等功能。

项目结构

项目的结构如下：

advanced-method-security-demo
├── src
│   ├── main
│   │   ├── java
│   │   │   ├── com
│   │   │   │   ├── example
│   │   │   │   │   ├── AdvancedMethodSecurityDemoApplication.java
│   │   │   │   │   ├── config
│   │   │   │   │   │   └── SecurityConfig.java
│   │   │   │   │   ├── controller
│   │   │   │   │   │   └── UserController.java
│   │   │   │   │   ├── model
│   │   │   │   │   │   └── User.java
│   │   │   │   │   │   └── Role.java
│   │   │   │   │   ├── repository
│   │   │   │   │   │   └── UserRepository.java
│   │   │   │   │   │   └── RoleRepository.java
│   │   │   │   │   ├── service
│   │   │   │   │   │   └── UserService.java
│   │   │   │   │   │   └── RoleService.java
│   │   │   │   │   └── security
│   │   │   │   │       └── CustomUserDetailsService.java
│   │   ├── resources
│   │   │   └── application.properties
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── AdvancedMethodSecurityDemoApplicationTests.java

代码实现

AdvancedMethodSecurityDemoApplication.java

package com.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class AdvancedMethodSecurityDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(AdvancedMethodSecurityDemoApplication.class, args);
    }
}

application.properties

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update

User.java

package com.example.model;
import javax.persistence.*;
import java.util.Set;
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id"))
    private Set<Role> roles;
    // Constructors, getters, and setters
    public User() {
    }
    public User(Long id, String username) {
        this.id = id;
        this.username = username;
    }
    // ... other constructors, getters and setters
}

Role.java

package com.example.model;
import javax.persistence.*;
import java.util.Set;
@Entity
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    @ManyToMany(mappedBy = "roles")
    private Set<User> users;
    // Getters and setters
}

UserRepository.java

package com.example.repository;
import com.example.model.User;
import
 org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}

RoleRepository.java

package com.example.repository;
import com.example.model.Role;
import org.springframework.data.jpa.repository.JpaRepository;
public interface RoleRepository extends JpaRepository<Role, Long> {
    Role findByName(String name);
}

CustomUserDetailsService.java

package com.example.security;
import com.example.model.User;
import com.example.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
@Service
public class CustomUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found");
        }
        return org.springframework.security.core.userdetails.User
                .withUsername(user.getUsername())
                .password(user.getPassword())
                .roles(user.getRoles().stream().map(Role::getName).toArray(String[]::new))
                .build();
    }
}

UserService.java

package com.example.service;
import com.example.model.User;
import com.example.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.access.prepost.PostAuthorize;
import org.springframework.security.access.prepost.PreFilter;
import org.springframework.security.access.prepost.PostFilter;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long userId) {
        userRepository.deleteById(userId);
    }
    @PostAuthorize("returnObject.username == authentication.name")
    public User getUser(Long userId) {
        return userRepository.findById(userId).orElse(null);
    }
    @PreFilter("filterObject.owner == authentication.name")
    public void updateUsers(List<User> users) {
        userRepository.saveAll(users);
    }
    @PostFilter("filterObject.owner == authentication.name")
    public List<User> getUsers() {
        return userRepository.findAll();
    }
}

SecurityConfig.java

package com.example.config;
import com.example.security.CustomUserDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private CustomUserDetailsService customUserDetailsService;
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(customUserDetailsService).passwordEncoder(passwordEncoder());
    }
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests().antMatchers("/login").permitAll()
            .anyRequest().authenticated()
            .and()
            .formLogin().permitAll()
            .and()
            .logout().permitAll();
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

UserController.java

package com.example.controller;
import com.example.model.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }
    @PostMapping("/update")
    public void updateUsers(@RequestBody List<User> users) {
        userService.updateUsers(users);
    }
    @GetMapping
    public List<User> getUsers() {
        return userService.getUsers();
    }
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

总结

通过本文，我们详细介绍了Spring Security中的全局方法安全性，包括预授权和后授权、预过滤和后过滤的实现和应用。我们探讨了这些机制的基本概念和工作原理，展示了如何在实际应用中实现这些安全措施，并通过详细的示例展示了具体的实现方法。

全局方法安全性是确保应用程序在方法级别上的安全性的重要手段。通过合理配置和使用预授权、后授权、预过滤和后过滤功能，开发者可以实现细粒度的安全控制，确保只有具备相应权限的用户才能执行敏感操作，只有符合条件的数据才能返回给客户端，从而构建出更加安全和可靠的Web应用程序。

在实际应用中，开发者应根据具体的业务需求和安全要求，灵活配置和使用Spring Security中的全局方法安全性功能，从而构建出更加安全和可靠的Web应用程序。通过遵循最佳实践，可以有效提高应用程序的安全性和性能，确保其在复杂的场景下仍能保持高水平的安全保护。