权限控制之Spirng Security框架

最新推荐文章于 2023-07-21 18:29:58 发布

嘿嘿嘿1212

最新推荐文章于 2023-07-21 18:29:58 发布

阅读量342

点赞数

分类专栏： java技术要点文章标签： Spring Security 权限控制快速入门

本文链接：https://blog.csdn.net/at10090/article/details/102768221

版权

java技术要点专栏收录该内容

14 篇文章 1 订阅

订阅专栏

1. Spring Security简介

Spring Security是 Spring提供的安全认证服务的框架。使用Spring Security可以帮助我们来简化认证和授权的过程。官网：https://spring.io/projects/spring-security,Spring Security是基于Filter(过滤器实现)

在这里插入图片描述

对应的maven坐标：

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

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

常用的权限框架除了Spring Security，还有Apache的shiro框架。

3.4 Spring Security入门案例

3.4.1 工程搭建

创建maven工程，打包方式为war，为了方便起见我们可以让入门案例工程依赖health_interface，这样相关的依赖都继承过来了,实际上导入的坐标。Spring Security是基于Filter(过滤器实现)

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheiheihei</groupId>
    <artifactId>springsecuritydemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>springsecuritydemo Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.itheiheihei</groupId>
            <artifactId>health_interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <configuration>
                    <!-- 指定端口 -->
                    <port>85</port>
                    <!-- 请求路径 -->
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

提供index.html页面，内容为hello Spring Security!!

3.4.2 配置web.xml

在web.xml中主要配置SpringMVC的DispatcherServlet和用于整合第三方框架的DelegatingFilterProxy，用于整合Spring Security。Spring Security是基于Filter(过滤器实现)

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <filter>
        <!-- DelegatingFilterProxy用于整合第三方框架
        整合Spring Security时过滤器的名称必须为springSecurityFilterChain，否则会抛出NoSuchBeanDefinitionException异常-->
        <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>
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 指定加载的配置文件 ，通过参数contextConfigLocation加载 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-security.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

3.4.3 配置spring-security.xml

在spring-security.xml中主要配置Spring Security的拦截规则和认证管理器。
Spring Security是基于Filter(过滤器实现)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:security="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/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://code.alibabatech.com/schema/dubbo
            http://code.alibabatech.com/schema/dubbo/dubbo.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/security
            http://www.springframework.org/schema/security/spring-security.xsd">
    <!--
    http:用于定义相关权限控制
    auto-config:是否自动配置
    设置true时框架会提供默认的一些设置,例如提供的登陆页面,登出处理等
    设置false时需要显示提供登陆表单配置,否则会报
    use-expressions:用于指定intercept-url中access属性是否使用表达式
    -->
    <security:http auto-config="true" use-expressions="true">
        <!--
        intercept-url:定义一个拦截规则
        pattern:对那些url进行权限控制
        access:在请求对应的URL时需要什么权限,默认配置时它应该是一个以逗号分隔的角色列表
        ,请求的用户只需要拥有其中的一个角色就能完成访问对应的URL
        -->
        <security:intercept-url pattern="/**" access="hasRole('ROLE_ADMIN')"/>
    </security:http>
    <!--authentication-manager:认证管理器,用于处理认证操作-->
    <security:authentication-manager>
        <!--authentication-provider:认证提供者,执行具体的认证逻辑-->
        <security:authentication-provider>
            <!--
            user-service:用于获取用户信息,提供给authentication
            provider:进行认证
            -->
            <security:user-service>
                <!--
                user:定义用户信息,可以指定用户名,密码,角色,后期可以改为从数据库查询用户信息
                {noop}:表示当前使用的密码为明文
                -->
                <security:user name="admin" password="{noop}1234" authorities="ROLE_ADMIN"/>
            </security:user-service>
        </security:authentication-provider>
    </security:authentication-manager>
</beans>

补充:hasAndRole等方法本质是一样的(调用同一方法)

3.5 对入门案例改进

前面我们已经完成了Spring Security的入门案例，通过入门案例我们可以看到，Spring Security将我们项目中的所有资源都保护了起来，要访问这些资源必须要完成认证而且需要具有ROLE_ADMIN角色。

但是入门案例中的使用方法离我们真实生产环境还差很远，还存在如下一些问题：

项目中我们将所有的资源（所有请求URL）都保护起来，实际环境下往往有一些资源不需要认证也可以访问，也就是可以匿名访问。
登录页面是由框架生成的，而我们的项目往往会使用自己的登录页面。
直接将用户名和密码配置在了配置文件中，而真实生产环境下的用户名和密码往往保存在数据库中。
在配置文件中配置的密码使用明文，这非常不安全，而真实生产环境下密码需要进行加密。

本章需要对这些问题进行改进。Spring Security是基于Filter(过滤器实现)

3.5.1 配置可匿名访问的资源(建议叫放行)

第一步：在项目中创建pages目录，在pages目录中创建a.html和b.html

第二步：在spring-security.xml文件中配置，指定哪些资源可以匿名访问,但是不能够获取匿名账号

<!--
http：用于定义相关权限控制
security:是否开启安全保护
pattern:拦截拦截,可以使用通配符表达式
-->
<security:http security="none" pattern="/pages/a.html"/>
<security:http security="none" pattern="/pages/b.html"/>
<!--可以无权限访问在pages目录下的资源-->
<security:http security="none" pattern="/pages/**"/>

注意:/**是放行下面的所有资源

通过上面的配置可以发现，pages目录下的文件可以在没有认证的情况下任意访问。
在<security:http auto-config="true" use-expressions="true">中的<security:intercept-url pattern="/路径" access="isAnonymous()"/>具有同一效果,但是可以获取到匿名账号

3.5.2 使用指定的登录页面

第一步：提供login.html作为项目的登录页面

 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
<form action="/login.do" method="post">
    username：<input type="text" name="username"><br>
    password：<input type="password" name="password"><br>
    <input type="submit" value="登陆">
</form>
</body>
</html>

第二步：修改spring-security.xml文件，指定login.html页面可以匿名访问

<security:http security="none" pattern="/login.html" />

第三步：修改spring-security.xml文件，加入表单登录信息的配置

<!--如果我们要使用自己指定的页面作为登录页面,必须配置登录表单,页面提交的登录表单请求是由框架负责处理-->
<!--
login-page:指定登录页面
username-parameter:绑定表单提交的账号
password-parameter:绑定表单提交的密码
login-processing-url:登录处理的URL
default-target-url:默认目标的URL
authentication-failure-url:权限验证失败跳转的URL
-->
<security:form-login
        login-page="/login.html"
        username-parameter="username"
        password-parameter="password"
        login-processing-url="/login.do"
        default-target-url="/index.html"
        authentication-failure-url="/login.html"
/>

注意:需要在<security:http></security:http>中进行配置

第四步：修改spring-security.xml文件，关闭CsrfFilter过滤器

 <!--
csrf:对应CsrfFilter过滤器
disabled:是否启用CsrfFilter过滤器,如果使用自定义登录页面需要关闭,
否则登录操作会被禁止报错(403)
Spring security默认登录页面存在隐藏域进行验证是否是默认页面,而使用自定义时没有,这时security将会认为不安全
-->
<security:csrf disabled="true"/>

注意:也是在<security:http></security:http>中进行配置,这是进行跨越请求的放行

3.5.3 从数据库查询用户信息

如果我们要从数据库动态查询用户信息，就必须按照spring security框架的要求提供一个实现UserDetailsService接口的实现类，并按照框架的要求进行配置即可。框架会自动调用实现类中的方法并自动进行密码校验。

实现类代码：

package com.itheiheihei.service;

import com.itheiheihei.pojo.User;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

import java.util.*;

/**
 * @author 嘿嘿嘿1212
 * @version 1.0
 * @date 2019/10/23 11:17
 */
public class SpringSecurityUserService implements UserDetailsService {

    public static Map<String, User> map = new HashMap<>();


    static {
        //模拟数据库信息
        com.itheiheihei.pojo.User user1 = new com.itheiheihei.pojo.User();
        user1.setUsername("admin");
        user1.setPassword("admin");

        com.itheiheihei.pojo.User user2 = new com.itheiheihei.pojo.User();
        user2.setUsername("xiaoming");
        user2.setPassword("1234");

        map.put(user1.getUsername(), user1);
        map.put(user2.getUsername(), user2);
    }

    /**
     * 根据用户名加载用户信息
     *
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        System.out.println("用户输入的用户名为" + username);
        //判空
        if (username == null) {
            return null;
        } else {
        	//模拟查询数据库
            User userInDb = map.get(username);
            //查询数据库是否为空
            if (userInDb == null) {
                return null;
            }
            //模拟数据库中的密码,需要查询数据库
            String passwordInDb = "{noop}" + userInDb.getPassword();


            List<GrantedAuthority> list = new ArrayList<>();
            //授权,需要改成查询数据库动态获取用户拥有的权限和角色
            list.add(new SimpleGrantedAuthority("permission_a"));
            list.add(new SimpleGrantedAuthority("permission_b"));
            //根据用户授予角色
            if ("admin".equals(username)) {
                //授予角色
                list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
            }
            org.springframework.security.core.userdetails.User securityUser = 
            new org.springframework.security.core.userdetails.User(username, passwordInDb, list);
            return securityUser;
        }
    }
}

spring-security.xml：

<!--authentication-manager:认证管理器,用于处理认证操作-->
    <security:authentication-manager>
        <!--authentication-provider:认证提供者,执行具体的认证逻辑-->
        <security:authentication-provider user-service-ref="userService">  
        </security:authentication-provider>
    </security:authentication-manager>
    <bean id="userService" class="com.itheiheihei.service.SpringSecurityUserService"/>

注意:处理类需要实现UserDetailsService接口,并在认证管理器中配置<security:authentication-provider user-service-ref="userService">

本章提供了UserService实现类，并且按照框架的要求实现了UserDetailsService接口。在spring配置文件中注册UserService，指定其作为认证过程中根据用户名查询用户信息的处理类。当我们进行登录操作时，spring security框架会调用UserService的loadUserByUsername方法查询用户信息，并根据此方法中提供的密码和用户页面输入的密码进行比对来实现认证操作。

3.5.4 对密码进行加密

前面我们使用的密码都是明文的，这是非常不安全的。一般情况下用户的密码需要进行加密后再保存到数据库中。

常见的密码加密方式有：

3DES、AES、DES：使用对称加密算法，可以通过解密来还原出原始密码
MD5、SHA1：使用单向HASH算法，无法通过计算还原出原始密码，但是可以建立彩虹表进行查表破解
bcrypt：将salt随机并混入最终加密后的密码，验证时也无需单独提供之前的salt，从而无需单独处理salt问题

加密后的格式一般为：

$2a$10$/bTVvqqlH9UiE0ZJZ7N2Me3RIgUCdgMheyTgV0B4cMCSokPa.6oCa

加密后字符串的长度为固定的60位。其中：$是分割符，无意义；2a是bcrypt加密版本号；10是cost的值；而后的前22位是salt值；再然后的字符串就是密码的密文了。

实现步骤：

第一步：在spring-security.xml文件中指定密码加密对象

<!--配置密码加密对象-->
<bean id="passwordEncoder"
class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder" />
	<!--认证管理器，用于处理认证操作-->
	<security:authentication-manager>
		<!--认证提供者，执行具体的认证逻辑--> 
		<security:authentication-provider user-service-ref="userService">
			<!--指定密码加密策略-->
			<security:password-encoder ref="passwordEncoder" /> 
		</security:authentication-provider>
	</security:authentication-manager>
<!--开启spring注解使用-->
<context:annotation-config></context:annotation-config>

第二步：修改UserService实现类

package com.itheiheihei.service;

import com.itheiheihei.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

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

/**
 * @author 嘿嘿嘿1212
 * @version 1.0
 * @date 2019/10/23 11:17
 */
public class SpringSecurityUserService2 implements UserDetailsService {

    //模拟数据库中的用户数据
    public static Map<String, User> map = new HashMap<>();


    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    public void initUserData() {
        User user1 = new User();
        user1.setUsername("admin");
        user1.setPassword(bCryptPasswordEncoder.encode("admin"));
        User user2 = new User();
        user2.setUsername("xiaoming");
        user2.setPassword(bCryptPasswordEncoder.encode("1234"));
        map.put(user1.getUsername(), user1);
        map.put(user2.getUsername(), user2);
    }

    /**
     * 根据用户名加载用户信息
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        initUserData();
        System.out.println("用户输入的用户名为" + username);
        if (username == null) {
            return null;
        } else {
            //查询数据库
            User user = map.get(username);
            //根据用户名没有查询到用户
            if(user==null){
                return null;
            }
            //模拟获取数据库中的密码
            String password = user.getPassword();

            List<GrantedAuthority> list = new ArrayList<>();
            //授权,需要改为查询数据库动态获取用户拥有的权限和角色
            list.add(new SimpleGrantedAuthority("permission_a"));
            list.add(new SimpleGrantedAuthority("permission_b"));
            if ("admin".equals(username)) {
                //授予角色
                list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
            }
            org.springframework.security.core.userdetails.User securityUser = 
            new org.springframework.security.core.userdetails.User(username, password, list);
            return securityUser;
        }
    }
}

注意:返回Security的User时,在5.0.0版本以上,建议在密码前添加{bcrypt}即

 User securityUser =  new oUser(username, "{bcrypt}"+password, list);

可能不添加{bcrypt}会出现报错情况

3.5.5 配置多种校验规则

为了测试方便，首先在项目中创建a.html、b.html、c.html、d.html几个页面修改spring-security.xml文件：

<!--只要认证通过就可以访问-->
<security:intercept-url pattern="/index.html" access="isAuthenticated()"/>
<security:intercept-url pattern="/pages/a.html" access="isAuthenticated()"/>

<!--拥有add权限就可以访问b.html页面-->
<security:intercept-url pattern="/pages/b.html" access="hasAuthority('add')"/>

<!--拥有ROLE_ADMIN角色就可以访问c.html页面-->
<security:intercept-url pattern="/pages/c.html" access="hasRole('ROLE_ADMIN')"/>

<!--拥有ROLE_ADMIN角色就可以访问d.html页面，注意：此处虽然写的是ADMIN角色，框架会自动加上前缀ROLE_-->
<security:intercept-url pattern="/pages/d.html" access="hasRole('ADMIN')"/>
<!--拥有ROLE_ADMIN角色就可以访问所有页面了,但是不包括被单独赋予了访问权限的URL-->
<security:intercept-url pattern="/**" access="hasRole('ROLE_ADMIN')"/>

注意:Spring security框架根据配置顺序给予URL添加访问权限,如果同一URL被赋予两次,将以先赋予的权限为准,在配置文件中表现为后赋予URL权限的<security:intercept-url>无效

3.5.6 注解方式权限控制

Spring Security除了可以在配置文件中配置权限校验规则，还可以使用注解方式控制类中方法的调用。例如Controller中的某个方法要求必须具有某个权限才可以访问，此时就可以使用Spring Security框架提供的注解方式进行控制。

实现步骤：

第一步：在spring-security.xml文件中配置组件扫描，用于扫描Controller

<mvc:annotation-driven></mvc:annotation-driven> 
<context:component-scan base-package="com.itheiheihei.controller"> 
</context:component-scan>

第二步：在spring-security.xml文件中开启权限注解支持

<!--开启注解方式权限控制-->

<security:global-method-security pre-post-annotations="enabled" />

第三步：创建Controller类并在Controller的方法上加入注解进行权限控制

package com.itheiheihei.controller;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 嘿嘿嘿1212
 * @version 1.0
 * @date 2019/10/23 18:51
 */
@RestController
@RequestMapping("/hello")
public class HelloController {


    /**
     * 表示拥有add的权限,才能够调用当前方法
     * @return
     */
    @RequestMapping("/add")
    @PreAuthorize("hasAuthority('add')")
    public String add() {
        return "success";
    }

    /**
     * 表示必须拥有ADMIN角色才能够调用该方法
     * @return
     */
    @RequestMapping("/delete")
    @PreAuthorize("hasRole('ROLE_ADMIN')")
    public String delete() {
        return "delete";
    }
}

注意:如hasRole等授予角色或权限中带有And的方法,那么要求拥有其中角色组或权限组中一项权限或角色的用户即可访问

3.5.7 退出登录

用户完成登录后Spring Security框架会记录当前用户认证状态为已认证状态，即表示用户登录成功了。那用户如何退出登录呢？我们可以在spring-security.xml文件中进行如下配置：

<!--
logout：退出登录
logout-url：退出登录操作对应的请求路径
logout-success-url：退出登录后的跳转页面
-->
<security:logout 
logout-url="/logout.do" 
logout-success-url="/login.html" 
invalidate-session="true"
/>

通过上面的配置可以发现，如果用户要退出登录，只需要请求/logout.do这个URL地址就可以，同时会将当前session失效，最后页面会跳转到login.html页面。

Security 请求跨域问题

在其他域名的请求访问时,需要放开权限时,在请求上添加@CrossOrigin,并指定开放的域名,如果不写,将会默认为*即开放访问.

@CrossOrigin(value={"域名"})
@RequsetMaping("/被请求的URL")
public void add(){
	....
}

嘿嘿嘿1212

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录