Springboot utilise Tomcat comme conteneur pour réaliser deux manières de rediriger http vers https!

1. Introduction

Cet article explique comment implémenter la redirection Http vers Https via le code dans Springboot. Cet article explique uniquement le cas de Tomcat en tant que conteneur, et d'autres conteneurs seront réunis à l'avenir.

2. Concepts associés

2.1 Qu'est-ce que la redirection

La soi-disant redirection signifie que vous vouliez à l'origine parcourir l'adresse A, mais après être arrivé sur le serveur, le serveur pense que l'interface de l'adresse A n'est plus là ou que vous n'êtes pas autorisé à y accéder. Il ne veut pas que vous visitiez l'adresse A; il vous suffit de vous indiquer une autre adresse B, Ensuite, vous allez visiter l'adresse B.

Il existe généralement deux codes de retour pour la redirection:

• 301: redirection permanente;
• 302: redirection temporaire.

Vérifiez les détails du réseau via Chrome et enregistrez la redirection de plusieurs sites Web:

site Internet	nom de domaine	Code de redirection	URL après redirection
Parlez lentement de citrouille	www.pkslow.com	301	https://www.pkslow.com
Google	www.google.com	307	https://www.google.com
Pomme	www.apple.com	307	https://www.apple.com
Alipay	www.alipay.com	301	https://www.alipay.com
QQ	www.qq.com	302	https://www.qq.com
Baidu	www.baidu.com	307	https://www.baidu.com

Remarque: 307 est également une sorte de redirection, qui est un nouveau code de statut.

2.2 Pourquoi rediriger

Combiné avec le tableau que j'ai spécifiquement énuméré ci-dessus, pensez-vous probablement pourquoi ce type de redirection est nécessaire? Il n'est pas difficile de constater que les redirections ci-dessus font une chose, qui est de rediriger http vers https. Les raisons sont les suivantes:

(1) http n'est pas sécurisé, vous devez utiliser une URL https sécurisée;

(2) Mais vous ne pouvez pas obliger les utilisateurs à saisir https: // chaque fois qu'ils accèdent à un site Web. C'est trop gênant, donc tout le monde est habitué à n'entrer que le nom de domaine, pas même www. Par conséquent, l'entrée de l'utilisateur est en fait d'accéder à la page Web http et elle doit être redirigée vers https pour répondre aux exigences d'un accès sécurisé.

2.3 Comment rediriger

Tout d'abord, le serveur doit prendre en charge http et https en même temps, sinon il n'y aura pas de redirection. Parce que https est nécessaire pour fournir un support, alors pourquoi fournir des services http? N'est-il pas simplement inutile de visiter directement https? La raison a déjà été mentionnée. Tout le monde est habitué à n'entrer qu'un simple nom de domaine à visiter. Pour le moment, il s'agit de http. Si vous ne fournissez pas d'assistance http, les utilisateurs pensent que votre site Web est déjà en panne.

Les deux protocoles fournissent une prise en charge, il est donc nécessaire d'ouvrir deux ports Socket. Généralement, http est 80 et https est 443. Ensuite, vous devez rediriger toutes les requêtes HTTP vers https. Différents serveurs ont des implémentations différentes. Maintenant, introduisez l'implémentation de Springboot + Tomcat.

3. Springboot Tomcat implémente la redirection

Lorsque Springboot utilise Tomcat comme conteneur de servlet, il existe deux façons de réaliser la redirection, l'une sans Spring Security et l'autre avec Spring Security. La structure du code est la suivante: le

code de la classe principale est le suivant:

package com.pkslow.ssl;

import com.pkslow.ssl.config.containerfactory.HttpToHttpsContainerFactoryConfig;
import com.pkslow.ssl.config.security.EnableHttpWithHttpsConfig;
import com.pkslow.ssl.config.security.HttpToHttpsWebSecurityConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

@SpringBootApplication
@Import({
    
    EnableHttpWithHttpsConfig.class, HttpToHttpsWebSecurityConfig.class})
//@Import(HttpToHttpsContainerFactoryConfig.class)
@ComponentScan(basePackages = "com.pkslow.ssl.controller")
public class SpringbootSslApplication {
    
    

	public static void main(String[] args) {
    
    
		SpringApplication.run(SpringbootSslApplication.class, args);
	}
	
}

@ComponentScan (basePackages = "com.pkslow.ssl.controller"): Le package de configuration n'est pas analysé car nous voulons utiliser @Import pour contrôler la méthode utilisée pour la redirection. Bien sûr, vous pouvez également utiliser d'autres méthodes de contrôle, telles que @ConditionalOnProperty, qui ne seront pas abordées ici.

• Lorsque Spring Security n'est pas utilisé, @Import (HttpToHttpsContainerFactoryConfig.class) est utilisé;
• Lorsque vous utilisez Spring Security, utilisez @Import ({EnableHttpWithHttpsConfig.class,
  HttpToHttpsWebSecurityConfig.class}).

Le contenu du fichier de configuration application.properties est le suivant:

server.port=443
http.port=80

server.ssl.enabled=true
server.ssl.key-store-type=jks
server.ssl.key-store=classpath:localhost.jks
server.ssl.key-store-password=changeit
server.ssl.key-alias=localhost

Besoin de spécifier deux ports, server.port est le port https; http.port est le port http. Notez qu'en l'absence de https, server.port fait référence au port http.

3.1 Configurer Container Factory pour implémenter la redirection

La classe configurée est HttpToHttpsContainerFactoryConfig, le code est le suivant:

package com.pkslow.ssl.config.containerfactory;

import org.apache.catalina.Context;
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.context.annotation.Bean;
import org.apache.catalina.connector.Connector;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

@Configuration
public class HttpToHttpsContainerFactoryConfig {
    
    
    @Value("${server.port}")
    private int httpsPort;

    @Value("${http.port}")
    private int httpPort;

    @Bean
    public TomcatServletWebServerFactory servletContainer() {
    
    
        TomcatServletWebServerFactory tomcat =
                new TomcatServletWebServerFactory() {
    
    

                    @Override
                    protected void postProcessContext(Context context) {
    
    
                        SecurityConstraint securityConstraint = new SecurityConstraint();
                        securityConstraint.setUserConstraint("CONFIDENTIAL");
                        SecurityCollection collection = new SecurityCollection();
                        collection.addPattern("/*");
                        securityConstraint.addCollection(collection);
                        context.addConstraint(securityConstraint);
                    }
                };
        tomcat.addAdditionalTomcatConnectors(createHttpConnector());
        return tomcat;
    }

    private Connector createHttpConnector() {
    
    
        Connector connector =
                new Connector(TomcatServletWebServerFactory.DEFAULT_PROTOCOL);
        connector.setScheme("http");
        connector.setSecure(false);
        connector.setPort(httpPort);
        connector.setRedirectPort(httpsPort);
        return connector;
    }
}

createHttpConnector (): Cette méthode réalise principalement la fonction d'ouverture de http sous la prémisse de https, et de configuration du port https redirigé.

3.2 Configurer la sécurité Spring pour implémenter la redirection

Il existe deux classes de configuration, l'une pour ouvrir le service http et l'autre pour implémenter la redirection.

La fonction principale de EnableHttpWithHttpsConfig est d'ouvrir le service http sous le principe d'avoir https.

package com.pkslow.ssl.config.security;

import org.apache.catalina.connector.Connector;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Configuration
public class EnableHttpWithHttpsConfig {
    
    
    @Value("${http.port}")
    private int httpPort;

    @Component
    public class CustomContainer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
    
    

        @Override
        public void customize(TomcatServletWebServerFactory factory) {
    
    
            Connector connector = new Connector(TomcatServletWebServerFactory.DEFAULT_PROTOCOL);
            connector.setPort(httpPort);
            connector.setScheme("http");
            connector.setSecure(false);
            factory.addAdditionalTomcatConnectors(connector);
        }
    }
}

HttpToHttpsWebSecurityConfig est principalement destiné à la configuration de Spring Security.Comme nous le savons tous, Spring Security est très puissant mais très compliqué. Les principaux commentaires ont été écrits dans le code:

package com.pkslow.ssl.config.security;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
public class HttpToHttpsWebSecurityConfig extends WebSecurityConfigurerAdapter {
    
    
    @Value("${server.port}")
    private int httpsPort;

    @Value("${http.port}")
    private int httpPort;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
    
    
        //redirect to https - 用spring security实现
        http.portMapper().http(httpPort).mapsTo(httpsPort);
        http.requiresChannel(
                channel -> channel.anyRequest().requiresSecure()
        );

        //访问路径/hello不用登陆获得权限
        http.authorizeRequests()
                .antMatchers("/hello").permitAll()
                .anyRequest().authenticated().and();
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
    
    
        //过滤了actuator后，不会重定向，也不用权限校验，这个功能非常有用
        web.ignoring()
                .antMatchers("/actuator")
                .antMatchers("/actuator/**");
    }
}

Conclusion:

Les amis qui ont besoin d'apprendre des matériaux peuvent cliquer pour entrer, mot de passe: cspp , obtenez-le gratuitement!