SpringSecurity和Shiro---权限设置

在 Web 开发中，安全一直是非常重要的一个方面。安全虽然属于应用的非功能性需求，但是应该在应用开发的初期就考虑进来。如果在应用开发的后期才考虑安全的问题，就可能陷入一个两难的境地：一方面，应用存在严重的安全漏洞，无法满足用户的要求，并可能造成用户的隐私数据被攻击者窃取；另一方面，应用的基本架构已经确定，要修复安全漏洞，可能需要对系统的架构做出比较重大的调整，因而需要更多的开发时间，影响应用的发布进程。因此，从应用开发的第一天就应该把安全相关的因素考虑进来，并在整个应用的开发过程中。

Spring Security 是针对Spring项目的安全框架，也是Spring Boot底层安全模块默认的技术选型，他可以实现强大的Web安全控制，对于安全控制，我们仅需要引入 spring-boot-starter-security 模块，进行少量的配置，即可实现强大的安全管理！

1.SpringSecurity

一、依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

二、主要的类：

• WebSecurityConfigurerAdapter：自定义Security策略

• AuthenticationManagerBuilder：自定义认证策略

• @EnableWebSecurity：开启WebSecurity模式（开启其他的配置，就是加@EnableWebSecurity这个注解）

Spring Security 主要的目标：认证和授权；

“授权” （Authorization）：定义权限

“认证”（Authentication）：给用户拥有的权限；

三、配置类：

SpringSecurity基础配置类：

package com.example.config;

import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

/**
 * @author Lenovo
 * @date 2023/5/13
 * @time 13:25
 * @project springboot_mybatis
 **/

@EnableWebSecurity //开启springsecurity;
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    //SpringSecurity定义的类：自己进行方法的重写

    //定义授权规则：
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
    }


    //进制权限认证：
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        super.configure(auth);
    }
}

SpringSecurity自己定义配置类：

package com.example.config;

import ch.qos.logback.core.joran.spi.DefaultNestedComponentRegistry;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

/**
 * @author Lenovo
 * @date 2023/5/13
 * @time 13:25
 * @project springboot_mybatis
 **/

@EnableWebSecurity //开启springsecurity;
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    //SpringSecurity定义的类：自己进行方法的重写


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //定义授权规则：给rule1、rule2 、rule3分别对应的权限：
        http.authorizeRequests().antMatchers("/").permitAll()
                .antMatchers("/rule1/**").hasRole("vip1")
                .antMatchers("/rule2/**").hasRole("vip2")
                .antMatchers("/rule3/**").hasRole("vip3");

        //开启自动配置的登录
        http.formLogin()
                .usernameParameter("username")//登录时的参数
                .passwordParameter("password")
                .loginPage("/toLogin") //去登录页
                .loginProcessingUrl("/login"); //登录成功后的页面

        //退出的配置：
        http.logout().logoutSuccessUrl("/");//退出后返回index页面；

        //记住我配置
        http.rememberMe().rememberMeParameter("remeber");
    }

    //进制权限认证：
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //连接数据库中进行用户权限认证： BCryptPasswordEncoder()进行密码的加密；
        auth.jdbcAuthentication().passwordEncoder(new BCryptPasswordEncoder())
                .withUser("jack").password(new BCryptPasswordEncoder().encode("123456")).roles("vip2","vip3")
                .and()
                .withUser("root").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2","vip3")
                .and()
                .withUser("guest").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1");

//注释，分别对不同的用户不同的权限：
    }
}

2.Shiro

Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。

主要功能：

Authentication：身份认证 / 登录，验证用户是不是拥有相应的身份；
Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；
Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通 JavaSE 环境的，也可以是如 Web 环境的；
Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
Web Support：Web 支持，可以非常容易的集成到 Web 环境；
Caching：缓存，比如用户登录后，其用户信息、拥有的角色 / 权限不必每次去查，这样可以提高效率；
Concurrency：shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；
Testing：提供测试支持；
Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
Remember Me：记住我。

1.主要组件：

三个核心组件：Subject, SecurityManager 和 Realms.
Subject：即“当前操作用户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是第三方进程、后台帐户（Daemon Account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。Subject代表了当前用户的安全操作，SecurityManager则管理所有用户的安全操作。
SecurityManager：它是Shiro框架的核心,Shiro通过SecurityManager来管理内部组件实例，并通过它来提供安全管理的各种服务。
Realm：
①Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。
②从这个意义上讲，Realm实质上是一个安全相关的DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro。当配置Shiro时，你必须至少指定一个Realm，用于认证和（或）授权。配置多个Realm是可以的，但是至少需要一个。
③Shiro内置了可以连接大量安全数据源（又名目录）的Realm，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果缺省的Realm不能满足需求，你还可以插入代表自定义数据源的自己的Realm实现。

2.配置依赖：

<dependencies>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>

3.配置类：

(1)配置log4j.properties:

log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n
log4j.logger.org.apache=WARN
log4j.logger.org.springframework=WARN
log4j.logger.org.apache.shiro=INFO
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN

(2)配置shrio.ini文件：

[users]
root = secret, admin
guest = guest, guest
presidentskroob = 12345, president
darkhelmet = ludicrousspeed, darkload, schwartz
lonestarr = veespa, goodguy, schwartz
[roles]
admin = *
schwartz = lightsaber:*
goodguy = winnebago:drive:eagle5

(3)快速开始：

第一步：获取当前的对象subject

第二步：通过当前用户拿到Session

第三步：判断当前用户是否被认证并且设置记住我和执行登录操作

第四步：测试角色

第五步：检测有什么样子的权限：粗粒度和细粒度

public class QuickStart {
    private static final transient Logger log = (Logger) LoggerFactory.getLogger(QuickStart.class);
    public static void main(String[] args) {
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("claspath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
        //获取当前的对象subject
        Subject currentUser = SecurityUtils.getSubject();
        //通过当前用户拿到Session
        Session session = currentUser.getSession();
        session.setAttribute("someKey","aValue");
        String value = (String) session.getAttribute("someKey");
        if(value.equals("aValue")){
            log.info("Subject**>session["+value+"]");
        }
        //判断当前用户是否被认证
        if (!currentUser.isAuthenticated()){
            //Token:令牌
            UsernamePasswordToken token = new UsernamePasswordToken("lonestarr","vespa");
            token.setRememberMe(true);//设置记住我
            //执行登录操作
            try {
                currentUser.login(token);
            }catch (UnknownAccountException uae){
                log.info("没有"+token.getPrincipal()+"这个用户名");
            }catch (IncorrectCredentialsException ice){
                log.info(token.getPrincipal()+"的密码错误");
            }catch (LockedAccountException lae){
                log.info(token.getPrincipal()+"被锁定");
            }
        }
        //测试角色
        if (currentUser.hasRole("schwartz")){
            log.info("角色通过");
        }else{
            log.info("角色有误");
        }
        //检测有什么样子的权限：粗粒度
        if (currentUser.isPermitted("lightsaber:*")){
            log.info("你可以用lightsaber");
        }else{
            log.info("你不可以用lightsaber");
        }
        //检测有什么样子的权限：细粒度
        if (currentUser.isPermitted("winnebago:drive:eagle5")){
            log.info("你可以drive eagle5");
        }else{
            log.info("你不可以drive eagle5");
        }
        //注销
        currentUser.logout();
        //关闭系统
        System.exit(0);
    }
}

（4):SpringBoot整合Shiro：

1): 导入依赖：

      <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.11.0</version>
        </dependency>

2）：创建Shiro中三个Bean对象：

package com.example.config;

import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @author Lenovo
 * @date 2023/5/13
 * @time 16:24
 * @project springboot_mybatis
 **/


/**
 * Shiro的三个组件：subject、SecurityManager、Realm
 */

@Configuration
public class ShiroConfig {

    //3.ShiroFilterFactoryBean对象；
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);

        return shiroFilterFactoryBean;
    }


    //2.DefaultWebSecurityManager
    @Bean(name = "securityManager") //自定义Bean的名字
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        //关联UserRealm:
        securityManager.setRealm(userRealm);
        return securityManager;
    }

    //1.创建Realm对象；
    @Bean
    public UserRealm userRealm(){
        return new UserRealm();
    }
    

}

创建UserRealm对象：

package com.example.config;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

/**
 * @author Lenovo
 * @date 2023/5/13
 * @time 16:34
 * @project springboot_mybatis
 **/

/**
 * 自定义Realm对象
 */
public class UserRealm  extends AuthorizingRealm {

    //授权的过程
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("执行授权。。。");
        return null;
    }

    //认证的过程：
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("执行认证。。。");

        return null;
    }
}

3）：认证与授权：后面补充

认证：

授权：