shiro学习四（Spring boot整合shiro读取数据库中的url实现接口请求过滤认证）

最新推荐文章于 2022-08-24 05:07:05 发布
最新推荐文章于 2022-08-24 05:07:05 发布
阅读量1k 收藏 4
点赞数
分类专栏： shiro 文章标签： shiro自定义relam shiro自定义过滤器 shiro过滤url请求 shiro实现登录 shiro实现权限认证
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bird_tp/article/details/107311634
版权

一、本篇概述

    前面两篇中有讲解Spring boot整合shiro如何通过读取ini文件，数据库用户数据实现登录和权限认证授权等，那么就有人问了，我如果通过数据库中存储的当前用户可以访问哪些rul，来实现过滤当前用户可以访问哪接口或者是可以访问哪些页面，那么该怎么做呢？

例如有一个接口，比如获取所有用户信息的接口，我要实现admin用户可以访问，但是其他用户不可以访问。对于接口而言自然就会有暴露给外部调用的接口url，而本篇主要就是讲解如何通过url来实现用户的权限过滤。

与上篇博客一样，因篇幅原因粘贴部分重要的代码，全部的代码下载demo案例

二、pom依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com</groupId>
    <artifactId>shiro3</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>shiro3</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- 添加mybatis-plus依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1.tmp</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.1.tmp</version>
        </dependency>

        <!-- 添加shrio依赖 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-starter</artifactId>
            <version>1.4.1</version>
        </dependency>

        <!-- 添加mysql依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        <!-- 添加阿里数据源依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- servlet依赖. -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
        <!-- jsp支持-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

三、代码生成器

与数据交互的dao层是用的mybatis plus，所以我们可以直接使用它提供的代码生成器修改一番生成我们需要的文件

package com.shiro3.util;

import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @Package: com.tp.mybatisplusstudy
 * @ClassName: CodeGenerator
 * @Author: tanp
 * @Description: 代码生成器，根据数据库中的表自动生成mapper和表格对应实体类等
 * @Date: 2020/4/21 20:26
 */
public class CodeGenerator {
    private static final String URL = "jdbc:mysql://192.169.1.167:3306/shiro2?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&useSSL=true";

    private static final String USER_NAME = "root";

    private static final String PASSWORD = "123456";

    private static final String AUTHOR = "tanp";

    /**
     * <p>
     * 读取控制台内容
     * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotEmpty(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

    public static void main(String[] args) {
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor(AUTHOR);
        gc.setOpen(false);
        //实体属性 Swagger2 注解
        gc.setSwagger2(false);
        gc.setDateType(DateType.ONLY_DATE);
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl(URL);
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername(USER_NAME);
        dsc.setPassword(PASSWORD);
        mpg.setDataSource(dsc);

        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setParent("com.shiro3");
        pc.setMapper("dao");
        mpg.setPackageInfo(pc);

        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };

        // 如果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";

        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return projectPath + "/src/main/resources/mapper/"
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });

        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();
        //控制 不生成 controller
        templateConfig.setController("");

        templateConfig.setXml(null);
        mpg.setTemplate(templateConfig);

        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);

        strategy.setSuperEntityColumns("id");
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
        strategy.setControllerMappingHyphenStyle(true);
        strategy.setTablePrefix("");
        mpg.setStrategy(strategy);
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        mpg.execute();
    }

}

三、shiro配置

package com.shiro3.shiro;

import com.shiro3.filter.URLPathMatchingFilter;
import com.shiro3.relam.AuthRealm;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.mgt.SessionsSecurityManager;
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 javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @Package: com.shior2
 * @ClassName: ShiroConfig
 * @Author: tanp
 * @Description: ${description}
 * @Date: 2020/7/3 14:11
 */

@Configuration
public class ShiroConfig {

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(@Qualifier("mySecurityManager") SecurityManager manager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        // 设置 SecurityManager
        shiroFilterFactoryBean.setSecurityManager(manager);

        // 如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
        shiroFilterFactoryBean.setLoginUrl("/login");
        // 登录成功后要跳转的链接
        shiroFilterFactoryBean.setSuccessUrl("/index");
        //未授权界面;
        shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized");

        //自定义拦截器
        Map<String, Filter> customisedFilter = new HashMap<>(6);
        customisedFilter.put("url", getURLPathMatchingFilter());

        //拦截器.
        Map<String,String> filterChainDefinitionMap = new LinkedHashMap<String,String>();
        //配置映射关系, 顺序判断
        // 配置不会被拦截的链接
        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/index", "anon");
        filterChainDefinitionMap.put("/static/**", "anon");
        filterChainDefinitionMap.put("/config*/**", "anon");
        //配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了，登出后跳转配置的loginUrl
        filterChainDefinitionMap.put("/doLogout", "logout");
        //其余接口一律拦截
        filterChainDefinitionMap.put("/**", "url");
        shiroFilterFactoryBean.setFilters(customisedFilter);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

        return shiroFilterFactoryBean;
    }

    // * URLPathMatchingFilter 不可以用@Bean管理起来。 原因是Shiro的bug, 这个也是过滤器，
    // * ShiroFilterFactoryBean 也是过滤器，当他们都出现的时候，默认的什么anno,authc,logout过滤器就失效了。所以不能把他声明为@Bean
    public URLPathMatchingFilter getURLPathMatchingFilter() {
        return new URLPathMatchingFilter();
    }

    @Bean("mySecurityManager")
    public SessionsSecurityManager securityManager(@Qualifier("authRealm") AuthRealm authRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(authRealm);
        return securityManager;
    }

    @Bean("authRealm")
    public AuthRealm getAuthRealm() {
        AuthRealm authRealm = new AuthRealm();
        return authRealm;
    }
}

   本篇博客的shiro配置与上篇博客相比，增加了一些配置，这里也就讲增加的配置讲解一下。增加的代码在ShiroFilterFactoryBean对象配置时添加，可以看到在配置该对象时，设置了登录页面、首页、未授权页面还有拦截器，可以看到对于不同的访问请求的url，分别设置了不同的权限。还设置了一个过滤器，实现url过滤，下面来看下过滤器的代码

四、URLPathMatchingFilter过滤器

package com.shiro3.filter;

import com.shiro3.service.IPermissionService;
import com.shiro3.util.SpringContextUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.UnauthorizedException;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.PathMatchingFilter;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.beans.factory.annotation.Autowired;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.util.Set;

/**
 * @Description URLPathMatchingFilter 不可以用@Bean管理起来。 原因是Shiro的bug, 这个也是过滤器，
 * ShiroFilterFactoryBean 也是过滤器，当他们都出现的时候，默认的什么anno,authc,logout过滤器就失效了。所以不能把他声明为@Bean。
 * @Date 2020/7/10 16:32
 * @Author tanp
 */
public class URLPathMatchingFilter extends PathMatchingFilter {
    @Autowired
    IPermissionService iPermissionService;

    @Override
    protected boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue)
            throws Exception {

        //因为URLPathMatchingFilter 并没有用@Bean管理起来，所以在该类中就无法就注解注入被Spring管理的IPermissionService类，需要手动获取
        if(null==iPermissionService){
            iPermissionService = SpringContextUtils.getContext().getBean(IPermissionService.class);
        }


        String requestURI = getPathWithinApplication(request);
        System.out.println("requestURI:" + requestURI);

        Subject subject = SecurityUtils.getSubject();
        // 如果没有登录，就跳转到登录页面
        if (!subject.isAuthenticated()) {
            WebUtils.issueRedirect(request, response, "/login");
            return false;
        }

        // 看看这个路径权限里有没有维护，如果没有维护，一律放行(也可以改为一律不放行)
        boolean needInterceptor = iPermissionService.needInterceptor(requestURI);
        if (!needInterceptor) {
            return true;
        } else {
            boolean hasPermission = false;
            String userName = subject.getPrincipal().toString();
            Set<String> permissionUrls = iPermissionService.listPermissionURLs(userName);
            for (String url : permissionUrls) {
                // 这就表示当前用户有这个权限
                if (url.equals(requestURI)) {
                    hasPermission = true;
                    break;
                }
            }

            if (hasPermission) {
                return true;
            } else {
                UnauthorizedException ex = new UnauthorizedException("当前用户没有访问路径 " + requestURI + " 的权限");
                subject.getSession().setAttribute("ex", ex);
                WebUtils.issueRedirect(request, response, "/unauthorized");
                return false;
            }

        }
    }
}

    在过滤器中，我们获取请求的url路径，然后通过用户名获取该用户可以访问的请求url路径，然后进行匹配判断是否有权限访问当前访问的请求url。

五、shiro调用

package com.shiro3.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * @Description 登录
 * @Date 2020/7/8 14:45
 * @Author tanp
 */
@Controller
@RequestMapping("")
public class LoginController {

    /**
     * @Description 登陆, 页面post提交才进入此方法
     * @Date 2020/7/8 14:45
     * @Author tanp
     */
    @RequestMapping(value = "/login", method = RequestMethod.POST)
    public String login(Model model, String name, String password) {
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(name, password);
        try {
            subject.login(token);
            Session session = subject.getSession();
            session.setAttribute("subject", subject);
            return "redirect:index";
        } catch (AuthenticationException e) {
            model.addAttribute("error", "验证失败");
            return "login";
        }
    }

    @RequestMapping(value = "/login", method = RequestMethod.GET)
    public String login1() {
        return "login";
    }

}

可以看到，无论配置如何变化，最终用户做登录对象做交互的都是subject对象

六、代码整体架构

七、数据库脚本

DROP DATABASE IF EXISTS shiro;
CREATE DATABASE shiro DEFAULT CHARACTER SET utf8;
USE shiro;
    
drop table if exists user;
drop table if exists role;
drop table if exists permission;
drop table if exists user_role;
drop table if exists role_permission;
    
create table user (
  id bigint auto_increment,
  name varchar(100),
  password varchar(100),
  salt varchar(100),
  constraint pk_users primary key(id)
) charset=utf8 ENGINE=InnoDB;
    
create table role (
  id bigint auto_increment,
  name varchar(100),
  desc_ varchar(100),
  constraint pk_roles primary key(id)
) charset=utf8 ENGINE=InnoDB;
    
create table permission (
  id bigint auto_increment,
  name varchar(100),
  desc_ varchar(100),
  url varchar(100),
  constraint pk_permissions primary key(id)
) charset=utf8 ENGINE=InnoDB;
    
create table user_role (
  id bigint auto_increment,
  uid bigint,
  rid bigint,
  constraint pk_users_roles primary key(id)
) charset=utf8 ENGINE=InnoDB;
    
create table role_permission (
  id bigint auto_increment,
  rid bigint,
  pid bigint,
  constraint pk_roles_permissions primary key(id)
) charset=utf8 ENGINE=InnoDB;
 
INSERT INTO `permission` VALUES (1,'addProduct','增加产品','/addProduct');
INSERT INTO `permission` VALUES (2,'deleteProduct','删除产品','/deleteProduct');
INSERT INTO `permission` VALUES (3,'editeProduct','编辑产品','/editeProduct');
INSERT INTO `permission` VALUES (4,'updateProduct','修改产品','/updateProduct');
INSERT INTO `permission` VALUES (5,'listProduct','查看产品','/listProduct');
INSERT INTO `permission` VALUES (6,'addOrder','增加订单','/addOrder');
INSERT INTO `permission` VALUES (7,'deleteOrder','删除订单','/deleteOrder');
INSERT INTO `permission` VALUES (8,'editeOrder','编辑订单','/editeOrder');
INSERT INTO `permission` VALUES (9,'updateOrder','修改订单','/updateOrder');
INSERT INTO `permission` VALUES (10,'listOrder','查看订单','/listOrder');
INSERT INTO `role` VALUES (1,'admin','超级管理员');
INSERT INTO `role` VALUES (2,'productManager','产品管理员');
INSERT INTO `role` VALUES (3,'orderManager','订单管理员');
INSERT INTO `role_permission` VALUES (1,1,1);
INSERT INTO `role_permission` VALUES (2,1,2);
INSERT INTO `role_permission` VALUES (3,1,3);
INSERT INTO `role_permission` VALUES (4,1,4);
INSERT INTO `role_permission` VALUES (5,1,5);
INSERT INTO `role_permission` VALUES (6,1,6);
INSERT INTO `role_permission` VALUES (7,1,7);
INSERT INTO `role_permission` VALUES (8,1,8);
INSERT INTO `role_permission` VALUES (9,1,9);
INSERT INTO `role_permission` VALUES (10,1,10);
INSERT INTO `role_permission` VALUES (11,2,1);
INSERT INTO `role_permission` VALUES (12,2,2);
INSERT INTO `role_permission` VALUES (13,2,3);
INSERT INTO `role_permission` VALUES (14,2,4);
INSERT INTO `role_permission` VALUES (15,2,5);
INSERT INTO `role_permission` VALUES (50,3,10);
INSERT INTO `role_permission` VALUES (51,3,9);
INSERT INTO `role_permission` VALUES (52,3,8);
INSERT INTO `role_permission` VALUES (53,3,7);
INSERT INTO `role_permission` VALUES (54,3,6);
INSERT INTO `role_permission` VALUES (55,3,1);
INSERT INTO `role_permission` VALUES (56,5,11);
INSERT INTO `user` VALUES (1,'zhang3','12345','e5ykFiNwShfCXvBRPr3wXg==');
INSERT INTO `user` VALUES (2,'li4','abcde','jPz19y7arvYIGhuUjsb6sQ==');
INSERT INTO `user_role` VALUES (43,2,2);
INSERT INTO `user_role` VALUES (45,1,1);

八、总结

   与前面一篇不同，本篇博客中的案例是真实的从前端页面获取用户信息的请求url，然后对用户进行登录判断，和url的过滤。

下载案例：

https://download.csdn.net/download/bird_tp/12609046

bird_tp
关注
专栏目录
spring boot整合Shiro实现单点登录
牛奋lch
08-07 4万+
前面的博客中，我们说道了Shiro的两个最大的特点，认证和授权，而单点登录也是属于认证的一部分，默认情况下，Shiro已经为我们实现了和Cas的集成，我们加入集成的一些配置就ok了。 1、加入shiro-cas包 org.apache.shiro shiro-cas 1.2.4
spring boot整合redis实现shiro的分布式session共享
热门推荐
牛奋lch
08-07 1万+
我们知道，shiro是通过SessionManager来管理Session的，而对于Session的操作则是通过SessionDao来实现的，默认的情况下，shiro实现了两种SessionDao，分别为CachingSessionDAO和MemorySessionDAO，当我们使用EhCache缓存时，则是使用的CachingSessionDAO，不适用缓存的情况下，就会选择基于内存的Sessi
spring boot整合shiro实现url请求过滤
07-13
本demo为Spring boot整合shiro，以mybatis plus做dao层交互数据，实现了读取数据库用户数据实现用户登录，权限认证，读取数据库中用户对应的url请求，实现请求的过滤。自定义了relam和过滤器来实现这些功能
shiro设置url过滤
Emily的博客
05-20 1万+
文章内容
Springboot整合shiro之过滤器注册源码分析
xulifeng1199的博客
10-23 427
Springboot原理不了解的可以先了解一下它的运行原理，通常我们都是在springboot项目下配置一个shiro配置类本项目中配置的类是ShiroConfig,截图如下： ShiroFilterFactoryBean是shiro包下带的一个类它实现了FactoryBean接口，根据spring原理我们可以知道在实例化ShiroFilterFactoryBean对象时会调用getObject()方法，截图如下: 该类中有个成员变量AbstractShiroFilter,该类最终实现了javax.se
java中 shiro过滤器设置接口过滤权限
m0_54850467的博客
08-17 725
今天遇到一个需求，要求后台接口不验证权限也能请求成功，由于我们的后台框架是nacos微服务，所以想到直接去改nacos中该微服务的shiro配置，我们打开shiro-common.yml文件，内容如下。我们在filterChainDefinitionMap里面增加一条记录/getSysinfoConfig:anon,修改后如下。然后重启该接口所在的微服务，这样请求该接口就不会被拦截了。anon是匿名访问anonymous的简称。修改后，我们发布配置。...
shiro设置url过滤配置详解
m0_67390788的博客
08-24 735
perms（权限）： /admins/user/**=perms[user:add:*],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，例如/admins/user/**=perms[“user:add:*,user:modify:*”]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。ssl:例子/admins/user/**=ssl没有参数，表示安全的url请求，协议为https。版权声明：本文为博主原创文章，转载请附上博文链接！
spring_boot_shiro
10-23
《Spring Boot整合Shiro实战详解》 在现代Java Web开发中，Spring Boot以其简洁的配置、快速的开发体验，已经成为主流框架。而Apache Shiro作为一款强大的安全管理框架，提供了认证、授权、会话管理和安全加密等...
Shiro配置URL过滤
Lv_cha19的博客
01-10 174
常用过滤器： anon不需要认证 authc需要认证 user验证通过或RememberMe登录的都可以 URL说明： /admin?=authc 表示可以请求以admin开头的字符串，如xxx/adminfefe，但无法匹配多个，即xxx/admindf/admin是不行的 /admin*=authc 表示可以匹配零个或者多...
基于Shiro 拦截URL，实现权限控制
08-02
NULL 博文链接：https://vti-iteye.iteye.com/blog/1963397
shiro之自动过虑URL，无需配置。
m0_67393342的博客
08-24 224
为取到当前访问的URL地址，在我的权限资源表中，我存的是每一个controller配制的@RequestMapping(value=”/main.html”) ，如果用户能访问此权限，自动通过。当然一些别的权限也可以是虚拟的URL或者NAME,看自己怎么定义。这是我的shiro.xml。
Springboot整合shiro：第三篇 用户授权-配置自定义URL过滤器 实现
老照片
09-25 995
本文是在前两篇的基础上来完成的：Springboot整合shiro：第二篇 用户授权 及Springboot整合shiro：第一篇 用户验证。 本来第二篇中已经完成了Shrio用户授权的功能，但是有采用注解的方式不够灵活，一旦权限发生改变就必须得修改代码重新打包部署，麻烦。所以，这篇采用自定义URL过滤器的方式来实现，权限可以自由随意配置/分配，无需改动代码，更加灵活。 编写自定义过滤器 package com.xl.practice.springbootshiropractice.shiro; impo
shiro学习三（spring boot整合shiro读取数据库数据实现用户登录，权限认证）
bird_tp的博客
07-08 1081
一、本篇概述 如果大家看过我shiro类的其他博客，关于shiro的一些基本知识点就不再讲诉，本篇博客主要是讲诉Spring boot如何通过Java配置获取securityManager对象，如何通过调用数据库数据实现认证登录等功能，其中与数据库交互用的mybatis -plus。因为代码量比上篇博客多，我就不将所有代码粘贴出来了，主要展示一些重要的部分，如果需要整个demo的，可以下载我的案例 二、pom依赖 粘贴项目中需要引入的依赖信息‘ <!-- 添加shrio依赖
Springboot整合shiro基于url身份认证和授权认证
bigsai
03-10 4344
你还不会shiro吗？ 前奏 shiro核心配置文件（rolesFilter可选）。 身份认证 多表登录源如何操作？ 授权管理 如何解决界面多角色/资源问题 访问效果 权限管理在日常开发中很重要，所以硬着头皮也要啃下来。 实现功能： 身份认证 对不同页面进行url授权 多表登录解决 同一个页面多role访问 项目完整github地址 欢迎star springboo...
shiro二，集成web时url过滤
gcc_java的博客
01-23 919
话不多说直接上代码：&lt;!-- 自定义Realm --&gt; &lt;bean id="myRealm" class="com.gcc.realm.MyRealm"/&gt; &lt;!-- 安全管理器 --&gt; &lt;bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSe
springboot整合shiro连接数据库
m0_46522108的博客
04-11 336
springboot整合shiro连接数据库 连接数据库认证实现注册和登录,注册保存到mysql密码进行md5加密和随机盐,登录连接数据库 pom.xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</arti
李子柒文化输出争议：Spring Boot整合Redis实现Shiro分布式Session共享
在“地域分布-spring boot整合redis实现shiro的分布式session共享的方法”这一主题中，我们主要聚焦于如何在Spring Boot应用中利用Redis来实现Shiro框架的分布式session共享。Spring Boot是Java开发中的一个微服务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值