权限控制（认证与授权_Spring Security入门案例）

最新推荐文章于 2024-04-21 16:56:00 发布

飞奔的嗨少

最新推荐文章于 2024-04-21 16:56:00 发布

阅读量960

点赞数

分类专栏： Java学习资源和工具

本文链接：https://blog.csdn.net/weixin_43908333/article/details/106871580

版权

Java学习资源和工具专栏收录该内容

25 篇文章 3 订阅

订阅专栏

一、认证和授权概念

前面我们已经完成了健康后台管理系统的部分功能，例如检查项管理、检查组管理、套餐管理、预约设置等。接下来我们需要思考2个问题：
问题1：在生产环境下我们如果不登录后台系统就可以完成这些功能操作吗？
答案显然是否定的，要操作这些功能必须首先登录到系统才可以。

问题2：是不是所有用户，只要登录成功就都可以操作所有功能呢？
答案是否定的，并不是所有的用户都可以操作这些功能。不同的用户可能拥有不同的权限，这就需要进行授权了。

认证：系统提供的用于识别用户身份的功能，用户名、密码进行登录其实就是认证，认证的目的是让系统知道你是谁。
授权：用户认证成功后，需要为用户授权，其实就是指定当前用户可以操作哪些功能。

二、权限模块数据模型

前面已经分析了认证和授权的概念，要实现最终的权限控制，需要有一套表结构支撑：
用户表t_user、权限表t_permission、角色表t_role、菜单表t_menu、用户角色关系表 t_user_role、角色权限关系表t_role_permission、角色菜单关系表t_role_menu。

用户表t_user

用户角色关系表 t_user_role

角色表t_role

角色菜单关系表t_role_menu

菜单表t_menu

角色权限关系表t_role_permission

权限表t_permission

表之间关系如下图：

通过上图可以看到，权限模块共涉及到7张表。在这7张表中，角色表起到了至关重要的作用，其处于核心位置，因为用户、权限、菜单都和角色是多对多关系。
接下来我们可以分析一下在认证和授权过程中分别会使用到哪些表：
认证过程：只需要用户表就可以了，在用户登录时可以查询用户表t_user进行校验，判断用户输入的用户名和密码是否正确。
授权过程：用户必须完成认证之后才可以进行授权，首先可以根据用户查询其角色，再根据角色查询对应的菜单，这样就确定了用户能够看到哪些菜单。然后再根据用户的角色查询对应的权限，这样就确定了用户拥有哪些权限。所以授权过程会用到上面7张表。

二、Spring Security简介

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

对应的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框架

三、Spring Security入门案例

`1.web工程搭建Spring Security入门案例`

创建maven工程，打包方式为war，为了方便起见我们可以让入门案例工程依赖 health_interface，这样相关的依赖都继承过来了。在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">
    <parent>
        <artifactId>health_parent</artifactId>
        <groupId>com.bianyiit</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springsecurity_demo</artifactId>
    <packaging>war</packaging>

    <name>springsecurity_demo 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.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.bianyiit</groupId>
            <artifactId>health_interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>springsecurity_demo</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <configuration>
                        <!-- 指定端口 -->
                        <port>85</port>
                        <!-- 请求路径 -->
                        <path>/</path>
                    </configuration>
                </plugin>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

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

`2.配置web.xml`

在web.xml中主要配置SpringMVC的DispatcherServlet和用于整合第三方框架的DelegatingFilterProxy，用于整合Spring Security。

<!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>
  <display-name>Archetype Created Web Application</display-name>
  <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.在resources下配置spring-security.xml`

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:security="http://www.springframework.org/schema/security"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
       
    <!--auto-config:自动配置，如果设置为true，表示自动应用一些默认配置，比如框架会提供一个默认的登录页面
        use-expressions:是否使用spring security提供的表达式来描述权限-->
    <security:http auto-config="true" use-expressions="true">
        <!--配置拦截规则，/** 表示拦截所有请求-->
        <!--pattern:描述拦截规则,asscess:指定所需的访问角色或者访问权限-->
        <security:intercept-url pattern="/**" access="hasRole('ROLE_ADMIN')"></security:intercept-url>
    </security:http>

    <!--配置认证管理器-->
    <security:authentication-manager>
        <!--配置认证提供者-->
        <security:authentication-provider>
            <!-- 配置一个具体的用户，后期需要从数据库查询用户  {noop}：表示当前使用的密码为明文-->
            <security:user-service>
                <security:user name="admin" password="{noop}1234" authorities="ROLE_ADMIN"/>
            </security:user-service>
        </security:authentication-provider>
    </security:authentication-manager>
 </beans>

`4.启动测试`

使用http://localhost:85/访问

四、对入门案例进行改进

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

但是入门案例中的使用方法离我们真实生产环境还差很远，还存在如下一些问题：
1、项目中我们将所有的资源（所有请求URL）都保护起来，实际环境下往往有一些资源不需要认证也可以访问，也就是可以匿名访问。
2、登录页面是由框架生成的，而我们的项目往往会使用自己的登录页面。
3、直接将用户名和密码配置在了配置文件中，而真实生产环境下的用户名和密码往往保存在数据库中。
4、在配置文件中配置的密码使用明文，这非常不安全，而真实生产环境下密码需要进行加密。
本章节需要对这些问题进行改进。

`1.配置可匿名访问的资源`

第一步：在项目中创建pages目录，在pages目录中创建a.html和b.html
第二步：在spring-security.xml文件中配置，指定哪些资源可以匿名访问

<!--配置资源可以匿名访问，就是不登录也可以访问-->
<security:http security="none" pattern="/pages/a.html"></security:http>
<security:http security="none" pattern="/pages/b.html"></security:http>
<!--以上两个配置也可以使用通配符进行访问-->
<security:http security="none" pattern="/pages/**"></security:http>

通过上面的配置可以发现，pages目录下的文件可以在没有认证的情况下任意访问。

`2.使用指定的登录页面`

第一步：在webapp目录下面定义login.html作为项目的登录页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录页面</title>
</head>
<body>
    <h3>自定义登录页面</h3>
    <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"></security:http>

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

<!--如果我们要使用自己的登录界面，必须配置登录表单-->
<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-forward-url="/login.html"/>

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

<!--由于我们自定义了登录界面，springSecurity默认是认为不安全的
    所以我们需要关闭CsrfFilter过滤器，否则登录操作会被禁用-->
<security:csrf disabled="true"></security:csrf>

此时的spring-security.xml文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:security="http://www.springframework.org/schema/security"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--以上两个配置也可以使用通配符进行访问-->
    <security:http security="none" pattern="/pages/**"></security:http>
    <security:http security="none" pattern="/login.html"></security:http>

    <!--auto-config:自动配置，如果设置为true，表示自动应用一些默认配置，比如框架会提供一个默认的登录页面
        use-expressions:是否使用spring security提供的表达式来描述权限-->
    <security:http auto-config="true" use-expressions="true">
        <!--配置拦截规则，/** 表示拦截所有请求-->
        <!--pattern:描述拦截规则,asscess:指定所需的访问角色或者访问权限-->
        <security:intercept-url pattern="/**" access="hasRole('ROLE_ADMIN')"></security:intercept-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-forward-url="/login.html"/>
        <!--由于我们自定义了登录界面，springSecurity默认是认为不安全的
            所以我们需要关闭CsrfFilter过滤器，否则登录操作会被禁用-->
        <security:csrf disabled="true"></security:csrf>
    </security:http>

    <!--配置认证管理器-->
    <security:authentication-manager>
        <!--配置认证提供者-->
        <security:authentication-provider>
            <!-- 配置一个具体的用户，后期需要从数据库查询用户  {noop}：表示当前使用的密码为明文-->
            <security:user-service>
                <security:user name="admin" password="{noop}1234" authorities="ROLE_ADMIN"/>
            </security:user-service>
        </security:authentication-provider>
    </security:authentication-manager>
 </beans>

3.启动测试
使用http://localhost:85/访问，此时pages下面的静态资源都可以访问到，并且用户可以webapp下的自定义的登录页面，当用户输入username=admin，password=1234，那么就可以登录成功显示hello Spring Security!!。

五、从数据库查询用户信息

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

UserService实现代码：

package com.oracle.service;

import com.oracle.pojo.UserInfo;
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.User;
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;

public class UserService implements UserDetailsService {
    //模拟向数据库中插入数据
    static Map<String, UserInfo> map=new HashMap<>();
    //创建两个用户，并且添加到map集合里面
    static {
        UserInfo userInfo1=new UserInfo("zs","123");
        UserInfo userInfo2=new UserInfo("ls","456");
        map.put(userInfo1.getUsername(),userInfo1);
        map.put(userInfo2.getUsername(),userInfo2);
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        System.out.println("username:"+username);  //接收前台传过来的username
        //模拟从数据库查询用户
        UserInfo userInfo = map.get(username);
        if(userInfo==null){
            return null;
        }
        //模拟查询数据库中用户的密码
        String password = "{noop}"+userInfo.getPassword();  
        List<GrantedAuthority> list = new ArrayList<>();
        //授权，后期需要改为查询数据库动态获得用户拥有的权限和角色
        list.add(new SimpleGrantedAuthority("add"));
        list.add(new SimpleGrantedAuthority("delete"));
        list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
        User user=new User(username,password,list);
        return user;
    }
}

UserInfo

public class UserInfo {
    String username;
    String password;

    public UserInfo(String username,String password){
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

代码目录结构：

spring-security.xml：

<!--配置认证管理器-->
<security:authentication-manager>
    <!--配置认证提供者-->
    <security:authentication-provider user-service-ref="userService">
   
    </security:authentication-provider>
</security:authentication-manager>
<!--配置bean-->
<bean id="userService" class="com.oracle.service.UserService"></bean>

六、对密码进行加密

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

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

加密后的格式一般为：

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

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

<!--配置认证管理器-->
<security:authentication-manager>
    <!--配置认证提供者-->
    <security:authentication-provider user-service-ref="userService">
        <!--指定加密策略-->
        <security:password-encoder ref="passwordEncoder"></security:password-encoder>
    </security:authentication-provider>
</security:authentication-manager>
<!--配置bean-->
<bean id="userService" class="com.oracle.service.UserService"></bean>
<!--配置加密对象-->
<bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"></bean>
<!--开启spring注解-->
<context:annotation-config></context:annotation-config>

第二步：修改UserService实现类

public class UserService implements UserDetailsService {

    @Autowired
    BCryptPasswordEncoder bCryptPasswordEncoder;


    //模拟向数据库中插入数据
    public Map<String, UserInfo> map = new HashMap<>();

    public void init(){
        UserInfo u1 = new UserInfo();
        u1.setUsername("admin");
        u1.setPassword(bCryptPasswordEncoder.encode("admin"));
        UserInfo u2 = new UserInfo();
        u2.setUsername("sunny");
        u2.setPassword(bCryptPasswordEncoder.encode("123"));
        map.put(u1.getUsername(),u1);
        map.put(u2.getUsername(),u2);
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        init();
        System.out.println("username:"+username);
        //模拟从数据库中查询用户
        UserInfo userInfo = map.get(username);
        if(userInfo==null){
            return null;
        }
        //模拟查询数据库中用户的密码  去掉明文标识{noop}
        String password = userInfo.getPassword();
        List<GrantedAuthority> list = new ArrayList<>();
        //授权，后期需要改为查询数据库动态获得用户拥有的权限和角色
        list.add(new SimpleGrantedAuthority("add"));
        list.add(new SimpleGrantedAuthority("delete"));
        list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
        User user = new User(username, password, list);
        return user;
    }
}

七、配置多种校验规则

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

<security:http auto-config="true" use-expressions="true">
    <!--配置多种校验规则-->
    <security:intercept-url pattern="/pages/a.html" access="isAuthenticated()"></security:intercept-url><!--只要认证通过就可以访问-->
    <security:intercept-url pattern="/pages/b.html" access="hasRole('add')"></security:intercept-url><!--拥有add权限的可以访问b页面-->
    <security:intercept-url pattern="/pages/c.html" access="hasRole('ROLE_ADMIN')"></security:intercept-url><!--拥有ROLE_ADMIN权限的可以访问c页面-->
    <!--拥有ROLE_ADMIN权限的可以访问b页面
        注意：虽然这里写的是ADMIN角色，但是框架会自动加上前缀ROLE_-->
    <security:intercept-url pattern="/pages/d.html" access="hasRole('ADMIN')"></security:intercept-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-forward-url="/login.html"/>
    <!--由于我们自定义了登录界面，springSecurity默认是认为不安全的
        所以我们需要关闭CsrfFilter过滤器，否则登录操作会被禁用-->
    <security:csrf disabled="true"></security:csrf>
</security:http>

为方便测试。改造UserService

package com.oracle.service;

import com.oracle.pojo.UserInfo;
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.User;
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;

public class UserService implements UserDetailsService {
   
    @Autowired
    BCryptPasswordEncoder bCryptPasswordEncoder;
    //模拟向数据库中插入数据
    public Map<String, UserInfo> map = new HashMap<>();

    /*初始化*/
    public void init(){
        UserInfo u1 = new UserInfo();
        u1.setUsername("zs");
        u1.setPassword(bCryptPasswordEncoder.encode("123"));
        UserInfo u2 = new UserInfo();
        u2.setUsername("ls");
        u2.setPassword(bCryptPasswordEncoder.encode("456"));
        map.put(u1.getUsername(),u1);
        map.put(u2.getUsername(),u2);
    }
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        init();
        //模拟从数据库查询用户
        UserInfo userInfo = map.get(username);
        if(userInfo==null){
            return null;
        }
        //模拟查询数据库中用户的密码
        String password = userInfo.getPassword();  //去掉明文标识{noop}
        List<GrantedAuthority> list = new ArrayList<>();
        //授权，后期需要改为查询数据库动态获得用户拥有的权限和角色
        if(username.equals("zs")){
            list.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
            list.add(new SimpleGrantedAuthority("add"));
        }
        User user=new User(username,password,list);
        return user;
    }
}

此时分别用zs用户ls用户登录测试效果。

八、注解方式权限控制

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

实现步骤：

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

<!--在spring-security.xml文件中配置组件扫描，用于扫描Controller-->
<mvc:annotation-driven></mvc:annotation-driven>
<context:component-scan base-package="com.oracle.controller"></context:component-scan>

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

<!--开启注解方式进行权限控制-->
<security:global-method-security pre-post-annotations="enabled"></security:global-method-security>

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

package com.oracle.controller;

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

@RestController
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/add")
    @PreAuthorize("hasAuthority('add')")//表示用户必须拥有add权限才能调用当 前方法     
    public String add(){
        System.out.println("add...");
        return "success";
    }

    @RequestMapping("/delete")
    @PreAuthorize("hasRole('ROLE_ADMIN')")//表示用户必须拥有ROLE_ADMIN角色 才能调用当前方法
    public String delete(){
        System.out.println("delete.....");
        return "success";
    }

}

此时分别用zs用户和ls用户登录测试效果。

九、退出登录

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

<!--退出登录-->
<security:logout logout-url="/logout.do"
                 logout-success-url="/login.html" invalidate-session="true"></security:logout>

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

使用管理员账户zs进登录

使用MD5对password进行加密

进入主页

管理员zs可以访问/hello/add.do

控制台打印方法名

退出登录

退出登录后返回登录界面

使用普通用户ls登陆

普通用户同样可以通过登录进入主页index.html

由于没有给ls分配add权限，所以普通用户ls无法访问/hello/add.do，浏览器显示403

同样，由于由于没有给ls分配delete权限，所以普通用户ls无法访问/hello/add.do，浏览器显示403

退出登录

退出登录后返回登录界面

飞奔的嗨少

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
权限控制（认证与授权_Spring Security入门案例）

一、认证和授权概念前面我们已经完成了健康后台管理系统的部分功能，例如检查项管理、检查组管理、套餐管理、预约设置等。接下来我们需要思考2个问题：问题1：在生产环境下我们如果不登录后台系统就可以完成这些功能操作吗？答案显然是否定的，要操作这些功能必须首先登录到系统才可以。问题2：是不是所有用户，只要登录成功就都可以操作所有功能呢？答案是否定的，并不是所有的用户都可以操作这些功能。不同的用户可能拥有不同的权限，这就需要进行授权了。认证：系统提供的用于识别用户身份的功能，用户名、密码进行登录其实就是认证
复制链接

扫一扫