`
kobe学java
  • 浏览: 258464 次
  • 性别: Icon_minigender_1
  • 来自: 苏州
社区版块
存档分类
最新评论

Spring Security 3应用的11个步骤

 
阅读更多

 

Spring Security 3应用的11个步骤

分类： spring2012-04-11 17:56 4人阅读 评论(0) 收藏 举报
  1. pring Security
    11个步骤为应用程序添加安全防护
  2. 历史与现状
    自2003年出现的Spring扩展插件Acegi Security发展而来。
    目前最新 版本为3.x，已成为Spring的一部分。
    为J2EE企业应用程序提供可靠的安全性服务。
  3. Authentication vs. Authorization
    区分概念验证与授权
    验证
    这 个用户是谁？
    用户身份可靠吗？
    授权
    某用户A是否可以访问资源R
    某用户A是否可以执行M操作
    某用户A是否可以对资 源R执行M操作
  4. SS中的验证特点
    支持多种验证方式
    支持多种加密格式
    支持组件的扩展和替换
    可以本地化 输出信息
  5. SS中的授权特点
    支持多种仲裁方式
    支持组件的扩展和替换
    支持对页面访问、方法访问、对象访问 的授权。
  6. SS核心安全实现
    Web安全
    通过配置Servlet Filter激活SS中的过滤器链
    实现 Session一致性验证
    实现免登陆验证（Remember-Me验证）
    提供一系列标签库进行页面元素的安全控制
    方法安全
    通 过AOP模式实现安全代理
    Web安全与方法安全均可以使用表达式语言定义访问规则
  7. 配置SS
    配置Web.xml，应用安全过滤器
    配置Spring，验证与授权部分
    在web页面 中获取用户身份
    在web页面中应用安全标签库
    实现方法级安全
  8. 1：配置web.xml

Java代码

  1.  
    1. <filter>  
    2. <filter-name>springSecurityFilterChain</filter-name>  
    3. <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
    4. </filter>  
    5. <filter-mapping>  
    6. <filter-name>springSecurityFilterChain</filter-name>  
    7. <url-pattern>/*</url-pattern>  
    8. </filter-mapping>  
    9. <context-param>  
    10. <param-name>contextConfigLocation</param-name>  
    11. <param-value>classpath:spring.xml</param-value>  
    12. </context-param>  
    13. <listener>  
    14. <listener-class>  
    15. org.springframework.web.context.ContextLoaderListener  
    16. </listener-class>  
    17. </listener>  

<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><context-param> <param-name>contextConfigLocation</param-name><param-value>classpath:spring.xml</param-value></context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener>

  1. 2：Spring配置文件中设置命名空间

Java代码

  1.  
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans:beansxmlns="http://www.springframework.org/schema/security"  
    3. xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4. xsi:schemaLocation="http://www.springframework.org/schema/beans  
    5. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
    6. http://www.springframework.org/schema/security  
    7. http://www.springframework.org/schema/security/spring-security-3.0.xsd">  
    8. </beans:beans>  

<?xmlversion="1.0" encoding="UTF-8"?><beans:beansxmlns="http://www.springframework.org/schema/security"xmlns:beans="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/securityhttp://www.springframework.org/schema/security/spring-security-3.0.xsd"></beans:beans>

 

  1. 3：配置最基本的验证与授权

Java代码

  1.  
    1. <http auto-config="true">  
    2. <intercept-url pattern="/**" access="ROLE_USER" />  
    3. </http>  
    4. <authentication-manager>  
    5. <authentication-provider>  
    6. <user-service>  
    7. <user name="tom" password="123" authorities="ROLE_USER, ROLE_A" />  
    8. <user name="jerry" password="123" authorities="ROLE_USER, ROLE_B" />  
    9. </user-service>  
    10. </authentication-provider>  
    11. </authentication-manager>  

<httpauto-config="true"> <intercept-url pattern="/**"access="ROLE_USER" /> </http> <authentication-manager><authentication-provider> <user-service> <username="tom" password="123" authorities="ROLE_USER,ROLE_A" /> <user name="jerry" password="123"authorities="ROLE_USER, ROLE_B" /> </user-service></authentication-provider> </authentication-manager>

  1. 4：通过数据库验证用户身份

Java代码

  1.  
    1. <authentication-manager>  
    2. <authentication-provider>  
    3. <password-encoder hash=“md5”/>  
    4. <jdbc-user-service data-source-ref="dataSource"/>  
    5. </authentication-provider>  
    6. </authentication-manager>  
    7. 数 据表结构见SS说明手册附录A  

<authentication-manager><authentication-provider> <password-encoder hash=“md5”/><jdbc-user-service data-source-ref="dataSource"/></authentication-provider> </authentication-manager> 数据表结构见SS说明手册附录A

  1. 5：完善web页面验证规则

Java代码

  1.  
    1. <http auto-config="true">  
    2. <intercept-url pattern="/js/**" filters="none"/>  
    3. <intercept-url pattern="/css/**" filters="none"/>  
    4. <intercept-url pattern="/images/**" filters="none"/>  
    5. <intercept-url pattern="/a.jsp" access="ROLE_A" />  
    6. <intercept-url pattern="/b.jsp" access="ROLE_B" />  
    7. <intercept-url pattern="/c.jsp" access="ROLE_A, ROLE_B" />  
    8. <intercept-url pattern="/**" access="ROLE_USER" />  
    9. </http>  

<httpauto-config="true"> <intercept-url pattern="/js/**"filters="none"/> <intercept-url pattern="/css/**"filters="none"/> <intercept-url pattern="/images/**"filters="none"/> <intercept-url pattern="/a.jsp"access="ROLE_A" /> <intercept-url pattern="/b.jsp"access="ROLE_B" /> <intercept-url pattern="/c.jsp"access="ROLE_A, ROLE_B" /> <intercept-urlpattern="/**" access="ROLE_USER" /> </http>

  1. 6：自定义验证配置

Java代码

  1.  
    1. <!-- 指 定登陆页面、成功页面、失败页面-->  
    2. <form-login login-page="/login.jsp" default-target-url="/index.jsp" authentication-failure-url="/login.jsp" />  
    3. <!-- 尝 试访问没有权限的页面时跳转的页面 -->  
    4. <access-denied-handler error-page="/accessDenied.jsp"/>  
    5. <!-- 使 用记住用户名、密码功能，指定数据源和加密的key -->  
    6. <remember-me data-source-ref="dataSource" />  
    7. <!-- logout 页面，logout后清除session -->  
    8. <logout invalidate-session="true" logout-success-url="/login.jsp" />  
    9. <!-- session 失 效后跳转的页面，最大登陆次数 -->  
    10. <session-management invalid-session-url="/sessionTimeout.htm">  
    11. <concurrency-control max-sessions="1" expired-url="/sessionTimeout.htm" />  
    12. </session-management>  
    13. </http>  
    14. 可 以使用SS自带的登陆页面作为login.jsp的模板  

<httpauto-config="true"> <!-- 指定登陆页面、成功页面、失败页面--> <form-loginlogin-page="/login.jsp" default-target-url="/index.jsp"authentication-failure-url="/login.jsp" /> <!-- 尝试访问没有权限的页面时跳转的页面 --> <access-denied-handlererror-page="/accessDenied.jsp"/> <!-- 使用记住用户名、密码功能，指定数据源和加密的key --> <remember-me data-source-ref="dataSource"/> <!-- logout页面，logout后清除session --> <logout invalidate-session="true"logout-success-url="/login.jsp" /> <!-- session 失效后跳转的页面，最大登陆次数 --> <session-managementinvalid-session-url="/sessionTimeout.htm"> <concurrency-controlmax-sessions="1" expired-url="/sessionTimeout.htm" /></session-management> </http> 可以使用SS自带的登陆页面作为login.jsp的模板

  1. 7：本地化消息输出
    拷贝本地化资源文件后，在配置文件中加载该文件：

Java代码

  1.  
    1. <!-- 加 载错误信息资源文件 -->  
    2. <beans:bean id="messageSource"   
    3. class="org.springframework.context.support.ReloadableResourceBundleMessageSource">  
    4. <beans:property name="basename" value="classpath:messages"/>  
    5. </beans:bean>  
    6. 资 源文件在SS核心包：spring-security-core-3.0.2.RELEASE.jar的orgspringframeworksecurity目录 中  

<!-- 加载错误信息资源文件 --><beans:bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource"><beans:property name="basename"value="classpath:messages"/> </beans:bean> 资源文件在SS核心包：spring-security-core-3.0.2.RELEASE.jar的orgspringframeworksecurity目录中

  1. 8：在web页面中获取用户信息

Java代码

  1.  
    1. 方式 一：Java代码  
    2. Authentication auth = SecurityContextHolder.getContext().getAuthentication();  
    3. Collection<GrantedAuthority> col = auth.getAuthorities();  
    4. 方 式二：标签库  
    5. <%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>  
    6. <sec:authentication property="name“/>  
    7. <sec:authentication property="authorities“/>  

方式一：Java代码 Authentication auth =SecurityContextHolder.getContext().getAuthentication();Collection<GrantedAuthority> col = auth.getAuthorities(); 方式二：标签库 <%@ taglib prefix="sec"uri="http://www.springframework.org/security/tags" %><sec:authentication property="name“/> <sec:authenticationproperty="authorities“/>

  1. 9：在web页面进行元素安全控制

Java代码

  1.  
    1. 方式一  
    2. <sec:authorizeifAnyGranted="ROLE_A">  
    3. <a href="a.jsp">你可以访问a.jsp</a>  
    4. </sec:authorize>  
    5. <sec:authorizeifNotGranted="ROLE_A">  
    6. 你 不可以访问a.jsp  
    7. </sec:authorize>  
    8. 方 式二  
    9. <sec:authorizeurl="/a.jsp">  
    10. <a href="a.jsp">你可以访问a.jsp</a>  
    11. </sec:authorize>  

方式一<sec:authorizeifAnyGranted="ROLE_A"> <ahref="a.jsp">你可以访问a.jsp</a></sec:authorize> <sec:authorizeifNotGranted="ROLE_A"> 你不可以访问a.jsp </sec:authorize> 方式二<sec:authorizeurl="/a.jsp"> <a href="a.jsp">你可以访问a.jsp</a> </sec:authorize>

  1. 10：全局方法安全控制

Java代码

  1.  
    1. <global-method-security pre-post-annotations="enabled">  
    2. <protect-pointcut expression="execution(* com.xasxt.*Service.add*(..))" access="ROLE_A"/>  
    3. <protect-pointcut expression="execution(* com.xasxt.*Service.delete*(..))" access="ROLE_B"/>  
    4. </global-method-security>  
    5. 此 处使用了AspectJ中常用的切入点表达式（百度：AspectJ execution）  

<global-method-securitypre-post-annotations="enabled"> <protect-pointcutexpression="execution(* com.xasxt.*Service.add*(..))"access="ROLE_A"/> <protect-pointcutexpression="execution(* com.xasxt.*Service.delete*(..))"access="ROLE_B"/> </global-method-security> 此处使用了AspectJ中常用的切入点表达式（百度：AspectJ execution）

  1. 11：使用注解进行方法安全控制

Java代码

  1.  
    1. public class DemoService {  
    2. @PreAuthorize("hasRole(&apos;ROLE_A&apos;)")  
    3. public void methodA() {  
    4. }  
    5. @PreAuthorize("hasAnyRole(&apos;ROLE_A, ROLE_B&apos;)")  
    6. public void methodB() {  
    7. }  
    8. }  
    9. hasRole 与hasAnyRole为SS通用内置表达式（google : spring security Common Built- In Expressions）  

public class DemoService {@PreAuthorize("hasRole(&apos;ROLE_A&apos;)") public voidmethodA() { } @PreAuthorize("hasAnyRole(&apos;ROLE_A, ROLE_B&apos;)")public void methodB() { } } hasRole与hasAnyRole为SS通用内置表达式（google : spring security Common Built-In Expressions）

  1. 12：下一步做什么？？？
    采用更安全的验证方式
    采用安全的数据传输方式
    实现动态授权
    自 定义验证与授权部件
    实现数据级安全

20.本Blog所有内容不得随意转载，版权属于作者所有。如需转载请与作者联系（fastzch@163.com    QQ：9184314）。
未经许可的转载，本人保留一切法律权益。
一直以来，发现有某些人完全不尊重我的劳动成果，随意转载，提醒一下那些人小心哪天惹上官司。

Spring Security 3.x 出来一段时间了，跟Acegi是大不同了，与2.x的版本也有一些小小的区别，网上有一些文档，也有人翻译Spring Security 3.x的guide，但通过阅读guide，无法马上就能很容易的实现一个完整的实例。

我花了点儿时间，根据以前的实战经验，整理了一份完整的入门教程，供需要的朋友们参考。
1，建一个web project，并导入所有需要的lib，这步就不多讲了。
2，配置web.xml，使用Spring的机制装载：

21. <?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext*.xml</param-value>
    </context-param>

    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    <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>


    <welcome-file-list>
        <welcome-file>login.jsp</welcome-file>
    </welcome-file-list>
</web-app>

22.这个文件中的内容我相信大家都很熟悉了，不再多说了。

2，来看看applicationContext-security.xml这个配置文件，关于Spring Security的配置均在其中：

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

    <http access-denied-page="/403.jsp"><!-- 当访问被拒绝时，会转到403.jsp -->
        <intercept-url pattern="/login.jsp" filters="none" />
        <form-login login-page="/login.jsp"
            authentication-failure-url="/login.jsp?error=true"
            default-target-url="/index.jsp" />
        <logout logout-success-url="/login.jsp" />
        <http-basic />
        <!-- 增加一个filter，这点与Acegi是不一样的，不能修改默认的filter了，这个filter位于FILTER_SECURITY_INTERCEPTOR之前 -->
        <custom-filter before="FILTER_SECURITY_INTERCEPTOR"
            ref="myFilter" />
    </http>

    <!-- 一个自定义的filter，必须包含authenticationManager,accessDecisionManager,securityMetadataSource三个属性，
    我们的所有控制将在这三个类中实现，解释详见具体配置 -->
    <beans:bean id="myFilter" class="com.robin.erp.fwk.security.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
            user-service-ref="myUserDetailService">
            <!--   如果用户的密码采用加密的话，可以加点“盐”
                <password-encoder hash="md5" />
            -->
        </authentication-provider>
    </authentication-manager>
    <beans:bean id="myUserDetailService"
        class="com.robin.erp.fwk.security.MyUserDetailService" />

    <!-- 访问决策器，决定某个用户具有的角色，是否有足够的权限去访问某个资源 -->
    <beans:bean id="myAccessDecisionManagerBean"
        class="com.robin.erp.fwk.security.MyAccessDecisionManager">
    </beans:bean>
    
    <!-- 资源源数据定义，即定义某一资源可以被哪些角色访问 -->
    <beans:bean id="securityMetadataSource"
        class="com.robin.erp.fwk.security.MyInvocationSecurityMetadataSource" />

</beans:beans>

24.
3，来看看自定义filter的实现：

25. package com.robin.erp.fwk.security;
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;

    // ~ Methods
    // ========================================================================================================

    /** *//**
     * Method that is actually called by the filter chain. Simply delegates to
     * the {@link #invoke(FilterInvocation)} method.
     * 
     * @param request
     *            the servlet request
     * @param response
     *            the servlet response
     * @param chain
     *            the filter chain
     * 
     * @throws IOException
     *             if the filter chain fails
     * @throws ServletException
     *             if the filter chain fails
     */
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        FilterInvocation fi = new FilterInvocation(request, response, chain);
        invoke(fi);
    }

    public FilterInvocationSecurityMetadataSource getSecurityMetadataSource() {
        return this.securityMetadataSource;
    }

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

    public void invoke(FilterInvocation fi) throws IOException,
            ServletException {
        InterceptorStatusToken token = super.beforeInvocation(fi);
        try {
            fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
        } finally {
            super.afterInvocation(token, null);
        }
    }

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

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

    @Override
    public void destroy() {
    }

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

}

26.最核心的代码就是invoke方法中的InterceptorStatusToken token = super.beforeInvocation(fi);这一句，即在执行doFilter之前，进行权限的检查，而具体的实现已经交给accessDecisionManager了，下文中会讲述。

4，来看看authentication-provider的实现：

27. package com.robin.erp.fwk.security;
import java.util.ArrayList;
import java.util.Collection;

import org.springframework.dao.DataAccessException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.GrantedAuthorityImpl;
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 {

    @Override
    public UserDetails loadUserByUsername(String username)
            throws UsernameNotFoundException, DataAccessException {
        Collection<GrantedAuthority> auths=new ArrayList<GrantedAuthority>();
        GrantedAuthorityImpl auth2=new GrantedAuthorityImpl("ROLE_ADMIN");
        auths.add(auth2);
        if(username.equals("robin1")){
            auths=new ArrayList<GrantedAuthority>();
            GrantedAuthorityImpl auth1=new GrantedAuthorityImpl("ROLE_ROBIN");
            auths.add(auth1);
        }
        
//        User(String username, String password, boolean enabled, boolean accountNonExpired,
//                    boolean credentialsNonExpired, boolean accountNonLocked, Collection<GrantedAuthority> authorities) {
        User user = new User(username,
                "robin", true, true, true, true, auths);
        return user;
    }
    
}

28.在这个类中，你就可以从数据库中读入用户的密码，角色信息，是否锁定，账号是否过期等，我想这么简单的代码就不再多解释了。

5，对于资源的访问权限的定义，我们通过实现FilterInvocationSecurityMetadataSource这个接口来初始化数据。

29. package com.robin.erp.fwk.security;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

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;
import org.springframework.security.web.util.AntUrlPathMatcher;
import org.springframework.security.web.util.UrlMatcher;

/** *//**
 * 
 * 此类在初始化时，应该取到所有资源及其对应角色的定义
 * 
 * @author Robin
 * 
 */
public class MyInvocationSecurityMetadataSource
        implements FilterInvocationSecurityMetadataSource {
    private UrlMatcher urlMatcher = new AntUrlPathMatcher();;
    private static Map<String, Collection<ConfigAttribute>> resourceMap = null;

    public MyInvocationSecurityMetadataSource() {
        loadResourceDefine();
    }

    private void loadResourceDefine() {
        resourceMap = new HashMap<String, Collection<ConfigAttribute>>();
        Collection<ConfigAttribute> atts = new ArrayList<ConfigAttribute>();
        ConfigAttribute ca = new SecurityConfig("ROLE_ADMIN");
        atts.add(ca);
        resourceMap.put("/index.jsp", atts);
        resourceMap.put("/i.jsp", atts);
    }

    // According to a URL, Find out permission configuration of this URL.
    public Collection<ConfigAttribute> getAttributes(Object object)
            throws IllegalArgumentException {
        // guess object is a URL.
        String url = ((FilterInvocation)object).getRequestUrl();
        Iterator<String> ite = resourceMap.keySet().iterator();
        while (ite.hasNext()) {
            String resURL = ite.next();
            if (urlMatcher.pathMatchesUrl(url, resURL)) {
                return resourceMap.get(resURL);
            }
        }
        return null;
    }

    public boolean supports(Class<?> clazz) {
        return true;
    }
    
    public Collection<ConfigAttribute> getAllConfigAttributes() {
        return null;
    }

}

30.看看loadResourceDefine方法，我在这里，假定index.jsp和i.jsp这两个资源，需要ROLE_ADMIN角色的用户才能访问。
这个类中，还有一个最核心的地方，就是提供某个资源对应的权限定义，即getAttributes方法返回的结果。注意，我例子中使用的是AntUrlPathMatcher这个path matcher来检查URL是否与资源定义匹配，事实上你还要用正则的方式来匹配，或者自己实现一个matcher。

6，剩下的就是最终的决策了，make a decision，其实也很容易，呵呵。

31. package com.robin.erp.fwk.security;
import java.util.Collection;
import java.util.Iterator;

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;


public class MyAccessDecisionManager implements AccessDecisionManager {

    //In this method, need to compare authentication with configAttributes.
    // 1, A object is a URL, a filter was find permission configuration by this URL, and pass to here.
    // 2, Check authentication has attribute in permission configuration (configAttributes)
    // 3, If not match corresponding authentication, throw a AccessDeniedException.
    public void decide(Authentication authentication, Object object,
            Collection<ConfigAttribute> configAttributes)
            throws AccessDeniedException, InsufficientAuthenticationException {
        if(configAttributes == null){
            return ;
        }
        System.out.println(object.toString());  //object is a URL.
        Iterator<ConfigAttribute> ite=configAttributes.iterator();
        while(ite.hasNext()){
            ConfigAttribute ca=ite.next();
            String needRole=((SecurityConfig)ca).getAttribute();
            for(GrantedAuthority ga:authentication.getAuthorities()){
                if(needRole.equals(ga.getAuthority())){  //ga is user's role.
                    return;
                }
            }
        }
        throw new AccessDeniedException("no right");
    }

    @Override
    public boolean supports(ConfigAttribute attribute) {
        // TODO Auto-generated method stub
        return true;
    }

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


}

32.在这个类中，最重要的是decide方法，如果不存在对该资源的定义，直接放行；否则，如果找到正确的角色，即认为拥有权限，并放行，否则throw new AccessDeniedException("no right");这样，就会进入上面提到的403.jsp页面。

参考资料：
1，Spring官方网站：http://www.springframework.org
2，文章所用的代码，MyEclipse工程，去掉了lib，请自行下载Spring Security 3.x的包，并copy至对应目录。工程源代码
3，根据网络上的资料，制作的CHM版的Spring Security 3.x 参考手册中文版
4，2009年3月，我在“IBM WebSphere技术专家沙龙（华南区广州站）”演讲时的PPT：《Spring Security--Protect your webapplication》，当时是Spring Security 2.x，很多原理是一样，可作参考。

教程中为了尽可能不跟其它框架关联上，所以去掉了访问数据库的部分，比如用户信息和资源配置信息的读取，直接写死在代码中了，大家可以根据自己的实际情况补充完整。

如有任何疑问，欢迎大家以评论的方式提问，也欢迎大家讨论！

分享到：
| Spring3 MVC + jQuery easyUI 做的ajax版本 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring Security 3应用的11个步骤.doc

    11个步骤为应用程序添加安全防护 2. 历史与现状 自2003年出现的Spring扩展插件Acegi Security发展而来。 目前最新 版本为3.x，已成为Spring的一部分。 为J2EE企业应用程序提供可靠的安全性服务。

    springsecurity3.0.5应用

    Spring Security 是一个强大的和高度可定制的身份验证和访问控制框架，用于Java应用程序。在Spring Security 3.0.5版本中，它提供了许多关键的安全特性，包括用户认证、权限控制、CSRF防护、会话管理等。这个版本是...

    spring security 3 源代码 不包含书，pets应用

    Spring Security 是一个强大的Java安全框架，用于保护基于Spring的应用程序。它提供了全面的身份验证、授权和访问控制功能，使得开发者可以轻松地实现安全控制。在Spring Security 3版本中，这个框架已经相当成熟，...

    Spring Security3 安全 个人总结

    Spring Security3 是一个基于 Java 的安全框架，提供了一个灵活的安全机制来保护基于 Spring 的应用程序。在这个总结中，我们将详细介绍 Spring Security3 的安全机制、原理和核心组件。 认证管理器 认证管理器是...

    Spring Security 3多用户登录实现一

    Spring Security 是一个强大的、高度可定制的身份验证和访问控制框架，广泛应用于Java EE平台上的安全解决方案。在本文中，我们将深入探讨如何在Spring Security 3中实现多用户登录功能。首先，我们需要理解Spring ...

    springSecurity 实现传参

    Spring Security 是一个强大的和高度可定制的身份验证和访问控制框架，用于Java应用程序。在这个场景中，我们关注的是如何使用Spring Security实现登录验证以及在登录过程中传递参数，特别是记录并返回用户登录前的...

    基于 Spring Boot 3Spring Security 6Vue.js 3 的前后端分离式论坛系统

    Spring Security 是一个全面的安全框架，用于保护基于Spring的应用。Spring Security 6 可能包括改进的身份验证和授权机制、支持最新的OAuth2标准以及增强的加密和安全配置选项。在这个论坛系统中，它扮演着核心角色...

    精彩：Spring Security 演讲PPT

    Spring Security 是一个功能强大的安全框架，可以为基于Java的应用程序提供认证(Authentication)、授权(Authorization)等功能，同时提供了丰富的配置选项来满足不同的应用场景需求。 #### 二、传统Web应用安全开发...

    Spring_Security_3应用的11个步骤.docx

    Spring_Security_3应用的11个步骤.docx

    spring-security3 配置和使用

    Spring Security 3 配置和使用 Spring Security 是一个强大且灵活的安全框架，旨在保护基于 Java 的 Web 应用程序。...通过以上步骤，我们便可以成功地配置和使用 Spring Security 3 来保护我们的 Web 应用程序。

    spring boot3.x结合spring security最新版实现jwt登录验证

    在现代Web应用开发中，Spring Boot和Spring Security是两个非常重要的框架。Spring Boot简化了Spring应用的初始搭建以及开发过程，而Spring Security则为应用程序提供了全面的安全管理解决方案。本教程将详细讲解...

    SpringBoot+SpringSecurity+WebSocket

    在IT行业中，SpringBoot、SpringSecurity和WebSocket是三个非常重要的技术组件，它们分别在应用程序开发、安全管理和实时通信方面发挥着关键作用。本项目结合这三个技术，构建了一个整合的示例，旨在展示如何在...

    狂神Spring Security静态资源

    Spring Security 是一个强大的安全框架，主要用于Java Web应用的安全管理，包括认证、授权和访问控制等。在Spring Boot中，Spring Security 提供了简洁的API和自动化配置，使得开发者能够快速集成安全功能。在这个名...

    Spring-Security-3应用的11个步骤.docx

    总之，Spring Security 3.x 提供了一个强大而全面的安全框架，能够帮助开发者快速、安全地实现应用程序的认证和授权。通过理解其核心概念和配置流程，可以有效地保护你的Java应用免受潜在的安全威胁。

    Spring security oauth源码

    Spring Security OAuth 是一个用于保护RESTful Web服务的框架，它为OAuth 1.0a和OAuth 2.0协议提供了全面的支持。在这个源码中，我们可能会看到如何将Spring Security与OAuth结合，以构建安全的Web应用程序和服务。...

    Spring Security3

    Spring Security 是一个强大的且高度可定制的身份验证和访问控制框架，它为基于 Java 的应用程序提供了广泛的保护机制。Spring Security 3 版本在此基础上进一步增强了其安全性功能，并优化了用户体验。 #### 二、...

    spring security实现动态授权

    Spring Security 是一个强大的安全框架，用于为Java应用提供安全控制。在传统的权限管理中，权限配置通常硬编码在应用程序中，这使得权限调整变得困难，每次变动都需要重新部署应用。然而，通过动态授权，我们可以将...

    利用spring security控制同一个用户只能一次登陆

    标题中的“利用Spring Security控制同一个用户只能一次登录”是指在基于Spring Security的Web应用程序中实现单点登录（Single Sign-On, SSO）的功能，确保同一时间只有一个设备或浏览器会话可以登录同一用户的账户。...

Magicbox
Global site tag (gtag.js) - Google Analytics