springboot+shiro自定义拦截器互踢问题

最新推荐文章于 2024-05-14 09:43:40 发布
最新推荐文章于 2024-05-14 09:43:40 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： springboot Java 文章标签： mysql kafka 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leijie0322/article/details/121511166
版权

shiro自定义拦截器继承AccessControllerFilter，实现session互踢机制。
应用场景：
我们经常会有用到，当A 用户在北京登录 ，然后A用户在天津再登录 ，要踢出北京登录的状态。如果用户在北京重新登录，那么又要踢出天津的用户，这样反复。又或是需要限制同一用户的同时在线数量，超出限制后，踢出最先登录的或是踢出最后登录的。
分析：
spring security就直接提供了相应的功能；Shiro的话没有提供默认实现，不过可以很容易的在Shiro中加入这个功能。那就是使用shiro强大的自定义访问控制拦截器：AccessControlFilter，集成这个接口后要实现下面这2个方法：isAccessAllowed、onAccessDenied
isAccessAllowed：表示是否允许访问；mappedValue就是[urls]配置中拦截器参数部分，如果允许访问返回true，否则false；
onAccessDenied：表示当访问拒绝时是否已经处理了；如果返回true表示需要继续处理；如果返回false表示该拦截器实例已经处理了，将直接返回即可。
部分代码：

public class KickOutSessionControlFilter extends AccessControlFilter {

    private static final Logger logger = LoggerFactory.getLogger(KickOutSessionControlFilter.class);

    /**
     * 踢出之前登录的/之后登录的用户 默认踢出之前登录的用户
     */
    private boolean kickOutAfter = false;
    /**
     * 同一个帐号最大会话数 默认1
     */
    private int maxSession = 1;
    /**
     * 会话管理器
     */
    private SessionManager sessionManager;
    /**
     * 会话缓存
     */
    private Cache<String, Deque<Serializable>> cache;

    public void setKickOutAfter(boolean kickOutAfter) {
        this.kickOutAfter = kickOutAfter;
    }

    public void setMaxSession(int maxSession) {
        this.maxSession = maxSession;
    }

    public void setSessionManager(SessionManager sessionManager) {
        this.sessionManager = sessionManager;
    }

    public void setCacheManager(RedisCacheManager cacheManager) {
        this.cache = cacheManager.getCache("shiro_redis_cache");
    }

    /**
     * 是否允许访问，返回true表示允许
     *
     * @param servletRequest
     * @param servletResponse
     * @param obj
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object obj) {
        return false;
    }

    /**
     * 表示访问拒绝时是否自己处理，如果返回true表示自己不处理且继续拦截器链执行，返回false表示自己已经处理了（比如重定向到另一个页面）。
     *
     * @param servletRequest
     * @param servletResponse
     * @return
     * @throws Exception
     */
    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        // 1同一个用户在不同ip上，不可以同时访问，后者会把前者踢出，即同一个用户不可以同时访问
        Subject subject = getSubject(servletRequest, servletResponse);
        System.out.println("===当前subject：==" + SecurityUtils.getSubject());
        if (!subject.isAuthenticated() && !subject.isRemembered()) {
            // 如果没有登录，直接进行之后的拦截器链
            return true;
        }
        // 当前用户
        User user = (User) subject.getPrincipal();
        String username = user.getUserName();
        
        // 当前会话
        Session session = subject.getSession();
        Serializable sessionId = session.getId();
        
        // 读取缓存用户 没有就存入
        Deque<Serializable> deque = cache.get(username);
        if (deque == null) {
            // 初始化队列
            deque = new ArrayDeque<Serializable>();
        }
        
        // 如果队列里没有当前会话sessionId，且当前会话未设置踢出标记（用户没有被踢出），放入队列
        if (!deque.contains(sessionId) && session.getAttribute("kickOut") == null) {
            // 将用户的sessionId存入队列
            deque.push(sessionId);
            // 将用户的sessionId存入队列缓存
            cache.put(username, deque);
        }
        
        // 如果队列里的sessionId数超出最大会话数，开始踢人
        while (deque.size() > maxSession) {
            Serializable kickOutSessionId = null;
            // 是否踢出后来登录的，默认是false，即后者登录的用户踢出前者登录的用户；
            if (kickOutAfter) {
                // 如果踢出后者
                kickOutSessionId = deque.removeFirst();
            } else {
                // 否则踢出前者
                kickOutSessionId = deque.removeLast();
            }
            // 踢出后再更新下缓存队列
            cache.put(username, deque);
            
            try {
                // 获取被踢出的sessionId的session对象
                Session kickOutSession = sessionManager.getSession(new DefaultSessionKey(kickOutSessionId));
                if (kickOutSession != null) {
                    // 设置会话的kickOut属性表示踢出了
                    kickOutSession.setAttribute("kickOut", true);
                    System.out.println("===将sessionId:==" + kickOutSession.getId() + "设置踢出标记");
                }
            } catch (Exception e) {
                // ignore exception
            }
        }
        // ajax请求，如果被踢出了，(前者或后者)直接退出，返回相应的状态
        if (session.getAttribute("kickOut") != null && (Boolean) session.getAttribute("kickOut") == true) {
            // 当前会话踢出标记不为空且等于true，会话被踢出了
            try {
                // 退出登录
                String ip = IPUtil.getIpAddress((HttpServletRequest) servletRequest);
                String url = ((HttpServletRequest) servletRequest).getRequestURL() + "";
                SecurityLogoutFilter.logout(subject);
                logger.info("IP地址为：" + ip + "的用户【" + username + "】被踢出，已在其他ip地址登录");
                ResponseUtil.returnResultAjax();
                return false;
            } catch (Exception e) {
                // ignore
            }
            return false;
        }
        return true;
    }
}

shiroFilterFactoryBean方法

		// 自定义过滤器
        Map<String, Filter> filters = new HashMap<>();
        // 同一用户登陆互踢
        filters.put("kickOut", kickOutSessionControlFilter());
		filterChainDefinitionMap.put("/**", "kickOut,authc");

定义拦截器的时候不需要加@Bean；

	//@Bean
    public KickoutSessionControlFilter kickoutSessionControlFilter(){
        KickoutSessionControlFilter kickoutSessionControlFilter = new KickoutSessionControlFilter();
        //用于根据会话ID，获取会话进行踢出操作的；
        //是否踢出后来登录的，默认是false；即后者登录的用户踢出前者登录的用户；
        kickoutSessionControlFilter.setKickoutAfter(false);
        //同一个用户最大的会话数，默认1；比如2的意思是同一个用户允许最多同时两个人登录；
        kickoutSessionControlFilter.setMaxSession(1);
        //被踢出后重定向到的地址
        kickoutSessionControlFilter.setKickoutUrl("/a/login");
        return kickoutSessionControlFilter;
    }

互踢分析：

1A用户第一次访问登录，进入互踢过滤器，获取当前会话，会话未认证不处理进入后面的拦截器，拦截器均未拦截住，进行正常登录获得会话token
2.1A用户第一次访问请求，进入互踢过滤器，获取当前会话，从cahe中获取deque，该deque不包含当前会话token且当前会话未设置标记，将会话token放入deque，放入cache，deque中token数量未超过1，当前会话的标记为空进入后面的拦截器
2.11A用户第二次访问请求，deque未变化，当前会话的标记为空进入后面的拦截器
2.2B用户第一次访问登录，进入互踢过滤器，获取当前会话，会话未认证不处理进入后面的拦截器，拦截器未拦截住，进行正常登录获得会话token
2.21B用户第一次访问请求，进入互踢过滤器，获取当前会话，从cache中获取deque，该deque不包含当前会话token且当前会话未设置标记，将会话token放入deque，放入cache，deque中token数量超过1，将deque中A的token删除，cache更新，将A的会话设置标记，当前会话的标记为空进入后面的拦截器
2.22B用户第二次访问请求，deque未变化，当前会话的标记为空进入后面的拦截器
3.1A用户第三次访问请求，进入互踢过滤器，获取当前会话，从cahe中获取deque，该deque不包含当前会话token但当前会话已设置标记不更新deque和cache，deque中的token数量未超过1，当前会话的标记不为空且为true，进行登出返回
3.2A用户第四次访问请求，会话过期请重新登录
4.1A用户第二次访问登录，进入进入互踢过滤器，获取当前会话，会话未认证不处理进入后面的拦截器，拦截器均未拦截住，进行正常登录获得会话token
4.2A用户第四次访问请求，进入互踢过滤器，获取当前会话，从cahe中获取deque，该deque不包含当前会话token且当前会话未设置标记，将会话token放入deque，放入cache，deque中token数量超过1，将deque中B的token删除，cache更新，将B的会话设备标记，当前会话的标记为空进入后面的拦截器
5B用户第三次访问请求，进入互踢过滤器，获取当前会话，从cahe中获取deque，该deque不包含当前会话token但当前会话已设置标记不更新deque和cache，deque中的token数量未超过1，当前会话的标记不为空且为true，进行登出返回
ldcaws
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot+Shiro学习之自定义拦截器管理在线用户（踢出用户）
qq_20954959的博客
03-05 1万+
应用场景 我们经常会有用到，当A 用户在北京登录 ，然后A用户在天津再登录 ，要踢出北京登录的状态。如果用户在北京重新登录，那么又要踢出天津的用户，这样反复。又或是需要限制同一用户的同时在线数量，超出限制后，踢出最先登录的或是踢出最后登录的。 第一个场景踢出用户是由用户触发的，有时候需要手动将某个在线用户踢出，也就是对当前在线用户的列表进行管理。 ··························
springboot+shiro+redis整合
03-12
在IT行业中，SpringBoot、Shiro和Redis是三个非常重要的技术组件，它们分别在不同的领域发挥...在实际应用中，还可以根据需要扩展Shiro的功能，比如添加自定义的拦截器，或者结合Spring Security进行更深度的安全控制。
springboot+shiro（自定义拦截器）+jwt实现前后端分离权限管理
点点的博客
07-13 4256
说明：前后端不分离的时候springboot+shiro可以实现有状态服务，前后端分离后工程就变成无状态服务，本文直接代码解决工程无状态问题。 一：前期准备工作 引入maven <!--token验证 jwt--> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9
在JAVA微服务项目中使用shiro全局拦截_shiro在微服务架构中如何使用
最新发布
2401_84968582的博客
05-14 359
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数网络安全工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上网络安全知识点！真正的体系化！
SpringBoot+Shiro实现登陆拦截功能
m0_67391521的博客
08-24 711
在我们自己的getAuthenticationInfo方法中，我们根据用户名查询出用户的信息，返回AuthenticationInfo对象，如果token与获取到的AuthenticationInfo都不为空，缓存AuthenticationInfo信息。–原先设定的没有访问权限的情况)。Subject: 即"用户"，外部应用都是和Subject进行交互的，subject记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。
springboot+shiro整合，自定义Shiro Filter过滤器
小哇
03-27 2269
关于springboot和shiro的整合，可以参考博文https://blog.csdn.net/qq_41712271/article/details/105127925 假如： /admin/order= roles["admin, root"] ，表示 /admin/order 这个接口需要用户同时具备 admin 与 root 角色 才可访问, 相当于hasAllRoles() 这个判...
SpringBoot+Shiro+JWT实现权限管理
m0_67390963的博客
08-24 1176
*** @description 自定义Realm,实现Shiro安全认证*/@Component/*** 必须重写此方法，不然会报错*/@Override}/*** 默认使用此方法进行用户名正确与否验证，错误抛出异常即可。*/@OverrideSystem.out.println("————身份认证方法————");// 解密获得username，用于和数据库进行对比。
SpringBoot+Shiro+Jwt实现登录认证
weixin_44740485的博客
05-08 1851
srpingboot这里就不再进行赘述，相信大家都非常的熟悉了 Shiro 一个安全框架，可以实现用户的认证和授权。比SpringSecurity要简单的多。 Jwt 我的理解就是可以进行客户端与服务端之间验证的一种技术，取代了之前使用 Session 来验证的不安全性 什么不适用 Session？ 原理是，登录之后客户端和服务端各自保存一个相应的 SessionId，每次客户端发起请求的时候就得携带这个 SessionId 来进行比对 1、Session 在用户请求量大的时候服务器开销太大了 2
springboot + shiro 静态资源拦截放行失效
m0_67402774的博客
04-25 1175
今天springboot 集成 shiro 的时候发现有的静态资源被放行，有的却被拦截了，先上filter代码 @Bean public ShiroFilterFactoryBean shiroFilter(DefaultWebSecurityManager securityManager){ ShiroFilterFactoryBean filter = new ShiroFilterFactoryBean(); // 过滤器就是shiro就行权限校验的核心，进
springboot+shiro+thymeleaf整合
桀骜浮沉的博客
03-04 595
springboot+shiro+thymeleaf整合 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jdbc</artifactId> </dependency> <dependen
【Java专题_01】springboot+Shiro+Jwt整合方案
weixin_40736233的博客
04-02 1万+
【Java专题_01】springboot+Shiro+Jwt整合方案
SpringBoot+shiro+redis+jwt .zip
01-03
4. `JwtTokenFilter.java`：自定义的过滤器，用于拦截请求，验证JWT并处理相关逻辑。 5. `UserServiceImpl.java`：用户服务接口实现，负责用户登录、权限验证等操作。 6. `RedisConfig.java`：`Redis`的相关配置，如...
管理系统系列--SpringBoot+Shiro权限管理系统脚手架.zip
02-25
通过配置Shiro的过滤器链，可以实现对不同资源的权限拦截，确保只有具备相应权限的用户才能访问特定的页面或接口。 在实际应用中，权限管理通常涉及到以下几个关键部分： 1. **用户认证**：用户登录时，Shiro会对...
springboot+Shiro 实现动态授权
09-05
最后，别忘了在`web.xml`或SpringBoot的配置中设置Shiro的过滤器，以便拦截请求并执行相应的安全逻辑。在这个项目中，由于使用了SpringBoot，我们可以在配置类中设置过滤器链，例如： ```java @Bean public ...
Springboot+Vue+shiro实现前后端分离、权限控制的示例代码
08-18
例如，使用Spring Boot的拦截器配置允许所有源的跨域请求： ```java @Component public class CommonInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest ...
idea中统计工程项目代码量
热门推荐
ldcaws的专栏
05-10 2万+
在工程应用中，有人会问你们写的应用系统的代码量是多少？额额，这个…下面就聊聊在idea工具中统计工程项目的代码量。
Java之hashMap遍历方式
ldcaws的专栏
02-19 2万+
在java开发中，hashMap是非常重要的容器类，存储的是键值对(key，value)。 HashMap继承AbstractMap，实现了Map、Cloneable、Serializable接口，非线程安全类，但是效率高。HashMap允许null健和null值，允许value重复，但不允许key重复。HashMap有两个参数影响其性能，初始容量和加载因子，当哈希表中的条目数超出加载因子与当前容量的乘积时，要对哈希表进行refresh操作，重建内部数据结构，容量扩大为之前的两倍，加载因子默认值为0.75。
Tomcat中clean操作的作用
ldcaws的专栏
07-29 1万+
如果你发现你的文件修改了、Tomcat也重启了，但访问的还是旧的文件，这个时候你需要clean下你的项目。 Clean will discard all build problems and built states. The projects will be rebuilt from scratch. 这里涉及到了一个单词build，build在程序员的词典里，应当不是建造的意思，应当是编
帮我写一个简单的demo项目，springboot+shiro+jwt+mybatis，数据库表1：user(id, username, password)，表2：role(id, rolename)，表3：permissions(id, permissionsname)，写出所有代码，不需要数据库代码和pmo.xml代码
05-26
好的，下面是一个简单的demo项目，基于Spring Boot集成Shiro和JWT进行权限控制，使用MyBatis操作数据库。 1. 创建一个Spring Boot项目，引入相关依赖： ``` <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.4.1</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>0.11.2</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <version>0.11.2</version> <scope>runtime</scope> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <version>0.11.2</version> <scope>runtime</scope> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.2.0</version> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope> </dependency> </dependencies> ``` 2. 配置Shiro相关的Bean和JWT相关的Bean，创建一个ShiroConfig类，并添加以下内容： ``` @Configuration public class ShiroConfig { @Bean public Realm realm() { // 创建自定义的Realm return new MyRealm(); } @Bean public SecurityManager securityManager() { // 创建SecurityManager，并设置Realm DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(); securityManager.setRealm(realm()); return securityManager; } @Bean public ShiroFilterFactoryBean shiroFilter() { // 创建ShiroFilterFactoryBean，并设置SecurityManager和拦截器 ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean(); shiroFilter.setSecurityManager(securityManager()); Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>(); filterChainDefinitionMap.put("/login", "anon"); filterChainDefinitionMap.put("/logout", "logout"); filterChainDefinitionMap.put("/**", "jwt"); shiroFilter.setFilterChainDefinitionMap(filterChainDefinitionMap); return shiroFilter; } @Bean public JwtRealm jwtRealm() { // 创建JwtRealm return new JwtRealm(); } @Bean public JwtFilter jwtFilter() { // 创建JwtFilter return new JwtFilter(); } } ``` 3. 配置MyBatis相关的Bean，创建一个MyBatisConfig类，并添加以下内容： ``` @Configuration @MapperScan("com.example.demo.mapper") public class MyBatisConfig { @Bean public DataSource dataSource() { // 创建H2数据库 return new EmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.H2) .addScript("schema.sql") .build(); } @Bean public SqlSessionFactory sqlSessionFactory() throws Exception { // 创建SqlSessionFactory，并设置DataSource和Mapper SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean(); sessionFactory.setDataSource(dataSource()); PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(); sessionFactory.setMapperLocations(resolver.getResources("classpath:/mapper/*.xml")); return sessionFactory.getObject(); } } ``` 4. 创建一个User实体类，包含id、username和password字段。 ``` public class User { private Long id; private String username; private String password; // getter和setter方法省略 } ``` 5. 创建一个Role实体类，包含id和roleName字段。 ``` public class Role { private Long id; private String roleName; // getter和setter方法省略 } ``` 6. 创建一个Permission实体类，包含id和permissionName字段。 ``` public class Permission { private Long id; private String permissionName; // getter和setter方法省略 } ``` 7. 创建一个UserMapper接口，定义对User表的操作。 ``` @Mapper public interface UserMapper { User findByUsername(String username); } ``` 8. 创建一个RoleMapper接口，定义对Role表的操作。 ``` @Mapper public interface RoleMapper { List<Role> findByUserId(Long userId); } ``` 9. 创建一个PermissionMapper接口，定义对Permission表的操作。 ``` @Mapper public interface PermissionMapper { List<Permission> findByRoleId(Long roleId); } ``` 10. 创建一个UserService类，添加以下内容： ``` @Service public class UserService { @Autowired private UserMapper userMapper; @Autowired private RoleMapper roleMapper; @Autowired private PermissionMapper permissionMapper; public User findByUsername(String username) { return userMapper.findByUsername(username); } public List<Role> findRolesByUserId(Long userId) { return roleMapper.findByUserId(userId); } public List<Permission> findPermissionsByRoleId(Long roleId) { return permissionMapper.findByRoleId(roleId); } } ``` 11. 创建一个JwtUtils类，添加以下内容： ``` public class JwtUtils { private static final String SECRET_KEY = "mysecretkey"; // 密钥 private static final long EXPIRATION_TIME = 60 * 60 * 24 * 7; // 过期时间，单位为秒 // 生成JWT public static String generateToken(String username) { Date now = new Date(); Date expirationDate = new Date(now.getTime() + EXPIRATION_TIME * 1000); return Jwts.builder() .setSubject(username) .setIssuedAt(now) .setExpiration(expirationDate) .signWith(SignatureAlgorithm.HS256, SECRET_KEY) .compact(); } // 解析JWT public static Claims parseToken(String token) { return Jwts.parser() .setSigningKey(SECRET_KEY) .parseClaimsJws(token) .getBody(); } // 验证JWT public static boolean validateToken(String token) { try { Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token); return true; } catch (Exception e) { return false; } } } ``` 12. 创建一个JwtRealm类，继承AuthorizingRealm类，添加以下内容： ``` public class JwtRealm extends AuthorizingRealm { @Autowired private UserService userService; // 支持JwtToken @Override public boolean supports(AuthenticationToken token) { return token instanceof JwtToken; } // 授权 @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { String username = (String) principals.getPrimaryPrincipal(); List<Role> roles = userService.findRolesByUserId(1L); // 假设用户ID为1 List<String> roleNames = roles.stream().map(Role::getRoleName).collect(Collectors.toList()); SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo(); authorizationInfo.addRoles(roleNames); for (Role role : roles) { List<Permission> permissions = userService.findPermissionsByRoleId(role.getId()); List<String> permissionNames = permissions.stream().map(Permission::getPermissionName).collect(Collectors.toList()); authorizationInfo.addStringPermissions(permissionNames); } return authorizationInfo; } // 认证 @Override protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException { String username = (String) token.getPrincipal(); User user = userService.findByUsername(username); if (user == null) { throw new UnknownAccountException(); } return new SimpleAuthenticationInfo(username, user.getPassword(), getName()); } } ``` 13. 创建一个JwtToken类，实现AuthenticationToken接口，添加以下内容： ``` public class JwtToken implements AuthenticationToken { private String token; public JwtToken(String token) { this.token = token; } @Override public Object getPrincipal() { return JwtUtils.parseToken(token).getSubject(); } @Override public Object getCredentials() { return token; } } ``` 14. 创建一个JwtFilter类，继承BasicHttpAuthenticationFilter类，添加以下内容： ``` public class JwtFilter extends BasicHttpAuthenticationFilter { @Override protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) { String token = getToken(request); if (token == null || !JwtUtils.validateToken(token)) { return false; } JwtToken jwtToken = new JwtToken(token); try { getSubject(request, response).login(jwtToken); return true; } catch (Exception e) { return false; } } @Override protected boolean onAccessDenied(ServletRequest request, ServletResponse response) { response.setContentType("application/json;charset=UTF-8"); try { PrintWriter out = response.getWriter(); out.write("{\"code\":401,\"message\":\"未登录\"}"); out.flush(); out.close(); } catch (IOException e) { e.printStackTrace(); } return false; } private String getToken(ServletRequest request) { HttpServletRequest httpServletRequest = (HttpServletRequest) request; String token = httpServletRequest.getHeader("Authorization"); if (StringUtils.isNotEmpty(token) && token.startsWith("Bearer ")) { return token.substring(7); } return null; } } ``` 15. 创建一个UserController类，添加以下内容： ``` @RestController public class UserController { @Autowired private UserService userService; @PostMapping("/login") public String login(String username, String password) { User user = userService.findByUsername(username); if (user == null || !user.getPassword().equals(password)) { return "{\"code\":401,\"message\":\"用户名或密码错误\"}"; } String token = JwtUtils.generateToken(username); return "{\"code\":200,\"message\":\"登录成功\",\"token\":\"" + token + "\"}"; } @GetMapping("/user") @RequiresPermissions("user:view") public String viewUser() { return "View User"; } } ``` 以上是一个简单的demo项目，实现了基于Spring Boot集成Shiro和JWT进行权限控制，使用MyBatis操作数据库。需要注意的是，这里的代码仅供参考，具体实现还需要根据实际情况进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值