安科网

Spring Security

明亮的技术

明亮的技术

2014-09-30

关注 关注

使用Spring Security 3 来实现多种用户类型的登录方式，在我看来，大致分为两大步，第一步是控制多种用户登录类型的登录界面的展示，第二步是控制多种用户登录的验证方式，而第二大步又可分为三个小步来展开，第一小步是验证过滤器，第二小步是验证凭证的制作，第三小步是验证用户凭证，在这里我将就这几步的分析与实现一步一步展开来进行描述。

      这里我假定有这样一个系统，分为前台用户和后台用户两种用户类型，针对这两种不同的用户，相应的验证是不一样的，前台用户登录需要提供邮箱地址和电话号码，而后台用户需要提供我们在登录方式中最为常见的用户名，密码和验证码，两种登录类型的登录界面和登录的验证处理流程都不相同，拥有自己的验证处理，验证成功的处理，验证失败的处理等。这里我会用四篇文章来详细阐述整个验证的流程实现，每一篇文章后都会附有我的项目压缩文件，有兴趣的朋友可以下载来进行尝试，我使用的是Maven来管理项目，项目的框架是Spring+Hibernate，使用到的开发工具是IntelliJ，这里我要给IntelliJ打个广告，当然是无偿的，呵呵，在这之前我曾使用过NetBeans，Eclipse等开发工具，IntelliJ是我使用过的最为优秀的开发工具，有兴趣的同学可以尝试下。

Spring Security 3多用户登录实现之二 多登录界面展示

接前讲，首先针对一个多种用户类型的登录需求，需要先实现多种用户类型的登录界面的展示，Spring Security提供了这样一个接口来帮助我们实现多种用户类型的登录界面的展示，这个接口就是AuthenticationEntryPoint， 实现这样一个接口，我们就可以随心所欲的控制登录界面的展示了，当我们访问一个受权限的资源，而当前又没有权限访问时，Spring Security就会将处理导向这个接口的实现。针对前讲我所提到的需求，在这里我将实现前台用户和后台用户登录界面的展示，先来看看我的源码实现吧，在这里为了实现多用户类型的登录，很多场景我都需要根据相应的请求参数或地址来判断我需要导向哪个URL地址，我在这里特实现了一个共用的接口和类，接口名为DirectUrlResolver。

package com.template.security.shared;  
  
import javax.servlet.http.HttpServletRequest;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午7:11 
 */  
public interface DirectUrlResolver {  
  
    boolean support(HttpServletRequest request);  
  
    String directUrl();  
}  
package com.template.security.shared;  
  
import javax.servlet.http.HttpServletRequest;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午7:12 
 */  
public abstract class AbstractDirectUrlResolver implements DirectUrlResolver {  
    protected String pattern;  
    protected String directUrl;  
  
    @Override  
    public abstract boolean support(HttpServletRequest request);  
  
    @Override  
    public String directUrl() {  
        return this.directUrl;  
    }  
  
    public void setPattern(String pattern) {  
        this.pattern = pattern;  
    }  
  
    public void setDirectUrl(String directUrl) {  
        this.directUrl = directUrl;  
    }  
}  
package com.template.security.shared;  
  
import com.template.utils.StringUtils;  
  
import javax.servlet.http.HttpServletRequest;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午7:13 
 */  
public class RequestParameterDirectUrlResolver extends AbstractDirectUrlResolver {  
    private String parameterName;  
  
    @Override  
    public boolean support(HttpServletRequest request) {  
        String parameterValue = request.getParameter(parameterName);  
        if (StringUtils.isEmpty(parameterValue)) {  
            return false;  
        }  
        return parameterValue.equals(this.pattern);  
    }  
  
    public void setParameterName(String parameterName) {  
        this.parameterName = parameterName;  
    }  
}  
package com.template.security.shared;  
  
import javax.servlet.http.HttpServletRequest;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午7:13 
 */  
public class RequestUriDirectUrlResolver extends AbstractDirectUrlResolver {  
  
    @Override  
    public boolean support(HttpServletRequest request) {  
        String requestURI = request.getRequestURI();  
        return requestURI.contains(this.pattern);  
    }  
}  

     RequestParameterDirectUrlResolver和RequestUriDirectUrlResolver都实现了DirectUrlResolver这样一个接口，前者的实现是根据相应请求中的参数来判断， 而后者的实现是根据相应的请求地址来判断。

    现在让我们来看看如何通过实现AuthenticationEntryPoint接口来控制什么时候展示前台登录界面，什么时候展示后台登录界面的吧。

package com.template.security.login;  
  
import com.template.security.shared.DirectUrlResolver;  
import org.springframework.security.core.AuthenticationException;  
import org.springframework.security.web.AuthenticationEntryPoint;  
  
import javax.servlet.ServletException;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午7:40 
 */  
public class MultipleAuthenticationLoginEntry implements AuthenticationEntryPoint {  
    private String defaultLoginUrl;  
    private List<DirectUrlResolver> directUrlResolvers = new ArrayList<DirectUrlResolver>();  
  
  
    @Override  
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {  
        for (DirectUrlResolver directUrlResolver : directUrlResolvers) {  
            if (directUrlResolver.support(request)) {  
                String loginUrl = directUrlResolver.directUrl();  
                response.sendRedirect(loginUrl);  
                return;  
            }  
        }  
  
        response.sendRedirect(defaultLoginUrl);  
    }  
  
    public void setDefaultLoginUrl(String defaultLoginUrl) {  
        this.defaultLoginUrl = defaultLoginUrl;  
    }  
  
    public void setDirectUrlResolvers(List<DirectUrlResolver> directUrlResolvers) {  
        this.directUrlResolvers = directUrlResolvers;  
    }  
}  

     再来看看在Spring配置文件中是如何对相应的登录入口进行配置的吧

package com.template.security.filter;  
  
import org.springframework.security.core.Authentication;  
import org.springframework.security.core.AuthenticationException;  
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;  
  
import javax.servlet.ServletException;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午10:00 
 */  
public class MultipleAuthenticationProcessingFilter extends AbstractAuthenticationProcessingFilter {  
    private List<AuthenticationTokenResolver> tokenResolvers = new ArrayList<AuthenticationTokenResolver>();  
  
    /** 
     * @param defaultFilterProcessesUrl the default value for <tt>filterProcessesUrl</tt>. 
     */  
    protected MultipleAuthenticationProcessingFilter(String defaultFilterProcessesUrl) {  
        super(defaultFilterProcessesUrl);  
    }  
  
    @Override  
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException, ServletException {  
        for (AuthenticationTokenResolver tokenResolver : tokenResolvers) {  
            if (tokenResolver.support(request)) {  
                Authentication authentication = tokenResolver.resolve(request);  
                return this.getAuthenticationManager().authenticate(authentication);  
            }  
        }  
  
        throw new UnsupportedOperationException("No authentication token resolver found!");  
    }  
  
    public void setTokenResolvers(List<AuthenticationTokenResolver> tokenResolvers) {  
        this.tokenResolvers = tokenResolvers;  
    }  
}  
package com.template.security.filter;  
  
import org.springframework.security.core.Authentication;  
  
import javax.servlet.http.HttpServletRequest;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午10:08 
 */  
public interface AuthenticationTokenResolver {  
  
    boolean support(HttpServletRequest request);  
  
  
    Authentication resolve(HttpServletRequest request);  
  
}  
package com.template.security.filter;  
  
import com.template.utils.StringUtils;  
import org.springframework.security.core.Authentication;  
  
import javax.servlet.http.HttpServletRequest;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午10:27 
 */  
public abstract class AbstractAuthenticationTokenResolver implements AuthenticationTokenResolver {  
    protected String parameterName;  
    protected String parameterValue;  
  
    protected AbstractAuthenticationTokenResolver() {  
    }  
  
    protected AbstractAuthenticationTokenResolver(String parameterName) {  
        this.parameterName = parameterName;  
    }  
  
    @Override  
    public boolean support(HttpServletRequest request) {  
        String parameterValue = request.getParameter(parameterName);  
        if (StringUtils.isEmpty(parameterValue)) {  
            return false;  
        }  
        return parameterValue.equals(this.parameterValue);  
    }  
  
    @Override  
    public abstract Authentication resolve(HttpServletRequest request);  
  
    public void setParameterName(String parameterName) {  
        this.parameterName = parameterName;  
    }  
  
    public void setParameterValue(String parameterValue) {  
        this.parameterValue = parameterValue;  
    }  
}  
package com.template.security.filter;  
  
import com.template.security.authentication.token.BackendAuthenticationToken;  
import org.springframework.security.core.Authentication;  
import org.springframework.security.core.GrantedAuthority;  
import org.springframework.security.core.authority.SimpleGrantedAuthority;  
  
import javax.servlet.http.HttpServletRequest;  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午10:29 
 */  
public class BackendAuthenticationTokenResolver extends AbstractAuthenticationTokenResolver {  
  
    protected BackendAuthenticationTokenResolver() {  
        super();  
    }  
  
    @Override  
    public Authentication resolve(HttpServletRequest request) {  
        String username = request.getParameter("username");  
        String password = request.getParameter("password");  
        String captcha = request.getParameter("captcha");  
        List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();  
        authorities.add(new SimpleGrantedAuthority("ROLE_ADMIN"));  
        return new BackendAuthenticationToken(username, password, authorities, captcha);  
    }  
}  
package com.template.security.filter;  
  
import com.template.security.authentication.token.ForendAuthenticationToken;  
import org.springframework.security.core.Authentication;  
import org.springframework.security.core.GrantedAuthority;  
import org.springframework.security.core.authority.SimpleGrantedAuthority;  
  
import javax.servlet.http.HttpServletRequest;  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午10:29 
 */  
public class ForendAuthenticationTokenResolver extends AbstractAuthenticationTokenResolver {  
  
    protected ForendAuthenticationTokenResolver() {  
        super();  
    }  
  
    @Override  
    public Authentication resolve(HttpServletRequest request) {  
        String email = request.getParameter("email");  
        String phone = request.getParameter("phone");  
        List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();  
        authorities.add(new SimpleGrantedAuthority("ROLE_ADMIN"));  
        return new ForendAuthenticationToken(email, phone, authorities);  
    }  
  
}  

    这里实现AbstractAuthenticationProcessingFilter接口的类MultipleAuthenticationProcessingFilter，用来根据相应的登录表单提交信息构造相应的登录用户凭证。为了实现根据前台登录表单信息构造前台用户凭证，根据后台登录表单信息构造后台用户凭证，使用了策略模式来实现，实现AbstractAuthenticationTokenResolver接口的BackendAuthenticationTokenResolver和ForendAuthenticationTokenResolver分别用来构造后台用户凭证和前台用户凭证，再来看看配置文件是如何进行配置的吧。

package com.template.security.authentication.token;  
  
import org.springframework.security.authentication.AbstractAuthenticationToken;  
import org.springframework.security.core.GrantedAuthority;  
import org.springframework.security.core.authority.SimpleGrantedAuthority;  
  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-4 
 * Time: 下午11:23 
 */  
public class ForendAuthenticationToken extends AbstractAuthenticationToken {  
    private String email;  
    private String phone;  
  
    public ForendAuthenticationToken(String email, String phone, List<GrantedAuthority> grantedAuthorities) {  
        super(grantedAuthorities);  
        this.email = email;  
        this.phone = phone;  
    }  
  
    public String getEmail() {  
        return email;  
    }  
  
    public String getPhone() {  
        return phone;  
    }  
  
    @Override  
    public Object getCredentials() {  
        return null;  
    }  
  
    @Override  
    public Object getPrincipal() {  
        return null;  
    }  
}  
package com.template.security.authentication.token;  
  
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;  
import org.springframework.security.core.GrantedAuthority;  
  
import java.util.Collection;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-4 
 * Time: 下午11:24 
 */  
public class BackendAuthenticationToken extends UsernamePasswordAuthenticationToken {  
    private String captcha;  
  
    public BackendAuthenticationToken(Object principal, Object credentials, Collection<? extends GrantedAuthority> authorities, String captcha) {  
        super(principal, credentials, authorities);  
        this.captcha = captcha;  
    }  
  
    public String getCaptcha() {  
        return captcha;  
    }  
}  

    为了标志我们创建的类为一个用户凭证并且能够被Spring Security识别，我们需要实现Authentication接口，因为Spring Security为我们提供了一个抽象的凭证，所以这里我的前台凭证就继承了这样一个抽象的凭证类，名为AbstractAuthenticationToken， 根据前台表单的提交信息有邮件地址和电话号码，所以实现的ForendAuthenticationToken包含这样两个属性，而Spring Security为我们提供了常见的用户名和密码的登录凭证实现，我的后台登录表单信息只是多了一个验证码，所以我直接继承了UsernamePasswordAuthenticationToken这样一个类。

Spring Security 3多用户登录实现之五 验证用户凭证

有了用户凭证后， 如何验证用户的凭证是否正确呢， 这就需要借助AuthenticationManager了， AuthenticationManager可以包含多个AuthenticationProvider， 每个AuthenticationProvider都会针对特定的AuthenticationToken， 也就是用户凭证来验证相应的用户凭证是否正确。

   来看看我为了实现验证前台用户凭证和后台用户凭证而实现的AuthenticationProvider吧。

package com.template.security.authentication.provider;  
  
import com.template.security.authentication.token.BackendAuthenticationToken;  
import org.springframework.security.authentication.AuthenticationProvider;  
import org.springframework.security.authentication.AuthenticationServiceException;  
import org.springframework.security.core.Authentication;  
import org.springframework.security.core.AuthenticationException;  
import org.springframework.security.core.context.SecurityContextHolder;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-4 
 * Time: 下午11:16 
 */  
public class BackendAuthenticationProvider implements AuthenticationProvider {  
  
    @Override  
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {  
        BackendAuthenticationToken authenticationToken = (BackendAuthenticationToken) authentication;  
//        String captcha = authenticationToken.getCaptcha();  
//        if (captcha.startsWith("ZZ")) {  
//            throw new AuthenticationServiceException("The captcha is wrong!");  
//        }  
        String username = (String) authenticationToken.getPrincipal();  
        String password = (String) authenticationToken.getCredentials();  
  
        if (username.equalsIgnoreCase("ZHONGGANG") && password.equalsIgnoreCase("123")) {  
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);  
            return authenticationToken;  
        }  
        throw new AuthenticationServiceException("The username or password is not correct!");  
    }  
  
    @Override  
    public boolean supports(Class<?> authentication) {  
        return BackendAuthenticationToken.class.isAssignableFrom(authentication);  
    }  
}  
package com.template.security.authentication.provider;  
  
import com.template.security.authentication.token.ForendAuthenticationToken;  
import org.springframework.security.authentication.AuthenticationProvider;  
import org.springframework.security.authentication.AuthenticationServiceException;  
import org.springframework.security.core.Authentication;  
import org.springframework.security.core.AuthenticationException;  
import org.springframework.security.core.context.SecurityContextHolder;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-4 
 * Time: 下午11:16 
 */  
public class ForendAuthenticationProvider implements AuthenticationProvider {  
  
    @Override  
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {  
        ForendAuthenticationToken authenticationToken = (ForendAuthenticationToken) authentication;  
        String email = authenticationToken.getEmail();  
        String phone = authenticationToken.getPhone();  
        if (email.endsWith("@qq.com") && phone.startsWith("139")) {  
            authenticationToken.setAuthenticated(true);  
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);  
            return authenticationToken;  
        }  
  
        throw new AuthenticationServiceException("The email or phone is not correct!");  
    }  
  
    @Override  
    public boolean supports(Class<?> authentication) {  
        return ForendAuthenticationToken.class.isAssignableFrom(authentication);  
    }  
}  

    不论是前台用户凭证验证还是后台用户凭证验证，都实现了AuthenticationProvider接口，其中的supports方法表明这个AuthenticationProvider需要对哪个类型的用户凭证进行验证。这里我只是进行了一个简单的验证，没有什么实际意义，如果你的验证需要与数据库打交道，你可以在AuthenticationProvider中注入你的服务。来看看配置文件中的相应配置信息吧。

package com.template.security.authentication.handler;  
  
import com.template.security.shared.DirectUrlResolver;  
import org.springframework.security.core.AuthenticationException;  
import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;  
  
import javax.servlet.ServletException;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午11:20 
 */  
public class MultipleAuthenticationFailureHandler extends SimpleUrlAuthenticationFailureHandler {  
    private List<DirectUrlResolver> resolvers = new ArrayList<DirectUrlResolver>();  
  
    @Override  
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {  
        for (DirectUrlResolver resolver : resolvers) {  
            if (resolver.support(request)) {  
                String directUrl = resolver.directUrl();  
                setDefaultFailureUrl(directUrl);  
            }  
        }  
  
        super.onAuthenticationFailure(request, response, exception);  
    }  
  
    public void setResolvers(List<DirectUrlResolver> resolvers) {  
        this.resolvers = resolvers;  
    }  
}  

    验证成功的处理需要实现AuthenticationSuccessHandler接口，我的后台验证成功处理是这样的

package com.template.security.authentication.handler;  
  
import com.template.security.shared.DirectUrlResolver;  
import org.springframework.security.core.Authentication;  
import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;  
  
import javax.servlet.ServletException;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * Created by IntelliJ IDEA. 
 * User: Zhong Gang 
 * Date: 12-11-9 
 * Time: 下午11:20 
 */  
public class MultipleAuthenticationSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {  
    private List<DirectUrlResolver> resolvers = new ArrayList<DirectUrlResolver>();  
  
    @Override  
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {  
        for (DirectUrlResolver resolver : resolvers) {  
            if (resolver.support(request)) {  
                String directUrl = resolver.directUrl();  
                setDefaultTargetUrl(directUrl);  
            }  
        }  
  
        super.onAuthenticationSuccess(request, response, authentication);  
    }  
  
    public void setResolvers(List<DirectUrlResolver> resolvers) {  
        this.resolvers = resolvers;  
    }  
}  

    不论是前台验证成功还是后台验证成功，前台验证失败还是后台验证失败我都有不同的处理，前台验证成功导向前台验证成功界面，后台验证成功导向后台验证成功界面， 前台验证失败导向前台登录界面， 后台验证失败导向后台登录界面，所以这里我使用了前面我书写的一个通用接口，也就是DirectUrlResolver。来看看验证处理成功或失败的配置信息。

Xml代码  Spring Security
  1. <beans:bean id="multipleAuthenticationSuccessHandler"  
  2.              class="com.template.security.authentication.handler.MultipleAuthenticationSuccessHandler">  
  3.      <beans:property name="alwaysUseDefaultTargetUrl" value="true"/>  
  4.      <beans:property name="resolvers">  
  5.          <beans:list>  
  6.              <beans:ref bean="backendAuthenticationSuccessUrlResolver"/>  
  7.              <beans:ref bean="forendAuthenticationSuccessUrlResolver"/>  
  8.          </beans:list>  
  9.      </beans:property>  
  10.  </beans:bean>  
  11.   
  12.  <beans:bean id="backendAuthenticationSuccessUrlResolver"  
  13.              class="com.template.security.shared.RequestParameterDirectUrlResolver">  
  14.      <beans:property name="parameterName" value="token"/>  
  15.      <beans:property name="pattern" value="backend"/>  
  16.      <beans:property name="directUrl" value="/backend/login/success"/>  
  17.  </beans:bean>  
  18.   
  19.  <beans:bean id="forendAuthenticationSuccessUrlResolver"  
  20.              class="com.template.security.shared.RequestParameterDirectUrlResolver">  
  21.      <beans:property name="parameterName" value="token"/>  
  22.      <beans:property name="pattern" value="forend"/>  
  23.      <beans:property name="directUrl" value="/forend/login/success"/>  
  24.  </beans:bean>  
  25.   
  26.  <beans:bean id="multipleAuthenticationFailureHandler"  
  27.              class="com.template.security.authentication.handler.MultipleAuthenticationFailureHandler">  
  28.      <beans:property name="resolvers">  
  29.          <beans:list>  
  30.              <beans:ref bean="backendAuthenticationFailureUrlResolver"/>  
  31.              <beans:ref bean="forendAuthenticationFailureUrlResolver"/>  
  32.          </beans:list>  
  33.      </beans:property>  
  34.  </beans:bean>  
  35.   
  36.  <beans:bean id="backendAuthenticationFailureUrlResolver"  
  37.              class="com.template.security.shared.RequestParameterDirectUrlResolver">  
  38.      <beans:property name="parameterName" value="token"/>  
  39.      <beans:property name="pattern" value="backend"/>  
  40.      <beans:property name="directUrl" value="/backend/login?error=1"/>  
  41.  </beans:bean>  
  42.   
  43.  <beans:bean id="forendAuthenticationFailureUrlResolver"  
  44.              class="com.template.security.shared.RequestParameterDirectUrlResolver">  
  45.      <beans:property name="parameterName" value="token"/>  
  46.      <beans:property name="pattern" value="forend"/>  
  47.      <beans:property name="directUrl" value="/forend/login?error=1"/>  
  48.  </beans:bean>  

    这里还需要将相应的验证Handler注入到前讲的认证处理Filter中。

spring框架 接口

明亮的技术

明亮的技术

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

关于使用IDEA的springboot框架往Redis里写入数据乱码问题

解决方法：在你RedisUtil类里加入下图红框的的代码，

vapaad 2020-10-22

一个90后女孩的第一个 Spring Boot 应用

本文转载自微信公众号「小明菜市场 」，作者小明菜市场。Spring Boot的出现，主要是用来解决 Spring 过去的一些问题，提出了约定优于配置的思想，默认对很多方法进行了设置，使得开发者可以快速的构建项目，集成第三方的内容。使得开发效率大大提升。S

与卿画眉共浮生 2020-11-13

Spring Batch真是个优秀的批处理框架，用完爱不释手！

Spring Batch是一个轻量级的、完善的批处理框架，作为Spring体系中的一员，它拥有灵活、方便、生产可用的特点。在应对高效处理大量信息、定时处理大量数据等场景十分简便。结合调度框架能更大地发挥Spring Batch的作用。Batch Core核

smalllove 2020-11-03

详解 | Spring Boot 核心的 3 个注解详解

本文转载自微信公众号「小明菜市场」，作者小明菜市场 。Spring Boot 最大的特点是无需 XML 配置文件，能够实现自动装配，并进行全自动化的jar包配置。Spring Boot 是微服务的核心，其Spring Cloud 是基于Spring Bo

hellowordmonkey 2020-11-02

SpringBoot Web 应用源码解析：综合实战和整体总结

关于 Web 方面的配置比较多，值得庆幸的是，Spring Boot 已经帮我们预置初始化了很多基础组件。但在实践的过程中，某些基础的组件并不能满足我们的实际需求,这时就需要我们重新初始化相应组件，甚至在某些极端的情况下需要完全接管 Spring Boot

丽丽 2020-10-30

Spring和SpringBoot最核心的3大区别，详解！

对于 Spring和 SpringBoot到底有什么区别，我听到了很多答案，刚开始迈入学习 SpringBoot的我当时也是一头雾水，随着经验的积累、我慢慢理解了这两个框架到底有什么区别，相信对于用了 SpringBoot很久的同学来说，还不是很理解 Sp

周太郎 2020-10-28

Java开发人员必知的常用类库，这些你都知道吗？

作为一名程序员，我们要避免重复发明轮子，尽可能使用一些成熟、优秀、稳定的的第三方库，站在巨人的肩膀上搭建可靠、稳定的系统。Spring框架为现代基于Java的企业应用程序提供了一个全面的编程和配置模型，使用开发基于Java语言的应用更加简单、便捷。Spri

greensomnuss 2020-10-27

Spring框架里注解@Autowired的工作原理

Suppose I have a bean named HelloWorld which has a member attribute points to another bean User.With annotation @Autowired, as l

职业炮灰 2020-10-16

一个快速找到Spring框架是在哪里找到XML配置文件并解析Beans定义的小技巧

The line 399 where exception is raised will be automatically located. The core logic to load xml file is just near the exception

与卿画眉共浮生 2020-10-14

Java程序员不能错过的7个基本框架

现在IT开发人员面对的较大挑战就是复杂性，构建的应用越来越复杂。今天给大家列出Java程序员不能错过的7个基本框架，或许会对你有帮助哦。Hibernate是优秀的Java持久性框架，是一个开放源代码的对象关系映射框架，它对 JDBC 进行轻量级的对象封装，

feinifi 2020-10-14

Java开发人员应该学习的5个基本框架

Spring，Hibernate，Spring Boot，Spring Security和Spring Cloud是最重要的Java框架。Java开发人员，您好，如果您正在考虑应该学习哪种框架以成为完整的开发人员，那么您来对地方了。尽管有数十种Java框架

feinifi 2020-10-13

SpringBoot的设计理念和目标、整体架构你有深入了解吗

读者可根据日常习惯，选择熟悉的代码阅读 I 具，比如 Intellij IDEA、Spring Tool Suite、Eclipse、 MyEclipse 等。阅读 Spring Boot 源代码之前，我们还需搭建基础阅读环境。Spring Boot 对

yangjinpingc 2020-10-09

聊一下简易版的“Spring Boot”写的咋样了

昨天早上，6 点多一点就起来写代码了，前天晚上和朋友一起吃晚饭回来之后也搞到很晚，有时候想尽快把某些东西写完的时候确实是会这样。但是，说实话效率会降低很多，不推荐这样做。像我之前写guide-rpc-framework[1] 的时候，经常周末不出门，一坐

davis 2020-09-29

摊牌了！我要手写一个“Spring Boot”

本文转载自微信公众号「JavaGuide」，作者Guide哥。我们经常会对自己早期写的代码感觉恶心，这是导致很多项目烂尾的很重要的一个原因之一。自己沉淀的知识更多，对于某个知识点的理解更加深刻。所以，最近几个月我一直抽空对 JavaGuide 上早期的一些

RickyIT 2020-09-27

Spring Boot：企业常用的Starter以及实现

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域成为

lisongchuang 2020-09-27

烂了大街的 Spring 循环依赖问题，你以为自己就真会了吗

初学 Spring 的时候，我们就知道 IOC，控制反转么，它将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理，不需要我们手动去各种 new XXX。所谓的循环依赖是指，A 依赖 B，B 又依赖 A，它们之间形成了循环依赖。在 Spri

tangxiong0 2020-09-03

最火热的极速开发框架Spring Boot-蛙课网

Spring Boot请添加链接描述是Spring家族中的一个全新的框架，它用来简化Spring应用程序的创建和开发过程，也可以说Spring Boot能简化我们之前采用Spring mvc + Spring + MyBatis 框架进行开发的过程；在以往

meleto 2020-08-17

Spring Boot 2.x基础教程：使用集中式缓存Redis

之前我们介绍了两种进程内缓存的用法，包括Spring Boot默认使用的ConcurrentMap缓存以及缓存框架EhCache。虽然EhCache已经能够适用很多应用场景，但是由于EhCache是进程内的缓存框架，在集群模式下时，各应用服务器之间的缓存都

幸运小侯子 2020-08-14

Java最全面试题之Spring篇

大家好，我是Java最全面试题库的提裤姐，今天这篇是JavaEE面试题系列的第三篇，主要总结了Spring相关的问题，在后续，会沿着第一篇开篇的知识线路一直总结下去，做到日更！如果我能做到百日百更，希望你也可以跟着百日百刷，一百天养成一个好习惯。谈谈你对

YangHuiLiang 2020-08-06

Spring Cloud Gateway 网关尝鲜

Spring Cloud Gateway是Spring官方基于Spring 5.0，Spring Boot 2.0和Project Reactor等技术开发的网关，Spring Cloud Gateway旨在为微服务架构提供一种简单而有效的统一的API路由

zmysna 2020-08-03
明亮的技术

明亮的技术

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号