Código de verificação de imagem de segurança da primavera código de exemplo

Lógica do código de verificação

Eu também fiz códigos de verificação em projetos antes. Existem muitos códigos na Internet que geram códigos de verificação, e alguns pacotes JAR de terceiros também podem gerar belos códigos de verificação. A lógica do código de verificação é muito simples. É para colocar uma tag de imagem na página de login e o SRC aponta para um controlador. Este controlador retorna a imagem gerada e retorna o fluxo de saída para a página. Ao gerar a imagem, o texto na imagem é colocado na sessão. Ao fazer login, traga o código de verificação inserido e retire -o da sessão. Compare os dois. O professor disse que o uso do código de verificação integrado da Spring Security é o mesmo que eu disse, mas é mais padronizado e geral.

A Spring Security é uma série de cadeias de filtro, então aqui o código de verificação também é declarado como um filtro, adicionado antes do filtro de login da cadeia de filtro e, em seguida, personalize uma classe de exceção para responder à mensagem de erro do código de verificação.

Estrutura de código:

O código de verificação é colocado no projeto principal e a configuração é feita no projeto do navegador.

Código principal:

1. ImageCode:

Primeiro, a classe ImageCode encapsula a imagem, texto e tempo de vencimento do código de verificação

 pacote com.imooc.security.core.validate.code; importar java.awt.image.bufferiMage; importar java.time.localdateTime; importar java.time.localtime;/** ** ** ** code* ClassName: imagecode* @Description: Código de verificação* @Author Liha Liha Imagem de bufferImage; Código de string privado; private LocalDateTime expireTime; // Tempo de expiração Ponto do tempo/** * * <p> Descrição: </p> * @param imagem * @param código * @param expiretn quantos segundos expira */public imageCode (imagem bufferedImage, código de string, int expiretn) {super (); this.image = imagem; this.code = code; // Tempo de expiração = tempo atual + número de segundos expirados. } public ImageCode (imagem bufferImage, código da string, LocalDateTime expireTime) {super (); this.image = imagem; this.code = code; this.expireTime = expireTime; } / *** Se o código de verificação expirou* @Description: se o código de verificação expirou* @param @return true expirado, false não expirado* @return boolean True expirado, false não expirado* @THOWS* @author lihaoyang* @date março 2, 2018* / public boolean isexPired () {) Locald Locald* } public bufferImage getImage () {retornar imagem; } public void setImage (imagem bufferImage) {this.image = image; } public String getCode () {Return Code; } public void setCode (código da string) {this.code = code; } public localDateTime getExpireTime () {return expiretime; } public void setexpireTime (LocalDateTime expireTime) {this.expiretime = expireTime; }}

Verifique o código: uma classe de ferramentas para gerar códigos de verificação. Aqui http://www.cnblogs.com/lihaoyang/p/7131512.html, é claro, você também pode usar pacotes JAR de terceiros, isso não importa.

ValidateCodeException : Exceção de código de verificação encapsulada

 /** * @title: validatecodeexception.java * @package com.imooc.security.core.validate.code * @Description: TODO * @Author Lihaoyang * @Date 2 de março de 2018 */package com.imooc.security.core.validate.code; org.springframework.security.core.authenticationException;/*** ClassName: ValidateCodeexception* @Description: Exceção de erro do código de verificação, exceção de autenticação Heritando a segurança da primavera* @author lihaoyang* @date 2, 2018*/public Class. estático final serialversionUid = 1L; public validateCodeexception (String msg) {super (msg); }}

ValidateCodeFilter : filtro de código de verificação

Lógica: A herdadora de uma vez que o Filter garante que o filtro seja chamado apenas uma vez a cada vez (não sei por quê), injetado no processador com falha de autenticação e chamado quando a verificação falhou.

 package com.imooc.security.core.validate.code;import java.io.IOException;import javax.servlet.FilterChain;import javax.servlet.ServletException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.apache.commons.lang.stringutils; importar org.springframework.security.web.authentication.authenticationfilureHandler; importação org.springframework.social.connect.web.hhtssionSonStrategets; org.springframework.web.bind.servletRequestBindingException; importar org.springframework.web.bind.servletRequestutils; importar org.springframework.web.context.request.servletwebrequest; importação org.springframework.web.filter.onceperRequestFilter;/*** Processe o código de verificação de login Filtro* ClassName: ValidAtecodeFilter* @Description:* Uma vez que o PublicSFilter: a ferramenta fornecida pela primavera garante que o filtro será chamado apenas uma vez* @Author Lihaoyd* Uma vez quePerrequestFilter {// Autorização falhou no processador AuthenticationFailureHandler AuthenticationFailureHandler; // obtenha a classe de ferramenta de sessão sessionStionstrategy sessionstrategy = new httpSessionsionStionstrategy (); @Override Protected void Dofilterinternal (solicitação HttPervletRequest, resposta HttPervletResponse, filtragem de filtragem) lança servletexception, ioexception {// se for uma solicitação de login, execute if (stringils.equals ("/autenticação/formation", request -shortrequest, execute if (stringils.equals ("/autenticação/formation", solicita -se, && stringutils.equalsignorecase (request.getMethod (), "post")) {try {validate (new servletwebrequest (request)); } catch (validateCodeException e) {// chamando o manipulador de erros e, finalmente, chamando de seu próprio autenticaçãoFailureHandler.onauthenticationFailure (solicitação, resposta, e); return; // encerrar o método, que não chama mais a cadeia de filtro}} // não é uma solicitação de login, ligue para outro filtro de filtro FilterChain.Dofilter (solicitação, resposta); } /** * Código de verificação de verificação * @Description: Código de verificação de verificação * @param @param request * @param @throws servletRequestBindingException * @return void * @Throws validateCodeexception * @author lihaoyang * @date 2 de março, 2018 * /private Valide (ServletWeReBReBeReBReBeReBrEstrEnTrEstrEstrEstrEstrEstrEstrEstrEstrEstrEstr) o objeto ImageCode na sessão imageCodeAcodeInsession = (ImageCode) sessionstrategy.getAttribute (request, validateCodecontroller.session_key); // Retire o código de verificação no request string imageCodeInRequest = servletRequestutils.getStringParameter (request.getRequest (), "imageCode"); // Verifique se (stringUtils.isblank (imageCodeInRequest)) {lança novo validateCodeexception ("O código de verificação não pode estar vazio"); } if (imageCodeInsession == NULL) {THROW NOVA VALALATECODEEXCECCECTION ("O código de verificação não existe, atualize o código de verificação"); } if (imageCodeInsession.isexired ()) {// remova o código de verificação expirado da sessão sessionStrategy.removeattribute (request, validateCodeController.session_key); lançar novo validateCodeexception ("O código de verificação expirou, atualize o código de verificação"); } if (! stringUtils.equalsignorecase (imageCodeInsession.getCode (), imageCodeInRequest)) {tire nova validateCodeexception ("erro de código de verificação"); } // A verificação é passada, remova o código de verificação na sessão sessionStrategy.removeattribute (request, validateCodeController.session_key); } public AuthenticationFailureHandler getAuthenticationFailureHandler () {return AuthenticationFailureHandler; } public void setauthenticationFailureHandler (autenticaçãoFailureHandler AuthenticationFailUrHandler) {this.authenticationFailureHandler = AuthenticationFailureHandler; }}

ValidateCodeController : Gere Controle de Código de Verificação

 pacote com.imooc.security.core.validado.code; importar java.io.ioexception; importar javax.imageio.imageio; importar javax.servlet.http.httpServletRequest; importar javax.servlet.http.htttletLeequest; org.springframework.social.connect.web.httpSessionsionsionsionStrategy; importar org.springframework.social.connect.web.sessionstrategy; importottot.springframework.web.bind.annatation.getMapping; importação ou org.springfringFring.web.bind.annotation.getMapping; importar ou org.springframework.web.context.request.servletwebrequest;/** * Verificação codecontrol * className: validateCodecOntroller * @Description: TODDO * @author lihaoyang * @1 março, 2018 */RestControlllerPublic "Session_key_image_code"; // Obter sessão Private Sessionstrategy sessionstrategy = new HttpSessionsionSionsionStrategy (); @GetMapping ("/verifyCode/image") public void CreateCode (solicitação httpServletRequest, httpServletResponse resposta) lança IoException {imageCode imageCode = createImageCode (solicitação, resposta); sessionstrategy.setAttribute (new servletwebrequest (solicitação), session_key, imageCode); Imageio.write (imageCode.getImage (), "jpeg", resposta.getOutputStream ()); } private ImageCode CreateImageCode (solicitação httpServLeTrequest, httpServletResponse resposta) {verifyCode verifyCode = new verifyCode (); Retornar novo ImageCode (verifyCode.getImage (), verifyCode.getText (), 60); }}

Configuração do filtro no BrowSerSecurityConfig :

 pacote com.imooc.security.browser; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.context.annotation.bean; importação org.springframework.context.annotation.configuration; importação; importar; org.springframework.security.config.annotation.web.configuration.webescurityConfigureRAdapter; importar org.springframework.security.crypt.bcrypt.bcrypspordworder; importação.sPringFramwork.sectfort.rt.rprypRadsworder; org.springframework.security.web.authentication.authenticationfilureHandler; importar org.springframework.security.web.authentication.authenticationFailureHandler; Immportrg.PringFramework.Security.web.authentication.UsernomEnPeShEstration; UnderNamepHandler; UsernomEnPenshArdEstration; aUtherMepHandler; UndernamepherMepherMepHoStionSenshEstration; aUthernamepherMepherMephOnmEnMepHoStionSenshEstration; aUtherMepHander; com.imooc.security.core.properties.SecurityProperties; import com.imooc.security.core.validate.code.validatecodeFilter; @configuration // Este é um sfiSeSecurtIrgin de specrowentRegurting da SetentRendEnguration do specraturing do sfiguraturing do scigaturing do scIerDort. SecurityProperties SecurityProperties; // Processador personalizado após o login bem -sucedido @AUTOWIRED AUTHenticações privadas itoocauthenticationsCessHandler; // Processador de autenticação personalizado @AUTOWIRED AUTHenticação privadaFailureHandler IMOOCAuthenticationFailureHandler; // Observe que ele é org.springframework.security.crypto.password.passwordEncoder @Bean public septandEncoder PasswordCoder () {// bcryptPasswordEncoder implementa a senha de retorno do novo bcryptPasswordDorder (); } // Versão 2: página de login configurável @Override Protected void Configure (httpsecurity http) lança exceção {// validateCodeFilter validateCodeFilter validateCodeFilter = new ValidAtecodeFilter (); // Use seu próprio manuseio de erros no filtro do código de verificação para validateCodeFilter.SetAuthenticationFailureHandler (IMOOCAuthenticationFailureHandler); //Implement the interface that needs authentication to jump form login, security = authentication + authorization //http.httpBasic() //This is the default pop-up box authentication // http.addFilterBefore(validateCodeFilter, UsernamePasswordAuthenticationFilter.class)//Load the verification code filter before the login filter.formLogin() //Form autentication.logInpage ("/autenticação/requer") // Processa autenticação do usuário BrowSecurityController // Filter UsernamePassWordAuthenticationFilter O URL de login padrão é "/login", que pode ser alterado aqui.Loginprocessingurl ("/autenticação/formation/fortin .s). Autenticação Postprocessor.FailureHandler (IMOOCAuthenticationFailureHandler) // Processando após o login falha.and () .authorizerequests () // Os seguintes são todos configurados autorizados /// Authentication/requer: lide Login, SecurityOnSon. Page.antMatchers ("/Autenticação/requer", SecurityProperties.getBrowser (). getLoginPage (), // Salve a página de login, mas não filtre, caso contrário, um erro "/verifyCode/image"). Permitall () // Código de verificação. // A proteção criptográfica está desligada; }}

Página de login: A página de login é feita relativamente aproximadamente. De fato, o código de verificação pode ser verificado quando a entrada do código de verificação perde o foco. Você também pode usar uma imagem de clique para atualizar a função de código de verificação, para que não faça isso aqui.

 <body> Página de login de demonstração. <br> <form action="/authentication/form" method="post"> <table> <tr> <td> Username: </td> <td><input type="text" name="username"/></td> <td></td> </tr> <tr> <td> Password: </td> <td><input type="password" name="password"/></td> <td> </td> </tr> <tr> <td> Código de verificação: </td> <td> <input type = "text" name = "imageCode"/> </td> <td> <img src = "/verifycode/image"/</td> </tr> <tr> <t> <t. type = "submit"> login </button> </td> </tr> </ table> </morm> </body>

Visite http: // localhost: 8080/Demo-login.html:

Responda a informações de exceção personalizadas

A função geral não é problema. Mas não é universal o suficiente, como a largura e a altura da imagem do código de verificação, o tempo de validade, o URL filtrado e a lógica do código de verificação são todos escritos até a morte. Estes podem ser feitos vivos e agora os benefícios de transformar códigos de verificação em um filtro são refletidos. Podemos configurar URLs que precisam ser filtrados. Às vezes, pode não apenas exigir códigos de verificação na página de login, que é mais geral.

1. Os parâmetros básicos do código de verificação para modificação de generalização podem ser correspondidos

É transformado em configurável, e o aplicativo refere -se ao módulo e o configura. Se não configurar, use a configuração padrão. Além disso, a configuração pode ser declarada no URL da solicitação ou no aplicativo. O professor é realmente um professor, e o código é muito versátil!

O efeito que quero alcançar é fazer essa configuração no Application.properties:

 #Verificação Código da imagem Largura, altura, número de caracteres IMOOC.Security.code.image.width = 100imooc.security.code.image.height = 30imooc.security.code.image.length = 6

Em seguida, você pode controlar o efeito do código de verificação. Como o código de verificação também é dividido no código de verificação de imagem e no código de verificação de SMS, você pode usar um nível de nível .code.image, que usa o arquivo de configuração personalizado do Springboot e precisa declarar a classe Java correspondente:

O atributo de código precisa ser declarado em SecurityProperties:

 pacote com.imooc.security.core.properties; importar org.springframework.boot.context.properties.configurationproperties; importar org.springframework.Context.annotation.configuration;/** ** Configuration Itens* ClassName: Security CelsPerts *DPRERS *DPRERTES *DPRONTIÇÕES *DIRGUNDOS ** ** *** IMOOC.Security in Application.Properties * * Imooc.Security.Browser.LoginPage = /demo-login.html * A configuração do navegador será lida em BrowSproperties *, isso é dividido por pontos, e o nível e o nível correspondem aos atributos da classe * @Author Liha Liha Liha, 2018*/@ConfigurationProperties (prefix = "iMooc.Security") Public Class SecurityProperties {Private BrowserProperties Browser = new BrowserProperties (); Código privado de validateCodeProperties = new ValidAtecodeProperties (); public BrowserProperties getBrowser () {retornar navegador; } public void setBrowser (navegador BrowserProperties) {this.browser = navegador; } public validateCodeProperties getCode () {Return Code; } public void setCode (Código ValidAcodeProperties) {this.code = code; }}

ValidateCodeProperties:

 pacote com.imooc.security.core.properties;/*** Configuração do código de verificação* ClassName: ValidAtecodeProperties* @Description: Configuração do código de verificação, o código de verificação inclui o código de verificação de imagem, o código de verificação SMS 2, etc., uma camada é incluída* @author lihaoyang *date @date march 2, etc., etc. Configuração Private ImageCodeProperties Image = new ImageCodeProperties (); public ImageCodeProperties getImage () {retornar imagem; } public void setImage (imagem ImageCodeProperties) {this.image = image; }}

ImageCodeProperties:

 pacote com.imooc.security.core.properties;/*** Código de verificação da imagem Class de configuração de código* ClassName: ImageCodeProperties* @Description: Código de verificação da imagem // altura da imagem private int altura = 23; // Número de caracteres de código de verificação Private Int Comning = 4; // Tempo de validade privado int expirein = 60; public int getWidth () {retornar largura; } public void setWidth (int width) {this.width = width; } public int getHeight () {return Hight; } public void sethight (int alting) {this.Height = altura; } public int getLength () {Return Comning; } public void setLength (int length) {this.length = length; } public int getExpirein () {return expirein; } public void se setExpirein (int expirein) {this.expirein = expirein; }}

Para configuração de nível de solicitação, se a solicitação contiver os parâmetros do código de verificação, use a solicitação:

O método CreateImageCode do validateCodeController é usado para controlá -lo para determinar se os parâmetros de solicitação têm esses parâmetros. Nesse caso, ele é passado para a classe de geração de código de verificação VerifyCode, que pode ser controlada dinamicamente durante a geração.

 Private ImageCode CreateImageCode (solicitação httpServletRequest, resposta httpServletResponse) {// primeiro leia o comprimento, a largura e os parâmetros de número dos caracteres da solicitação, se houver, use -o (s) (largura), e o settomProrties); int height = servletRequestutils.getIntParameter (solicitação, "altura", SecurityProperties.getCode (). getImage (). getHeight ()); int charLength = this.SecurityProperties.getCode (). getImage (). getLength (); VerifyCode verifyCode = new VerifyCode (largura, altura, comprimento de charlen); Retornar novo ImageCode (verifyCode.getImage (), verifyCode.getText (), this.SecurityProperties.getCode (). getImage (). getExpirein ()); }

Verifique o código:

 public verifyCode (int w, int h, int charlength) {super (); this.w = w; this.h = h; this.charLength = charlength; }

Experimento: faça configuração no nível do aplicativo no projeto de demonstração

Faça login no formulário para fazer configuração de nível de solicitação

 <img src = "/verifyCode/imagem? largura = 200"/>

acesso:

O comprimento é o parâmetro 200 da banda de estágio solicitante, a altura é de 30 e os caracteres estão configurados 6.

2. A interface para a interceptação do código de verificação da modificação universal pode ser configurada

O primeiro efeito é configurar dinamicamente as interfaces que precisam ser interceptadas no application.properties :

ImageCodeProperties adicionou um novo atributo: private String url ; // O URL interceptado é corresponder à configuração da imagem acima.

Core, filtro de código de verificação precisa ser modificado:

1. Declare um conjunto de conjuntos no interceptador para armazenar os URLs configurados no arquivo de configuração que precisam ser interceptados.

2. Implemente a interface InitializingBean. Objetivo: Quando todos os outros parâmetros forem montados, inicialize o valor dos URLs que precisam ser interceptados e reescreva o método AfterPropertiesset para implementá -lo.

3. Injete o SecurityProperties e leia o arquivo de configuração

4.

5. Defina o BrowSerSecurityConfig no projeto do navegador para chamar o método AfterPropertiEsset.

6. Configure o URL a ser filtrado no Application.Properties do projeto Demo que referencia o módulo.

ValidateCodeFilter:

 /** * Process the login verification code filter* ClassName: ValidateCodeFilter * @Description: * Inherit the tools provided by OncePerRequestFilter: spring to ensure that the filter will be called only once each time* Implement the purpose of the InitializingBean interface: * When other parameters are assembled, initialize the value of the urls that needs to be intercepted* @author lihaoyang * @date March 2, 2018*/classe pública validateCodeFilter estende uma vez que o FilterFilter implementa InicializandoBean {// Authentication Processador Automenticação privada AuthenticationFailureHandler AuthenticationFailureHandler; // obtenha a classe de ferramenta de sessão sessionStionstrategy sessionstrategy = new httpSessionsionStionstrategy (); // A coleção de URL que precisa ser interceptada conjunto privado <String> urls = novo hashset <> (); // Leia Configuração Private SecurityProperties SecurityProperties; // Classe de ferramentas de primavera privada anti -pathatcher Antpathmatcher = new AntPathmatcher (); @Override public void depoisPropertiESSET () lança servletexception {super.afterPropertiesset (); // Leia os URLs do string interceptado configurado [] configurls = stringutils.splitbywholeseParatorPreserveReallTokens (SecurityProperties.getCode (). GetImage (). Geturl (), ","); for (string configurl: configurls) {urls.add (configurl); } // O login solicitações deve interceptar urls.add ("/autenticação/form"); } @Override Protected void DofilterInternal (solicitação httpServletRequest, resposta httpServletResponse, filtragem de filtro) lança servleTexception, ioexception { / *** ** ** Filting It Matches* Matches* Matches* Matches* Matches* Matches* / Url e o URLENT solicitado; for (string url: urls) {if (antpathmatcher.match (url, request.getRequesturi ())) {ação = true; }} if (ação) {try {validate (new servletwebrequest (request)); } catch (validateCodeException e) {// chamando o manipulador de erros e, finalmente, chamando de seu próprio autenticaçãoFailureHandler.onauthenticationFailure (solicitação, resposta, e); return; // encerrar o método, que não chama mais a cadeia de filtro}} // não é uma solicitação de login, ligue para outras cadeias de filtro FilterChain.Dofilter (solicitação, resposta); } // omitindo código irrelevante ,,}

BrowSerSecurityConfig:

Configurar URL:

 #Verificação Código de interceptação Configuração da interface IMOOC.Security.code.image.url =/user,/user/*

Teste: /Usuário /Usuário /1 foi interceptado

Visite a página de login sem escrever código de verificação:

Consistente com as expectativas. Neste ponto, a configuração dinâmica da interface de interceptação é concluída

3. A lógica de geração do código de verificação pode ser configurável

Os programas melhor escritos geralmente têm interfaces abertas, permitindo que os usuários personalizem a implementação. Se eles não implementarem, use a implementação padrão. Vamos fazer isso para que a geração de códigos de verificação possa ser implementada por si mesma. Se você deseja tornar a lógica de geração de código de verificação configurável, não pode apenas gravar uma classe do gerador de código de verificação de imagem. Você precisa extrair a geração de código de verificação para um interface validateCodeGenerator, um método para gerar gerador de código de verificação (). Como o código de verificação também possui código de verificação de imagem, código de verificação de SMS etc., fazemos uma implementação padrão em nosso módulo de verificação, como o código de verificação de imagem ImageCodeGenerator. No ImageCodeGenerator, não adicionamos anotação @Component a esta classe. Em seguida, use a classe de configuração ValidAcodeBeanConfig que grava um bean de código de verificação. Esta classe de configuração configura vários grãos de implementação de código de verificação necessários, como o código de verificação de imagem Implementation ImageGenerator, o código de verificação de SMS etc. Seus tipos de retorno são todos validateCodeGenerator. Use a anotação @conditionalonMissingBean (name = "ImageCodeGenerator"). Pode -se julgar que, se o atual contêiner de mola tiver um feijão chamado ImageCodeGenerator, ele será usado e se não houver configuração; portanto, se outras pessoas se referirem ao seu módulo, se outras pessoas implementarem o código de verificação para gerar a interface validatEcodeGenerator, para que o nome da classe de implementação seja imageGener e use o próprio implementação.

Código principal:

Interface do gerador de código ValidateCodeGenerator:

 pacote com.imooc.security.core.validado.code; importar org.springframework.web.context.request.servletwebrequest;/** * interface de geração de código de verificação * CLASTENATENATEMATE (ValidatecodeGener * @DENCRUTA: / * *

O gerador de código de verificação de imagem implementa o ImageCodeGenerator:

 pacote com.imooc.security.core.validado.code; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.stereotype.component; import org.springframework.webind.bind.sertlepretrequestutils; org.springframework.web.context.request.servletwebrequest; import com.imooc.security.core.properties.SecurityProperties;/** * Código de verificação da imagem * CLASSE LIRATIONSNAME: ImageCodeGenerator * @Description: TODO * Author LiHOLHOR * implementa o validateCodeGenerator {@AUTowired Private SecurityProperties SecurityProperties; @Override Public ImageCode Generator (Solicitação de servletwebrequest) {// primeiro leia a solicitação se há algum comprimento, largura e parâmetros de caracteres. Se houver, use -o e o padrão int width = servletRequestutils.getIntParameter (request.getRequest (), "width", securityproperties.getCode (). GetImage (). GetWidth ()); int height = servletRequestutils.getIntParameter (request.getRequest (), "altura", securityProperties.getCode (). getImage (). getHeight ()); int charLength = this.SecurityProperties.getCode (). getImage (). getLength (); VerifyCode verifyCode = new VerifyCode (largura, altura, comprimento de charlen); Retornar novo ImageCode (verifyCode.getImage (), verifyCode.getText (), this.SecurityProperties.getCode (). getImage (). getExpirein ()); } Public SecurityProperties getSecurityProperties () {return SecurityProperties; } public void SetSecurityProperties (SecurityProperties SecurityProperties) {this.SecurityProperties = SecurityProperties; }}

ValidateCodeBeanConfig:

 pacote com.imooc.security.core.validado.code; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.boot.autoconfigure.condition.condition.condition.port.condition.condition.onmingBean; org.springframework.context.annotation.bean; importar org.springframework.context.annotation.configuration; importar com.imooc.security.core.properties.SecurityProperties;/** * Configure The Bean da classe real do co -cotidizador Configure o feijão da classe de implementação real do validateCodeGenerator *, como a implementação do código de verificação de imagem e a implementação do código de verificação do SMS * @author lihaoyang * @date 5 de março de 2018 */ @configurationpublic Class ValidaterCodeBeanFig {@Autired PrivatePerties SecurityPertiesPublic /** * @Description: * @ConditionalOnMissingBean Anotation significa que, quando o contêiner de mola não possui um ImageCodeGenerator, a função é tornar o programa mais extensível. A classe de configuração está configurada no módulo principal. Isso significa que, se o projeto que se referir ao módulo * possui sua própria implementação, que implementa a interface ValidAcodeGenerator e define sua própria implementação. O nome também é chamado ImageCodeGenerator, * é usado para implementar a implementação no nível do aplicativo e, se não houver essa implementação, use essa implementação padrão. * @param @return * @return validateCodeGenerator * @throws * @author lihaoyang * @date 5 de março de 2018 */ @Bean @ConditionalonMissingBean (name = "imageCodeGenerator") public ValdalateGodeGenerator ImageCodeGenerator () {(imageGenerator ") codeGenerator.SetSecurityProperties (SecurityProperties); Retornar CodeGenerator; }}

Dessa forma, se um módulo se referir a este módulo de código de verificação, ele personaliza a implementação, como:

 pacote com.imooc.code; importar org.springframework.tereotype.component; importar org.springframework.web.context.request.servletwebrequest; importar com.imooc.security.core.validado.code.imageCode; importar; com.imooc.security.core.validate.code.ValidateCodeGenerator;@Component("imageCodeGenerator")public class DemoImageCodeGenerator implements ValidateCodeGenerator { @Override public ImageCode generator(ServletWebRequest request) { System.err.println("generated verification code for the demo project implementation,,"); retornar nulo; }}

Dessa forma, quando o ValidateCodeBeanConfig configura o bean do código de verificação, ele usará a implementação personalizada do usuário.

O código completo é colocado no github: https://github.com/lhy1234/spring-security

Resumir

O exposto acima é o código de exemplo da função Código de verificação da imagem de segurança da primavera introduzida pelo editor. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!