SpringBoot集成Shiro安全框架

最新推荐文章于 2024-04-10 10:50:21 发布
最新推荐文章于 2024-04-10 10:50:21 发布
阅读量5.1k 收藏 214
点赞数 40
分类专栏： SpringBoot学习 文章标签： shiro
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33922980/article/details/91984897
版权

SpringBoot集成Shiro安全框架

1.shiro的定义

1.shiro的作用
认证、授权、加密、会话管理、Web集成、缓存

2.shiro的名词
在这里插入图片描述

Authentication:身份认证/登录，验证用户是不是拥有相应的身份
Authorization：授权，即权限 管理，验证某个人已经登录的人是否拥有某些权限
Session Management：会话管理，即用户登录后就是一次会话，在没有退出之前所有的信息都是在会话中。。
Cryptography：加密，保护数据的安全性，密码加密
Web Support：Web支持，可以非常容易的集成到web环境
Caching:缓存，比如用户登录之后，他的用户信息，权限不必每次去查
Concurrency:shiro支持多线程应用兵法验证，即如果在一个线程中开启另外一个线程，权限会自动传递过去
Testing:提供测试支持
Run AS:允许一个用户假装另一个用户(如果他们允许)的身份进行访问
Remember Me:记住我，这是一个常见的功能，即一次登录后，下次再来的话就不用登录了
记住一点，Shiro不会去维护用户、维护权限:这些需要我们自己去设计/提供，然后通过相应的接口注入给Shiro即可！

3.shiro的架构
在这里插入图片描述
Subject，Subject其实代表的就是当前正在执行操作的用户，只不过因为“User”一般指代人，但是一个“Subject”可以是人，也可以是任何的第三方系统，服务账号等任何其他正在和当前系统交互的第三方软件系统。
所有的Subject实例都被绑定到一个SecurityManager，如果你和一个Subject交互，所有的交互动作都会被转换成Subject与SecurityManager的交互。

SecurityManager。SecurityManager是Shiro的核心，他主要用于协调Shiro内部各种安全组件，不过我们一般不用太关心SecurityManager，对于应用程序开发者来说，主要还是使用Subject的API来处理各种安全验证逻辑。

Realm，这是用于连接Shiro和客户系统的用户数据的桥梁。一旦Shiro真正需要访问各种安全相关的数据（比如使用用户账户来做用户身份验证以及权限验证）时，他总是通过调用系统配置的各种Realm来读取数据。
在这里插入图片描述

2.SpringBoot集成shiro的步骤

1.添加maven依赖

 <!-- shiro整合springboot所需相关依赖-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>
        <!-- 兼容于thymeleaf的shiro -->
        <dependency>
            <groupId>com.github.theborakompanioni</groupId>
            <artifactId>thymeleaf-extras-shiro</artifactId>
            <version>2.0.0</version>
        </dependency>
        <!--end.......-->

2.新建缓存文件
ehcache-shiro.xml


<ehcache updateCheck="false" name="cacheManagerConfigFile">

    <!--
       name:缓存名称。
       maxElementsInMemory：缓存最大个数。
       eternal:对象是否永久有效，一但设置了，timeout将不起作用。
       timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
       timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
       overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
       diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
       maxElementsOnDisk：硬盘最大缓存个数。
       diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
       diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
       memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
       clearOnFlush：内存数量最大时是否清除。
   -->

    <defaultCache maxElementsInMemory="10000" eternal="false"
                  timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="false"
                  diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
                  memoryStoreEvictionPolicy="LRU"/>

    <!-- 登录记录程序锁定1分钟 -->
    <cache name="shiro-activeSessionCache" eternal="false"
           maxElementsInMemory="10000" overflowToDisk="false" timeToIdleSeconds="0"
           timeToLiveSeconds="0" statistics="true"/>
</ehcache>

3.重要的shiro配置类
不需要完全记住，只需要修改其中的一小部分

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import org.apache.shiro.cache.ehcache.EhCacheManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator;
import org.apache.shiro.session.mgt.eis.MemorySessionDAO;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @ Author     ：Zgq
 * @ Date       ：Created in 18:22 2019/6/11
 * @ Description：shiro的配置类
 * @ Modified By：
 * @Version: $
 */
@Configuration
public class ShiroConfig {

    /**
    唯一需要修改的地方，有注释
     * ShiroFilterFactoryBean 处理拦截资源文件问题。
     * 注意：单独一个ShiroFilterFactoryBean配置是或报错的，
     * 因为在初始化ShiroFilterFactoryBean的时候需要注入：SecurityManager
     * Filter Chain定义说明
     * 1、一个URL可以配置多个Filter，使用逗号分隔
     * 2、当设置多个过滤器时，全部验证通过，才视为通过
     * 3、部分过滤器可指定参数，如perms，roles
     */
    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 必须设置 SecurityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        // 如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
        //访问的是后端url地址为 /login的接口,/未登录页面,会跳转到登录页面
        shiroFilterFactoryBean.setLoginUrl("/login");
        // 登录成功后要跳转的链接
        shiroFilterFactoryBean.setSuccessUrl("/index");
        // 未授权界面;，基于AOP拦截，都会到登录页面
        shiroFilterFactoryBean.setUnauthorizedUrl("/login");
        // 拦截器.
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();

        // 配置不会被拦截的链接 顺序判断，anon放开，不会拦截，authc会拦截
        //静态资源不能被拦截
        filterChainDefinitionMap.put("/assets/**", "anon");
        filterChainDefinitionMap.put("/css/**", "anon");
        filterChainDefinitionMap.put("/js/**", "anon");
        filterChainDefinitionMap.put("/images/**", "anon");
        filterChainDefinitionMap.put("/fonts/**", "anon");

        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/userLogin", "anon");
        // 配置退出过滤器,其中的具体的退出代码Shiro已经替我们实现了
        filterChainDefinitionMap.put("/logout", "logout");
        //配置某个url需要某个权限码
        filterChainDefinitionMap.put("/hello", "perms[how_are_you]");
        // 过滤链定义，从上向下顺序执行，一般将 /**放在最为下边
        // <!-- authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问-->
       filterChainDefinitionMap.put("/**", "authc");

        //配置记住我或认证通过可以访问的地址
        filterChainDefinitionMap.put("/index", "user");
//        filterChainDefinitionMap.put("/", "user");



        System.out.println("Shiro拦截器工厂类注入成功");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }


    /**
     * 缓存
     * @return
     */
    @Bean
    public EhCacheManager getEhCacheCache() {
        EhCacheManager em = new EhCacheManager();
        em.setCacheManagerConfigFile("classpath:ehcache-shiro.xml");
        return em;
    }


    /**
     * 代理
     * @return
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator daap = new DefaultAdvisorAutoProxyCreator();
        daap.setProxyTargetClass(true);
        return daap;
    }


    @Bean
    public DefaultWebSessionManager getDefaultWebSessionManager() {
        DefaultWebSessionManager defaultWebSessionManager = new DefaultWebSessionManager();
        defaultWebSessionManager.setSessionDAO(getMemorySessionDAO());
        defaultWebSessionManager.setGlobalSessionTimeout(1 * 60 * 60 * 1000);
        defaultWebSessionManager.setSessionValidationSchedulerEnabled(true);
        defaultWebSessionManager.setSessionIdCookieEnabled(true);
        defaultWebSessionManager.setSessionIdCookie(getSimpleCookie());
        return defaultWebSessionManager;
    }


    @Bean
    public MemorySessionDAO getMemorySessionDAO() {
        MemorySessionDAO memorySessionDAO = new MemorySessionDAO();
        memorySessionDAO.setSessionIdGenerator(javaUuidSessionIdGenerator());
        return memorySessionDAO;
    }


    @Bean
    public JavaUuidSessionIdGenerator javaUuidSessionIdGenerator() {
        return new JavaUuidSessionIdGenerator();
    }

    /**
     * cookie对象
     * @return
     */
    @Bean
    public SimpleCookie getSimpleCookie() {
        SimpleCookie simpleCookie = new SimpleCookie();
        simpleCookie.setName("security.session.id");
        //<!-- 记住我cookie生效时间30天 ,单位秒;-->
        simpleCookie.setMaxAge(259200);
        simpleCookie.setPath("/");
        return simpleCookie;
    }

    /**
     * cookie管理对象;
     * @return
     */
    /*@Bean
    public CookieRememberMeManager rememberMeManager(){
        System.out.println("ShiroConfiguration.rememberMeManager()");
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(getSimpleCookie());
        return cookieRememberMeManager;
    }*/

    @Bean
    public LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }


    /**
     * 注入 securityManager
     */
    @Bean(name = "securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(
            ShiroRealm shiroRealm) {
        DefaultWebSecurityManager dwsm = new DefaultWebSecurityManager();
        // 关联realm.
        dwsm.setRealm(shiroRealm);
        //用户授权/认证信息Cache,采用EhCache缓存
        dwsm.setCacheManager(getEhCacheCache());
        dwsm.setSessionManager(getDefaultWebSessionManager());
        //注入记住我管理器;
      /*  dwsm.setRememberMeManager(rememberMeManager());*/
        return dwsm;
    }

    @Bean
    public ShiroRealm shiroRealm(EhCacheManager cacheManager) {
        ShiroRealm shiroRealm = new ShiroRealm();
        shiroRealm.setCacheManager(cacheManager);
        return shiroRealm;
    }

    //开启shiro注解支持
    @Bean
    public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(ShiroRealm shiroRealm){
        AuthorizationAttributeSourceAdvisor aasa =new AuthorizationAttributeSourceAdvisor();
        aasa.setSecurityManager(getDefaultWebSecurityManager(shiroRealm));
        return aasa;
    }

    /**
     * 配置前台页面thymeleaf页面的标签
     * @return
     */
    @Bean
    public ShiroDialect shiroDialect() {
        return new ShiroDialect();
    }

}

4.核心的授权认证类

import com.example.echart.entity.Permission;
import com.example.echart.entity.Role;
import com.example.echart.entity.User;
import com.example.echart.mapper.UserRoleMapper;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.mgt.eis.SessionDAO;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.support.DefaultSubjectContext;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * @ Author     ：Zgq
 * @ Date       ：Created in 18:19 2019/6/11
 * @ Description：Shiro中最主要的代码，核心代码，用户认证授权处
 * @ Modified By：
 * @Version: $
 */
public class ShiroRealm extends AuthorizingRealm {


    @Autowired
    private SessionDAO sessionDAO;

    @Autowired
    private UserRoleMapper userRoleMapper;
    
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection auth) {
        //授权
        String username = (String)auth.getPrimaryPrincipal();
        System.out.println("进入到授权Realm中："+username);

        List<Role> dbroleList = userRoleMapper.selectRoleList(username);
        List<String> roleList=new ArrayList<String>();
        for(Role r:dbroleList){
            roleList.add(r.getCode());
        }

        List<Permission> dbpermissions = userRoleMapper.selectPermissionList(username);
        List<String> permissionList=new ArrayList<String>();
        for(Permission p:dbpermissions){
            permissionList.add(p.getPermission());
        }



//        roleList.add("ADMIN");
//        roleList.add("USER");

//        List<String> permissionList=new ArrayList<String>();
//        permissionList.add("ADMIN:USER:UPDATA");
//        permissionList.add("ADMIN:USER:DELETE");

        SimpleAuthorizationInfo simpleAuthorizationInfo=new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.addRoles(roleList);
        simpleAuthorizationInfo.addStringPermissions(permissionList);

        return simpleAuthorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
        //认证
        String username = (String)auth.getPrincipal();
        System.out.println("进入到认证Realm中："+username);

        //在认证之前判断当前登录用户，只允许一个账号登录
        Collection<Session> sessions = sessionDAO.getActiveSessions();
        for (Session session : sessions){
            String loginedUsername = String.valueOf(session.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY));

            if(username.equals(loginedUsername)){
                session.setTimeout(0);
                break;
            }
        }


        //通过username在数据库中查询用户，判断密码
        User dbuser = userRoleMapper.selectByUserName(username);

        //通过用户名在数据库中拿到，判断用户名和密码对不对
        if(dbuser!=null){
            SimpleAuthenticationInfo authInfo = new SimpleAuthenticationInfo(username, dbuser.getPwd(), "userRealm");
            return authInfo;
        }

        return null;
    }
}

5.登录的Controller类，LoginController

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.Map;

/**
 * @ Author     ：Zgq
 * @ Date       ：Created in 10:30 2019/6/12
 * @ Description：登录层方法
 * @ Modified By：
 * @Version: $
 */

@Controller
public class LoginController {

    //登录页面
    @RequestMapping(value = {"/login"})
    public String login(Map<String,String> map) {
        map.put("msg","请登录");
        return "/shiro/login-page";
    }


    //登录成功页面
    @RequestMapping(value = {"/index"})
    public String index(Map<String,String> map) {
        map.put("msg","登录成功");
        //获取用户信息
        Subject subject = SecurityUtils.getSubject();
        String username = (String)subject.getPrincipal();
        map.put("username",username);
        return "/shiro/index";
    }

    //登录请求
    @RequestMapping(value = {"/userLogin"})
    public String userLogin(String username, String pwd,boolean rememberMe, Map<String,String> map)
    {
        Subject subject = SecurityUtils.getSubject();

        //根据自己盐加密的方式，放入密码
        String encodePwd = new Md5Hash(pwd, username).toString();

        UsernamePasswordToken auth = new UsernamePasswordToken(username, encodePwd,rememberMe);
        try {
            subject.login(auth);
            return "redirect:/index";
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg","账号或密码错误");
            return "redirect:/login";
        }
    }


    //退出登录
    @RequestMapping(value = {"/loginOut"})
    public String loginOut(Map<String,String> map) {

        //获取用户信息
        Subject subject = SecurityUtils.getSubject();
        subject.logout();

        map.put("msg","退出登录");
        return "redirect:/login";
    }


    /**
     * 加密的测试
     * @param args
     */
    public static void main(String[] args) {
        //加密
        String zhouguoqing = new Md5Hash("111", "admin1").toString();
        System.out.println(zhouguoqing);
    }
}

6.因为是和数据库直接对接的，所以我也新建了一个UserRoleMapper接口，返回数据

import com.example.echart.entity.Permission;
import com.example.echart.entity.Role;
import com.example.echart.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

import java.util.List;

@Mapper
@Component
public interface UserRoleMapper {

    /**
     * 通过登录名查询信息
     * @param username
     * @return
     * @throws Exception
     */
    @Select("select * from t_user where username=#{username} limit 1")
    User selectByUserName(String username);


    /**
     * 通过用户名查询用户角色信息
     * @param username
     * @return
     * @throws Exception
     */
    @Select("select * from t_user u,t_role r,t_user_role ur where u.username=#{username} and ur.userId=u.id and ur.roleId=r.id")
    List<Role>  selectRoleList(String username);


    /**
     * 通过用户名查找用户权限
     * @param username
     * @return
     */
    @Select("select * from t_permission p \n" +
            "where p.id in(\n" +
            "\tselect permissionId from t_role_permission rp \n" +
            "\twhere rp.roleId in (\n" +
            "\t\t\tselect ur.roleId from t_user_role ur where userId in(\n" +
            "\t\t\tselect u.id from t_user u where u.username=#{username}\n" +
            "\t\t\t)\n" +
            "\t)\n" +
            ")")
    List<Permission> selectPermissionList(String username);



}

7.前台页面thymeleaf的展示

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml"
      xmlns:shiro="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<span th:text="${msg}"></span>
你好:<span th:text="${username}"></span>

<form action="/loginOut" method="post">
    <input type="submit" value="退出">
</form>



<p shiro:hasRole="ADMIN">ADMIN角色</p>
<p shiro:hasRole="USER">USER角色</p>
<p shiro:hasRole="SUPERMANE">SUPERMAN角色</p>

<p shiro:hasPermission="ADMIN:USER:UPDATA">UPDATA权限</p>
<p shiro:hasPermission="ADMIN:USER:DELETE">DELETE权限</p>
<p shiro:hasPermission="ADMIN:USER:INSERT">INSERT权限</p>
<p shiro:hasPermission="ADMIN:USER:SELECT">SELECT权限</p>
</body>
</html>

3.完成的效果

在这里插入图片描述
用不同用户登录之后会自动获取登录用户的角色和权限信息

学习地址:https://www.bilibili.com/video/av44084437

Super周博客
关注
  • 40
    点赞
  • 踩
  • 214
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
SpringBoot集成 Shiro安全框架【完整源码+数据库】
02-16
SpringBoot集成 Shiro安全框架，适合小白刚刚接触Shiro，或者需要对Shiro进一步加深理解的同学
Spring Boot整合 Shiro安全框架
qq_45040652的博客
01-12 2082
** Spring Boot 整合Shiro 安全框架 ** 关于Spring Boot整合Shiro安全框架的步骤，以后项目中用到 可以按照 步骤配置应用起来 1.pom文件添加依赖 1.pom文件添加依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.5.3</versio
SpringBoot整合Shiro安全框架
oyc的博客
06-05 930
什么是Shiro Shiro是一个强大的简单易用的Java安全框架，主要用来更便捷的认证，授权，加密，会话管理。Shiro首要的和最重要的目标就是容易使用并且容易理解，通过Shiro易于理解的API,您可以快速、轻松地获得任何应用程序——从最小的移动应用程序最大的网络和企业应用程序。 Shiro架构 Shiro架构图 - Authentication：身份认证/登录 - Authorization：验证权限，即，验证某个人是否有做某件事的权限。 - Session Management:会话管理。管理
Springboot整合shiro_springboot shiro，2024年最新网络安全初级开发是如何一步步成为高级开发
最新发布
2401_84183033的博客
04-10 1015
在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。需要完整版PDF学习资源私我。
SpringBoot整合安全框架
qq_45625290的博客
08-28 133
跳转自狂神说的笔记 狂神说Springboot Security详细总结
SpringBoot整合安全性框架SpringSecurity
weixin_44976835的博客
02-25 736
SpringSecurity是一种基于Spring应用提供的声明式的安全保护性的框架，它可以在web请求级别的和方法调用级别处理身份和授权。 首先需要在Maven中导包： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId&g
SpringBoot配置shiro安全框架
热门推荐
ggboy的博客
01-18 4万+
首先引入pom、 &amp;amp;lt;!--SpringBoot 2.1.0--&amp;amp;gt; &amp;amp;lt;parent&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;org.springframework.boot&amp;amp;lt;/groupId&amp;amp;gt; &amp;amp;lt;artifactId&amp;amp
springboot 与shiro安全框架的整合
08-05
Springboot+shiro springboot 与shiro安全框架的整合，适合初学者。
springboot集成freemarker和shiro框架
03-14
网上找不到springboot框架集成freemarker过程中再集成shiro框架，所以写了一个，供大家使用。
SpringBoot集成Shiro、Jwt和Redis
10-24
SpringBoot集成Shiro、Jwt和Redis，使用MyBatisPlus框架实现后台数据库操作。
SpringBoot整合Shiro框架集成权限管理
06-17
1、SpringBoot框架的优秀整合能力结合Shrio轻量安全高适用的权限框架，可以将权限运用到实质，方便高效 2、该文件中包含有shiro的介绍及整合过程 3、SpringBoot整合Shiro的相关教程视频
6.Springboot集成安全框架
小门的博客
08-24 365
艾编程架构课程第十节笔记未完待续SpringSecurity1.Springboot集成SpringSecurity1.1SpringSecurity简介WebSecurityConfigurerAdpater：AuthenticationManagerBuilder：1.2开始导入SpringSecurity SpringSecurity 1.Springboot集成SpringSecurity 它是一个安全组件：shiro 在web开发中，安全是第一位的，我们可以通过拦截器、过滤器来做权限认证 安全应该在
SpringBoot整合SpringSecurity安全框架
weixin_43246215的博客
09-06 1143
目录官方文档以及参考资料安全简介SpringSecurity的简介项目环境搭建1、新建一个SpringBoot项目，导入Web的功能，添加Thymeleaf依赖。2、导入素材到static内，导入页面到templates目录下，并且在application.yml文件中关闭模板引擎缓存3、书写跳转的页面Controller，启动测试一下认识SpringSecurity用户认证和权限控制编写配置类SecurityConfig授权管理请求身份认证内存中的身份认证JDBC验证（参考）注销和权限控制注销权限控制记住
SpringBoot：Spring Boot整合Shiro安全框架
zhuguang10的博客
03-16 1420
最近在由Spring Boot2.x构建的更简洁的后台管理系统，完美整合SpringMvc + Shiro + MybatisPlus + Beetl技术，项目开发完成会开源出来，希望能对大家学习道路上有所帮助。在这一篇中我将把我整合Shiro过程记录下来，希望对大家的学习这块能有所帮助。 maven依赖包 。 org.apache.shiro shiro-spring 1.4.0 &...
SpringBoot———安全框架之Shiro
qq_45673367的博客
08-04 323
SpringBoot扩展——Shiro简介功能核心组件Subject——主体SecurityManager——安全管理器Authenricator——认证器Authorizer——授权器SessionManager——会话管理器SessionDao——会话DAOCacheManager——缓存控制器Realm——领域Cryptography——密码管理器 简介 Apache Shiro是一个强大且易用的Java安全框架，执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、
SpringBoot整合Shiro安全框架（一）
weixin_45150104的博客
11-06 282
综述：    Shiro框架是Apache旗下的一个开源项目，它是轻量级安全框架，非常简便易用，同Spring旗下的Security安全框架相比较，它更加简便，易用和灵活，没有Security复杂。Shiro包括：认证、授权、加密和会话管理等功能。 主要功能：    1、验证用户身份    2、用户授权，权限访问    3、支持单点登录（SSO）功能    4
Springboot整合shiro做安全框架(一)
luobw的博客
04-29 367
shiro是开源安全框架，提供身份认证，授权，会话管理，加密等操作 会话管理： 传统项目是cookie维持会话管理， 前后分离开发是获取shiro的sessionId维持会话，参考：https://blog.csdn.net/u013615903/article/details/78781166/ 本此整合默认用cookie管理，参考：https://www.cnblogs.com/ask...
SpringSecurity框架快速搭建（SpringBoot整合Security）
weixin_67573348的博客
06-16 1194
框架整合
什么是shiro安全框架，以及在springboot中如何使用
lovoo的博客
07-12 155
一、 概述 Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。 其中 SecurityManager是核心，相当于Spring MVC的前端控制器，起管家调度作用。 Subject可以理解为账户。来验证其是否合法或者权限。 Realms可以理解为数据源，即程序从Realm中拿数据来确认该用户时候是合法，权限等。Realm可以自己实现，继承Rea
springboot集成shiro框架
06-28
Spring Boot 集成 Shiro 框架可以实现在应用中实现安全认证、权限控制等功能。下面是大致的集成步骤： 1. 添加 Shiro 依赖 在 `pom.xml` 文件中添加 Shiro 的依赖。可以选择适合自己项目的版本号。 ```xml ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值