SpringSecurity详解整合JWT实现全过程

介绍

本文将详细讲解如何使用Spring Security和JWT实现基于token的用户身份认证和授权管理，帮助开发者更好地理解和使用Spring Security，同时提高安全性能和开发效率。

知识储备

在阅读本文之前，请确保你已经熟悉以下内容：

1. Spring框架，特别是Spring Security模块；
2. JWT的基本原理和用法；
3. RESTfulAPI接口的设计和实现。

实现过程

1. 创建Spring Boot项目并导入依赖

在创建Spring Boot项目时，需要同时添加Spring Security和JWT的相关依赖。

<!-- Spring Security Core -->
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-core</artifactId>
    <version>5.1.6.RELEASE</version>
</dependency>

<!-- Spring Security Web -->
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-web</artifactId>
    <version>5.1.6.RELEASE</version>
</dependency>

<!-- Spring Security Config -->
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-config</artifactId>
    <version>5.1.6.RELEASE</version>
</dependency>

<!-- Spring MVC -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.3.9.RELEASE</version>
</dependency>

<!-- Jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>

<!-- JWT -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

2. 配置Spring Security

在Spring Security的配置类中，需要定义用户身份认证和授权管理的相关信息。这里我们使用内存模式来存储用户信息。

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests()
                .antMatchers("/api/v1/authenticate").permitAll()
                .anyRequest().authenticated()
                .and()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService)
                .passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.addAllowedOrigin("*");
        configuration.addAllowedMethod("*");
        configuration.addAllowedHeader("*");

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);

        return source;
    }
}

3. 实现用户登录

在用户登录过程中，需要检查用户的登录信息，并返回包含用户信息的JWT token。

@RestController
public class AuthController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JwtUtils jwtUtils;

    @PostMapping("/api/v1/authenticate")
    public ResponseEntity<Object> authenticate(@RequestBody LoginDTO loginDTO) {
        try {
            authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(
                            loginDTO.getUsername(),
                            loginDTO.getPassword()
                    )
            );
        } catch (Exception e) {
            return ResponseEntity.badRequest().body("invalid username or password");
        }

        UserDetails userDetails = userDetailsService.loadUserByUsername(loginDTO.getUsername());
        String token = jwtUtils.generateToken(userDetails);

        return ResponseEntity.ok(new AuthToken(token));
    }
}

4. 实现用户注册和角色授权

在用户注册过程中，需要加密存储用户的密码信息，同时创建对应的用户角色信息（这里我们使用了简单的角色定义方式）。

@RestController
public class UserController {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @PostMapping("/api/v1/users")
    public ResponseEntity<Object> register(@RequestBody UserDTO userDTO) {
        User user = new User();
        user.setUsername(userDTO.getUsername());
        user.setPassword(passwordEncoder.encode(userDTO.getPassword()));
        user.setRole(userDTO.getRole());

        try {
            userDetailsService.loadUserByUsername(user.getUsername());
            return ResponseEntity.badRequest().body("user already exists");
        } catch (UsernameNotFoundException e) {}

        userDetailsService.createUser(user);

        return ResponseEntity.ok(user);
    }

    @PostMapping("/api/v1/users/{username}/roles")
    public ResponseEntity<Object> authorize(@PathVariable("username") String username, @RequestBody List<String> roles) {
        User user = (User) userDetailsService.loadUserByUsername(username);

        if (user == null) {
            return ResponseEntity.notFound().build();
        }

        user.setRoles(new HashSet<>(roles));
        userDetailsService.updateUser(user);

        return ResponseEntity.ok(user);
    }
}

5. 实现API接口的安全访问

在访问API接口时，需要使用用户的JWT token进行身份验证或授权管理，这里我们可以使用Spring Security提供的注解来实现。

@RestController
public class UserController {

    @GetMapping("/api/v1/users")
    public ResponseEntity<Object> getUsers() {
        Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        if (principal instanceof UserDetails) {
            return ResponseEntity.ok("list of users");
        }

        return ResponseEntity.unauthorized().build();
    }

    @Secured("ROLE_ADMIN")
    @GetMapping("/api/v1/users/{username}")
    public ResponseEntity<Object> getUser(@PathVariable("username") String username) {
        return ResponseEntity.ok("user " + username);
    }
}

示例1：使用Postman测试

我们可以使用Postman来完成以下测试：

1. 使用POST请求发送用户登录信息（例如：用户名为user，密码为password）获取JWT token；
2. 使用JWT token作为请求头（Authorization:Bearer token）访问安全API接口。

示例2：使用Java代码验证

我们可以使用以下Java代码来测试：

1. 创建一个基于Spring的Java应用程序；
2. 使用Java程序访问安全API接口，通过JWT token验证和授权。

public class Client {

    public static void main(String[] args) {
        String token = "your_jwt_token_here";

        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.add("Authorization", "Bearer " + token);
        HttpEntity<Object> requestEntity = new HttpEntity<>(headers);

        ResponseEntity<Object> responseEntity = restTemplate.exchange("http://localhost:8080/api/v1/users", HttpMethod.GET, requestEntity, Object.class);
        System.out.println(responseEntity.getBody());
    }
}

结论

通过本文的讲解，我们可以清晰地了解如何使用Spring Security和JWT来实现基于token的用户身份认证和授权管理，并提高安全性能和开发效率。在Spring MVC应用程序中，Spring Security已被广泛使用，因此我们可以用它来保护我们的业务数据和实现用户管理。