虽然可以用一个自定义的html页面来完成表单登录

时间:2019-10-05 11:48来源:美高梅手机游戏网站
①加页面:定义该页面hcx-signIn.html为登录页面:②配授权 个性化用户认证流程 自定义登录页面 自定义登陆成功处理 自定义登录失败处理 一、自定义登录页面 我们不能每次都去使用

①加页面:定义该页面hcx-signIn.html为登录页面:②配授权

个性化用户认证流程

  • 自定义登录页面
  • 自定义登陆成功处理
  • 自定义登录失败处理

一、自定义登录页面

我们不能每次都去使用SpringSecurity默认的很简单的登录页面样式去进行登录,需要我们去自定义自己的登录页面的话,我们怎么实现呢?在BrowserSecurityConfig类中的configure方法中,我在http.formLogin()的后面去添加一行代码“.loginPage”,那么在用户访问页面的时候就会去根据配置的这个url去访问相对应的自定义登录页面。

位置:在src->main->resources中我新建了一个文件夹resources,然后在此文件夹下创建文件“tinner-signIn.html”

<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <title>登录</title></head><body> <h1>标准登录页面</h1> <h3>表单登录</h3> <form action="/authentication/form" method="post"> <table> <tr> <td>用户名:</td> <td><input type="text" name="username"/></td> </tr> <tr> <td>密码:</td> <td><input type="password" name="password"/></td> </tr> <tr> <td colspan="2"><button type="submit">登录</button></td> </tr> </table> </form></body></html>

@Configurationpublic class BrowserSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private SecurityProperties securityProperties; @Bean public PasswordEncoder passwordEncoder(){ return new BCryptPasswordEncoder(); } @Override protected void configure(HttpSecurity http) throws Exception {// super.configure; //实现的效果:让它去表单登录,而不是alert框 http.formLogin() .loginPage("/tinner-signIn.html") .loginProcessingUrl("/authentication/form") .and() .authorizeRequests()//对请求进行授权 .antMatchers("/tinner-signIn.html").permitAll() .anyRequest()//任何请求 .authenticated()//都需要身份认证 .and.disable(); }}

可以看到我额外地添加了两行代码,一个是指定了登录的页面,另一个是对于"/tinner-signIn.html"这个页面,我们必须将它放行,不能让它去进行资源权限的校验,否则会发生“重定向次数过多”。csrf().disable(); 是跨站请求伪造的安全机制。SpringSecurity默认地会有csrf跨站请求伪造防护的机制。因为是从一个html,进行post去提交给服务器的,涉及到跨站请求。

@Configurationpublic class BrowserSecurityConfig extends WebSecurityConfigurerAdapter{ @Bean //加密 public PasswordEncoder passwordEncoder() { //如果系统本身有了其他的加密方式,此处就应该返回自己写的passwordencoder,再实现encoder和matches方法 return new BCryptPasswordEncoder(); } @Override protected void configure(HttpSecurity http) throws Exception { //使用表单登录:指定了身份认证的方式 http.formLogin() .loginPage("/hcx-signIn.html")//自定义登录页面 //http.httpBasic() //使用回之前的认证方式 .and() .authorizeRequests()//表示以下都是授权的配置 .antMatchers("/hcx-signIn.html").permitAll()//访问该url不需要身份认证 .anyRequest()//任何请求 .authenticated();//都需要身份认证 }}

自定义登录页面

之前我们使用SpringSecurity默认配置的登录页面,如表单登录或者HTTP BASIC登录,这里我们想自定义登录页面。首先我们修改安全配置:

@Configuration
public class BrowserSecurityConfig extends WebSecurityConfigurerAdapter{

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

    @Override
    protected void configure(HttpSecurity http) throws Exception{
        http.formLogin()
            .loginPage("/login.html")
            .and()
            .authorizeRequests()
            .anyRequest()
            .authenticated();
    }
}

在configure方法中指定了登陆页面的URL后病并且在项目的/src/main/resources/下建一个resources文件夹,这个文件夹里面放的是项目的文件默认放置的路径,在这个文件夹目录下添加一个login.html登陆页面:

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>登录</title>
</head>
<body>
    <h2>标准登录页面</h2>
</body>
</html>

启动应用后,我们访问地址http://localhost://8080/user/1后页面显示:

美高梅手机游戏网站 1

error.png

导致这个错误的原因是:我们在实现BrowserSecurityConfig 类的方法中,设置了登录页面为login.html的同时也设置了身份认证,导致访问login.html页面(也是一次请求)的时候也进行身份认证,如此循环往复循环访问,错误提示重定向次数过多。为此我们修改代码如下:

    @Override
    protected void configure(HttpSecurity http) throws Exception{
        http.formLogin()
            .loginPage("/login.html")
            .and()
            .authorizeRequests()
            .antMatchers("/login.html").permitAll()
            .anyRequest()
            .authenticated();
    }

添加的antMatchers("/login.html").permitAll()这句表示当请求url符合这个路径时不进行身份认证,修改后我们访问http://localhost://8080/user/1后默认就跳到了我们自己配置的login.html登录页面了。
接下来我们对自定义的登录页面进行修改:

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>登陆页面</title>
</head>
<body>
    <h2>标准登陆页面</h2>
    <h3>表单登录</h3>
    <form action="/authentication/form" method="post">
        <table>
            <tr>
                <td>用户名:</td>
                <td><input type="text" name="username"></td>
            </tr>
            <tr>
                <td>密码:</td>
                <td><input type="text" name="password"></td>
            </tr>
            <tr>
                <td colspan="2"><button type="submit">登录</button></td>
            </tr>
        </table>
    </form>
</body>
</html>

表单的属性action="/authentication/form" method="post"是我们自己定义的url。记得第一讲说过,表单登录的请求在SpringSecurity中是由UsernamePasswordAuthenticationFilter过滤器来处理的,这个过滤器类中:

    public UsernamePasswordAuthenticationFilter() {
        super(new AntPathRequestMatcher("/login", "POST"));
    }

可见过滤器只处理url是:/login的POST请求,而我们修改后的登录页面提交时url是/authentication/form,为此我们需要在配置类中告诉SpringSecurity现在表单登录的请求url是多少:

    @Override
    protected void configure(HttpSecurity http) throws Exception{
        http.formLogin()
            .loginPage("/login.html")
            .loginProcessingUrl("/authentication/form")
            .and()
            .authorizeRequests()
            .antMatchers("/login.html").permitAll()
            .anyRequest()
            .authenticated();
    }

loginProcessingUrl("/authentication/form")这句代码就是设置登录请求的url路径。
修改后我们重启应用,访问http://localhost://8080/user/1后默认跳出我们设置的登录页面:

美高梅手机游戏网站 2

image.png

填写正确的账号和密码后提交报错,如下:

美高梅手机游戏网站 3

error.png

这是由SpringSecurity默认的跨站伪造防护导致的,此处我们修改设置如下:

    @Override
    protected void configure(HttpSecurity http) throws Exception{
        http.formLogin()
            .loginPage("/login.html")
            .loginProcessingUrl("/authentication/form")
            .and()
            .authorizeRequests()
            .antMatchers("/login.html").permitAll()
            .anyRequest()
            .authenticated()
            .and()
            .csrf().disable();
    }

修改后我们再次登录,这是表单登录页面填写正确的账号和密码后程序能访问到restful api了。
修改后我们现在的情况是当我们在浏览器发起一个请求访问http://localhost://8080/user/1的时候,
首先跳转到登录页面提示我们登录。但如果我们想访问url中末尾带html的,如http://localhost://8080/index.html的时候返回登录页面,而如果访问http://localhost://8080/user/1的时候返回错误码,为此我们需要新建一个自定义的控制器来对以html结尾的请求和非html结尾的请求进行区分,我们在控制器的方法中判断是否是html结尾的请求引发的跳转,如果是则返回登录页面,如果不是则返回401状态码和错误信息。
下面我们新建一个控制器:

@RestController
public class BrowserSecurityController {
    private Logger logger = LoggerFactory.getLogger(getClass());
    private RequestCache requestCache = new HttpSessionRequestCache();
    private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();
    @Autowired
    private SecurityProperties securityProperties;
    /**
     * 当需要身份认证时跳转到这里
     * @param request
     * @param response
     * @return
     * @throws IOException 
     */
    @RequestMapping("/authentication/require")
    @ResponseStatus(code = HttpStatus.UNAUTHORIZED)
    public SimpleResponse requireAuthentication(HttpServletRequest request, HttpServletResponse response) throws IOException{

        SavedRequest savedRequest = requestCache.getRequest(request, response);

        if(savedRequest != null){
            String target = savedRequest.getRedirectUrl();
            logger.info("引发跳转的请求是:"+target);
            if(StringUtils.endsWithIgnoreCase(target, ".html")){
                redirectStrategy.sendRedirect(request, response, securityProperties.getBrowser().getLoginPage());
            }

        }
        return new SimpleResponse("访问的服务需要身份认证,请引导用户到登录页面");
    }
}

当请求url符合“/authentication/require”的路径时访问上述控制器的requireAuthentication方法,这个方法通过RequestCache对象和SavedRequest对象获取保存在缓存中的请求url,如果请求url的后缀为.html,则页面重定向到securityProperties.getBrowser().getLoginPage()的返回值;否则返回状态码HttpStatus.UNAUTHORIZED,即401,并且提示“访问的服务需要身份认证,请引导用户到登录页面”。注:
SimpleResponse类用于封装返回信息,使得以json格式返回,下面是这个SimpleResponse类的实现:

public class SimpleResponse {
    public SimpleResponse(Object content){
        this.content = content;
    }
    private Object content;
    public Object getContent() {
        return content;
    }
    public void setContent(Object content) {
        this.content = content;
    }
}

那securityProperties.getBrowser().getLoginPage()具体是什么内容呢?
是这样的,我们将以.html为末尾的请求对应的跳转页面配置到了项目的属性文件application.properties文件中:

spring.security.browser.loginPage=/demo-signin.html

我们将这个自己配的属性分成两层,一层是spring.security,另一层是spring.security下的browser。为了获取这个属性,编写类SecurityProperties获取前缀是spring.security的属性

@ConfigurationProperties(prefix = "spring.security")
public class SecurityProperties {
    private BrowserProperties browser = new BrowserProperties();
    public BrowserProperties getBrowser() {
        return browser;
    }
    public void setBrowser(BrowserProperties browser) {
        this.browser = browser;
    }   
}

@ConfigurationProperties(prefix = "spring.security")注解表示读取前缀是“spring.security”的属性。
这个SecurityProperties 类中又有一个变量BrowserProperties browser保存属性文件中配的第三个字段browser的值,BrowserProperties对象的属性loginPage保存了第四个字段loginPage的值。下面是BrowserProperties类的具体实现:

public class BrowserProperties {
        private String loginPage;
    public String getLoginPage() {
        return loginPage;
    }
    public void setLoginPage(String loginPage) {
        this.loginPage = loginPage;
    }   
}

为使SecurityProperties这个读取属性文件的类生效,需要再加一个配置类;

@Configuration
@EnableConfigurationProperties(SecurityProperties.class)
public class SecurityCoreConfig {
}

通过以上配置来使能获取属性配置的类生效。

最后我们修改登录行为:

@Configuration
public class BrowserSecurityConfig extends WebSecurityConfigurerAdapter{

    @Autowired 
    SecurityProperties securityProperties;

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

    @Override
    protected void configure(HttpSecurity http) throws Exception{
        http.formLogin()
            .loginPage("/authentication/require") //跳转的登录页
            .loginProcessingUrl("/authentication/form") //登录时的请求
            .and()
            .authorizeRequests()
            .antMatchers("/authentication/require",
                    securityProperties.getBrowser().getLoginPage()).permitAll()
            .anyRequest()
            .authenticated()
            .and()
            .csrf().disable();
    }
}

启动应用后,当我们访问访问http://localhost:8080/user/1的时候由于没有携带携带登录信息,跳转到我们设置的”/authentication/require“路径下,这个路径由我们刚设置的控制器来处理,末尾没有html信息,所以返回的401,并且提示”访问的服务需要身份认证,请引导用户到登录页面“,并且url跳转到/authentication/require。如果访问http://localhost:8080/index.html的时候,则跳转到securityProperties.getBrowser().getLoginPage()指定的demo-signin.html页面上。demo-signin.html代码如下:

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>登录</title>
</head>
<body>
    <h2>demo 登录页</h2>
</body>
</html>

二、自定义登录改进

虽然可以用一个自定义的html页面来完成表单登录,但是现在出现了两个问题:

  • 在起始的时候发送的是一个rest服务的请求,但是在跳转控制上返回去的是一个html,这种方式是不合理的。rest服务应该返回的是状态码和Json的信息。我们需要做的是如果是html请求就跳到登录页上,如果不是就返回Json数据
  • 我写了一个标准的登录页面,但是我希望能提供一个可重用的安全模块(即有多个项目都会使用这个安全木块,但是这些项目不可能只用这一个简单样式的登录页面)。如何能让这些项目使用自己自定义的登录页面?如果不使用自己定义的登录页面,才会使用我自己写的这个简单样式的登录页面。

基于以上问题,我来对这个安全模块进行改进:

先来看看整体的流程图

美高梅手机游戏网站 4处理不同类型的请求

hcx-signIn.html:

自定义登录成功页面

当我们访问http://localhost:8080/user/1的时候先会跳到表单登录页,填写完账号密码登陆成功后,会默认跳转到/user/1请求对应的控制器上,这一步是SpringSecurity默认的处理类来处理的,如果我们想登陆成功后不执行默认的操作,而是实现我们需要的操作,就要了解一下接下来的内容。
自定义登录成功页面需要实现AuthenticationSuccessHandler接口:

@Component
public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
            Authentication authentication) throws IOException, ServletException {
        //Authentication接口封装认证信息

        logger.info("登录成功");

        response.setContentType("application/json;charset=UTF-8");

        //将authentication认证信息转换为json格式的字符串写到response里面去
        response.getWriter().write(objectMapper.writeValueAsString(authentication));
    }
}

我们在接口的AuthenticationSuccessHandler方法中将认证信息放到response信息中。
此外我们要使用这个自定义的登陆成功处理类,而不是使用默认的处理人,需要修改登陆行为配置类:

@Configuration
public class BrowserSecurityConfig extends WebSecurityConfigurerAdapter{

    @Autowired 
    SecurityProperties securityProperties;

    @Autowired
    private MyAuthenticationSuccessHandler myAuthenticationSuccessHandler;

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

    @Override
    protected void configure(HttpSecurity http) throws Exception{
        http.formLogin()
            .loginPage("/authentication/require") //跳转的登录页
            .loginProcessingUrl("/authentication/form") //登录时的请求
            .successHandler(myAuthenticationSuccessHandler) //表单登录成功时使用我们自己写的处理类
            .and()
            .authorizeRequests()
            .antMatchers("/authentication/require",
                    securityProperties.getBrowser().getLoginPage()).permitAll()
            .anyRequest()
            .authenticated()
            .and()
            .csrf().disable();
    }
}

通过引入MyAuthenticationSuccessHandler对象,并使用successHandler方法将其设置为登录成功的处理类。
这样启动应用后,表单登录填写完账号密码登陆成功后,页面显示我们塞到response中的认证信息:

美高梅手机游戏网站 5

pageinfo.png

美高梅手机游戏网站 6

network.png

其中authenticated=true表示已经经过身份认证,authorities:admin等表示用户的权限是admin,credentials表示密码,一般springsecurity做了处理,不会返回到前台,所以为空,最重要的是printcipal中的内容,里面有我们之前在UserDetail类中设置的四个布尔值等信息。

<1>定义返回数据类型

在写这个Controller时,我们需要知道,对于html请求,我们不可能永远跳转到一个死的登录页面上去,我需要提供一个能力,去读取配置文件实现活的返回页面。在这个方法上,我返回的是一个http的状态码。这个方法应该返回的是一个自定义的类,里面去返回各种各样的属性,因此我来创建一个返回类SimpleResponse ,里面只有一个Object类型的变量

public class SimpleResponse { public SimpleResponse(Object content) { this.content = content; } private Object content; public Object getContent() { return content; } public void setContent(Object content) { this.content = content; }}
<!DOCTYPE html><html><head><meta charset="UTF-8"><title>登录</title></head><body> <h2>标准登录页面</h2></body></html>

自定义登录失败处理

相应的,登录失败的处理要实现的接口是

@Component
public class MyAuthenticationFailHandler implements AuthenticationFailureHandler {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
            AuthenticationException exception) throws IOException, ServletException {

        logger.info("登陆失败");
        response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().write(objectMapper.writeValueAsString(exception));
    }
}

实现方法中第三个方法不是认证信息而是登录失败的异常对象,我们选中AuthenticationException,然后右键选择open hierarchy查看类的继承图:

美高梅手机游戏网站 7

image.png

由上图可以发现,这个异常继承了很多其他异常,如UsernameNotFoundException异常(请求中没有用户名和密码),BadCredentialsException异常(账号密码错误)。
在onAuthenticationFailure处理方法中我们将错误信息返回,启动应用后,如果输入错误的账号密码后登陆,页面显示如下:

美高梅手机游戏网站 8

image.png

打印出来的都是错误的堆栈信息。

<2>将页面配置写活

返回的数据类型定义完了,就需要去将配置的自定义页面去写活,在这里我们使用demo项目去引用Browser项目,在demo的配置文件中我定义了一个html

tinner.security.browser.loginPage=/login.html

我希望如果demo项目做了这个页面配置就跳转到demo配置的自定义页面,如果没有进行配置则跳转到browser项目定义的登录页面。为了实现这个逻辑,我需要去将这些配置进行封装,将它们封装到一个类里面中去。

美高梅手机游戏网站 9系统配置封装

这个图就是对整个项目配置文件的封装,我会去定义一个SecurityProperties类,然后这个类中又分为几个子类(根据配置项的不同去划分)。代码我写在了Tinner-security-core项目中

美高梅手机游戏网站 10代码结构因为系统的配置无论是浏览器模块还是app模块中都会用到。先去定义BrowserProperties类

public class BrowserProperties { private String loginPage = "/tinner-signIn.html"; private LoginType loginType = LoginType.JSON; public LoginType getLoginType() { return loginType; } public void setLoginType(LoginType loginType) { this.loginType = loginType; } public String getLoginPage() { return loginPage; } public void setLoginPage(String loginPage) { this.loginPage = loginPage; }}

然后去定义SecurityProperties类

import org.springframework.boot.context.properties.ConfigurationProperties;@ConfigurationProperties(prefix = "tinner.security")public class SecurityProperties { private BrowserProperties browser = new BrowserProperties(); public BrowserProperties getBrowser() { return browser; } public void setBrowser(BrowserProperties browser) { this.browser = browser; }}

可以看到在SecurityProperties类中包含了BrowserProperties,BrowserProperties类中有一个属性loginPage,默认值是browser模块中的自定义标准登录页面,LoginType定义了登录的方式,是基于html还是json的,LoginType是一个枚举,其定义如下:

public enum LoginType { REDIRECT, JSON;}

美高梅手机游戏网站 11登录页面目录.png

扩展

我们在上面设计了登录成功和登录失败后的自定义处理类,但是如果执行了自定义处理类后,就不会执行默认的处理类的跳转到原来url的逻辑,为此我们可以继承springsecurity的默认处理类,并且加上配置来确定是否要跳转或是执行自定义行为,修改后的代码如下:

@Component
public class MyAuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {

    private Logger logger = LoggerFactory.getLogger(getClass());

    private LoginType loginType = LoginType.JSON;

    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    private SecurityProperties securityProperties;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
            Authentication authentication) throws IOException, ServletException {
        //Authentication接口封装认证信息

        logger.info("登录成功");

        if(loginType.equals(securityProperties.getBrowser().getLoginType())){
            response.setContentType("application/json;charset=UTF-8");

            //将authentication认证信息转换为json格式的字符串写到response里面去
            response.getWriter().write(objectMapper.writeValueAsString(authentication));
        }
        else{
            super.onAuthenticationSuccess(request, response, authentication);
        }
    }
}

此时登录处理器MyAuthenticationSuccessHandler继承的类MyAuthenticationSuccessHandler已经实现了AuthenticationSuccessHandler接口,并且MyAuthenticationSuccessHandler就是springsecurity默认登录成功的处理器。代码中的LoginType是一个枚举,实现如下:

public enum LoginType {
    REDIRECT,
    JSON
}

此外,在application.properties属性文件中又加上一个配置项:

spring.security.browser.loginType=REDIRECT

用于配置是否是执行框架的默认的行为还是执行我们的自定义行为。并在BrowserProperties类中加上这个属性,便于获取到这个属性。所以执行结果是,当我们在属性文件中配置了REDIRECT后,如果登录成功后,就会执行父类的onAuthenticationSuccess方法,即框架的默认行为,如果设置了JSON,登录成功后,就会执行自定义的response填入JSON数据返回给也页面的行为。这样想选哪种只需要修改属性文件就行。
同理,我们修改处理登录失败的代码如下:

@Component
public class MyAuthenticationFailHandler extends SimpleUrlAuthenticationFailureHandler {

    private Logger logger = LoggerFactory.getLogger(getClass());

    private LoginType loginType = LoginType.JSON;

    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    private SecurityProperties securityProperties;

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
            AuthenticationException exception) throws IOException, ServletException {

        if(loginType.equals(securityProperties.getBrowser().getLoginType())){
            logger.info("登陆失败");
            response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write(objectMapper.writeValueAsString(exception));
        }
        else{
            super.onAuthenticationFailure(request, response, exception);
        }

    }

}

修改后的登录成功失败后的逻辑就会变得更加灵活了。

<3>写自定义的Controller
@RestControllerpublic class BrowserSecurityController { private Logger LOGGER = LoggerFactory.getLogger(this.getClass; private RequestCache requestCache = new HttpSessionRequestCache(); private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy(); @Autowired private SecurityProperties securityProperties; /** * 当需要身份认证时,跳转到这里 * @param request * @param response * @return */ @RequestMapping("/authentication/require") @ResponseStatus(code = HttpStatus.UNAUTHORIZED) public SimpleResponse requireAuthentication(HttpServletRequest request, HttpServletResponse response) throws IOException { //判断引发跳转的是html还是不是html SavedRequest savedRequest = requestCache.getRequest(request,response); if (savedRequest != null ){ String target = savedRequest.getRedirectUrl(); LOGGER.info("引发跳转的请求是:"+target); if (StringUtils.endsWithIgnoreCase(target,"html")){ redirectStrategy.sendRedirect(request,response,securityProperties.getBrowser().getLoginPage; } } return new SimpleResponse("访问的服务需要身份认证,请引导用户到登录页"); }}

然后在BrowserSecurityConfig去进行配置

@Configurationpublic class BrowserSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private SecurityProperties securityProperties; @Bean public PasswordEncoder passwordEncoder(){ return new BCryptPasswordEncoder(); } @Override protected void configure(HttpSecurity http) throws Exception {// super.configure; //实现的效果:让它去表单登录,而不是alert框 http.formLogin() .loginPage("/authentication/require") .loginProcessingUrl("/authentication/form") .and() .authorizeRequests()//对请求进行授权 .antMatchers("/authentication/require",securityProperties.getBrowser().getLoginPage.permitAll() .anyRequest()//任何请求 .authenticated.csrf().disable();//都需要身份认证 }}

最后这个自定义的controller的逻辑就是跟我流程图里面的逻辑一样,如果请求是一个html请求,去根据配置文件去进行跳转(如果用户配了自定义登录页面就走其对应的页面,如果用户没配置,则走browser默认的标准登录页面去进行登录。)

注意,如果忘记配授权的话就会进入死循环:

三、自定义登录成功处理

在默认的处理中,登录成功之后会重定向到在地址栏中输入的url上面,但是往往不满足我们真实的开发场景:比如登录成功后进行签到处理、进行积分的累积等。如果要实现登录成功处理其实非常简单,只需要实现一个接口(AuthenticationSuccessHandler)即可。代码写在了browser项目中

@Component("tinnerAuthentivationSuccessHandler")public class TinnerAuthentivationSuccessHandler implements AuthenticationSuccessHandler { private Logger LOGGER = LoggerFactory.getLogger(this.getClass; @Autowired private ObjectMapper objectMapper; @Autowired private SecurityProperties securityProperties; @Override public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException { LOGGER.info; httpServletResponse.setContentType("application/json;charset=UTF-8"); httpServletResponse.getWriter().write(objectMapper.writeValueAsString(authentication)); }}

实现了AuthenticationSuccessHandler接口后,只需要重写onAuthenticationSuccess方法即可,这个方法会在登录成功之后调用,里面除了HttpServletRequest 和HttpServletResponse 对象之外,还有一个Authentication 接口对象,这个接口的作用是封装认证信息,比如认证通过之后的session信息。我在用户登录成功之后将authentication对象中的信息返回给了前台。然后在BrowserSecurityConfig去进行配置

/** * WebSecurityConfigurerAdapter是springSecurity提供的一个适配器类 */@Configurationpublic class BrowserSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private SecurityProperties securityProperties; @Autowired private AuthenticationSuccessHandler tinnerAuthentivationSuccessHandler; @Bean public PasswordEncoder passwordEncoder(){ return new BCryptPasswordEncoder(); } @Override protected void configure(HttpSecurity http) throws Exception {// super.configure; //实现的效果:让它去表单登录,而不是alert框 http.formLogin() .loginPage("/authentication/require") .loginProcessingUrl("/authentication/form") .successHandler(tinnerAuthentivationSuccessHandler) .and() .authorizeRequests()//对请求进行授权 .antMatchers("/authentication/require",securityProperties.getBrowser().getLoginPage.permitAll() .anyRequest()//任何请求 .authenticated.csrf().disable();//都需要身份认证 }}

然后我们去访问系统的资源,会先跳转到登录页面,登录成功之后,我会看到一系列的用户相关信息

美高梅手机游戏网站 12用户相关信息

解释:

第一个是authenticated为true,表示用户通过了身份认证authorities中封装了用户的身份权限信息credentials是用户输入的用户密码,但是默认的SpringSecurity对其进行了处理返回的是nulldetails包含了认证请求的一些信息:访问地址以及sessionIdname是用户写的用户名principal是userdetails里面的内容

在未来如果用到QQ微信授权登录,其authentication信息是不一样的。

美高梅手机游戏网站 13死循环.png

四、自定义登录失败处理

美高梅手机游戏网站 ,SpringSecurity默认的是返回错误信息,比如我们的业务场景需要“连续三次输入密码不允许登录、记录错误日志”等的逻辑。失败处理也应该是返回一个json对象,只需要实现AuthenticationFailureHandler接口即可

@Component("tinnerAuthentivationFailureHandler")public class TinnerAuthentivationFailureHandler implements AuthenticationFailureHandler { private Logger LOGGER = LoggerFactory.getLogger(this.getClass; @Autowired private ObjectMapper objectMapper; @Autowired private SecurityProperties securityProperties; @Override public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException { LOGGER.info; httpServletResponse.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value; httpServletResponse.setContentType("application/json;charset=UTF-8"); httpServletResponse.getWriter().write(objectMapper.writeValueAsString; }}

可以看到,在实现了这个接口之后实现了onAuthenticationFailure方法,其中的第三个参数不再是验证信息的那个对象,而是一个异常,这是因为登录失败的时候会抛出一系列异常(用户名未找到、密码错误等),这个时候登录信息是不完整的,我们就拿不到那个登录验证信息,取而代之的是一个认证过程中发生的错误所包含的异常。同样,去config中进行配置

/** * WebSecurityConfigurerAdapter是springSecurity提供的一个适配器类 */@Configurationpublic class BrowserSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private SecurityProperties securityProperties; @Autowired private AuthenticationSuccessHandler tinnerAuthentivationSuccessHandler; @Autowired private AuthenticationFailureHandler tinnerAuthentivationFailureHandler; @Bean public PasswordEncoder passwordEncoder(){ return new BCryptPasswordEncoder(); } @Override protected void configure(HttpSecurity http) throws Exception {// super.configure; //实现的效果:让它去表单登录,而不是alert框 http.formLogin() .loginPage("/authentication/require") .loginProcessingUrl("/authentication/form") .successHandler(tinnerAuthentivationSuccessHandler) .failureHandler(tinnerAuthentivationFailureHandler)// http.httpBasic .authorizeRequests()//对请求进行授权 .antMatchers("/authentication/require",securityProperties.getBrowser().getLoginPage.permitAll() .anyRequest()//任何请求 .authenticated.csrf().disable();//都需要身份认证 }}

然后访问系统中的rest服务资源,输入错误的用户密码,然后会受到一个500的请求,里面包含了错误消息以及其堆栈信息。

美高梅手机游戏网站 14失败信息

运行后访问:

五、改进

如果我把登录和失败的处理方式写死,写成只返回json的方式也是不合适的,因为在某些项目中,我们可能会用到相关模板去进行架构(jsp、freemarker模板等)。它的登录不是异步进行登录的而是同步进行的。我们需要让用户可以进行自己的配置去进行动态地选择同步登录还是异步登录(跳转、返回JSON)。在LoginType中我定义了两个枚举类型:JSON和redirect。通过判断这个枚举类型来动态地实现登录方式。然后重新构造登录成功处理器和登录失败处理器:登录成功处理器:

@Component("tinnerAuthentivationSuccessHandler")//public class TinnerAuthentivationSuccessHandler implements AuthenticationSuccessHandler {public class TinnerAuthentivationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler { private Logger LOGGER = LoggerFactory.getLogger(this.getClass; @Autowired private ObjectMapper objectMapper; @Autowired private SecurityProperties securityProperties; @Override public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException { LOGGER.info; if (LoginType.JSON.equals(securityProperties.getBrowser().getLoginType{ httpServletResponse.setContentType("application/json;charset=UTF-8"); httpServletResponse.getWriter().write(objectMapper.writeValueAsString(authentication)); }else{ super.onAuthenticationSuccess(httpServletRequest,httpServletResponse,authentication); } }}

我们现在没有去实现AuthenticationSuccessHandler 接口,而是去继承了SavedRequestAwareAuthenticationSuccessHandler 类,这个类是SpringSecurity提供的默认的登录成功处理器,然后重写父类的方法,去进行了if判断。同样的在登录失败处理器中:

@Component("tinnerAuthentivationFailureHandler")//public class TinnerAuthentivationFailureHandler implements AuthenticationFailureHandler {public class TinnerAuthentivationFailureHandler extends SimpleUrlAuthenticationFailureHandler { private Logger LOGGER = LoggerFactory.getLogger(this.getClass; @Autowired private ObjectMapper objectMapper; @Autowired private SecurityProperties securityProperties; @Override public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException { LOGGER.info; if (LoginType.JSON.equals(securityProperties.getBrowser().getLoginType{ httpServletResponse.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value; httpServletResponse.setContentType("application/json;charset=UTF-8"); httpServletResponse.getWriter().write(objectMapper.writeValueAsString; }else{ super.onAuthenticationFailure(httpServletRequest,httpServletResponse,e); } }}

然后如果我在demo项目中指定了登录类型为重定向

tinner.security.browser.loginType=REDIRECT

然后在src->main->resources目录下我定义了一个index.hmtl,然后在浏览器中访问这个html页面,会先重定向到登录页面,输入错误的用户名密码,则跳转到了spring默认的登录失败的页面中,然后重新输入一次正确的用户名密码,则自动跳转到了index.hmtl页面中去。

美高梅手机游戏网站 15访问结果页面.png

过滤器默认处理的登录请求是/login post形式如果使用了新的请求路径,还需要配置,让SpringSecurity知道

hcx-signIn.html:

<title>登录</title></head><body> <h2>标准登录页面</h2> <h3>表单登录</h3> <form action="/authentication/form" method="post"> <table> <tr> <td>用户名:</td> <td><input type="text" name="username"></td> </tr> <tr> <td>密码:</td> <td><input type="password" name="password"></td> </tr> <tr> <td colspan="2"><button type="submit">登录</button></td> </tr> </table> </form></body>

MyUserDetailsService:

@Componentpublic class MyUserDetailsService implements UserDetailsService{ private Logger logger = LoggerFactory.getLogger(getClass; @Autowired private PasswordEncoder passwordEncoder; @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { logger.info("登录用户名:"+username); //根据用户名查找用户信息 //根据查找到的用户信息判断用户是否被冻结 //为了把用户是否冻结的信息告诉SpringSecurity,new User的构造方法使用包含四个布尔返回值的参数的方法 //此处没有读取数据库,直接用静态数据 密码:123456 静态权限:admin 这些在实际开发中需要从数据库中获取 //passwordEncoder.encode,在实际应用中,此步骤应该在注册的时候就做好了,此处就直接在数据库拿出加密好的数据 String password = passwordEncoder.encode; logger.info("数据库密码是:"+password); return new User(username,password, true,true,true,false, AuthorityUtils.commaSeparatedStringToAuthorityList; } /** * 此处,当前的方法loadUserByUsername返回的是UserDetails接口的实例,使用了Spring默认的User类 * 实际的应用中,并不一定更要使用该类,只要是UserDetails这个接口的实现就可以 * 可以使用对应的DAO接口实现UserDetails接口 */ }

BrowserSecurityConfig:

@Configurationpublic class BrowserSecurityConfig extends WebSecurityConfigurerAdapter{ @Bean //加密 public PasswordEncoder passwordEncoder() { //如果系统本身有了其他的加密方式,此处就应该返回自己写的passwordencoder,再实现encoder和matches方法 return new BCryptPasswordEncoder(); } @Override protected void configure(HttpSecurity http) throws Exception { //使用表单登录:指定了身份认证的方式 http.formLogin() .loginPage("/hcx-signIn.html")//自定义登录页面 .loginProcessingUrl("/authentication/form") //配置让Spring知道让UsernamePasswordAuthenticationFilter过滤器去处理/authentication/form路径 //http.httpBasic() //使用回之前的认证方式 .and() .authorizeRequests()//表示以下都是授权的配置 .antMatchers("/hcx-signIn.html").permitAll()//当访问hcx-signIn.html时,不需要身份认证 .anyRequest()//任何请求 .authenticated()//都需要身份认证 .and.disable(); }}

美高梅手机游戏网站 16表单登录页面.png

改进:处理不同类型的请求把上面直接是跳转到一个页面,换成一个Controller,让Controller判断是否是一个HTML请求引发的跳转,如果是就返回登录页面如果不是就返回401状态码和错误信息:

美高梅手机游戏网站 17处理不同类型的请求.png

BrowserSecurityController:在该类中处理需要身份认证的请求:

@RestControllerpublic class BrowserSecurityController { private Logger logger = LoggerFactory.getLogger(getClass; //判断引发跳转的是否是html //用RequestCache拿到引发跳转的请求 private RequestCache requestCache = new HttpSessionRequestCache(); private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy(); @Autowired private SecurityProperties securityProperties; /** * 当需要身份认证时,跳转到这里 * @param request * @param response * @return * @throws IOException */ @RequestMapping("/authentication/require") @ResponseStatus(code=HttpStatus.UNAUTHORIZED) //返回状态码 public SimpleResponse requireAuthentication(HttpServletRequest request,HttpServletResponse response) throws IOException{ //拿到引发跳转的请求 SavedRequest savedRequest = requestCache.getRequest(request, response); if(savedRequest!=null) { //引发跳转请求的url String targetUrl = savedRequest.getRedirectUrl(); logger.info("引发跳转的请求时: "+targetUrl); if(StringUtils.endsWithIgnoreCase(targetUrl, ".html")) {//判断引发跳转的请求是否是以.html结尾 //跳转到登录页 /** * request * response * url:要跳转的url 此处不可能固定的跳转到某一个页面,配置可以使用标准登录页还是使用自己写的登录页 */ redirectStrategy.sendRedirect(request, response,securityProperties.getBrowser().getLoginPage;//url://跳转到用户配置的login的配置 } } //如果不是一个html请求,返回401状态码和错误信息 return new SimpleResponse("访问的服务需要身份认证,请引导用户到登录页"); }}

使用户可以自己去配登录页面:在application.properties中配置:

hcx.security.browser.loginPage = /demo-signIn.html

demo-signIn.html:

<!DOCTYPE html><html><head><meta charset="UTF-8"><title>登录</title></head><body> <h2>Demo登录页</h2></body></html>

当做了该配置之后,就会跳转到demo-signIn.html该页面;如果没有该配置,则跳转到原本配置的标准登录页

美高梅手机游戏网站 18实现配置跳转到不同登录页.png

编辑:美高梅手机游戏网站 本文来源:虽然可以用一个自定义的html页面来完成表单登录

关键词: