httpsecurity调用接口返回login

这个问题比较抽象，我不知道你具体指的是什么情况。但是通常来说，当调用一个需要认证的接口时，如果用户未登录或者认证信息无效，服务器会返回一个 HTTP 401 Unauthorized 状态码，提示用户需要进行登录。此时，客户端应该跳转到登录界面，让用户输入用户名和密码进行认证。认证成功后，服务器会返回一个带有认证信息的 token，客户端需要将该 token 存储起来，并且每次调用需要认证的接口时都带上该 token，以便服务器验证用户的身份。如果客户端在调用接口时没有带上有效的 token，服务器会返回 HTTP 401 Unauthorized 状态码，此时客户端应该跳转到登录界面，让用户重新进行认证。

相关问题

Spring Security如何在接口中登录方式

Spring Security提供了多种方式来实现接口中的登录，其中常见的方式是使用token认证。以下是一个简单的示例：

1. 配置Spring Security

在Spring Security的配置文件中，需要配置一个TokenAuthenticationFilter来处理token认证。具体如下：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .apply(new JwtConfigurer(jwtTokenProvider));
    }

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

    @Bean
    public JwtTokenProvider jwtTokenProvider() {
        return new JwtTokenProvider();
    }

    @Bean
    public TokenAuthenticationFilter jwtAuthenticationTokenFilter() throws Exception {
        return new TokenAuthenticationFilter();
    }
}

2. 创建TokenAuthenticationFilter

TokenAuthenticationFilter是一个过滤器，用于在请求头中读取并验证token。具体如下：

public class TokenAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = jwtTokenProvider.resolveToken(request);
        if (token != null && jwtTokenProvider.validateToken(token)) {
            Authentication auth = jwtTokenProvider.getAuthentication(token);
            if (auth != null) {
                SecurityContextHolder.getContext().setAuthentication(auth);
            }
        }
        filterChain.doFilter(request, response);
    }
}

3. 创建JwtTokenProvider

JwtTokenProvider用于生成和验证token。具体如下：

public class JwtTokenProvider {

    private static final String SECRET_KEY = "secret_key";
    private static final long EXPIRATION_TIME = 864_000_000; // 10 days
    private static final String TOKEN_PREFIX = "Bearer ";
    private static final String HEADER_STRING = "Authorization";

    public String createToken(String username) {
        Claims claims = Jwts.claims().setSubject(username);

        Date now = new Date();
        Date validity = new Date(now.getTime() + EXPIRATION_TIME);

        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(validity)
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }

    public Authentication getAuthentication(String token) {
        String username = getUsername(token);
        User user = userService.loadUserByUsername(username);
        return new UsernamePasswordAuthenticationToken(user, "", user.getAuthorities());
    }

    public String getUsername(String token) {
        return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody().getSubject();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
            return true;
        } catch (SignatureException | MalformedJwtException | ExpiredJwtException | UnsupportedJwtException | IllegalArgumentException ex) {
            return false;
        }
    }

    public String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader(HEADER_STRING);
        if (bearerToken != null && bearerToken.startsWith(TOKEN_PREFIX)) {
            return bearerToken.substring(TOKEN_PREFIX.length());
        }
        return null;
    }
}

4. 创建登录接口

在登录接口中，需要调用JwtTokenProvider.createToken方法生成token，并将token返回给客户端。具体如下：

@RestController
public class LoginController {

    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody LoginRequest loginRequest) {
        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                        loginRequest.getUsername(),
                        loginRequest.getPassword()
                )
        );
        SecurityContextHolder.getContext().setAuthentication(authentication);
        String token = jwtTokenProvider.createToken(loginRequest.getUsername());
        return ResponseEntity.ok(new JwtResponse(token));
    }
}

5. 测试接口

使用Postman等工具发送请求，将生成的token放入请求头中，即可访问需要登录后才能访问的接口。

Spring Security在登录接口自定义一个过期时间过滤器如何实现

要在Spring Security的登录接口中自定义一个过期时间过滤器，你可以按照以下步骤进行操作：

1. 创建一个过滤器类，实现`javax.servlet.Filter`接口。你可以命名为`ExpirationFilter`。

import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class ExpirationFilter extends UsernamePasswordAuthenticationFilter {

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        UserDetails userDetails = (UserDetails) authResult.getPrincipal();
        // 在这里获取用户登录成功的信息，包括过期时间
        // 比较过期时间与当前时间，如果已过期则进行相应的处理
        // 比如返回一个自定义的错误信息或者进行重新登录等操作
        
        // 调用父类的方法，继续处理认证成功后的操作
        super.successfulAuthentication(request, response, chain, authResult);
    }
}

2. 在Spring Security配置类中，将自定义的过滤器添加到登录接口的过滤器链中。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
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;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private ExpirationFilter expirationFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .addFilterBefore(expirationFilter, UsernamePasswordAuthenticationFilter.class)
            .authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .and()
            .logout()
                .logoutUrl("/logout");
    }
}

在上述配置中，通过`addFilterBefore`方法将`ExpirationFilter`添加到`UsernamePasswordAuthenticationFilter`之前，确保过期时间的检查在身份验证之后进行。

请注意，以上代码只是一个示例，你需要根据你的实际需求进行相应的修改和逻辑处理。