shiro入门demo(三)身份认证+授权+拦截

已于 2024-04-27 08:32:24 修改
阅读量510 收藏 9
点赞数 9
分类专栏： Shiro+VUE 文章标签： oracle 数据库
于 2023-12-27 17:19:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_t_y_y/article/details/135251139
版权

一、session管理会话：

1、pom：

<groupId>com.demo.shiro</groupId>
    <artifactId>shiro-filter-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

        <!--单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--shiro-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.2.2</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.31</version>
        </dependency>

        <!-- AOP依赖,必须,否则shiro权限拦截验证不生效 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
    </dependencies>

2、Realm：这里没有连接数据库，在UserConstants中假设数据

/**
 * 模拟数据库查询数据，假设有：用户名/密码/角色/资源
 * admin/123/xtgly/user_manage、role_manage、menu_manage、school_manage
 * zs/123/userAdmin、roleAdmin/user_manage、role_manage、menu_manage
 * ls/123/schoolAdmin/school_manage
 */
public class UserConstants {

    public static Map<String, String> getUsers() {
        Map<String,String> users = new HashMap<>();
        users.put("admin","123");
        users.put("zs","123");
        users.put("ls","123");
        return users;
    }

    public static Map<String,List<String>> getUserRoles() {
        Map<String,List<String>> userRoles = new HashMap<>();
        //admin
        List<String> adminRoles = new ArrayList<>();
        adminRoles.add("xtgly");
        userRoles.put("admin",adminRoles);
        //zs
        List<String> zsRoles = new ArrayList<>();
        zsRoles.add("userAdmin");
        zsRoles.add("roleAdmin");
        userRoles.put("zs",zsRoles);
        //ls
        List<String> lsRoles = new ArrayList<>();
        lsRoles.add("schoolAdmin");
        userRoles.put("ls",lsRoles);
        return userRoles;
    }

    public static Map<String,List<String>> getUserPermissions() {
        Map<String,List<String>> userPermissions = new HashMap<>();
        List<String> lsPermissions = new ArrayList<>();
        //ls
        lsPermissions.add("school_manage");
        userPermissions.put("ls",lsPermissions);
        //zs
        List<String> zsPermissions = new ArrayList<>();
        zsPermissions.add("user_manage");
        zsPermissions.add("role_manage");
        zsPermissions.add("menu_manage");
        userPermissions.put("zs",zsPermissions);
        //admin
        List<String> adminPermissions = new ArrayList<>();
        adminPermissions.add("school_manage");
        userPermissions.put("admin",adminPermissions);
        return userPermissions;
    }
}

public class MyRolePermissionRealm extends AuthorizingRealm {

    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
        String primaryPrincipal = (String) principal.getPrimaryPrincipal();
        Map<String, List<String>> userRoles = UserConstants.getUserRoles();
        List<String> roles = userRoles.get(primaryPrincipal);
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.addRoles(roles);
        //资源
        Map<String, List<String>> userPermissions = UserConstants.getUserPermissions();
        List<String> permissions = userPermissions.get(primaryPrincipal);
        simpleAuthorizationInfo.addStringPermissions(permissions);
        return simpleAuthorizationInfo;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String username = (String) token.getPrincipal();
        String password = new String((char[]) token.getCredentials());
        Map<String,String> dbUsers = UserConstants.getUsers();
        Set<String> dbUserNames = dbUsers.keySet();
        //验证用户名
        if(!dbUserNames.contains(username)){
            throw new UnknownAccountException();
        }
        //验证密码
        String dbPwd = dbUsers.get(username);
        if(!dbPwd.equals(password)){
            throw new IncorrectCredentialsException();
        }
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(username,password,this.getName());
        return simpleAuthenticationInfo;
    }
}

3、拦截器：

public class ShiroFormAuthenticationFilter extends FormAuthenticationFilter{
    Logger logger  = LoggerFactory.getLogger(ShiroFormAuthenticationFilter.class);

    /**
     * 未登陆
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        if (!isLoginRequest(request, response)) {
            this.handleErrorMsg(request,response);
           return false;
        }
        if (isLoginSubmission(request, response)) {
            if (logger.isTraceEnabled()) {
                logger.trace("Login submission detected.  Attempting to execute login.");
            }
            return executeLogin(request, response);
        } else {
            if (logger.isTraceEnabled()) {
                logger.trace("Login page view.");
            }
            return true;
        }
    }

    private void handleErrorMsg(ServletRequest request, ServletResponse response) throws IOException {
        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse resp = (HttpServletResponse) response;
        resp.setHeader("Access-Control-Allow-Origin",  req.getHeader("Origin"));
        resp.setHeader("Access-Control-Allow-Credentials", "true");
        resp.setContentType("application/text; charset=utf-8");
        resp.setCharacterEncoding("UTF-8");
        PrintWriter out = resp.getWriter();
        out.println("登陆失效");
        out.flush();
        out.close();
    }
}

4、配置文件：

import com.demo.shiro.filter.ShiroFormAuthenticationFilter;
import com.demo.shiro.realm.MyRolePermissionRealm;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.realm.Realm;
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.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;

import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

@Configuration
public class ShiroConfig {

    //域
    @Bean
    public Realm getMyShiroRealm(){
        return new MyRolePermissionRealm();
    }

    //入口
    @Bean
    public SecurityManager getMySecurityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(this.getMyShiroRealm());
        SecurityUtils.setSecurityManager(securityManager);
        return securityManager;
    }

    //拦截器配置
    @Bean
    public ShiroFilterFactoryBean shirFilter() {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(this.getMySecurityManager());
        //shiroFilterFactoryBean.setLoginUrl("/login");
        /**
         * 只写这个，访问报错
         * {
         *   "timestamp": 1703231180623,
         *   "status": 404,
         *   "error": "Not Found",
         *   "message": "No message available",
         *   "path": "/shiroTest/login.jsp"
         * }
         */
        Map<String, String> filterChainDefinitionMap = new HashMap<>();
        filterChainDefinitionMap.put("/**","authc");
        filterChainDefinitionMap.put("/login/login","anon");
        LinkedHashMap<String, Filter> filtsMap=new LinkedHashMap<String, Filter>();
        filtsMap.put("authc",new ShiroFormAuthenticationFilter() );
        shiroFilterFactoryBean.setFilters(filtsMap);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }


    //以下为注解支持配置
    /**
     * Shiro生命周期处理器
     */
    @Bean(name = "lifecycleBeanPostProcessor")
    public static LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    /**
     * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
     */
    @Bean
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }

    /**
     * 开启Shiro-aop注解支持
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
}

5、util

public class SessionUtil {
    public static String getUser() {
        Subject subject = SecurityUtils.getSubject();
        Session session = subject.getSession();
        return (String) session.getAttribute("currUserAccount");
    }
}

6、controller：

@RequestMapping("/login")
@RestController
public class LoginController {

    @RequestMapping("/login")
    public String login(String username,String password){
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token=new UsernamePasswordToken(
                username, password
        );
        try {
            subject.login(token);
            System.out.println("认证成功");
            Session session = subject.getSession();
            //缓存用户
            session.setAttribute("currUserAccount",username);
            return (String) session.getId();
        } catch (AuthenticationException e) {
            System.out.println("认证失败");
            e.printStackTrace();
        }
        return null;
    }

    @RequestMapping("/logOut")
    public void logOut(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
    }
}

@RequestMapping("/user")
@RestController
public class UserManageController {

    @RequestMapping("/test")
    @RequiresRoles("userAdmin")
    public String test(){
        return "这是用户管理";
    }
    
    @RequestMapping("/getUser")
    public String getUser(){
        return SessionUtil.getUser();
    }
}
@RequestMapping("/school")
@RestController
public class SchoolManageController {

    @RequestMapping("/test")
    @RequiresPermissions("school_manage")
    public String test(){
        return "这是学校管理";
    }
}

测试：

（1）admin用户

访问无角色权限的接口、有资源权限校验的接口

   

（2）zs用户

       

访问无资源权限接口、有角色接口

退出登陆，并再次访问接口

    

二、token令牌校验：

以上使用了session存储当前会话的用户，前端不需要带入用户身份信息；后端自然也无需校验用户是否合法，只需要（shiro自动）判断是否登陆了即可，当前浏览器session会话有效时间内，对后端都是同一个用户。关于token和session的对比在另一篇博客有讲解。项目中一般使用token管理会话。

1）自定义token：如UUID，登陆成功后生成一个UUID作为token，同时将userId与token键值对缓存到redis中并设置失效时间，再自定义拦截器根据前端传入的token从redis中取userId，如果userId为空则不通过。这种方法对于token是错误的还是失效了无法区分。

2）JWT：更安全的token。根据username、password生成token，可以根据token反解析出userId，由此判断token是否正确；缓存到redis中设置过期时间，可以判断是否过期。

下面以jwt为例，管理用户身份。代码修改点：

1、pom新增依赖
 <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.7.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.6</version>
        </dependency>
2、新增redis配置：

application新增redis连接配置

my.redis.server.host=127.0.0.1
my.redis.server.port=6379
my.redis.server.password = wtyy
my.redis.server.jedis.pool.maxTotal=500
my.redis.server.jedis.pool.maxIdle=10
my.redis.server.jedis.pool.maxWaitMillis=5000
my.redis.server.jedis.pool.min-idle=5
my.redis.server.timeout=5000

 并新增redis配置文件JedisConfig和redis操作类RedisClient

3、拦截器部分：

（1）shiro配置类中：设置/login/logOut接口白名单（/login/login前面已经设置过了），其他接口均经过自定义JwtFilter拦截器：

Map<String, String> filterChainDefinitionMap = new HashMap<>();
        filterChainDefinitionMap.put("/**","authc");
        filterChainDefinitionMap.put("/login/login","anon");
        filterChainDefinitionMap.put("/login/logOut","anon");
        LinkedHashMap<String, Filter> filtsMap=new LinkedHashMap<String, Filter>();
        //filtsMap.put("authc",new ShiroFormAuthenticationFilter() );
        //非登陆接口，需要校验token是否合法
        filtsMap.put("authc",new JwtFilter() );
        shiroFilterFactoryBean.setFilters(filtsMap);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

（2）JwtFilter拦截器：校验token正确性

public class JwtFilter extends BasicHttpAuthenticationFilter {

    private static RedisClient redisClient;

    /**
     *
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        System.out.println("JwtFilter.isAccessAllowed开始");
        HttpServletRequest req = (HttpServletRequest) request;
        String token = req.getHeader("token");
        if (StringUtils.isEmpty(token)) {
            System.out.println("JwtFilter.isAccessAllowed token为空");
            this.hanldeErrorResp(response,"token为空");
            return false;
        }
        String jwtUserId = JwtUtil.getUsername(token);
        if(StringUtils.isEmpty(jwtUserId)){
            System.out.println("JwtFilter.isAccessAllowed token不正确");
            this.hanldeErrorResp(response,"token不正确");
            return false;
        }
        ServletContext servletContext = request.getServletContext();
        ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        redisClient = (RedisClient) context.getBean("redisClient");
        String redisToken = redisClient.get(jwtUserId);
        if(StringUtils.isEmpty(redisToken)){
            System.out.println("JwtFilter.isAccessAllowed token过期");
            this.hanldeErrorResp(response,"token过期");
            return false;
        }
        if(token.equals(redisToken)){
            return true;
        }
        this.hanldeErrorResp(response,"token过期");
        return false;
    }

    private void hanldeErrorResp(ServletResponse response, String errorMsg) {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/text;charset=utf-8");
        PrintWriter out = null;
        try {
            out = response.getWriter();
        } catch (IOException e) {
            e.printStackTrace();
        }
        out.write(errorMsg);
    }
}

4、新增jwt的util，用于生成jwt和获取userId：

package com.demo.shiro.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.demo.shiro.constant.UserConstants;

import javax.servlet.http.HttpServletRequest;
import java.util.Date;

public class JwtUtil {

    /**
     * 校验token是否正确
     * @param token  密钥
     * @param secret 用户的密码
     * @return 是否正确
     */
    public static boolean verify(String token, String username, String secret) {
        try {
            // 根据密码生成JWT效验器
            Algorithm algorithm = Algorithm.HMAC256(secret);
            JWTVerifier verifier = JWT.require(algorithm).withClaim("username", username).build();
            // 效验TOKEN
            DecodedJWT jwt = verifier.verify(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 获得token中的信息无需secret解密也能获得
     * @return token中包含的用户名
     */
    public static String getUsername( HttpServletRequest req) {
        try {
            String token =  req.getHeader("token");
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("username").asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    public static String getUsername( String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("username").asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    /**
     * 生成签名,5min(分钟)后过期
     * @param username 用户名
     * @param secret   用户的密码
     * @return 加密的token
     */
    public static String sign(String username, String secret) {
        Date date = new Date(System.currentTimeMillis() + UserConstants.EXPIRE_TIME);
        Algorithm algorithm = Algorithm.HMAC256(secret);
        // 附带username信息
        return JWT.create()
                .withClaim("username", username)
                .withExpiresAt(date)
                .sign(algorithm);
    }
}

 5、controller接口修改：

@RequestMapping("/login")
@RestController
public class LoginController {

    @Autowired
    private RedisClient redisClient;

    @RequestMapping("/login")
    public String login(String username,String password){
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token=new UsernamePasswordToken(
                username, password
        );
        try {
            subject.login(token);
            System.out.println("认证成功");
            String jwtToken = JwtUtil.sign(username, password);
            redisClient.set(username,jwtToken);
            return jwtToken;
        } catch (AuthenticationException e) {
            System.out.println("认证失败");
            e.printStackTrace();
        }
        return null;
    }

    @RequestMapping("/logOut")
    public void logOut(){
        Subject subject = SecurityUtils.getSubject();
        String username = (String) subject.getPrincipal();
        redisClient.delete(username);
        subject.logout();
    }
}

/user/getUser接口修改，（当然session管理也可以用下面这种方法获取当前登陆用户）

@RequestMapping("/getUser")
    public String getUser(){
        Subject subject = SecurityUtils.getSubject();
        return (String) subject.getPrincipal();
    }

测试：

1）登陆

2）访问业务接口：

    

3）退出登陆，使用原来的token再次访问业务接口：

    

w_t_y_y
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
shiro入门demo
04-18
Apache Shiro 是一个强大且易用的 Java 安全框架，提供身份认证、授权、加密以及会话管理功能，简化了开发人员在应用安全方面的开发工作。本教程将引导你入门 Shiro，通过一个简单的 demo 来理解其基本概念和用法。 ...
shiro+spring+data+session+redis实现单点登录
08-03
Apache Shiro是一款轻量级的安全框架，提供了认证、授权、会话管理和加密等核心功能。在SSO场景中，Shiro主要负责用户的认证和权限管理。它能够处理用户登录、验证用户凭证，并根据用户角色和权限控制对资源的访问。...
shiro学习笔记4——认证流程+授权流程
xinpz的博客
08-03 635
shiro第二天 shiro授权 shiro和企业项目整合开发   1 复习   什么是权限管理？ 权限管理是系统的安全范畴，要求必须是合法的用户才可以访问系统（用户认证），且必须具有该 资源的访问权限才可以访问该 资源（授权）。 认证：对用户合法身份的校验，要求必须是合法的用户才可以访问系统。 授权：访问控制，必须具有该 资源的访问权限才可以访问该 资源。   权限模型：标准权...
Spring Boot集成Shiro快速入门Demo
最新发布
HBLOG
05-17 735
Shiro是一个功能强大、灵活的，开源的安全框架，主要可以帮助我们解决程序开发中认证和权限等问题。基于拦截器做的权限系统，权限控制的粒度有限，为了方便各种各样的常用的权限管理需求的实现，我们有必要使用比较好的安全框架。早期Spring security 作为一个比较完善的安全框架比较火，但是Springsecurity学习成本比较高，于是就出现了shiro安全框架，学习成本降低了很多，而且基本的功能也比较完善。Shiro的架构Subject：主题。被验证的对象，一般指的当前用户对象。
[Shiro教程] Shiro 教程基于SSM（SpringMVC + Spring + Mybatis）
韩迎宾的博客
05-29 2039
一、Shiro简介Apache Shiro 是 Java  的一个安全框架。我们经常看到它被拿来和 Spring  的 Security  来对比。大部分人认为 Shiro  比 Security  要简单。我的观点赞成一半一半吧。首先 Shiro  确实和 Security  是同类型的框架，主要用来做安全，也就是我们俗称的权限校验（控制）。居多人对 Shrio  的定义为好入门。我选型为 Sh...
springboot+shiro入门篇
qq_34297563的博客
04-02 562
shiro分两篇文章写，应该分三篇来写，第一篇写各种概念和shiro执行流程，框架图这些的，但这些网上太多，我就不写了，主要侧重点在于实际应用。如果不看这个入门篇，进阶篇可能会看不懂，当然高手随便。文章中概念都是网上查阅后复制粘贴的，如有雷同，很是正常。代码为自己编写亲自测试，保证质量。此刻应有掌声~~ 1、概念 shiro是一个强大的简单易用的Java安全框架，主要用来更便捷的认证，...
JAVA整合Shiro实现认证授权-简单实现demo
tttttt521的博客
07-12 292
官方代码 Apache官网10分钟快速入门 作用：验证用户身份，用户访问权限控制 demo 实现-未连接数据库 引入依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>1.4.1</version> </dependency> 测试之前
1-1 shiro与springboot入门（springboot+mybatis+shiro+thymleaf）
brusion的博客
10-19 1285
shiro与springboot入门（springboot+mybatis+shiro+thymleaf） 项目结构 01-demo |--com.demo |--ShiroApplication（启动类） |--bean(java实体对象) |--Permission,Role,User |--config（配置文件...
shiro(入门二)shiro集成spring+mybatis+springMvc+Redis（附带源码）
念念不忘，必有回响
03-04 770
1.准备工作 1.1准备所需要的依赖架包 &amp;amp;amp;amp;lt;dependencies&amp;amp;amp;amp;gt; &amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp;gt; &amp;amp;amp;amp;lt;groupId&amp;amp;amp;amp;gt;org.springframework&amp;amp;amp;amp;lt;/groupI
Spring+SpringMVC+Mybatis+Shiro 入门
福荼荼的踩坑路
10-02 188
Spring+SpringMVC+Mybatis+Shiro 1.配置文件 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" ...
springboot+mybatis整合shiro
qq_45009980的博客
09-24 295
参考了b站的springboot视频。 1、shiro简介 它是阿帕奇的java安全框架。包含了三个主要对象：subject（当前用户）、SecurityManager（安全管理）、Realm（数据相关）。 Shiro 可以帮助我们完成：认证、授权、加密、会话管理、与 Web 集成、缓存等。其基本功能点如下图所示： shiro详细介绍 2、demo结构： 3、使用了springboot、mybatis、druid etc，实现登录控制，用户认证、请求授权（本文没有实现授权）等。 4、首先搭建环境： j
shirodemo(spring3+shiro)(认证授权)
12-18
在“shirodemo”中，Shiro 负责用户的身份验证。这个过程包括：收集用户提交的凭证（如用户名和密码），验证这些凭证，如果验证成功，则认为用户已通过认证。Shiro 提供了 RememberMe 功能，可以在用户下次访问时...
shirodemo整合spring+springmvc+shiro
12-25
Apache Shiro是一个强大且易用的Java安全框架，提供了认证、授权、加密和会话管理功能，使得开发者能够更轻松地处理应用安全问题。本文将详细介绍如何将Shiro与Spring、SpringMVC进行整合，构建一个高效的J2EE安全...
SpringBoot+Shiro+JWT+Jedis+MybatisPlus+前后端分离+基于url通用权限管理系统
01-25
Shiro框架是用于身份验证、授权和会话管理的安全框架，它在此系统中扮演着核心角色。Shiro支持基于URL的权限拦截，这意味着可以为每个URL分配特定的访问权限，只有拥有相应权限的用户才能访问。这种方式提高了权限...
前后端分离(JWT管理)(一)简单实例
热门推荐
w_t_y_y的博客
06-29 1万+
一、代码： 二、测试：
前后端分离(session管理)(一)简单实例
w_t_y_y的博客
06-11 1621
springboot集成shiro简单实例
shiro概述（三）拦截器
w_t_y_y的博客
12-14 1432
也就是说一次请求只会走一次拦截器链；另外提供enabled属性，表示是否开启该拦截器实例，默认enabled=true表示开启，如果不想让某个拦截器工作，可以设置为false即可。当我们组装拦截器链时会根据这个名字找到相应的拦截器实例；4、AdviceFilter：提供了AOP风格的支持，类似于SpringMVC中的Interceptor。3、ShiroFilter：是整个Shiro的入口点，用于拦截需要安全控制的请求进行处理。一、介绍：shiro使用了与servlet一样的Filter进行接口扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

w_t_y_y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值