ForeverChance
ForeverChance

结合源码学习使用SpringSecurity

一、 关键词

Authentication：鉴权，我理解为身份认证，是权限验证中的一个特殊的分支。
Authorization：授权，表示为权限验证。
AuthenticationProvider：认证处理，对每一个支持的认证对象的身份进行认证。
AuthenticationManager：认证管理器，管理多个AuthenticationProvider，实现允许多个认证处理去执行不同来源的身份认证。
AccessDecisionManager：验证管理器，主要是对Security表达式(表达式数量可以是多个)进行权限验证处理。例如：authenticated()、hasRole()、hasAuthority()、access(表达式)等方法进行权限的验证。其中authenticated()表示对用户是否拥有验明的身份权，即为身份认证。
权限通过：AccessDecisionManager管理有三个实现类，分别对应三种权限验证通过的方式。权限验证通过是通过类似投票方式决定，有三种投票机制
  ACCESS_GRANTED：赞成票
  ACCESS_ABSTAIN：弃权票
  ACCESS_DENIED：否决票

通过方式 实现类 解释
非否决通过 AffirmativeBased 1.有赞成票即可通过
2.全部弃权即可通过
少数服从多数 ConsensusBased 1.赞成票大于否决票则通过
2.赞成票和否决票相同，allowIfEqualGrantedDeniedDecisions=true则通过
3.全部弃权，allowIfEqualGrantedDeniedDecisions=true则通过
一致通过 UnanimousBased 1.有赞成票，没有反对票则通过
2.全部否决，allowIfAllAbstainDecisions=true则通过

二、 基本流程

 1.从@EnableWebSecurity说起

 源码如下

@Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
@Target(value = { java.lang.annotation.ElementType.TYPE })
@Documented
@Import({ WebSecurityConfiguration.class, // 导入WebSecurity配置，是针对于Web方面的一些注册
        SpringWebMvcImportSelector.class,
        OAuth2ImportSelector.class })
@EnableGlobalAuthentication // 允许全局定义认证机制，包含一些认证的注册配置等等
@Configuration
public @interface EnableWebSecurity {

    /**
     * Controls debugging support for Spring Security. Default is false.
     * @return if true, enables debug support with Spring Security
     */
    boolean debug() default false;
}

 在WebSecurityConfiguration类中有setFilterChainProxySecurityConfigurer()方法，这个方法将会导入关于SpringSecurity的所有配置器对象(实现WebSecurityConfigurer接口的实例)，方法如下：

@Autowired(required = false)
    public void setFilterChainProxySecurityConfigurer(
            ObjectPostProcessor objectPostProcessor,
            // 在本处需要导入系统中关于WebSecurityConfigurer配置器
            @Value("#{@autowiredWebSecurityConfigurersIgnoreParents.getWebSecurityConfigurers()}") List> webSecurityConfigurers)
 
 
 进入@autowiredWebSecurityConfigurersIgnoreParents.getWebSecurityConfigurers()方法进行调试。如图
 
 
 
 
  
 
   
  
   
 
  
 
  

    getWebSecurityConfigurers()方法 
  
 
 
 
 
  从图中可知，Spring将会注入SpringBootWebSecurityConfiguration对象 
 
  查看SpringBootWebSecurityConfiguration源码 
 
 
 
 
  
 
   
  
   
 
  
 
  

    SpringBootWebSecurityConfiguration 
  
 
 
 
 
  从图中可知： 
 
 
 
     
  
  • 根据@ConditionalOnClass和@ConditionalOnMissingBean这两个条件来自定义创建WebSecurityConfigurerAdapter对象，从而实现注入。
    •  
  
  • 因此，通常自定义Security配置的话，都是继承WebSecurityConfigurerAdapter，并注入到Spring容器中就好。
    •  
  
  •  
    如果配置多个Security配置器，则如图
     
     
   
     
    
     
     
     结合源码学习使用SpringSecurity_第1张图片 
     
     
    
     
    
     
   
     
    •  
 
 
 
 
  
 
   
 结合源码学习使用SpringSecurity_第2张图片 
   
 
  
 
  

    配置后运行情况 
  
 
 
 
 
 2.那么注册配置器后有什么用呢？
 
 
 根据Spring官方文档中描述如图
 
 
 
 
  
 
   
  
   
 
  
 
  
 
 
 
 
  SpringBoot的自启动实现三点： 
 
 
 
     
  
  • 启用Spring Security的默认配置，该配置将Servlet过滤器创建为名为springSecurityFilterChain的bean。该bean负责应用程序中的所有安全性（保护应用程序URL，验证提交的用户名和密码，重定向到登录表单等）。
    •  
  
  • 创建一个UserDetailsService bean，其中包含用户名user和随机生成的密码，该密码将记录到控制台。
    •  
  
  •  
    对于每个请求，使用Servlet容器向名为springSecurityFilterChain的bean注册过滤器。
     注册名为springSecurityFilterChain的过滤器，实际上注册的是FilterChainProxy对象，该对象中保存有两个WebSecurityConfigurer配置器的配置过滤器链。而整个请求的过滤都将通过这一系列过滤器进行过滤。如图
     
     
   
     
    
     
     
     结合源码学习使用SpringSecurity_第3张图片 
     
     
    
     
    
     
   
     
    •  
 
 
 
 3.查看FilterChainProxy类源码，分析其作用
 
 
// FilterChainProxy类的doFilter方法
public void doFilter(ServletRequest request, ServletResponse response,
      FilterChain chain) throws IOException, ServletException {
   // 配置每一个请求只过滤一次。
   boolean clearContext = request.getAttribute(FILTER_APPLIED) == null;
   if (clearContext) {
      try {
         request.setAttribute(FILTER_APPLIED, Boolean.TRUE);
         doFilterInternal(request, response, chain);
      }
      finally {
         SecurityContextHolder.clearContext();
         request.removeAttribute(FILTER_APPLIED);
      }
   }
   else {
      doFilterInternal(request, response, chain);
   }
}

 
 
 可以看出最终将都将会执行doFilterInternal方法。继续查看该方法源码
 
 
private void doFilterInternal(ServletRequest request, ServletResponse response,
      FilterChain chain) throws IOException, ServletException {

   FirewalledRequest fwRequest = firewall
         .getFirewalledRequest((HttpServletRequest) request);
   HttpServletResponse fwResponse = firewall
         .getFirewalledResponse((HttpServletResponse) response);

   List filters = getFilters(fwRequest);

   if (filters == null || filters.size() == 0) {
      if (logger.isDebugEnabled()) {
         logger.debug(UrlUtils.buildRequestUrl(fwRequest)
               + (filters == null ? " has no matching filters"
                     : " has an empty filter list"));
      }

      fwRequest.reset();

      chain.doFilter(fwRequest, fwResponse);

      return;
   }

   // 通过自定义过滤器执行链来执行每一个过滤器
   VirtualFilterChain vfc = new VirtualFilterChain(fwRequest, chain, filters);
   vfc.doFilter(fwRequest, fwResponse);
}

 
 
 进入List filters = getFilters(fwRequest);方法
 
 
private List getFilters(HttpServletRequest request) {
   for (SecurityFilterChain chain : filterChains) {
      if (chain.matches(request)) {
         return chain.getFilters();
      }
   }
   return null;
}

 
 
 该方法表明将从所有的WebSecurityConfiguration配置对象所生成的过滤器链集合中找出与当前请求所匹配的过滤器链，并返回过滤器链中的所有过滤器。
 
 
 
 
 
  
 
   
 结合源码学习使用SpringSecurity_第4张图片 
   
 
  
 
  
 
 
 
 
 
 
 
  
 
   
 结合源码学习使用SpringSecurity_第5张图片 
   
 
  
 
  

    请求匹配的过滤链的所有过滤器 
  
 
 
 
 
 所有的过滤器如下：
 
 
     
  
  • 1.org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter 
    •  
  
  • 2.org.springframework.security.web.context.SecurityContextPersistenceFilter 
    •  
  
  • 3.org.springframework.security.web.header.HeaderWriterFilter 
    •  
  
  • 4.org.springframework.security.web.csrf.CsrfFilter 
    •  
  
  • 5.org.springframework.security.web.authentication.logout.LogoutFilter 
    •  
  
  • 6.org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter 
    •  
  
  • 7.org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter 
    •  
  
  • 8.org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter 
    •  
  
  • 9.org.springframework.security.web.authentication.www.BasicAuthenticationFilter 
    •  
  
  • 10.org.springframework.security.web.savedrequest.RequestCacheAwareFilter 
    •  
  
  • 11.org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter 
    •  
  
  • 12.org.springframework.security.web.authentication.rememberme.RememberMeAuthenticationFilter 
    •  
  
  • 13.org.springframework.security.web.authentication.AnonymousAuthenticationFilter 
    •  
  
  • 14.org.springframework.security.web.session.SessionManagementFilter 
    •  
  
  • 15.org.springframework.security.web.access.ExceptionTranslationFilter 
    •  
  
  • 16.org.springframework.security.web.access.intercept.FilterSecurityInterceptor 
    •  
  
  • 17.org.springframework.security.access.intercept.aopalliance.MethodSecurityInterceptor(注:并未出现在过滤链中，只是可以归为一类型理解处理) 
    •  
 
 
 
 4.在WebSecurityConfiguration配置中，过滤器是如何加入到请求过滤链中的
 
 
 
  
 
   
 结合源码学习使用SpringSecurity_第6张图片 
   
 
  
 
  
 
 
 
 
 
  
 
   
  
   
 
  
 
  
 
 
 
 
 
  
 
   
 结合源码学习使用SpringSecurity_第7张图片 
   
 
  
 
  

    默认配置 
  
 
 
 
 
 
 
 自定义配置增加rememberMe()方法，使过滤器链中加入RememberMeAuthenticationFilter
 
 
 
 
 
  
 
   
 结合源码学习使用SpringSecurity_第8张图片 
   
 
  
 
  

    自定义配置 
  
 
 
 
 
 
 
 添加全局方法注解，会使用代理MethodSecurityInterceptor处理业务方法
 
 
 
 
 
  
 
   
  
   
 
  
 
  
 
 
 
 
三、 粗略分析每个过滤器
 
 
 前提：解释一下OncePerRequestFilter过滤器，因为有一些过滤器都会继承OncePerRequestFilter，所以在此先看一下该过滤器的作用
 
 
 0.OncePerRequestFilter
 
 
 源码如下：
 
 
public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
        HttpServletRequest httpRequest = (HttpServletRequest)request;
        HttpServletResponse httpResponse = (HttpServletResponse)response;
        // 是否被过滤
        String alreadyFilteredAttributeName = this.getAlreadyFilteredAttributeName();
        boolean hasAlreadyFilteredAttribute = request.getAttribute(alreadyFilteredAttributeName) != null;
        if (!this.skipDispatch(httpRequest) && !this.shouldNotFilter(httpRequest)) {
            // 通过此处控制每个请求只被过滤一次
            if (hasAlreadyFilteredAttribute) {
                if (DispatcherType.ERROR.equals(request.getDispatcherType())) {
                    this.doFilterNestedErrorDispatch(httpRequest, httpResponse, filterChain);
                    return;
                }

                filterChain.doFilter(request, response);
            } else {
                // 设置已经被过滤
                request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);

                try {
                    // 主要的过滤方法
                    this.doFilterInternal(httpRequest, httpResponse, filterChain);
                } finally {
                    request.removeAttribute(alreadyFilteredAttributeName);
                }
            }
        } else {
            filterChain.doFilter(request, response);
        }

    } else {
        throw new ServletException("OncePerRequestFilter just supports HTTP requests");
    }
}


 
 
 作用：大致表现为每一个请求只能被过滤器过滤一次。过滤时调用doFilterInternal方法，因此每一个子类只需要看doFilterInternal方法即可。
 
 
 1. WebAsyncManagerIntegrationFilter
 
 
 名称：Web异步管理器集成过滤器，继承OncePerRequestFilter
  源码：
 
 
@Override
    protected void doFilterInternal(HttpServletRequest request,
            HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        SecurityContextCallableProcessingInterceptor securityProcessingInterceptor = (SecurityContextCallableProcessingInterceptor) asyncManager
                .getCallableInterceptor(CALLABLE_INTERCEPTOR_KEY);
        if (securityProcessingInterceptor == null) {
            asyncManager.registerCallableInterceptor(CALLABLE_INTERCEPTOR_KEY,
                    new SecurityContextCallableProcessingInterceptor());
        }

        filterChain.doFilter(request, response);
    }

 
 
 作用：提供SecurityContext和SpringWeb的集成
 
 
     
  
  • doFilter前：进行SecurityContext和SpringWeb集成
    •  
  
  • doFilter后：无
    •  
 
 
 
 2. SecurityContextPersistenceFilter
 
 
 名称：SecurityContext持久化过滤器
  源码：
 
 
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
      throws IOException, ServletException {
   HttpServletRequest request = (HttpServletRequest) req;
   HttpServletResponse response = (HttpServletResponse) res;

   if (request.getAttribute(FILTER_APPLIED) != null) {
      // 防止重复过滤 ensure that filter is only applied once per request
      chain.doFilter(request, response);
      return;
   }

   final boolean debug = logger.isDebugEnabled();

   request.setAttribute(FILTER_APPLIED, Boolean.TRUE);
   // 提前创建session,如果SecurityContext使用HttpSession管理。作用暂时不清楚
   if (forceEagerSessionCreation) {
      HttpSession session = request.getSession();

      if (debug && session.isNew()) {
         logger.debug("Eagerly created session: " + session.getId());
      }
   }

   // 实际上就是讲request和response封装为一个对象，然后传入SecurityContext持久库中加载SecurityContext。
   HttpRequestResponseHolder holder = new HttpRequestResponseHolder(request,
         response);
   // 从SecurityContext持久库中加载SecurityContext
   SecurityContext contextBeforeChainExecution = repo.loadContext(holder);

   try {
      // 将加载后的SecurityContext设置到SecurityContextHolder中，方便以后使用
      SecurityContextHolder.setContext(contextBeforeChainExecution);

      chain.doFilter(holder.getRequest(), holder.getResponse());

   }
   finally {
      SecurityContext contextAfterChainExecution = SecurityContextHolder
            .getContext();
      // 清空SecurityContextHolder中的SecurityContext
      SecurityContextHolder.clearContext();
      // 将经过一系列修改的SecurityContext保存至SecurityContext库中。
      repo.saveContext(contextAfterChainExecution, holder.getRequest(),
            holder.getResponse());
      request.removeAttribute(FILTER_APPLIED);

      if (debug) {
         logger.debug("SecurityContextHolder now cleared, as request processing completed");
      }
   }
}


 
 
 作用：对SecurityContext进行持久化储存
 
 
     
  
  • doFilter前：尝试从SecurityContext持久库中调用loadContext方法加载SecurityContext，并设置到SecurityContextHolder中方便之后使用
    •  
  
  •  doFilter后： 
   
       
    
    • 清空SecurityContextHolder中的SecurityContext
      •  
    
    • 将经过一系列修改的SecurityContext保存至SecurityContext库中。
      •  
   
     
    •  
 
 
 
 其他：关于SecurityContextRepository的载入和自定义。
 
 
     
  
  • 加载SecurityContextRepository：调用http. securityContext()，进入后直接调用SecurityContextConfigurer的configure(H http)方法。
    •  
 
 
 
public void configure(H http) {

   // 从sharedObject中拿SecurityContextRepository对象
   SecurityContextRepository securityContextRepository = http
         .getSharedObject(SecurityContextRepository.class);
   // 如果没拿到，则新建一个session管理的SecurityContextRepository对象
   if (securityContextRepository == null) {
      securityContextRepository = new HttpSessionSecurityContextRepository();
   }
   SecurityContextPersistenceFilter securityContextFilter = new SecurityContextPersistenceFilter(
         securityContextRepository);
   // 拿到session管理配置
   SessionManagementConfigurer sessionManagement = http
         .getConfigurer(SessionManagementConfigurer.class);
   // 从session管理配置中拿到创建策略
   SessionCreationPolicy sessionCreationPolicy = sessionManagement == null ? null
         : sessionManagement.getSessionCreationPolicy();
   // 如果是ALWAYS策略，则允许securityContextFilter提前创建session
   if (SessionCreationPolicy.ALWAYS == sessionCreationPolicy) {
      securityContextFilter.setForceEagerSessionCreation(true);
   }
   // 对securityContextFilter过滤器后置处理
   // 其会调用http.objectPostProcessor()方法提供的后置处理器。
   securityContextFilter = postProcess(securityContextFilter);
   http.addFilter(securityContextFilter);
}


 
 
     
  
  •  因此：有两种自定义SecurityContextRepository的方法。 
   
       
    
    • 一是http.setSharedObject(SecurityContextRepository.class, obj)将自定义的库对象放入到SharedObject中
      •  
    
    • 二是http.securityContext(Customizer> securityContextCustomizer)重新自定义SecurityContextPersistenceFilter过滤器
      •  
   
     
    •  
 
 
 
 3. HeaderWriterFilter
 
 
 名称：请求头填写过滤器
  继承OncePerRequestFilter
  源码：
 
 
    @Override
    protected void doFilterInternal(HttpServletRequest request,
            HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        if (this.shouldWriteHeadersEagerly) {
            doHeadersBefore(request, response, filterChain);
        } else {
            doHeadersAfter(request, response, filterChain);
        }
    }

 
 
 作用：为请求头添加headers
 
 
     
  
  • doFilter前：如果属性shouldWriteHeadersEagerly为true，则会在过滤前添加请求头。否则，过滤前不会添加。
    •  
  
  • doFilter后：如果属性shouldWriteHeadersEagerly为false，则会在过滤后添加请求头。否则，过滤后不会添加。
    •  
  
  • shouldWriteHeadersEagerly默认为false
    •  
 
 
 
 4. CsrfFilter
 
 
 名称：Csrf过滤器，继承OncePerRequestFilter
  作用：开启Csrf防御
 
 
     
  
  • doFilter前：验证是否csrf安全
    •  
  
  • doFilter后：无
    •  
 
 
 
 5. LogoutFilter
 
 
 名称：登出过滤器
  源码：
 
 
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        // 判断是否为登出请求
        if (requiresLogout(request, response)) {
            Authentication auth = SecurityContextHolder.getContext().getAuthentication();

            if (logger.isDebugEnabled()) {
                logger.debug("Logging out user '" + auth
                        + "' and transferring to logout destination");
            }

            // 登出的处理
            this.handler.logout(request, response, auth);
            // 登出成功后处理
            logoutSuccessHandler.onLogoutSuccess(request, response, auth);

            return;
        }

        chain.doFilter(request, response);
    }

 
 
 作用：处理登出请求
 
 
     
  
  • doFilter前：如果是登出请求，则进行登出处理和登出成功后处理。通过http.logout().addLogoutHandler().logoutSuccessHandler()可以增加处理机制
    •  
  
  • doFilter后：无
    •  
 
 
 
 6. UsernamePasswordAuthenticationFilter
 
 
 名称：用户认证过滤器
  继承AbstractAuthenticationProcessingFilter，是基于浏览器的基于HTTP的身份验证请求的抽象处理器
  源码：
 
 
// AbstractAuthenticationProcessingFilter的doFilter方法
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        // 判断是否为登录请求
        if (!requiresAuthentication(request, response)) {
            chain.doFilter(request, response);

            return;
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Request is to process authentication");
        }

        Authentication authResult;

        try {
            // 尝试去获取认证对象
            authResult = attemptAuthentication(request, response);
            if (authResult == null) {
                // return immediately as subclass has indicated that it hasn't completed
                // authentication
                return;
            }
            // session处理机制处理认证对象，默认为NullAuthenticatedSessionStrategy不进行处理
            sessionStrategy.onAuthentication(authResult, request, response);
        }
        catch (InternalAuthenticationServiceException failed) {
            logger.error(
                    "An internal error occurred while trying to authenticate the user.",
                    failed);
            unsuccessfulAuthentication(request, response, failed);

            return;
        }
        catch (AuthenticationException failed) {
            // Authentication failed
            unsuccessfulAuthentication(request, response, failed);

            return;
        }

        // 认证成功后判断是否继续执行其他过滤器
        if (continueChainBeforeSuccessfulAuthentication) {
            chain.doFilter(request, response);
        }
        //
        successfulAuthentication(request, response, chain, authResult);
    }

 
 
// UsernamePasswordAuthenticationFilter的attemptAuthentication方法
public Authentication attemptAuthentication(HttpServletRequest request,
            HttpServletResponse response) throws AuthenticationException {
        if (postOnly && !request.getMethod().equals("POST")) {
            throw new AuthenticationServiceException(
                    "Authentication method not supported: " + request.getMethod());
        }
        // 从请求中获取参数名为'username','password'的值
        String username = obtainUsername(request);
        String password = obtainPassword(request);

        if (username == null) {
            username = "";
        }

        if (password == null) {
            password = "";
        }

        username = username.trim();
        // 通过用户名密码生成一个未经验证的认证对象
        UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(
                username, password);

        // Allow subclasses to set the "details" property
        setDetails(request, authRequest);
        // 通过认证管理器对该认证对象进行认证
        return this.getAuthenticationManager().authenticate(authRequest);
    }

 
 
 作用：判断用户是否为登录请求，如果是登录请求，提取其中的用户名和密码并保存认证对象到SecurityContextHolder中
 
 
     
  
  • doFilter前：如果不是登录请求，跳过当前过滤。如果是登录请求，则尝试去获取认证对象。认证对象主要是通过认证管理器下认证机制对包含用户名和密码的对象进行认证并返回。
    •  
  
  • 如果continueChainBeforeSuccessfulAuthentication属性为false,则不执行后置过滤。如果为true。执行后置过滤
    •  
  
  • doFilter后：如果不执行后置过滤或者执行完后置过滤后去执行一些成功登录的处理，包括保存认证对象、rememberMe记录、成功后的自定义处理器处理
    •  
 
 
 
 7. DefaultLoginPageGeneratingFilter
 
 
 名称：生成默认登录页过滤器
  作用：生成默认的登录页
 
 
     
  
  • doFilter前：生成登录页
    •  
  
  • doFilter后：无
    •  
 
 
 
 8. DefaultLogoutPageGeneratingFilter
 
 
 名称：生成默认登出页过滤器，继承OncePerRequestFilter
  作用：生成默认的登出页
 
 
     
  
  • doFilter前：如果匹配默认/logout的GET请求，则渲染登出页。如果不匹配，则跳过该过滤器。
    •  
  
  • doFilter后：无
    •  
 
 
 
 9. BasicAuthenticationFilter
 
 
 名称：Http基本认证过滤器
  源码：
 
 
    @Override
    protected void doFilterInternal(HttpServletRequest request,
            HttpServletResponse response, FilterChain chain)
                    throws IOException, ServletException {
        final boolean debug = this.logger.isDebugEnabled();
        try {
            // 判断是否包含请求头Authorization,并且该值以BASIC开头,将其值朱哪位认证对象
            UsernamePasswordAuthenticationToken authRequest = authenticationConverter.convert(request);
            if (authRequest == null) {
                chain.doFilter(request, response);
                return;
            }

            String username = authRequest.getName();

            if (debug) {
                this.logger
                        .debug("Basic Authentication Authorization header found for user '"
                                + username + "'");
            }
            // 需要对从请求头中获取的认证对象进行认证处理器进行处理
            if (authenticationIsRequired(username)) {
                // 认证管理器对该认证对象进行认证
                Authentication authResult = this.authenticationManager
                        .authenticate(authRequest);

                if (debug) {
                    this.logger.debug("Authentication success: " + authResult);
                }
                // 保存认证对象到SecurityContextHolder
                SecurityContextHolder.getContext().setAuthentication(authResult);
                // rememberMe记录
                this.rememberMeServices.loginSuccess(request, response, authResult);
                
                onSuccessfulAuthentication(request, response, authResult);
            }

        }
        catch (AuthenticationException failed) {
            SecurityContextHolder.clearContext();

            if (debug) {
                this.logger.debug("Authentication request for failed: " + failed);
            }

            this.rememberMeServices.loginFail(request, response);

            onUnsuccessfulAuthentication(request, response, failed);

            if (this.ignoreFailure) {
                chain.doFilter(request, response);
            }
            else {
                this.authenticationEntryPoint.commence(request, response, failed);
            }

            return;
        }

        chain.doFilter(request, response);
    }

 
 
 作用：对Http请求进行基本认证，是对请求头Authorization的认证
 
 
     
  
  • doFilter前：判断是否包含请求头Authorization,并且该值以BASIC开头。如果该值不可以转换为认证对象，跳过该过滤器。如果可以转换为认证对象，如果需要对改对象进行认证处理，则使用认证管理器对其进行处理，然后依次保存认证对象、rememberMe记录、成功后处理器处理
    •  
  
  • doFilter后：无
    •  
 
 
 
 10. RequestCacheAwareFilter
 
 
 名称：请求缓存过滤器
  源码：
 
 
public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {

        // 尝试去获取缓存的请求
        HttpServletRequest wrappedSavedRequest = requestCache.getMatchingRequest(
                (HttpServletRequest) request, (HttpServletResponse) response);

        chain.doFilter(wrappedSavedRequest == null ? request : wrappedSavedRequest,
                response);
    }

 
 
 作用：缓存当前的请求，可以用作重新登录后的再次请求使用
 
 
     
  
  • doFilter前：尝试去获取缓存的请求，如果缓存请求不为null，则doFilter中传入缓存的请求，否则传入原有的请求。
    •  
  
  • doFilter后：无
    •  
 
 
 
 11. SecurityContextHolderAwareRequestFilter
 
 
 名称：SecurityContextHolder包装请求过滤器
  源码：
 
 
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        chain.doFilter(this.requestFactory.create((HttpServletRequest) req,
                (HttpServletResponse) res), res);
    }

 
 
 作用：将request包装，更适用于SecurityContext
 
 
     
  
  • doFilter前：将request和rolePrefix(角色前缀)、authenticationEntryPoint(认证异常处理)、authenticationManager(认证管理器)、logoutHandlers(退出处理)、trustResolver(身份信任处理)绑定。
    •  
  
  • doFIlter后：无
    •  
 
 
 
 12. RememberMeAuthenticationFilter
 
 
 名称：rememberMe认证过滤器
  源码：
 
 
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        // 本身是登录的状态，则不需要对rememberMe的对象进行认证
        if (SecurityContextHolder.getContext().getAuthentication() == null) {
            // 通过服务类从请求的rememerMe中拿到认证对象
            // rememberMeServices通常
            //  1.如果有PersistentTokenRepository token持久化库，则会PersistentTokenBasedRememberMeServices服务，从持久库中拿
            //  2.如果没有持久化库，则使用基本的rememberMe服务，TokenBasedRememberMeServices
            Authentication rememberMeAuth = rememberMeServices.autoLogin(request,
                    response);

            if (rememberMeAuth != null) {
                // 尝试去通过认证管理器来认证rememberMe对象
                try {
                    rememberMeAuth = authenticationManager.authenticate(rememberMeAuth);

                    // 保存至SecurityContextHolder中
                    SecurityContextHolder.getContext().setAuthentication(rememberMeAuth);

                    onSuccessfulAuthentication(request, response, rememberMeAuth);

                    if (logger.isDebugEnabled()) {
                        logger.debug("SecurityContextHolder populated with remember-me token: '"
                                + SecurityContextHolder.getContext().getAuthentication()
                                + "'");
                    }

                    // Fire event
                    if (this.eventPublisher != null) {
                        eventPublisher
                                .publishEvent(new InteractiveAuthenticationSuccessEvent(
                                        SecurityContextHolder.getContext()
                                                .getAuthentication(), this.getClass()));
                    }

                    if (successHandler != null) {
                        // 认证成功后的处理
                        successHandler.onAuthenticationSuccess(request, response,
                                rememberMeAuth);

                        return;
                    }

                }
                catch (AuthenticationException authenticationException) {
                    if (logger.isDebugEnabled()) {
                        logger.debug(
                                "SecurityContextHolder not populated with remember-me token, as "
                                        + "AuthenticationManager rejected Authentication returned by RememberMeServices: '"
                                        + rememberMeAuth
                                        + "'; invalidating remember-me token",
                                authenticationException);
                    }

                    rememberMeServices.loginFail(request, response);

                    onUnsuccessfulAuthentication(request, response,
                            authenticationException);
                }
            }

            chain.doFilter(request, response);
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("SecurityContextHolder not populated with remember-me token, as it already contained: '"
                        + SecurityContextHolder.getContext().getAuthentication() + "'");
            }

            chain.doFilter(request, response);
        }
    }

 
 
 作用：认证rememberMe的对象
 
 
     
  
  • doFilter前：如果非登录状态，并且可以从请求中rememberMe相关中拿到认证对象。那么就使用认证管理器进行认证，之后成功后进行成功认证处理。否则，则跳过该过滤器
    •  
  
  • doFilter后：无
    •  
 
 
 
 其他：关于remember的一些配置。可以使用http.rememberMe()方法获取配置对象，进行一些配置。
  例如：
 
 
     
  
  • tokenRepository()配置rememberMe对象获取服务
    •  
  
  • rememberMeParameter()登录时表示remememberMe的参数
    •  
  
  • rememberMeCookieName()配置rememberMe的cookie名称
    •  
  
  • 可以参考RememberMeConfigurer类的源码
    •  
 
 
 
 13. AnonymousAuthenticationFilter
 
 
 名称：匿名认证过滤器
  源码：
 
 
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {

        if (SecurityContextHolder.getContext().getAuthentication() == null) {
            SecurityContextHolder.getContext().setAuthentication(
                    createAuthentication((HttpServletRequest) req));

            if (logger.isDebugEnabled()) {
                logger.debug("Populated SecurityContextHolder with anonymous token: '"
                        + SecurityContextHolder.getContext().getAuthentication() + "'");
            }
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("SecurityContextHolder not populated with anonymous token, as it already contained: '"
                        + SecurityContextHolder.getContext().getAuthentication() + "'");
            }
        }

        chain.doFilter(req, res);
    }

 
 
 作用：检测SecurityContextHolder中是否有认证对象，如果没有，就创建一个匿名访问对象。
 
 
     
  
  • doFilter前：检测SecurityContextHolder中是否有认证对象，如果没有，就创建一个匿名访问对象
    •  
  
  • doFilter后：无
    •  
 
 
 
 14. SessionManagementFilter
 
 
 名称：会话管理过滤器
  源码：
 
 
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        // 过滤器只执行一次
        if (request.getAttribute(FILTER_APPLIED) != null) {
            chain.doFilter(request, response);
            return;
        }

        request.setAttribute(FILTER_APPLIED, Boolean.TRUE);

        // 如果SecurityContext持久库中包含本次请求的context。不包含则进行一系列处理
        if (!securityContextRepository.containsContext(request)) {
            // 本次请求的认证对象
            Authentication authentication = SecurityContextHolder.getContext()
                    .getAuthentication();

            // 认证对象不为null且不是匿名对象
            if (authentication != null && !trustResolver.isAnonymous(authentication)) {
                // The user has been authenticated during the current request, so call the
                // session strategy
                try {
                    // session处理
                    sessionAuthenticationStrategy.onAuthentication(authentication,
                            request, response);
                }
                catch (SessionAuthenticationException e) {
                    // The session strategy can reject the authentication
                    logger.debug(
                            "SessionAuthenticationStrategy rejected the authentication object",
                            e);
                    SecurityContextHolder.clearContext();
                    failureHandler.onAuthenticationFailure(request, response, e);

                    return;
                }
                // Eagerly save the security context to make it available for any possible
                // re-entrant
                // requests which may occur before the current request completes.
                // SEC-1396.
                // 重新再保存至SecurityContext持久库中
                securityContextRepository.saveContext(SecurityContextHolder.getContext(),
                        request, response);
            }
            else {
                // 如果认证对象不存在，则检查session是否过期
                if (request.getRequestedSessionId() != null
                        && !request.isRequestedSessionIdValid()) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Requested session ID "
                                + request.getRequestedSessionId() + " is invalid.");
                    }

                    if (invalidSessionStrategy != null) {
                        invalidSessionStrategy
                                .onInvalidSessionDetected(request, response);
                        return;
                    }
                }
            }
        }

        chain.doFilter(request, response);
    }

 
 
 作用：执行与会话相关的一些设置
 
 
     
  
  •  doFilter前：如果持久库中存在本次请求的securityContext，跳过该过滤器。如果不存在，则需要做session处理。 
   
       
    
    • 匿名对象，检测session是否过期
      •  
    
    • 其他认证对象，通过SessionAuthenticationStrategy的实际对象做出相应的处理，然后将处理后的认证对象重新保存在SecurityContext持久库中
      •  
   
     
    •  
  
  • doFilter后：无
    •  
 
 
 
 15. ExceptionTranslationFilter
 
 
 名称：异常事务过滤器
  源码：
 
 
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        try {
            chain.doFilter(request, response);

            logger.debug("Chain processed normally");
        }
        catch (IOException ex) {
            throw ex;
        }
        catch (Exception ex) {
            // Try to extract a SpringSecurityException from the stacktrace
            Throwable[] causeChain = throwableAnalyzer.determineCauseChain(ex);
            RuntimeException ase = (AuthenticationException) throwableAnalyzer
                    .getFirstThrowableOfType(AuthenticationException.class, causeChain);

            if (ase == null) {
                ase = (AccessDeniedException) throwableAnalyzer.getFirstThrowableOfType(
                        AccessDeniedException.class, causeChain);
            }

            if (ase != null) {
                if (response.isCommitted()) {
                    throw new ServletException("Unable to handle the Spring Security Exception because the response is already committed.", ex);
                }
                handleSpringSecurityException(request, response, chain, ase);
            }
            else {
                // Rethrow ServletExceptions and RuntimeExceptions as-is
                if (ex instanceof ServletException) {
                    throw (ServletException) ex;
                }
                else if (ex instanceof RuntimeException) {
                    throw (RuntimeException) ex;
                }

                // Wrap other Exceptions. This shouldn't actually happen
                // as we've already covered all the possibilities for doFilter
                throw new RuntimeException(ex);
            }
        }
    }

 
 
 作用：对过滤器中抛出的异常进行处理
 
 
     
  
  • doFilter前：无
    •  
  
  •  doFilter后： 
   
       
    
    • 如果是AuthenticationException异常，需要AuthenticationEntryPoint对象处理
      •  
    
    • 如果是AccessDeniedException异常，需要AccessDeniedHandler对象处理
      •  
    
    • 如果是其他异常，继续向上抛
      •  
   
     
    •  
 
 
 
 其他：可以通过http. exceptionHandling().authenticationEntryPoint().accessDeniedHandler()来进行添加。
 
 
 16. FilterSecurityInterceptor
 
 
 名称：安全拦截器
  源码：
 
 
// FilterSecurityInterceptor过滤方法
public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        // 包装request, response, chain
        FilterInvocation fi = new FilterInvocation(request, response, chain);
        invoke(fi);
    }
public void invoke(FilterInvocation fi) throws IOException, ServletException {
        // request不为null AND 并且不是第一次过滤 AND observeOncePerRequest(每一个请求观察一次,默认为true)
        if ((fi.getRequest() != null)
                && (fi.getRequest().getAttribute(FILTER_APPLIED) != null)
                && observeOncePerRequest) {
            // filter already applied to this request and user wants us to observe
            // once-per-request handling, so don't re-do security checking
            fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
        }
        else {
            // 控制请求被检查一次
            if (fi.getRequest() != null && observeOncePerRequest) {
                fi.getRequest().setAttribute(FILTER_APPLIED, Boolean.TRUE);
            }

            // 过滤前的处理
            InterceptorStatusToken token = super.beforeInvocation(fi);

            try {
                fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
            }
            finally {
                // 再次保存SecurityContext至SecurityContextHodler中
                super.finallyInvocation(token);
            }

            // 后置处理，使用后置管理器(AfterInvocationManager)处理
            super.afterInvocation(token, null);
        }
    }

 
 
// AbstractSecurityInterceptor的beforeInvocation方法
protected InterceptorStatusToken beforeInvocation(Object object) {
        Assert.notNull(object, "Object was null");
        final boolean debug = logger.isDebugEnabled();

        if (!getSecureObjectClass().isAssignableFrom(object.getClass())) {
            throw new IllegalArgumentException(
                    "Security invocation attempted for object "
                            + object.getClass().getName()
                            + " but AbstractSecurityInterceptor only configured to support secure objects of type: "
                            + getSecureObjectClass());
        }

        // 获取验证方式的spel表达式集合
        Collection attributes = this.obtainSecurityMetadataSource()
                .getAttributes(object);

        if (attributes == null || attributes.isEmpty()) {
            if (rejectPublicInvocations) {
                throw new IllegalArgumentException(
                        "Secure object invocation "
                                + object
                                + " was denied as public invocations are not allowed via this interceptor. "
                                + "This indicates a configuration error because the "
                                + "rejectPublicInvocations property is set to 'true'");
            }

            if (debug) {
                logger.debug("Public object - authentication not attempted");
            }

            publishEvent(new PublicInvocationEvent(object));

            return null; // no further work post-invocation
        }

        if (debug) {
            logger.debug("Secure object: " + object + "; Attributes: " + attributes);
        }

        if (SecurityContextHolder.getContext().getAuthentication() == null) {
            credentialsNotFound(messages.getMessage(
                    "AbstractSecurityInterceptor.authenticationNotFound",
                    "An Authentication object was not found in the SecurityContext"),
                    object, attributes);
        }

        // 如果认证对象仍然需要认证，则使用认证管理器进行认证
        Authentication authenticated = authenticateIfRequired();

        // Attempt authorization
        try {
            // 对权限进行验证,即对access()、authenticated()、hasRole()、hasAuthority()进行验证。
            // 验证处理方式是使用验证管理器进行验证。
            //  1.AffirmativeBased 非否决通过
            //  2.ConsensusBased 少数服从多数
            //  3.UnanimousBased 一致通过
            this.accessDecisionManager.decide(authenticated, object, attributes);
        }
        catch (AccessDeniedException accessDeniedException) {
            publishEvent(new AuthorizationFailureEvent(object, attributes, authenticated,
                    accessDeniedException));

            throw accessDeniedException;
        }

        if (debug) {
            logger.debug("Authorization successful");
        }

        if (publishAuthorizationSuccess) {
            publishEvent(new AuthorizedEvent(object, attributes, authenticated));
        }

        // Attempt to run as a different user
        Authentication runAs = this.runAsManager.buildRunAs(authenticated, object,
                attributes);

        if (runAs == null) {
            if (debug) {
                logger.debug("RunAsManager did not change Authentication object");
            }

            // no further work post-invocation
            return new InterceptorStatusToken(SecurityContextHolder.getContext(), false,
                    attributes, object);
        }
        else {
            if (debug) {
                logger.debug("Switching to RunAs Authentication: " + runAs);
            }

            SecurityContext origCtx = SecurityContextHolder.getContext();
            SecurityContextHolder.setContext(SecurityContextHolder.createEmptyContext());
            SecurityContextHolder.getContext().setAuthentication(runAs);

            // need to revert to token.Authenticated post-invocation
            return new InterceptorStatusToken(origCtx, true, attributes, object);
        }
    }
private Authentication authenticateIfRequired() {
        Authentication authentication = SecurityContextHolder.getContext()
                .getAuthentication();

        // 如果认证对象已经得到认证 并且 !alwaysReauthenticate(不是一定需要认证)
        if (authentication.isAuthenticated() && !alwaysReauthenticate) {
            if (logger.isDebugEnabled()) {
                logger.debug("Previously Authenticated: " + authentication);
            }

            return authentication;
        }

        // 认证管理器认证
        authentication = authenticationManager.authenticate(authentication);

        // We don't authenticated.setAuthentication(true), because each provider should do
        // that
        if (logger.isDebugEnabled()) {
            logger.debug("Successfully Authenticated: " + authentication);
        }

        SecurityContextHolder.getContext().setAuthentication(authentication);

        return authentication;
    }

 
 
 作用：拦截之前过滤器过滤后的认证对象，然后对其进行最终的身份认证或者是权限验证。
 
 
     
  
  • doFilter前：获取匹配该请求的权限验证spel表达式，如果任然需要认证，可以使用认证管理器再次进行认证。然后执行权限验证，验证表达式是否通过。(通过有三种模式：一票通过，少数服从多数，全票通过)
    •  
  
  • doFilter后：使用后置管理器进行处理。
    •  
 
 
 
 17. MethodSecurityInterceptor
 
 
 名称：方法拦截器
  源码：
 
 
public Object invoke(MethodInvocation mi) throws Throwable {
    InterceptorStatusToken token = super.beforeInvocation(mi);

    Object result;
    try {
        result = mi.proceed();
    }
    finally {
        super.finallyInvocation(token);
    }
    return super.afterInvocation(token, result);
}

 
 
 作用：如果配置文件中开启@EnableGlobalMethodSecurity，并且开了prePostEnabled或securedEnabled或jsr250Enabled等就会使用到该拦截器，通过切面的方式，在业务方法前后进行认证或验证。
 
 
四、 认证管理器和验证管理器
 
 
 1. 认证管理器—AuthenticationManager
 
 
 源码：
 
 
public interface AuthenticationManager {

   /**
    * 主要是进行身份认证，认证成功返回认证后的对象，认证不成功则抛出相应的异常AuthenticationException
    */
   Authentication authenticate(Authentication authentication)
         throws AuthenticationException;
}


 
 
 实现类：ProviderManager
 
 
 源码：
 
 
public Authentication authenticate(Authentication authentication)
      throws AuthenticationException {
   Class toTest = authentication.getClass();
   AuthenticationException lastException = null;
   AuthenticationException parentException = null;
   Authentication result = null;
   Authentication parentResult = null;
   boolean debug = logger.isDebugEnabled();

   // 获取所有的认证处理
   for (AuthenticationProvider provider : getProviders()) {
      // 判断当前的认证处理是否支持对当前的认证对象的认证
      if (!provider.supports(toTest)) {
         continue;
      }

      if (debug) {
         logger.debug("Authentication attempt using "
               + provider.getClass().getName());
      }

      try {
         // 执行认证处理的认证方法
         result = provider.authenticate(authentication);

         // 认证后的结果不为null的话，则认为返回是通过认证的认证对象
         if (result != null) {
            // 如果认证后的对象没有细节内容，则将原有的认证对象的细节内容填充至认证后的对象中
            copyDetails(authentication, result);
            break;
         }
      }
      catch (AccountStatusException | InternalAuthenticationServiceException e) {
         prepareException(e, authentication);
         // SEC-546: Avoid polling additional providers if auth failure is due to
         // invalid account status
         throw e;
      } catch (AuthenticationException e) {
         lastException = e;
      }
   }

   // 经过当前提供的一系列认证处理后仍然返回null 并且 该认证管理器具有父级处理认证的方式(需要新建实例时传入)
   if (result == null && parent != null) {
      // Allow the parent to try.
      try {
         // 那么就可以使用父级认证管理器来对当前的认证对象进行认证
         result = parentResult = parent.authenticate(authentication);
      }
      catch (ProviderNotFoundException e) {
         // ignore as we will throw below if no other exception occurred prior to
         // calling parent and the parent
         // may throw ProviderNotFound even though a provider in the child already
         // handled the request
      }
      catch (AuthenticationException e) {
         lastException = parentException = e;
      }
   }

   if (result != null) {
      if (eraseCredentialsAfterAuthentication
            && (result instanceof CredentialsContainer)) {
         // Authentication is complete. Remove credentials and other secret data
         // from authentication
         ((CredentialsContainer) result).eraseCredentials();
      }

      // If the parent AuthenticationManager was attempted and successful than it will publish an AuthenticationSuccessEvent
      // This check prevents a duplicate AuthenticationSuccessEvent if the parent AuthenticationManager already published it
      if (parentResult == null) {
         eventPublisher.publishAuthenticationSuccess(result);
      }
      return result;
   }

   // Parent was null, or didn't authenticate (or throw an exception).

   if (lastException == null) {
      lastException = new ProviderNotFoundException(messages.getMessage(
            "ProviderManager.providerNotFound",
            new Object[] { toTest.getName() },
            "No AuthenticationProvider found for {0}"));
   }

   // If the parent AuthenticationManager was attempted and failed than it will publish an AbstractAuthenticationFailureEvent
   // This check prevents a duplicate AbstractAuthenticationFailureEvent if the parent AuthenticationManager already published it
   if (parentException == null) {
      prepareException(lastException, authentication);
   }

   throw lastException;
}


 
 
 作用：通过配置多套认证处理(AuthenticationProvider)，以应对不同情况下的认证情形，是对认证的扩展。
 
 
 认证处理类：AuthenticationProvider
 
 
 源码：
 
 
public interface AuthenticationProvider {

   /**
    * 对认证对象进行认证
    * 返回认证后的对象表示已经被认证
    * 返回null表示不做处理
    * 抛出异常，表示认证失败
    */
   Authentication authenticate(Authentication authentication)
         throws AuthenticationException;

   /**
    * 支持的认证对象实体类
    * 返回true表示支持
    * 返回false表示不支持，将不进行authenticate认证
    */
   boolean supports(Class authentication);
}

 
 
 作用：认证处理，对每一个支持的认证对象的身份进行认证。
 
 
 关于AuthenticationManager的配置
 
 
     
  
  • 使用http. authenticationProvider()方法直接添加认证处理。
    •  
 
 
 
public void configure(HttpSecurity http) throws Exception {
    http
            .authenticationProvider(new AuthenticationProvider(){
                @Override
                public Authentication authenticate(Authentication authentication) throws AuthenticationException {
                    System.out.println("认证000");
                    return authentication;
                }

                @Override
                public boolean supports(Class authentication) {
                    return true;
                }
            })
            .authorizeRequests()
            .antMatchers("/test").access("hasAnyRole('ADMIN', 'USER')")
            .anyRequest().authenticated()
            .and()
            // .formLogin().and()
            .rememberMe().and() // rememberMe过滤器 -- RememberMeAuthenticationFilter
            .httpBasic();
}


 
 
 说明：该AuthenticationProvider是直接插入到默认的认证管理器中。与下列的几个配置方法不冲突
 
 
     
  
  • 继承WebSecurityConfigurerAdapter类时覆写authenticationManager()方法
    •  
 
 
 
class CustomizeWebSecurityConfigurer extends WebSecurityConfigurerAdapter{
    @Override
    public void configure(HttpSecurity http) throws Exception {
       
        http
                .authorizeRequests()
                .antMatchers("/test").access("hasAnyRole('ADMIN', 'USER')")
                .anyRequest().authenticated()
                .and()
                // .formLogin().and()
                .rememberMe().and() // rememberMe过滤器 -- RememberMeAuthenticationFilter
                .httpBasic();
    }

    @Override
    protected AuthenticationManager authenticationManager() throws Exception {
        AuthenticationProvider provider = new AuthenticationProvider(){
            @Override
            public Authentication authenticate(Authentication authentication) throws     AuthenticationException {
                System.out.println("认证111");
                return null;
            }

            @Override
            public boolean supports(Class authentication) {
                return true;
            }
        };
        ProviderManager providerManager = new ProviderManager(Arrays.asList(provider));
        return providerManager;
    }

}


 
 
 说明：该AuthenticationManager是被注册到FilterSecurityInterceptor的默认AuthenticationManager的parent认证管理器中
 
 
     
  
  • 直接向Spring中注册AuthenticationManager的Bean
    •  
 
 
 
@Bean
public AuthenticationManager authenticationManager() {
    AuthenticationProvider provider = new AuthenticationProvider(){
        @Override
        public Authentication authenticate(Authentication authentication) throws AuthenticationException {
            System.out.println("认证333");
            return authentication;
        }

        @Override
        public boolean supports(Class authentication) {
            return true;
        }
    };
    ProviderManager providerManager = new ProviderManager(Arrays.asList(provider));
    return providerManager;
}


 
 
 说明：该AuthenticationManager是被注册到FilterSecurityInterceptor的默认AuthenticationManager的parent认证管理器中，也会注册到MethodSecurityInterceptor认证管理器中。
 
 
     
  
  • 可以向Spring注册AuthenticationProvider
    •  
 
 
 
@Bean
public AuthenticationProvider authenticationProvider() {
    return new AuthenticationProvider(){
        @Override
        public Authentication authenticate(Authentication authentication) throws AuthenticationException {
            System.out.println("认证222");
            return authentication;
        }

        @Override
        public boolean supports(Class authentication) {
            return true;
        }
    };
}


 
 
 说明：注入AuthenticationProvider只能提供一个对象的注册，并且该AuthenticationProvider是注册到FilterSecurityInterceptor的默认AuthenticationManager的parent认证管理器中，也会注册到MethodSecurityInterceptor认证管理器中。
 
 
 FilterSecurityInterceptor优先等级如下：
 
 
     
  
  • http. authenticationProvider最优先使用。
    •  
  
  •  继承覆写 > AuthenticationProvider > AuthenticationManager
      源码： 
    •  
 
 
 
@Bean
public AuthenticationProvider authenticationProvider() {
    return new AuthenticationProvider(){
        @Override
        public Authentication authenticate(Authentication authentication) throws AuthenticationException {
            System.out.println("认证222");
            return null;
        }

        @Override
        public boolean supports(Class authentication) {
            return true;
        }
    };
}

/**
 * 传入自定义的认证管理器
 * @return
 */
@Bean
public AuthenticationManager authenticationManager() {
    AuthenticationProvider provider = new AuthenticationProvider(){
        @Override
        public Authentication authenticate(Authentication authentication) throws AuthenticationException {
            System.out.println("认证333");
            return null;
        }

        @Override
        public boolean supports(Class authentication) {
            return true;
        }
    };
    ProviderManager providerManager = new ProviderManager(Arrays.asList(provider));
    return providerManager;
}

@Order(1)
class CustomizeWebSecurityConfigurer extends WebSecurityConfigurerAdapter{
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
                .authenticationProvider(new AuthenticationProvider(){
                    @Override
                    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
                        System.out.println("认证000");
                        return null;
                    }

                    @Override
                    public boolean supports(Class authentication) {
                        return true;
                    }
                })
                .authorizeRequests()
                .antMatchers("/test").access("hasAnyRole('ADMIN', 'USER')")
                .anyRequest().authenticated()
                .and()
                // .formLogin().and()
                .rememberMe().and() // rememberMe过滤器 -- RememberMeAuthenticationFilter
                .httpBasic();
    }

    @Override
    protected AuthenticationManager authenticationManager() throws Exception {
        AuthenticationProvider provider = new AuthenticationProvider(){
            @Override
            public Authentication authenticate(Authentication authentication) throws AuthenticationException {
                System.out.println("认证111");
                return null;
            }

            @Override
            public boolean supports(Class authentication) {
                return true;
            }
        };
        ProviderManager providerManager = new ProviderManager(Arrays.asList(provider));
        return providerManager;
    }

}


 
 
 说明：当前情况下先执行”认证000”，由于返回null，所以执行”认证111”，如果去掉覆写，执行”认证222”，如果去掉AuthenticationProvider注册，执行”认证333”
 
 
 2. 验证管理器—AccessDecisionManager
 
 
 关于验证管理器的配置：
 
 
     
  
  • 使用http. authorizeRequests().accessDecisionManager()方法配置
    •  
 
 
 
class OtherWebSecurityConfigurer extends WebSecurityConfigurerAdapter{
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests().accessDecisionManager(new AffirmativeBased(Arrays.asList(new WebExpressionVoter())))
                .anyRequest().authenticated()
                .and()
                .formLogin().and()
                .httpBasic();
    }
}


 
 
五、 全局方法的注解权限验证和过滤
 
 
 1. @EnableGlobalMethodSecurity注解
 
 
 开启全局的验证方法，下面解释一下常用的注解
 
 
 2. prePostEnabled
 
 
 说明：设置true时，将可以使用@ PreAuthorize、@PostAuthorize、@PreFilter、@PostFilter注解
 
 
 参考：开启prePostEnabled
 
 
     
  
  • PreAuthorize：前置权限验证。
    •  
  
  • PostAuthorize：后置权限验证。
    •  
  
  • PreFilter：前置过滤。
    •  
  
  • PostFilter：后置过滤
    •  
 
 
 
 3. securedEnabled
 
 
 说明：设置true时，允许使用SpringSecurity内置的方法验证。可以使用@Secured
 
 
 参考：开启Secured
 
 
 4. jsr250Enabled
 
 
 说明：设置true时，允许使用JSR250注解进行验证。
 
 
六、 总结
 
 
 1. 通常情况下
 
 
 在FilterSecurityInterceptor过滤器之前，SecurityContextHolder中存在认证对象，即算通过认证。
 
 
 2. 权限验证
 
 
 authenticated()验证通过的是非匿名对象，并不是使用Authentication认证对象的isAuthenticated()方法进行验证。
 
 
 3. 注解@EnableGlobalMethodSecurity
 
 
 使用该注解后，会使用代理模式。通过MethodSecurityInterceptor的invoke()方法来对业务方法进行验证等操作
 
 
 4. 过滤器参考图
 
 
 
  
 
   
 结合源码学习使用SpringSecurity_第9张图片 
   
 
  
 
  

    SpringSecurity过滤流程 
  
 
 
 
 
 5. 其他
 
 
 SpringSecurity参考文档：参考文档
  SpringSecurity中文参考文档：中文参考文档
  核心源码及注释下载：网盘链接 提取码: bwpv
  关于Spring源码调试及注释：文章链接
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(结合源码学习使用SpringSecurity)

        

            

                
    
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 消息中间件有哪些常见类型
                        xmh-sxh-1314
java
                        
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    
                    
    • 
                    
  • html 中如何使用 uniapp 的部分方法
                        某公司摸鱼前端
htmluni-app前端
                        
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    
                    
    • 
                    
  • 水平垂直居中的几种方法（总结）
                        LJ小番茄
CSS_玄学语言htmljavascript前端csscss3
                        
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • C#中使用split分割字符串
                        互联网打工人no1
c#
                        
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
    
                    
    • 
                    
  • Python中os.environ基本介绍及使用方法
                        鹤冲天Pro
#Pythonpython服务器开发语言
                        
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
    
                    
    • 
                    
  • 水泥质量纠纷案代理词
                        徐宝峰律师

                        
    贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
    
                    
    • 
                    
  • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    
                    
    • 
                    
  • LLM 词汇表
                        落难Coder
LLMsNLP大语言模型大模型llama人工智能
                        
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
    
                    
    • 
                    
  • PHP环境搭建详细教程
                        好看资源平台
前端php
                        
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
    
                    
    • 
                    
  • 下载github patch到本地
                        小米人er
我的博客gitpatch
                        
    以下是几种从GitHub上下载以.patch结尾的补丁文件的方法：通过浏览器直接下载打开包含该.patch文件的GitHub仓库。在仓库的文件列表中找到对应的.patch文件。点击该文件，浏览器会显示文件的内容，在页面的右上角通常会有一个“Raw”按钮，点击它可以获取原始文件内容。然后在浏览器中使用快捷键（如Ctrl+S或者Command+S）将原始文件保存到本地，选择保存的文件名并确保后缀为.p
    
                    
    • 
                    
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
    
                    
    • 
                    
  • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    
                    
    • 
                    
  • SQL Server_查询某一数据库中的所有表的内容
                        qq_42772833
SQLServer数据库sqlserver
                        
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 【加密社】Solidity 中的事件机制及其应用
                        加密社
闲侃区块链智能合约区块链
                        
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
    
                    
    • 
                    
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
                        nseejrukjhad
langchaineasyui前端python
                        
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
    
                    
    • 
                    
  • 使用Faiss进行高效相似度搜索
                        llzwxh888
faisspython
                        
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
    
                    
    • 
                                
  • [星球大战]阿纳金的背叛
                                    comsci

                                    
     
      本来杰迪圣殿的长老是不同意让阿纳金接受训练的......... 
 
    但是由于政治原因,长老会妥协了...这给邪恶的力量带来了机会 
 
    所以......现代的地球联邦接受了这个教训...绝对不让某些年轻人进入学院 
 
   
    
                                
    • 
                                
  • 看懂它，你就可以任性的玩耍了！
                                    aijuans
JavaScript
                                    
              javascript作为前端开发的标配技能，如果不掌握好它的三大特点：1.原型 2.作用域 3. 闭包 ,又怎么可以说你学好了这门语言呢？如果标配的技能都没有撑握好，怎么可以任性的玩耍呢？怎么验证自己学好了以上三个基本点呢，我找到一段不错的代码，稍加改动，如果能够读懂它，那么你就可以任性了。 
function jClass(b
    
                                
    • 
                                
  • Java常用工具包 Jodd
                                    Kai_Ge
javajodd
                                    
    Jodd 是一个开源的 Java 工具集， 包含一些实用的工具类和小型框架。简单，却很强大！  写道   Jodd = Tools + IoC + MVC + DB + AOP + TX + JSON + HTML < 1.5 Mb  
Jodd 被分成众多模块，按需选择，其中 
 
  工具类模块有：  
  
   jodd-core    &nb
    
                                
    • 
                                
  • SpringMvc下载
                                    120153216
springMVC
                                    
    @RequestMapping(value = WebUrlConstant.DOWNLOAD)
	public void download(HttpServletRequest request,HttpServletResponse response,String fileName) {
		OutputStream os = null;
		InputStream is = null;

    
                                
    • 
                                
  • Python 标准异常总结
                                    2002wmj
python
                                    
    Python标准异常总结  
    AssertionError 断言语句（assert）失败   AttributeError 尝试访问未知的对象属性   EOFError 用户输入文件末尾标志EOF（Ctrl+d）   FloatingPointError 浮点计算错误   GeneratorExit generator.close()方法被调用的时候   ImportError 导入模块失
    
                                
    • 
                                
  • SQL函数返回临时表结构的数据用于查询
                                    357029540
SQL Server
                                    
    这两天在做一个查询的SQL，这个SQL的一个条件是通过游标实现另外两张表查询出一个多条数据，这些数据都是INT类型，然后用IN条件进行查询，并且查询这两张表需要通过外部传入参数才能查询出所需数据，于是想到了用SQL函数返回值，并且也这样做了，由于是返回多条数据，所以把查询出来的INT类型值都拼接为了字符串，这时就遇到问题了，在查询SQL中因为条件是INT值，SQL函数的CAST和CONVERST都
    
                                
    • 
                                
  • java 时间格式化 | 比较大小| 时区 个人笔记
                                    7454103
javaeclipsetomcatcMyEclipse
                                    
    个人总结！ 不当之处多多包含！ 
 
  引用   1.0 如何设置 tomcat 的时区： 
         位置：(catalina.bat---JAVA_OPTS  下面加上) 
         set JAVA_OPT
    
                                
    • 
                                
  • 时间获取Clander的用法
                                    adminjun
Clander时间
                                    
    /** 
   * 得到几天前的时间 
   * @param d 
   * @param day 
   * @return 
   */ 
  public static Date getDateBefore(Date d,int day){ 
   Calend
    
                                
    • 
                                
  • JVM初探与设置
                                    aijuans
java
                                    
    JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台
    
                                
    • 
                                
  • SQL中ON和WHERE的区别
                                    avords

                                    
    SQL中ON和WHERE的区别       
数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。   www.2cto.com     在使用left jion时，on和where条件的区别如下：    1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。  
    
                                
    • 
                                
  • 说说自信
                                    houxinyou
工作生活
                                    
    自信的来源分为两种,一种是源于实力,一种源于头脑.实力是一个综合的评定,有自身的能力,能利用的资源等.比如我想去月亮上,要身体素质过硬,还要有飞船等等一系列的东西.这些都属于实力的一部分.而头脑不同,只要你头脑够简单就可以了!同样要上月亮上,你想,我一跳,1米,我多跳几下,跳个几年,应该就到了!什么?你说我会往下掉?你笨呀你!找个东西踩一下不就行了吗? 
  
  
无论工作还
    
                                
    • 
                                
  • WEBLOGIC事务超时设置
                                    bijian1013
weblogicjta事务超时
                                    
            系统中统计数据，由于调用统计过程，执行时间超过了weblogic设置的时间，提示如下错误： 
统计数据出错!
原因：The transaction is no longer active - status: 'Rolling Back. [Reason=weblogic.transaction.internal
    
                                
    • 
                                
  • 两年已过去，再看该如何快速融入新团队
                                    bingyingao
java互联网融入架构新团队
                                    
    偶得的空闲，翻到了两年前的帖子 
该如何快速融入一个新团队，有所感触，就记下来，为下一个两年后的今天做参考。 
 
    时隔两年半之后的今天，再来看当初的这个博客，别有一番滋味。而我已经于今年三月份离开了当初所在的团队，加入另外的一个项目组，2011年的这篇博客之后的时光，我很好的融入了那个团队，而直到现在和同事们关系都特别好。大家在短短一年半的时间离一起经历了一
    
                                
    • 
                                
  • 【Spark七十七】Spark分析Nginx和Apache的access.log
                                    bit1129
apache
                                    
    Spark分析Nginx和Apache的access.log，第一个问题是要对Nginx和Apache的access.log文件进行按行解析，按行解析就的方法是正则表达式： 
  
Nginx的access.log解析正则表达式 
  
val PATTERN = """([^ ]*) ([^ ]*) ([^ ]*) (\\[.*\\]) (\&q
    
                                
    • 
                                
  • Erlang patch
                                    bookjovi
erlang
                                    
    Totally five patchs committed to erlang otp, just small patchs. 
IMO, erlang really is a interesting programming language, I really like its concurrency feature. 
but the functional programming style 
    
                                
    • 
                                
  • log4j日志路径中加入日期
                                    bro_feng
javalog4j
                                    
    要用log4j使用记录日志，日志路径有每日的日期，文件大小5M新增文件。 
实现方式 
log4j: 
<appender name="serviceLog"
		class="org.apache.log4j.RollingFileAppender">
      	<param name="Encoding" v
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-桥接模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/**
 * 个人觉得关于桥接模式的例子，蜡笔和毛笔这个例子是最贴切的：http://www.cnblogs.com/zhenyulu/articles/67016.html
 * 笔和颜色是可分离的，蜡笔把两者耦合在一起了：一支蜡笔只有一种
    
                                
    • 
                                
  • windows7下SVN和Eclipse插件安装
                                    chenyu19891124
eclipse插件
                                    
    今天花了一天时间弄SVN和Eclipse插件的安装，今天弄好了。svn插件和Eclipse整合有两种方式，一种是直接下载插件包，二种是通过Eclipse在线更新。由于之前Eclipse版本和svn插件版本有差别，始终是没装上。最后在网上找到了适合的版本。所用的环境系统：windows7JDK：1.7svn插件包版本：1.8.16Eclipse：3.7.2工具下载地址：Eclipse下在地址：htt
    
                                
    • 
                                
  • [转帖]工作流引擎设计思路
                                    comsci
设计模式工作应用服务器workflow企业应用
                                    
     作为国内的同行，我非常希望在流程设计方面和大家交流，刚发现篇好文(那么好的文章，现在才发现，可惜)，关于流程设计的一些原理，个人觉得本文站得高，看得远，比俺的文章有深度，转载如下 
 
================================================================================= 
 
自开博以来不断有朋友来探讨工作流引擎该如何
    
                                
    • 
                                
  • Linux 查看内存，CPU及硬盘大小的方法
                                    daizj
linuxcpu内存硬盘大小
                                    
    一、查看CPU信息的命令 
 
[root@R4 ~]# cat /proc/cpuinfo |grep "model name" && cat /proc/cpuinfo |grep "physical id" 
model name : Intel(R) Xeon(R) CPU X5450 @ 3.00GHz 
model name : 
    
                                
    • 
                                
  • linux 踢出在线用户
                                    dongwei_6688
linux
                                    
    两个步骤： 
1.用w命令找到要踢出的用户，比如下面： 
  
[root@localhost ~]# w
 18:16:55 up 39 days,  8:27,  3 users,  load average: 0.03, 0.03, 0.00
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT
    
                                
    • 
                                
  • 放手吧,就像不曾拥有过一样
                                    dcj3sjt126com

                                    
    内容提要：   
静悠悠编著的《放手吧就像不曾拥有过一样》集结“全球华语世界最舒缓心灵”的精华故事，触碰生命最深层次的感动，献给全世界亿万读者。《放手吧就像不曾拥有过一样》的作者衷心地祝愿每一位读者都给自己一个重新出发的理由，将那些令你痛苦的、扛起的、背负的，一并都放下吧！把憔悴的面容换做一种清淡的微笑，把沉重的步伐调节成春天五线谱上的音符，让自己踏着轻快的节奏，在人生的海面上悠然漂荡，享受宁静与
    
                                
    • 
                                
  • php二进制安全的含义
                                    dcj3sjt126com
PHP
                                    
    PHP里，有string的概念。
string里，每个字符的大小为byte（与PHP相比，Java的每个字符为Character，是UTF8字符，C语言的每个字符可以在编译时选择）。
byte里，有ASCII代码的字符，例如ABC，123，abc，也有一些特殊字符，例如回车，退格之类的。
特殊字符很多是不能显示的。或者说，他们的显示方式没有标准，例如编码65到哪儿都是字母A，编码97到哪儿都是字符
    
                                
    • 
                                
  • Linux下禁用T440s，X240的一体化触摸板(touchpad)
                                    gashero
linuxThinkPad触摸板
                                    
    自打1月买了Thinkpad T440s就一直很火大，其中最让人恼火的莫过于触摸板。 
  
Thinkpad的经典就包括用了小红点(TrackPoint)。但是小红点只能定位，还是需要鼠标的左右键的。但是自打T440s等开始启用了一体化触摸板，不再有实体的按键了。问题是要是好用也行。 
  
实际使用中，触摸板一堆问题，比如定位有抖动，以及按键时会有飘逸。这就导致了单击经常就
    
                                
    • 
                                
  • graph_dfs
                                    hcx2013
Graph
                                    
    package edu.xidian.graph;

class MyStack {
	private final int SIZE = 20;
	private int[] st;
	private int top;

	public MyStack() {
		st = new int[SIZE];
		top = -1;
	}

	public void push(i
    
                                
    • 
                                
  • Spring4.1新特性——Spring核心部分及其他
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • 配置HiveServer2的安全策略之自定义用户名密码验证
                                    liyonghui160com

                                    
      
  
具体从网上看 
  
http://doc.mapr.com/display/MapR/Using+HiveServer2#UsingHiveServer2-ConfiguringCustomAuthentication 
  
 
  
   
   LDAP Authentication using OpenLDAP 
   Setting 
    
                                
    • 
                                
  • 一位30多的程序员生涯经验总结
                                    pda158
编程工作生活咨询
                                    
    1.客户在接触到产品之后，才会真正明白自己的需求。 
　　这是我在我的第一份工作上面学来的。只有当我们给客户展示产品的时候，他们才会意识到哪些是必须的。给出一个功能性原型设计远远比一张长长的文字表格要好。 2.只要有充足的时间，所有安全防御系统都将失败。 
　　安全防御现如今是全世界都在关注的大课题、大挑战。我们必须时时刻刻积极完善它，因为黑客只要有一次成功，就可以彻底打败你。   3.
    
                                
    • 
                                
  • 分布式web服务架构的演变
                                    自由的奴隶
linuxWeb应用服务器互联网
                                    
    最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易
    
                                
    • 
                                
  • 初探Druid连接池之二——慢SQL日志记录
                                    xingsan_zhang
日志连接池druid慢SQL
                                    
    由于工作原因，这里先不说连接数据库部分的配置，后面会补上，直接进入慢SQL日志记录。 
  
1.applicationContext.xml中增加如下配置： 
<bean abstract="true" id="mysql_database" class="com.alibaba.druid.pool.DruidDataSourc
    
                                
    •