springboot+mybatis+shiro——登录认证和权限控制

最新推荐文章于 2022-03-22 13:12:18 发布
最新推荐文章于 2022-03-22 13:12:18 发布
阅读量480 收藏 1
点赞数 1
分类专栏： 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011874298/article/details/87692401
版权

引入依賴

 <!-- Shiro shiro-core是核心包 shiro-web是与web整合 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
            <version>1.3.2</version>
        </dependency>

        <!-- shiro+redis缓存插件 -->
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>2.4.2.1-RELEASE</version>
        </dependency>

数据库

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for u_permission
-- ----------------------------
DROP TABLE IF EXISTS `u_permission`;
CREATE TABLE `u_permission` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `url` varchar(256) DEFAULT NULL COMMENT 'url地址',
  `name` varchar(64) DEFAULT NULL COMMENT 'url描述',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of u_permission
-- ----------------------------
INSERT INTO `u_permission` VALUES ('1', '/user/select', '用户查询');
INSERT INTO `u_permission` VALUES ('2', '/admin/add', '管理员添加');
INSERT INTO `u_permission` VALUES ('3', '/admin/delete', '管理员删除');

-- ----------------------------
-- Table structure for u_role
-- ----------------------------
DROP TABLE IF EXISTS `u_role`;
CREATE TABLE `u_role` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) DEFAULT NULL COMMENT '角色名称',
  `type` varchar(10) DEFAULT NULL COMMENT '角色类型',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of u_role
-- ----------------------------
INSERT INTO `u_role` VALUES ('1', 'admin', '1');
INSERT INTO `u_role` VALUES ('2', 'user', '1');
INSERT INTO `u_role` VALUES ('3', 'visitor', '1');

-- ----------------------------
-- Table structure for u_role_permission
-- ----------------------------
DROP TABLE IF EXISTS `u_role_permission`;
CREATE TABLE `u_role_permission` (
  `rid` bigint(20) DEFAULT NULL COMMENT '角色ID',
  `pid` bigint(20) DEFAULT NULL COMMENT '权限ID'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of u_role_permission
-- ----------------------------
INSERT INTO `u_role_permission` VALUES ('1', '3');
INSERT INTO `u_role_permission` VALUES ('1', '2');
INSERT INTO `u_role_permission` VALUES ('2', '1');

-- ----------------------------
-- Table structure for u_user
-- ----------------------------
DROP TABLE IF EXISTS `u_user`;
CREATE TABLE `u_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `nickname` varchar(20) DEFAULT NULL COMMENT '用户昵称',
  `email` varchar(128) DEFAULT NULL COMMENT '邮箱|登录帐号',
  `pswd` varchar(32) DEFAULT NULL COMMENT '密码',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `last_login_time` datetime DEFAULT NULL COMMENT '最后登录时间',
  `status` bigint(1) DEFAULT '1' COMMENT '1:有效，0:禁止登录',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of u_user
-- ----------------------------
INSERT INTO `u_user` VALUES ('1', 'admin', null, '123456', '2017-05-10 20:22:59', null, '1');
INSERT INTO `u_user` VALUES ('2', 'user', null, '123456', null, null, '1');

-- ----------------------------
-- Table structure for u_user_role
-- ----------------------------
DROP TABLE IF EXISTS `u_user_role`;
CREATE TABLE `u_user_role` (
  `uid` bigint(20) DEFAULT NULL COMMENT '用户ID',
  `rid` bigint(20) DEFAULT NULL COMMENT '角色ID'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of u_user_role
-- ----------------------------
INSERT INTO `u_user_role` VALUES ('1', '1');
INSERT INTO `u_user_role` VALUES ('2', '2');
SET FOREIGN_KEY_CHECKS=1;

控制层

package com.gift_redemption.controller;

import com.gift_redemption.model.UUser;
import org.apache.ibatis.annotations.Param;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

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


/**
 * @Auther: ZhuFei
 * @Date: 2019/2/15 14:53
 * @Description:
 */
@RestController
public class LoginController {
    private static Logger logger = LoggerFactory.getLogger(LoginController.class);


    //跳转到登录表单页面
    @PostMapping("login")
    public String login() {
//        ModelAndView
        return "need login";
    }

    //登录成功后，跳转的页面
    @PostMapping("success")
    public String index() {
        return "success";
    }

    //未登录，可以访问的页面
    @PostMapping("index")
    public String list(UUser user) {
        return "index";
    }

    //登陆验证，这里方便url测试，正式上线需要使用POST方式提交
    @PostMapping("ajaxLogin")
    public String index(@RequestBody UUser user) {
        if (user.getNickname() != null && user.getPswd() != null) {
            UsernamePasswordToken token = new UsernamePasswordToken(user.getNickname(), user.getPswd(), "login");
            Subject currentUser = SecurityUtils.getSubject();
            logger.info("对用户[" + user.getNickname() + "]进行登录验证..验证开始");
            try {
                currentUser.login( token );
                //验证是否登录成功
                if (currentUser.isAuthenticated()) {
                    logger.info("用户[" + user.getNickname() + "]登录认证通过(这里可以进行一些认证通过后的一些系统参数初始化操作)");
                    System.out.println("用户[" + user.getNickname() + "]登录认证通过(这里可以进行一些认证通过后的一些系统参数初始化操作)");
                    return "redirect:/";
                } else {
                    token.clear();
                    System.out.println("用户[" + user.getNickname() + "]登录认证失败,重新登陆");
                    return "redirect:/login";
                }
            } catch ( UnknownAccountException uae ) {
                logger.info("对用户[" + user.getNickname() + "]进行登录验证..验证失败-username wasn't in the system");
            } catch ( IncorrectCredentialsException ice ) {
                logger.info("对用户[" + user.getNickname() + "]进行登录验证..验证失败-password didn't match");
            } catch ( LockedAccountException lae ) {
                logger.info("对用户[" + user.getNickname() + "]进行登录验证..验证失败-account is locked in the system");
            } catch ( AuthenticationException ae ) {
                logger.error(ae.getMessage());
            }
        }
        return "login";
    }

    /**
     * ajax登录请求接口方式登陆
     * @param username
     * @param password
     * @return
     */
    @PostMapping
    @ResponseBody
    public Map<String,Object> submitLogin(@Param(value = "nickname") String username,
                                          @Param(value = "pswd") String password) {
        Map<String, Object> resultMap = new LinkedHashMap<>();
        try {

            UsernamePasswordToken token = new UsernamePasswordToken(username, password);
            SecurityUtils.getSubject().login(token);
            resultMap.put("status", 200);
            resultMap.put("message", "登录成功");

        } catch (Exception e) {
            resultMap.put("status", 500);
            resultMap.put("message", e.getMessage());
        }
        return resultMap;
    }

    //登出
    @PostMapping("logout")
    public String logout(){
        return "logout";
    }

    //错误页面展示
    @PostMapping("403")
    public String error(){
        return "error ok!";
    }

    //管理员功能
    @RequiresRoles("admin")
    @RequiresPermissions("管理员添加")
    @PostMapping("admin/add")
    public String create(){
        return "add success!";
    }

    //用户功能
    @RequiresRoles("user")
    @RequiresPermissions("用户查询")
    @PostMapping("user_select")
    public String detail(){
        return "select success";
    }


}

Shiro配置

package com.gift_redemption.config;

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.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;

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

/**
 * @Auther: ZhuFei
 * @Date: 2019/2/15 15:14
 * @Description:
 */
@Configuration
public class ShiroConfiguration {
    /**
     * ShiroFilterFactoryBean 处理拦截资源文件问题。
     * 注意：单独一个ShiroFilterFactoryBean配置是或报错的，以为在
     * 初始化ShiroFilterFactoryBean的时候需要注入：SecurityManager
     *
     * Filter Chain定义说明 1、一个URL可以配置多个Filter，使用逗号分隔 2、当设置多个过滤器时，全部验证通过，才视为通过
     * 3、部分过滤器可指定参数，如perms，roles
     *
     */

    @Bean(name = "lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    @Bean(name = "shiroRealm")
    @DependsOn("lifecycleBeanPostProcessor")
    public ShiroRealm shiroRealm() {
        ShiroRealm realm = new ShiroRealm();
        return realm;
    }

    /*@Bean(name = "ehCacheManager")
    @DependsOn("lifecycleBeanPostProcessor")
    public EhCacheManager ehCacheManager(){
        EhCacheManager ehCacheManager = new EhCacheManager();
        return ehCacheManager;
    }*/
    /**
     * 配置shiro redisManager
     * 网上的一个 shiro-redis 插件，实现了shiro的cache接口、CacheManager接口就
     * @return
     */
    @Bean
    public RedisManager redisManager() {
        RedisManager redisManager = new RedisManager();
        redisManager.setHost("localhost");
        redisManager.setPort(6379);
        redisManager.setExpire(18000);// 配置过期时间
        // redisManager.setTimeout(timeout);
        // redisManager.setPassword(password);
        return redisManager;
    }
        /**
         * cacheManager 缓存 redis实现
         * 网上的一个 shiro-redis 插件
         * @return
        */
    @Bean
    public RedisCacheManager cacheManagers() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }
    /**
     * RedisSessionDAO shiro sessionDao层的实现 通过redis
     */
    /*public RedisSessionDAO redisSessionDAO() {
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }*/
    /**
     * shiro session的管理
     */
    /*public DefaultWebSessionManager SessionManager() {
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setSessionDAO(redisSessionDAO());
        return sessionManager;
    }*/

    @Bean(name = "securityManager")
    public DefaultWebSecurityManager securityManager(){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(shiroRealm());
        securityManager.setCacheManager(cacheManagers());//用户授权/认证信息Cache, 采用EhCache 缓存
        return securityManager;
    }

    @Bean(name = "shiroFilter")
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        // 过滤链定义，从上向下顺序执行，一般将 /**放在最为下边
        Map<String, String> filterChainDefinitionManager = new LinkedHashMap<>();
        // 配置退出过滤器,其中的具体的退出代码Shiro已经替我们实现了
        filterChainDefinitionManager.put("/logout", "logout");
        // authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问
        filterChainDefinitionManager.put("/user/**", "authc,roles[user]");
        filterChainDefinitionManager.put("/admin/**", "authc,roles[admin]");
        filterChainDefinitionManager.put("/login", "anon");
        filterChainDefinitionManager.put("/index", "anon");
        filterChainDefinitionManager.put("/ajaxLogin", "anon");
        filterChainDefinitionManager.put("/statistic/**",  "anon");
        filterChainDefinitionManager.put("/**",  "authc,roles[user]");//其他资源全部拦截
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionManager);
        // 如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
        shiroFilterFactoryBean.setLoginUrl("/login");
        // 登录成功后要跳转的链接
        shiroFilterFactoryBean.setSuccessUrl("/success");
        // 未授权界面
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");

        return shiroFilterFactoryBean;
    }

    @Bean
    @ConditionalOnMissingBean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator daap = new DefaultAdvisorAutoProxyCreator();
        daap.setProxyTargetClass(true);
        return daap;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor aasa = new AuthorizationAttributeSourceAdvisor();
        aasa.setSecurityManager(securityManager);
        return aasa;
    }
}

ShiroRealm.java

package com.gift_redemption.config;

import com.gift_redemption.model.UPermission;
import com.gift_redemption.model.URole;
import com.gift_redemption.model.UUser;
import com.gift_redemption.service.PermissionService;
import com.gift_redemption.service.RoleService;
import com.gift_redemption.service.UserService;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

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

/**
 * @Auther: ZhuFei
 * @Date: 2019/2/15 11:19
 * @Description:配置对应的验证，以及过滤条件
 */

//实现AuthorizingRealm接口用户用户认证
public class ShiroRealm extends AuthorizingRealm {

    private Logger logger = LoggerFactory.getLogger(ShiroRealm.class);

    @Autowired
    private UserService userService;
    @Autowired
    private RoleService roleService;
    @Autowired
    private PermissionService permissionService;

    /**
     * 登录认证
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        logger.info("验证当前Subject时获取到token为：" + token.toString());
        //查出是否有此用户
        String username = token.getUsername();
        UUser hasUser = userService.findUserByName(username);

        if (hasUser != null) {
            // 若存在，将此用户存放到登录认证info中，无需自己做密码对比，Shiro会为我们进行密码对比校验
            List<URole> rlist = roleService.findRoleByUserId(hasUser.getId());//获取用户角色
            List<Long> roleIds = new ArrayList<>();
            rlist.forEach(item -> roleIds.add(item.getId()));
            List<UPermission> plist = permissionService.findListByRoleIds(roleIds);//获取用户权限

            List<URole> roleStrlist=new ArrayList<>();用户的角色集合
            List<UPermission> perminsStrlist=new ArrayList<>();//用户的权限集合

            List<String> roleNames=new ArrayList<>();用户的角色集合
            List<String> pNames=new ArrayList<>();//用户的权限集合
            for (URole role : rlist) {
                roleStrlist.add(role);
                roleNames.add(role.getName());
            }
            for (UPermission uPermission : plist) {
                perminsStrlist.add(uPermission);
                pNames.add(uPermission.getName());
            }
            hasUser.setRoleNames(roleNames);
            hasUser.setPermissionNames(pNames);
            hasUser.setRoles(roleStrlist);
            hasUser.setPermissions(perminsStrlist);
            // 若存在，将此用户存放到登录认证info中，无需自己做密码对比，Shiro会为我们进行密码对比校验
            return new SimpleAuthenticationInfo(hasUser, hasUser.getPswd(), getName());
        }

        return null;
    }

    /**
     * 权限认证
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        logger.info("##################执行Shiro权限认证##################");
        UUser user = (UUser) principalCollection.getPrimaryPrincipal();
        if (user != null) {
            //权限信息对象info,用来存放查出的用户的所有的角色（role）及权限（permission）
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            //用户的角色集合
            info.addRoles(user.getRoleNames());
            //用户的权限集合
            info.addStringPermissions(user.getPermissionNames());

            return info;
        }
        // 返回null的话，就会导致任何用户访问被拦截的请求时，都会自动跳转到unauthorizedUrl指定的地址
        return null;
    }
}

测试

君允
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
企业员工角色权限管理平台（SpringBoot2.0+Mybatis+Shiro+Vue）
08-07
课程简介：历经半个多月的时间，Debug亲自撸的 “企业员工角色权限管理平台” 终于完成了。正如字面意思，本课程讲解的是一个真正意义上的、企业级的项目实战，主要介绍了企业级应用系统中后端应用权限的管理，其中主要涵盖了六大核心业务模块、十几张数据库表。 其中的核心业务模块主要包括用户模块、部门模块、岗位模块、角色模块、菜单模块和系统日志模块；与此同时，Debug还亲自撸了额外的附属模块，包括字典管理模块、商品分类模块以及考勤管理模块等等，主要是为了更好地巩固相应的技术栈以及企业应用系统业务模块的开发流程！ 核心技术栈列表： 值得介绍的是，本课程在技术栈层面涵盖了前端和后端的大部分常用技术，包括Spring Boot、Spring MVC、Mybatis、Mybatis-Plus、Shiro(身份认证与资源授权跟会话等等)、Spring AOP、防止XSS攻击、防止SQL注入攻击、过滤器Filter、验证码Kaptcha、热部署插件Devtools、POI、Vue、LayUI、ElementUI、JQuery、HTML、Bootstrap、Freemarker、一键打包部署运行工具Wagon等等，如下图所示： 课程内容与收益： 总的来说，本课程是一门具有很强实践性质的“项目实战”课程，即“企业应用员工角色权限管理平台”，主要介绍了当前企业级应用系统中员工、部门、岗位、角色、权限、菜单以及其他实体模块的管理；其中，还重点讲解了如何基于Shiro的资源授权实现员工-角色-操作权限、员工-角色-数据权限的管理；在课程的最后，还介绍了如何实现一键打包上传部署运行项目等等。如下图所示为本权限管理平台的数据库设计图： 以下为项目整体的运行效果截图： 值得一提的是，在本课程中，Debug也向各位小伙伴介绍了如何在企业级应用系统业务模块的开发中，前端到后端再到数据库，最后再到服务器的上线部署运行等流程，如下图所示：
shiro进行权限控制的四种方式
m0_67402026的博客
04-07 6327
我们使用shiro进行权限控制 有以下几种方式 1. URL拦截权限控制：基于filter过滤器实现 我们在spring配置文件中配置shiroFilter时配置 /css/ = anon /js/ = anon /images/ = anon /validatecode.jsp = anon /login.jsp = anon /userActionlogin.action = anon /pagebasestaff.action = perms\["staff-
springboot+mybatis整合shiro
qq_45009980的博客
09-24 288
参考了b站的springboot视频。 1、shiro简介 它是阿帕奇的java安全框架。包含了三个主要对象：subject（当前用户）、SecurityManager（安全管理）、Realm（数据相关）。 Shiro 可以帮助我们完成：认证、授权、加密、会话管理、与 Web 集成、缓存等。其基本功能点如下图所示： shiro详细介绍 2、demo结构： 3、使用了springboot、mybatis、druid etc，实现登录控制，用户认证、请求授权（本文没有实现授权）等。 4、首先搭建环境： j
springboot+mybatis+shiro搭建教程(附数据表结构)
qq_22899047的博客
09-02 886
翻了下，网上的带持久化结构的教程都没用mybatis的版本，也很少有带数据表结构的，就自己动手写了这么一个教程，接下来废话不多说，上干货 项目结构 首先，把数据表准备好 user(用户表) userId 用户id userName 用户名 password 用户密码 ...
手把手教你 SpringBoot+MyBatis+Shiro 搭建项目框架
程序员小乐
03-22 1057
点击上方 "程序员小乐"关注,星标或置顶一起成长每天凌晨00点00分,第一时间与你相约每日英文I will care even mo...
myshiro:提供一套基于SpringBoot+layui+Shiro+tk_mybatis 的权限管理思路.前后端都加以控制,做到按钮接口级别的权限管理系统 ,在线地址：http
05-14
安全框架采用Shiro，可实现对按钮级别的权限控制,前端页面使用LayUI构建，主题风格小清新简洁， ,使用activiti实现业务流程的管理。 系统模块（已完成） 请假模块 （已完成） 演示环境账号密码： 账号 密码 权限 ...
基于SpringBoot+Layui+shiro安全框架和Ehcache缓存框架搭建的学生管理系统源码+项目说明.zip
01-08
我在菜单栏用了shiro标签对菜单进行控制，根据登录用户的不同，显示不同的菜单和操作按钮。 新接触的Layui的表单可以说是非常实用了，但是我用ehcache缓存对list集合进行缓存时，layui的表格分页功能就会失效（比如...
基于SpringBoot的后端server脚手架，集成MyBatis、Shiro+源代码+文档说明
11-28
## 权限控制 —— shiro `server-api`模块集成了shiro进行权限控制，参见`com.boilerplate.server.init.ShiroConfig`类。 对于纯粹的后端server而言，可能还需要自己实现一个生成错误json的filter来替换默认...
基于SpringBoot+Layui搭建的学生管理系统源码+项目说明（毕设）.zip
01-06
我在菜单栏用了shiro标签对菜单进行控制，根据登录用户的不同，显示不同的菜单和操作按钮。 新接触的Layui的表单可以说是非常实用了，但是我用ehcache缓存对list集合进行缓存时，layui的表格分页功能就会失效（比如...
采用SpringBoot2.0、MyBatis-plus、Shiro框架，开发的一套权限系统
最新发布
03-08
采用SpringBoot2.0、MyBatis-plus、Shiro框架，开发的一套权限系统，敏捷开发代码生成器 基于人人开源二次封装改造，内置生成JSP，HTML，VUE，AVUE样板.zip 适合学习/练手、毕业设计、课程设计、期末/期中/大作业、...
springboot+mybatis+shiro整合
12-06
该项目使用maven模块架构，springboot集成了mybatis，shiro，因为时间短，目前只达到了该结构，该项目引用了公司jar，里面全部是工具类
springboot+mybatis+shiro权限控制
04-04
springboot+mybatis+shiro+mysql实现 数据查询，动态权限控制，以及错误统一拦截处理，权限控制的是控制后台粗粒度控制。想要页面实现细粒度，直接在页面加shrio的标签就行，后台都是整通了的，压缩包中包含 数据库文件数据，mybatis动态生成mapper等等
SpringBoot+MyBatis+Shiro权限管理系统
12-23
适合学习SpringBoot、MyBatis、Shiro的开发小白，包含源码和数据脚本，文章地址：https://blog.csdn.net/u013343114/article/details/111592137
springBoot集成mybatis+shiro+jsp
11-01
springBoot框架搭建以及mybatis和修改默认模板为加载jsp页面和shiro验证登陆，访问http://127.0.0.1:8080/index
基于springBoot+mybatis+shiro后台管理系统
09-02
基于springBoot+mybatis+shiro+thymeleaf 模板引擎 实现的后台管理系统，可以在当前系统的基础上进行二次开发
Spring Boot 整合 Shiro + MyBatis
菜可夫斯基的博客
03-22 988
创建Spring Boot 工程，并添加依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring-boot-web-starter</artifactId> <version>1.8.0</version> </dep.
springboot+shiro+mybatis实现角色权限控制
热门推荐
牧竹子
05-11 3万+
背景spring+spirngmvc+shiro的整合已经有很多了，之前的项目中也用过，但是最近想在springboot中使用shiro这样，其他项目需要的时候只需要把它依赖进来就可以直接使用，至于shiro的原理其他的blog都有很多介绍。这里只讲几个重点在项目中注意的地方。 shiro官网 http://shiro.apache.org/shiro配置中重要的几个文件其实最重要的就是shir
springboot+mybatis+shiro的简单应用
m0_49562228的博客
08-13 240
Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。三个核心组件：Subject, SecurityManager 和 Realms. Subject：即“当前操作用户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是第三方进程、后台帐户（Daemon Account） 或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。Subject代表了当前用户的安全操作，SecurityManager则管理所有用户的安全操作。 SecurityMan
spring boot +mybatis+shiro
lichongda的专栏
04-25 5662
技术框架采用spring boot +mybatis+shiro无状态的方式，缓存使用redis。整个架构采用异步+json的方式传输，前端使用layUI，权限控制到按钮级别,多说无意，直接贴代码. 登陆页面: 首页： 用户管理： 角色管理： 菜单管理: 定时任务： 定时任务支持动态添
bootstrap+springboot+mybatis+shiro
05-12
Bootstrap、Spring Boot、MyBatis、Shiro都是在开发中常用的框架和工具。 Bootstrap是一个流行的前端开发框架，它提供了许多UI组件和样式，简化了Web页面的开发过程，使页面看起来更加美观和易于使用。 Spring ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值