Spring Boot 应用中 HTTP 到 HTTPS 的健壮重定向策略

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    // ... 其他安全配置 ...

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception{
        return httpSecurity
                // ... 其他授权规则 ...
                .requiresChannel()
                    .anyRequest().requiresSecure() // 要求所有请求必须是安全的
                .and()
                .portMapper()
                    .http(8080).mapsTo(8443) // 将 HTTP 8080 映射到 HTTPS 8443
                .and().build();
    }

    // ... 其他 Bean ...
}

package tacos.config;

import org.apache.catalina.Context;
import org.apache.catalina.connector.Connector;
import org.apache.tomcat.util.descriptor.web.SecurityCollection;
import org.apache.tomcat.util.descriptor.web.SecurityConstraint;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import tacos.repository.UserRepository;

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
@EnableWebSecurity
public class SecurityConfig {

    // ... 其他 Spring Security 相关 Bean，如 passwordEncoder(), userDetailsService(), filterChain() ...
    // 注意：filterChain() 中可以保留 requiresChannel().anyRequest().requiresSecure()，
    // 但 portMapper().http(8080).mapsTo(8443) 在此方案下并非强制，
    // 因为重定向由 Tomcat 连接器直接处理。

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

    // 假设 userDetailsService 和 filterChain 保持原有逻辑，此处省略，
    // 但确保 filterChain 中不再强依赖 portMapper 进行重定向，
    // 或者即使有，Tomcat 级别的重定向会先发生。

    @Bean
    public UserDetailsService userDetailsService(UserRepository userRepository){
        return username -> {
            // ... 用户查找逻辑 ...
            return null; // 示例，实际应返回 UserDetails
        };
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception{
        // 这里的 SecurityFilterChain 可以保持原样，或者移除 portMapper 部分，
        // 因为 Tomcat 级别的重定向会优先执行。
        // requiresChannel().anyRequest().requiresSecure() 仍然可以保留，作为安全保障。
        return httpSecurity.authorizeRequests()
                .antMatchers("/design","/orders","/orders/*").hasRole("USER")
                .antMatchers("/", "/**").permitAll()
                .antMatchers("/h2-console/**").permitAll()
                .and()
                .csrf().ignoringAntMatchers("/h2-console/**")
                .and()
                .headers().frameOptions().sameOrigin()
                .and()
                .formLogin().loginPage("/login")
                .loginProcessingUrl("/authenticate")
                .usernameParameter("user")
                .passwordParameter("pwd")
                .defaultSuccessUrl("/design", true)
                .and()
                .oauth2Login().loginPage("/login")
                .and()
                .logout()
                .and()
                .requiresChannel().anyRequest().requiresSecure() // 仍然建议保留此行作为安全层面的要求
                // .and()
                // .portMapper().http(8080).mapsTo(8443) // 此行在此 Tomcat 方案下可移除或保留，但不再是主要重定向机制
                .and().build();
    }

    /**
     * 配置嵌入式 Tomcat 服务器，添加 HTTP 到 HTTPS 的重定向连接器。
     */
    @Bean
    public ServletWebServerFactory servletContainer() {
        TomcatServletWebServerFactory tomcat = new TomcatWebServerFactory() {
            @Override
            protected void postProcessContext(Context context) {
                // 创建一个安全约束，要求所有请求必须是 CONFIDENTIAL (HTTPS)
                SecurityConstraint securityConstraint = new SecurityConstraint();
                securityConstraint.setUserConstraint("CONFIDENTIAL"); // 强制使用 HTTPS
                SecurityCollection collection = new SecurityCollection();
                collection.addPattern("/*"); // 匹配所有 URL 模式
                securityConstraint.addCollection(collection);
                context.addConstraint(securityConstraint);
            }
        };
        // 添加一个额外的 Tomcat 连接器，用于处理 HTTP 请求并重定向到 HTTPS
        tomcat.addAdditionalTomcatConnectors(redirectConnector());
        return tomcat;
    }

    /**
     * 创建一个用于 HTTP 重定向的 Tomcat 连接器。
     */
    private Connector redirectConnector() {
        Connector connector = new new Connector("org.apache.coyote.http11.Http11NioProtocol"); // 使用 NIO 协议
        connector.setScheme("http"); // 设置连接器协议为 HTTP
        connector.setPort(8080); // 监听 HTTP 端口
        connector.setSecure(false); // 标记为非安全连接器
        connector.setRedirectPort(8443); // 将所有请求重定向到 HTTPS 8443 端口
        return connector;
    }
}