Spring-security框架

spring-security框架

1. 概述
    spring-security一个能够为基于Spring的企业应用系统提供声明式的安全訪问控制解决方式的安全框架
    简单的说就是一个常用于后台控制权限的框架
    主要分为:用户认证,用户授权两部分

2. 快速入门
    1. 入门准备
        1.1 导入依赖jar包
            spring-security-web
            spring-security-config
            spring-security-taglibs(在jsp中引入可以在jsp页面进行权限认证并对页面进行限制)
            spring-security-core

        1.2 在web.xml中创建filter以及listener

            * listener与context-param是为了在web项目运行的时候加载spring-security的配置文件,交给spring管理对象

            <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-security.xml</param-value>
            </context-param>

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

           * filter是为了拦截url,可以进行后续的用户认证以及用户权限管理 
           * 特别注意: springSecurityFilterChain这个名字不能更改. 因为源码中在加载时名字写死了是这个

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

        1.3 在spring-security.xml中配置核心文件

        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
            xmlns:security="http://www.springframework.org/schema/security"
            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.xsd          
            http://www.springframework.org/schema/security          
            http://www.springframework.org/schema/security/spring-security.xsd">

            <!--下面三个注解是配置后可以在controller上加来控制不同角色的访问权限-->
            <!--在spring-security.xml中开启jsr250的注解支持,使用这个注解需要导入依赖-->
            <!--<security:global-method-security jsr250-annotations="enabled"/>-->

            <!--在spring-security.xml中开启自带表达式的注解-->
            <!--<security:global-method-security pre-post-annotations="enabled"/>-->

            <!--开启@Secured注解-->
            <security:global-method-security secured-annotations="enabled"/>



            <!-- 配置不拦截的资源 -->
            <security:http pattern="/login.jsp" security="none"/>
            <security:http pattern="/failer.jsp" security="none"/>
            <security:http pattern="/css/**" security="none"/>
            <security:http pattern="/img/**" security="none"/>
            <security:http pattern="/plugins/**" security="none"/>

            <!-- 
            配置具体的规则 
            auto-config="true"    不用自己编写登录的页面，框架提供默认登录页面
            use-expressions="false"    是否使用SPEL表达式,当使用自带表达式时候,可以设置为true,access写为hasRole('ROLE_USER')
            可以使用||或者&&
            -->
            <security:http auto-config="true" use-expressions="false">
            <!-- 配置具体的拦截的规则 pattern="请求路径的规则" access="访问系统的人，必须有ROLE_USER的角色" -->
            <security:intercept-url pattern="/**" access="ROLE_USER,ROLE_ADMIN"/>

            <!-- 定义跳转的具体的页面
            login-processing-url为登录时候拦截的路径,要与form表单中的action相同
            default-target-url 默认权限认证通过时候的跳转页面
            -->
            <security:form-login  
                login-page="/login.jsp"
                login-processing-url="/login.do"
                default-target-url="/index.jsp"
                authentication-failure-url="/failer.jsp"
            />

            <!-- 关闭跨域请求 -->
            <security:csrf disabled="true"/>

            <!-- 退出的相关的方法,以及退出到的页面 -->
            <security:logout invalidate-session="true" logout-url="/logout.do" logout-success-url="/login.jsp" />

            </security:http>

            <!-- 切换成数据库中的用户名和密码 -->
            <security:authentication-manager>
            <security:authentication-provider user-service-ref="userService">
                <!-- 配置加密的方式,当数据库中存放的是明文的时候,不要加,并且验证时候在密码前加 {noop} -->
                <security:password-encoder ref="passwordEncoder"/>
            </security:authentication-provider>
            </security:authentication-manager>

            <!-- 配置加密类 -->
            <bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>

            <!-- 提供了入门的方式，在内存中存入用户名和密码 ,而通常来说,这些应该放置在数据库中
            <security:authentication-manager>
            <security:authentication-provider>
                <security:user-service>
                    <security:user name="admin" password="{noop}admin" authorities="ROLE_USER"/>
                </security:user-service>
            </security:authentication-provider>
            </security:authentication-manager>
            -->
            <!--当使用自带表达式的注解的时候,开启对表达式的支持,或者配置一个下面的bean-->
            <bean id="webexpressionHandler"
              class="org.springframework.security.web.access.expression.DefaultWebSecurityExpressionHandler"/>


        </beans>
    2. 配置完毕后,运行项目.
    spring-security会拦截病跳转到一个验证的页面,当配置了登陆界面时,会跳转到自定义的页面.输入正确的username与password时即可

3. 部分详解
    1. 自定义service实现验证步骤
        spring-security定义了一系列的接口,并且代替了mvc中的controller,我们只需实现service层以及dao层的代码即可
        1.1 service层的实现
            * 定义一个接口 extends UserDetailsService
              ps:为了扩展性,所以先使用接口集成UserDetailsService
            * 实现自定义的接口并重写loadUserByUsername(String username)方法
            public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
                //查询出一个userInfo
                UserInfo userInfo = null;
                try {
                     userInfo = userDao.findByUsername(username);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //将自己的对象封装成为UserDetails
                //User是UserDetails的一个实现类
                //不对userinfo中的status进行验证
                //User user = new User(userInfo.getUsername(),"{noop}"+userInfo.getPassword(),getAuthorities(userInfo.getRoles()));
                //对userinfo中的status进行验证未加密
                //User user = new User(userInfo.getUsername(),"{noop}"+userInfo.getPassword(),userInfo.getStatus()==1?true:false,
                //加密后的不用加noop
                User user = new User(userInfo.getUsername(),userInfo.getPassword(),userInfo.getStatus()==1?true:false,
                    true,true,true,getAuthorities(userInfo.getRoles()));
                return user;
                }

                public List<SimpleGrantedAuthority> getAuthorities(List<Role> roles){
                List<SimpleGrantedAuthority> list = new ArrayList<SimpleGrantedAuthority>();
                for (Role role : roles) {
                    list.add(new SimpleGrantedAuthority("ROLE_"+role.getRoleName()));
                }
                return list;
                }

    2.服务器端方法级权限控制
        * 开启注解
            配置文件
            <security:global-method-security jsr250-annotations="enabled"/>
            <security:global-method-security secured-annotations="enabled"/>
            <security:global-method-security pre-post-annotations="disabled"/>
            注解开启
            @EnableGlobalMethodSecurity:Spring Security默认是禁用注解的，要想开启注解，需要在继承
            WebSecurityConfigurerAdapter的类上加 @EnableGlobalMethodSecurity注解并将AuthenticationManager定义为Bean。

        * jsr250注解

            @RolesAllowed表示访问对应方法时所应该具有的角色
                示例: @RolesAllowed({"USER", "ADMIN"}) 该方法只要具有"USER", "ADMIN"任意一种权限就可以访问。
                这里可以省略前缀ROLE_，实际的权限可能是ROLE_ADMIN
            @PermitAll表示允许所有的角色进行访问，也就是说不进行权限控制
            @DenyAll是和PermitAll相反的，表示无论什么角色都不能访问

            常用写法:
                @RolesAllowed("ADMIN")

        * 支持表达式的注解
            * 表达式注解需要开启表达式的支持
            <!--当使用自带表达式的注解的时候,开启对表达式的支持,或者配置一个下面的bean-->
                <bean id="webexpressionHandler"
              class="org.springframework.security.web.access.expression.DefaultWebSecurityExpressionHandler"/>

            @PreAuthorize 在方法调用之前,基于表达式的计算结果来限制对方法的访问
                示例:
                @PreAuthorize("#userId == authentication.principal.userId or hasAuthority(‘ADMIN’)")
                void changePassword(@P("userId") long userId ){... }
                这里表示在changePassword方法执行之前，判断方法参数userId的值是否等于principal中保存的当前用户的userId，
                或者当前用户是否具有ROLE_ADMIN权限，两种符合其一，就可以访问该方法。
            @PostAuthorize 允许方法调用,但是如果表达式计算结果为false,将抛出一个安全性异常
                示例:
                    @PostAuthorize
                User getUser("returnObject.userId == authentication.principal.userId or hasPermission(returnObject, 'ADMIN')");
            @PostFilter 允许方法调用,但必须按照表达式来过滤方法的结果
            @PreFilter 允许方法调用,但必须在进入方法之前过滤输入值

            Authentication可以简单理解为: 存储的认证对象
            Principle 可以简单理解为：　在认证对象中存储的用户对象．


            常用写法:
                @PreAuthorize("authentication.principal.username == 'tom'")    //用户名是否为tom
                @PreAuthorize(hasRole('ROLE_ADMIN')")//用户是否具有ROLE_ADMIN角色,这里的ROLE_不能省略
        * @Secured注解
            @Secured注解标注的方法进行权限控制的支持，其值默认为disabled
                常用写法:
                    @Secured("ROLE_USER")
                    public Account readAccount(Long id);

    3.页面权限标签
        * 先引入taglib
            <%@taglib prefix="security" uri="http://www.springframework.org/security/tags" %>

        * 在jsp中我们可以使用以下三种标签来控制权限
            authentication
                <security:authentication property="" htmlEscape="" scope="" var=""/> 
                注意property=""中的值,多写为 principal.username

                property： 只允许指定Authentication所拥有的属性，可以进行属性的级联获取，如principal.username
                不允许直接通过方法进行调用
                htmlEscape：表示是否需要将html进行转义。默认为true。
                scope：与var属性一起使用，用于指定存放获取的结果的属性名的作用范围，默认我pageContext。Jsp中拥
                有的作用范围都进行进行指定
                var： 用于指定一个属性名，这样当获取到了authentication的相关信息后会将其以var指定的属性名进行存
                放，默认是存放在pageConext中

                常用写法:
                <security:authentication property="principal.username"/>

            authorize
                <security:authorize access="" method="" url="" var=""></security:authorize>

                access： 需要使用表达式来判断权限，当表达式的返回结果为true时表示拥有对应的权限
                method：method属性是配合url属性一起使用的，表示用户应当具有指定url指定method访问的权限，
                method的默认值为GET，可选值为http请求的7种方法
                url：url表示如果用户拥有访问指定url的权限即表示可以显示authorize标签包含的内容
                var：用于指定将权限鉴定的结果存放在pageContext的哪个属性中


                常用写法:
                <security:authorize access="hasRole('ADMIN')"></security:authorize>

            accesscontrollist
                accesscontrollist标签是用于鉴定ACL权限的。其一共定义了三个属性：hasPermission、domainObject和var，
                其中前两个是必须指定的
                <security:accesscontrollist hasPermission="" domainObject="" var=""></security:accesscontrollist>

                hasPermission：hasPermission属性用于指定以逗号分隔的权限列表
                domainObject：domainObject用于指定对应的域对象
                var：var则是用以将鉴定的结果以指定的属性名存入pageContext中，以供同一页面的其它地方使用