spring security4.2.2的maven配置+spring-security配置详解+java源码+数据库设计

一、引子

最近项目需要添加权限拦截，经讨论决定采用spring security4.2.2！废话少说直接上干货！

spring security 4.2.2文档：http://docs.spring.io/spring-security/site/docs/4.2.2.RELEASE/reference/htmlsingle/#el-access-web

spring security 3 中文2文档：http://www.mossle.com/docs/auth/html/index.html

二、pom.xml配置

需要在pom.xml里配置spring security的依赖，可以通过http://mvnrepository.com/search?q=spring+securitye查询不同版本需要的spring的版本支持。

   <!--spring security  -->
         <dependency>
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-core</artifactId>
             <version>4.2.2.RELEASE</version>
         </dependency>

         <dependency>
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-web</artifactId>
             <version>4.2.2.RELEASE</version>
         </dependency>

          <dependency>
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-config</artifactId>
             <version>4.2.2.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-taglibs</artifactId>
             <version>4.2.2.RELEASE</version>
         </dependency>

三、web.xml配置

需要在web.xml中配置Spring Security控制权限过滤器，

   <filter>
         <filter-name>springSecurityFilterChain</filter-name>
         <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
     </filter>
     <filter-mapping>
         <filter-name>springSecurityFilterChain</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>  

四、spring-security.xml配置

下面最主要的就是spring-security.xml的配置了

 <?xml version="1.0" encoding="UTF-8"?>
 <beans:beans xmlns:beans="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="http://www.springframework.org/schema/security"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans.xsd
             http://www.springframework.org/schema/security
             http://www.springframework.org/schema/security/spring-security.xsd" >

     <!-- 打印调试信息，仅在开发环境中使用 -->
     <!-- <debug/> -->

     <!-- 不需要被拦截的请求 -->
     <http pattern="/loginPage" security="none"/>
     <http pattern="/scripts/**" security="none"/>

     <!--
         登录页面可以使用第一种：
         <http pattern="/login.jsp" security="none"></http>
         <form-login login-page="/login.jsp" authentication-failure-url="/login.jsp?error=true" ......
         这种方式直接访问.jsp
         也可以使用Controller来控制，两种方式登录页面login.jsp的位置不一样！！！
         下面是第二种方式：
         <http pattern="/login" security="none"></http>
         <form-login login-page="/login" login-processing-url="/login" ......
         第一个配置告诉spring security,类似于/login的url请求不做过滤处理,而第二个配置信息又告诉spring security url为/login的post请求登录请求处理。正是这种冲突导致了405错误的发生。
         既然知道了错误原因，那么只要避免冲突就能解决这个问题:使登录页的请求和登录处理的请求不一致,然后只配置登录页的请求不做拦截处理.
         我采用的方法是使用默认的登录URL /login,修改登录页面跳转url为/loginPage。请自行修改代码和配置信息
         这样是不是就大工告成了呢？很遗憾，当你启动程序时,输出用户名和密码,不管正确与否，都会有404 Not Found等着你,这又是为什么呢?
         登录请求404错误
         首先,建议你看一下spring security自动生成的登录页源码,你会发现有如下代码
         <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}" />
         对于什么是csrf,请自行参考网上的资料。
         spring security默认情况下csrf protection是开启的,由于我们的登录页没有配置csrf的相关信息，因此spring security内置的过滤器将此链接置为无效链接
         解决办法就是配置csrf protection为不可用状态,在配置文件中增加
         <csrf disabled="true"/>
     -->

     <!--
         1、<http auto-config="true">,他可以自动配置login form,BSIC 认证和logout URL 和logout services,如果没有特殊表明，这个的默认值是false。想要自己配置则设置为"true"
         2、Spring Security采用的是一种就近原则，就是说当用户访问的url资源满足多个intercepter-url时，系统将使用第一个符合条件的intercept-url进行权限控制
      -->
     <http  auto-config="true" use-expressions="true">
         <!--
             另一种权限表达式：
             <http use-expressions="false">
             <intercept-url pattern='/**' access='ROLE_USER' />
         -->
         <!-- 禁用CSRF保护，默认是启用 -->
         <csrf disabled="true"/>

         <anonymous enabled="false"/>

         <!-- 基于角色认证（必须拥有ROLE_XXX角色才能访问所有/**/XXX/**资源） -->
         <!-- 确保对功能URL访问都需要权限 -->
         <intercept-url pattern="/**/add/**" access="hasRole('ADD')"/>
         <intercept-url pattern="/**/update/**" access="hasRole('UPDATE')"/>
         <intercept-url pattern="/**/delete/**" access="hasRole('DELETE')"/>
         <intercept-url pattern="/**/download/**" access="hasRole('DOWNLOAD')"/>
         <intercept-url pattern="/**/access/**" access="hasRole('ADMIN')"/>

         <!-- Ensures that any request to our application requires the user to be authenticated  -->
         <intercept-url pattern="/**" access="authenticated"/>

         <!--
             实现免登陆验证，默认有效时间是两周，启用rememberMe之后的两周内，用户都可以直接跳过系统，直接进入系统。
             实际上，Spring Security中的rememberMe是依赖cookie实现的，当用户在登录时选择使用rememberMe，系统就会在登录成功后将为用户生成一个唯一标识，并将这个标识保存进cookie中
             Spring Security生成的cookie名称是SPRING_SECURITY_REMEMBER_ME_COOKIE，它的内容是一串加密的字符串，
             当用户再次访问系统时，Spring Security将从这个cookie读取用户信息，并加以验证。如果可以证实cookie有效，就会自动将用户登录到系统中，并为用户授予对应的权限。
         -->

         <!--
             <remember-me remember-me-parameter="remember-me"
             data-source-ref="dataSource"/>
             spring security还提供了remember me的另一种相对更安全的实现机制 :在客户端的cookie中，仅保存一个无意义的加密串（与用户名、密码等敏感数据无关），然后在db中保存该加密串-用户信息的对应关系，自动登录时，用cookie中的加密串，到db中验证，如果通过，自动登录才算通过。会自动在你的数据库里创建一个表：PERSISTENT_LOGINS。
             如果不加data-source-ref="dataSource"，会将上述信息放在内存中！
             作者的项目有些特殊要求，所有采用了下面的方式:登录后要在myAuthenticationSuccessHandler做特殊的处理！
         -->
         <remember-me authentication-success-handler-ref="myAuthenticationSuccessHandler"/>

         <!--
             login-page : 表示用户登陆时显示我们自定义的登录页面
             authentication-failure-url : 登录认证失败转向的url,当用户输入的登录名和密码不正确时，系统将再次跳转到登录页面，并添加一个error=true参数作为登陆失败的标示,这个标识是我们自定义的。
             default-target-url : 登录认证成功转向的地址
          -->
         <form-login
             login-page="/loginPage"
             authentication-failure-url="/loginPage?error=true"
             authentication-success-handler-ref="myAuthenticationSuccessHandler"
         />

         <!-- 登出后，返回到登陆页面 -->
         <!--  <logout logout-success-url="/loginPage" logout-url="/logout"/>
                    delete-cookies="JSESSIONID":退出删除JSESSIONID
         -->
         <logout />
         <!--
             控制同步session的过滤器
             如果concurrency-control标签配置了error-if-maximum-exceeded="true"，max-sessions="1"，那么第二次登录时，是登录不了的。
             如果error-if-maximum-exceeded="false"，那么第二次是能够登录到系统的，
             但是第一个登录的账号再次发起请求时，会跳转到expired-url配置的url中,
             如果没有配置expired-url，则显示：
             This session has been expired (possibly due to multiple concurrent logins being attempted as the same user).
             翻译过来意思就是说：这个会话已经过期(可能由于多个并发登录尝试相同的用户)
          -->

         <session-management invalid-session-url="/loginPage" >
             <concurrency-control max-sessions="1" error-if-maximum-exceeded="false" expired-url="/loginPage"/>
         </session-management>

         <!-- 指定自己的权限验证过滤器，首先走自己的的过滤器 myFilter，如果被拦截就报没有权限；
              如果通过会走spring security自带的拦截器，即上面配置的权限配置！
         -->
         <custom-filter before="FILTER_SECURITY_INTERCEPTOR" ref="myFilter"/>
     </http>

     <!-- 权限认证Spring日志监听器  -->
     <beans:bean class="org.springframework.security.authentication.event.LoggerListener"/>
     <beans:bean class="org.springframework.security.access.event.LoggerListener"/>

     <!--
              一个自定义的filter，必须包含authenticationManager,accessDecisionManager,securityMetadataSource三个属性，
          我们的所有控制将在这三个类中实现，解释详见具体配置。
     -->
     <beans:bean id="myFilter" class="com.tcbd.common.interceptor.MyFilterSecurityInterceptor" >
         <beans:property name="authenticationManager" ref="authenticationManager" />
         <beans:property name="accessDecisionManager" ref="myAccessDecisionManagerBean" />
         <beans:property name="securityMetadataSource" ref="securityMetadataSource" />
     </beans:bean>

     <!-- 验证配置，实现用户认证的入口，主要实现UserDetailsService接口即可  -->
     <authentication-manager alias="authenticationManager" >
         <authentication-provider ref="daoAuthenticationProvider" >
         </authentication-provider>
     </authentication-manager>

     <beans:bean id="daoAuthenticationProvider" class="org.springframework.security.authentication.dao.DaoAuthenticationProvider">
         <beans:property name="userDetailsService" ref="myUserDetailService" />
         <beans:property name="passwordEncoder" ref="passwordEncoder" />
     </beans:bean>
     <!-- spring推荐的单向加密算法 -->
     <beans:bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>

     <!-- 在这个类中，读入用户的密码，角色信息，是否锁定，账号是否过期等属性信息  -->
     <beans:bean id="myUserDetailService" class="com.tcbd.common.interceptor.MyUserDetailService" />

     <!-- 访问决策器，决定某个用户具有的角色，是否有足够的权限去访问某个资源 -->
     <beans:bean id="myAccessDecisionManagerBean" class="com.tcbd.common.interceptor.MyAccessDecisionManager" ></beans:bean>

     <!-- 资源源数据定义，即定义某一资源可以被哪些角色访问 -->
     <beans:bean id="securityMetadataSource" class="com.tcbd.common.interceptor.MyFilterSecurityMetadataSource" />

     <beans:bean id="myAuthenticationSuccessHandler" class="com.tcbd.common.interceptor.MyAuthenticationSuccessHandler"/>

 </beans:beans>

spring security为我们提供了三种通配符。
通配符：?
示例：/admin/g?t.jsp
匹配任意一个字符，/admin/g?t.jsp可以匹配/admin/get.jsp和/admin/got.jsp或是/admin/gxt.do。不能匹配/admin/xxx.jsp。
通配符：*
示例：/admin/*.jsp
匹配任意多个字符，但不能跨越目录。/*/index.jsp可以匹配/admin/index.jsp和/user/index.jsp，但是不能匹配/index.jsp和/user/test/index.jsp。
通配符：**
示例：/**/index.jsp
可以匹配任意多个字符，可以跨越目录，可以匹配/index.jsp，/admin/index.jsp，/user/admin/index.jsp和/a/b/c/d/index.jsp

五、自己的拦截器

1，读入用户的密码，角色信息，是否锁定，账号是否过期等属性信息 ：MyUserDetailService

 import java.util.ArrayList;
 import java.util.Collection;

 import javax.annotation.Resource;

 import org.apache.commons.lang.StringUtils;
 import org.apache.log4j.Logger;
 import org.springframework.dao.DataAccessException;
 import org.springframework.security.core.GrantedAuthority;
 import org.springframework.security.core.authority.SimpleGrantedAuthority;
 import org.springframework.security.core.userdetails.User;
 import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.core.userdetails.UsernameNotFoundException;

 /**
  * 从数据库中读入用户的密码，角色信息，是否锁定，账号是否过期等
  *
  */
 public class MyUserDetailService implements UserDetailsService {
     @Resource
     private UserService userService;

     /**
      * 数据库交互获取用户拥有的权限角色，并设置权限
      */
     @Override
     public UserDetails loadUserByUsername(String userCode) throws UsernameNotFoundException, DataAccessException {
         // 根据登录用户名获取用户信息
         Users user = new Users();
         user.setUserCode(username);
         user = userService.selectByModel(user);
         if (null != user) {
             // 存放权限
             Collection<GrantedAuthority> auths = new ArrayList<GrantedAuthority>();
                 String action = user.getRole();
                 if (StringUtils.isNotBlank(action)) {
                     String[] roleaCtion = action.split(",");
                     for (int i = 0; i < roleaCtion.length; i++) {
                         SimpleGrantedAuthority auth = new SimpleGrantedAuthority(roleaCtion[i]);
                         auths.add(auth);
                     }
                 }
                 //spring security自带的User对象
             User userDetails = new User(username, user.getPassword(), true, true, true, true, auths);
             return userDetails;
         }
         return null;
     }
 }

2，定义某一资源可以被哪些角色访问：MyFilterSecurityMetadataSource

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;

 import javax.servlet.http.HttpServletRequest;

 import org.apache.log4j.Logger;
 import org.springframework.security.access.ConfigAttribute;
 import org.springframework.security.access.SecurityConfig;
 import org.springframework.security.web.FilterInvocation;
 import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;

 public class MyFilterSecurityMetadataSource implements FilterInvocationSecurityMetadataSource {
     private static Logger logger = Logger.getLogger(MyFilterSecurityMetadataSource.class);

     public List<ConfigAttribute> getAttributes(Object object) {
         FilterInvocation fi = (FilterInvocation) object;
         HttpServletRequest request = fi.getRequest();
         String requestUrl = fi.getRequest().getRequestURI();
         List<ConfigAttribute> attributes = new ArrayList<ConfigAttribute>();
         // 所有URL对应的角色，应用启动就存放到静态资源里，得到的结果是：不同的URL下，包含的多个角色
         Map<String, String> resRoles = Constant.URL_ROLES;

         for (Map.Entry<String, String> ent : resRoles.entrySet()) {
             String url = ent.getKey();
             String roles = ent.getValue();
             //根据业务写自己的匹配逻辑
             if(requestUrl.startsWith(url)){
                 attributes.addAll(SecurityConfig.createListFromCommaDelimitedString(roles));
             }
         }
         logger.debug("【"+request.getRequestURI()+"】 roles: "+attributes);
         return attributes;
     }

     public Collection<ConfigAttribute> getAllConfigAttributes() {
         return null;
     }

     public boolean supports(Class<?> clazz) {
         return FilterInvocation.class.isAssignableFrom(clazz);
     }
 }

3，访问决策器，决定某个用户具有的角色，是否有足够的权限去访问某个资源：MyAccessDecisionManager

 import java.util.Collection;
 import java.util.Iterator;

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.security.access.AccessDecisionManager;
 import org.springframework.security.access.AccessDeniedException;
 import org.springframework.security.access.ConfigAttribute;
 import org.springframework.security.access.SecurityConfig;
 import org.springframework.security.authentication.InsufficientAuthenticationException;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.GrantedAuthority;

 /**
  * 在这种方法中,需要与configAttributes比较验证
  * 1、一个对象是一个URL,一个过滤器被这个URL找到权限配置,并通过这里
  * 2、如果没有匹配相应的认证,AccessDeniedException
  *
  */
 public class MyAccessDecisionManager implements AccessDecisionManager {

     private static final Log logger = LogFactory.getLog(MyAccessDecisionManager.class);

     /**
      * 在这个类中，最重要的是decide方法，如果不存在对该资源的定义，直接放行； 否则，如果找到正确的角色，即认为拥有权限，并放行，否则throw
      * new AccessDeniedException("no right");这样，就会进入上面提到的/accessDenied.jsp页面。
      * @param authentication ：当前用户所且有的角色
      * @param object :当前请求的URL
      * @param configAttributes :当前URL所且有的角色
      */
     @Override
     public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes)
             throws AccessDeniedException, InsufficientAuthenticationException {
         // 资源所需的角色列表，如果角色列表为空，则放行！继续下一个拦截器。
         if (configAttributes == null) {
             return;
         }
         // 即将访问的资源URL,如 : /admin.jsp
         logger.info("URL :"+object);
         // 遍历所需的角色集合
         Iterator<ConfigAttribute> ite = configAttributes.iterator();
         while (ite.hasNext()) {
             ConfigAttribute ca = ite.next();
             // 该资源所需要的角色
             String needRole = ((SecurityConfig) ca).getAttribute();
             // authentication.getAuthorities()获取用户所拥有的角色列表,如：OLE_DEFULT
             for (GrantedAuthority grantedAuthority : authentication.getAuthorities()) {
                 // 将资源所需要的角色与用户拥有的角色比较
                 if (needRole.equals(grantedAuthority.getAuthority())) {
                     // grantedAuthority is user's role.
                     // 角色相同，直接放行
                     return;
                 }
             }
         }
         // 否则，提示没有权限访问该资源
         throw new AccessDeniedException("no right");
     }

     @Override
     public boolean supports(ConfigAttribute attribute) {
         return true;
     }

     @Override
     public boolean supports(Class<?> clazz) {
         return true;
     }

 }

4，拦截器核心，MyFilterSecurityInterceptor

 import java.io.IOException;

 import javax.servlet.Filter;
 import javax.servlet.FilterChain;
 import javax.servlet.FilterConfig;
 import javax.servlet.ServletException;
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;

 import org.springframework.security.access.SecurityMetadataSource;
 import org.springframework.security.access.intercept.AbstractSecurityInterceptor;
 import org.springframework.security.access.intercept.InterceptorStatusToken;
 import org.springframework.security.web.FilterInvocation;
 import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;

 /**
  *
  */
 public class MyFilterSecurityInterceptor extends AbstractSecurityInterceptor
         implements Filter {

     private FilterInvocationSecurityMetadataSource securityMetadataSource;

     /* get、set方法 */
     public FilterInvocationSecurityMetadataSource getSecurityMetadataSource() {
         return securityMetadataSource;
     }

     public void setSecurityMetadataSource(
             FilterInvocationSecurityMetadataSource securityMetadataSource) {
         this.securityMetadataSource = securityMetadataSource;
     }

     @Override
     public Class<? extends Object> getSecureObjectClass() {
         return FilterInvocation.class;
     }

     @Override
     public SecurityMetadataSource obtainSecurityMetadataSource() {
         return this.securityMetadataSource;
     }

     @Override
     public void doFilter(ServletRequest request, ServletResponse response,
             FilterChain chain) throws IOException, ServletException {

         FilterInvocation fi = new FilterInvocation(request, response, chain);
         invoke(fi);
     }

     public void invoke(FilterInvocation fi) throws IOException,
             ServletException {
         /**
          * 最核心的代码就是@link InterceptorStatusToken token = super.beforeInvocation(fi);
          * 它会调用我们定义的MyInvocationSecurityMetadataSource.getAttributes方法和MyAccessDecisionManager.decide方法
          * 这一句，即在执行doFilter之前，进行权限的检查，而具体的实现已经交给@link MyAccessDecisionManager 了
          */
         InterceptorStatusToken token = super.beforeInvocation(fi);
         try {
             //继续走下一个拦截器，也就是org.springframework.security.web.access.intercept.FilterSecurityInterceptor
             fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
         } finally {
             super.afterInvocation(token, null);
         }
     }

     @Override
     public void destroy() {

     }

     @Override
     public void init(FilterConfig arg0) throws ServletException {

     }

 }

5，登录页面（需要自己改一些东西）

 <%@ page language="java" contentType="text/html; charset=UTF-8"
     pageEncoding="UTF-8"%>
 <%@ taglib prefix='fmt' uri="http://java.sun.com/jsp/jstl/fmt" %>
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 <%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags"%>
 <!DOCTYPE html>
 <html lang="zh-CN">
   <head>
     <meta charset="utf-8">
     <meta http-equiv="X-UA-Compatible" content="IE=edge">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
     <meta name="description" content="">
     <meta name="author" content="">
     <link rel="icon" href="/favicon.ico">

     <title><fmt:message key="application.title"></fmt:message></title>

     <!-- Bootstrap core CSS -->
     <link href="/scripts/plugins/bootstrap/css/bootstrap.min.css" rel="stylesheet">

     <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
     <!-- Custom styles for this template -->

     <link href="/scripts/apps/css/signin.css" rel="stylesheet">

     <style type="text/css">
     .tip {
         font-size: 10px;
         color: red;
         text-align: center;
     }

     </style>
   </head>

   <body>
     <div class="container">
         <c:url var="loginUrl" value="/login" />
       <form action="${loginUrl}" id="login_form" class="form-signin" method="post">
           <div class="form-signin-heading text-center">
             <h2 ><fmt:message key="application.title"></fmt:message></h2>
           </div>
           <div id="tip" class="tip"></div>
           <c:if test="${param.error != null}">
                 <span style="color:red">用户名或密码有误</span>
         </c:if>

         <label for="inputEmail" class="sr-only">登录帐号</label>
         <input type="text" id="inputUserCode" name="username" class="form-control" placeholder="登录帐号"  autofocus>
            <label for="inputPassword" class="sr-only">登录密码</label>
            <input type="password" id="inputPassword" name="password" class="form-control" placeholder="登录密码">
         <div class="input-group input-sm">
           <div class="checkbox">
             <label><input type="checkbox" id="rememberme" name="remember-me" value="true"> 下次自动登录</label>
           </div>
         </div>
         <button id="login_button" class="btn btn-lg btn-primary btn-block" type="submit">登录</button>
       </form>

     </div> 

     <script src="/scripts/plugins/jQuery/jquery-2.2.3.min.js"></script>
   </body>
 </html>

在JSP中相应的操作按钮上加上如下标签，控制显示：

<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags"%> 该标签一定要加上！！！
<sec:authorize access="hasRole('ADD')">
<a href="/XXX/add">增加</a>
</sec:authorize>

数据库设计：user表里有roleId，role表，resource-role表，resource表