精华内容
下载资源
问答
  • Spring Boot-Shiro-Vue 提供一套基于SpringBoot-shiro-vue的权限管理思路. 前后端都加以控制,做到按钮/接口级别的权限 DEMO admin/123456 管理员身份登录,可以新增用户,角色. 角色可以分配权限 控制菜单是否显示,...
  • 前后端分离的权限管理综合demo,包含技术点:springboot、mybatis(使用tkmapper)、shirovue、bootstrap、axios、sweetalert、webpack
  • vue+shiro实现前端细颗粒按钮级权限,并且可以实现删除和禁用两种不同模式,里面需要的前置技术包括 :vue\vue的自定义指令\vue的自定义插件\vuex
  • springboot+vue+shiro 前后盾分离,权限整合,vue路由配置解析,有sql语句,shiro 权限验证。
  • springboot + jwt + shiro + vue建造的前端项目 技术交流:QQ--1649471814 项目技术 应用了vue全家桶vue-cli3.0 + vuex axios vue-router elementUi。 项目部署 1.首先安装node和vue的基本环境,自行上网百度。 2.cd...
  • 是基于Spring Boot、ShiroVue等技术进行开发,主要是对后台管理系统常用模块前后端整体抽取构建成通用模板。也是集中对权限管理进行再次封装,以至于简单操作,便于二次开发代码重复。主要实现管理员管理、角色...
  • 适用人群Java开发人员,Vue开发人员,前后端分离开发人员,权限管理和配置开发人员 课程概述【讲师介绍】讲师职称: 现某知名大型互联网公司资深架构师,技术总监,职业规划师,首席面试官,曾在某上市培训机构,...
  • springboot shiro vue造成的跨域问题

    千次阅读 2019-04-24 10:00:44
    复杂请求 造成复杂请求的原因就是在请求头部添加了token等信息,浏览器会认为是复杂请求。复杂请求的执行过程是有两... 预请求直接被shiro拦截了,所以真正的请求永远也到不了后台,这个就是问题的关键。此时需要...

    复杂请求

               造成复杂请求的原因就是在请求头部添加了token等信息,浏览器会认为是复杂请求。复杂请求的执行过程是有两步的,浏览器会提前发送一个探针请求(也叫预请求)到服务端,这个请求通过以后才会将真正的请求带着header的信息发送出去

    预请求被拦截

                  预请求直接被shiro拦截了,所以真正的请求永远也到不了后台,这个就是问题的关键。此时需要自定义一个拦截器来处理预请求的问题

    package com.**.common.shiro.filter;
    
    import org.apache.shiro.web.filter.authc.PassThruAuthenticationFilter;
    import org.apache.shiro.web.util.WebUtils;
    import org.springframework.web.bind.annotation.RequestMethod;
    
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class MyShiroAuthFilter extends PassThruAuthenticationFilter {
    
    
    	@Override
    	public boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
    		HttpServletRequest req = (HttpServletRequest)request;
    		if(req.getMethod().equals(RequestMethod.OPTIONS.name())){
    			return true;
    		}
    		return super.onPreHandle(request, response, mappedValue);
    	}
    	@Override
    	protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
    		HttpServletResponse httpResp = WebUtils.toHttp(response);
    		HttpServletRequest httpReq = WebUtils.toHttp(request);
    
    		/**系统重定向会默认把请求头清空,这里通过拦截器重新设置请求头,解决跨域问题*/
    		httpResp.addHeader("Access-Control-Allow-Origin", httpReq.getHeader("Origin"));
    		httpResp.addHeader("Access-Control-Allow-Headers", "*");
    		httpResp.addHeader("Access-Control-Allow-Methods", "*");
    		httpResp.addHeader("Access-Control-Allow-Credentials", "true");
    
    		WebUtils.toHttp(response).sendRedirect(httpReq.getContextPath()+"/user/unauth");
    		return false;
    	}
    
    }
    

     然后在shiro的配置文件中添加过滤器

     @Bean
        public ShiroFilterFactoryBean shirFilter(DefaultWebSecurityManager securityManager) {
    
            ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
            shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager());
            Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
    
            //注意过滤器配置顺序 不能颠倒
            //配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了,登出后跳转配置的loginUrl
            filterChainDefinitionMap.put("/user/logout", "logout");
            shiroFilterFactoryBean.setLoginUrl("/user/unauth");
            filterChainDefinitionMap.put("/user/unauth", "anon");
            filterChainDefinitionMap.put("/user/login", "anon");
    
            /**swagger拦截配置*/
            filterChainDefinitionMap.put("/swagger-ui.html", "anon");
            filterChainDefinitionMap.put("/swagger-resources/**", "anon");
            filterChainDefinitionMap.put("/swagger-resources", "anon");
            filterChainDefinitionMap.put("/v2/api-docs", "anon");
            filterChainDefinitionMap.put("/webjars/springfox-swagger-ui/**", "anon");
    
            Map<String, Filter> filters = new HashMap<>();
            filters.put("authc",new MyShiroAuthFilter());
            shiroFilterFactoryBean.setFilters(filters);
            filterChainDefinitionMap.put("/**", "authc");
            shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
            return shiroFilterFactoryBean;
        }

     

    展开全文
  • 前后端分离的时候,我在服务器的controller...在vue.js中能得到数据,但是只要加了shiro他就会显示![图片说明](https://img-ask.csdn.net/upload/201808/15/1534335492_175068.png),请问前端或者后台还需要怎么配置吗
  • 包括Spring Boot、Spring MVC、Mybatis、Mybatis-Plus、Shiro(身份认证与资源授权跟会话等等)、Spring AOP、防止XSS攻击、防止SQL注入攻击、过滤器Filter、验证码Kaptcha、热部署插件Devtools、POI、Vue、LayUI、...
  • vue+element+springboot+shiro权限控制,mysql数据库 登录帐号/密码 admin:111111
  • 止步传统CRUD,进阶代码优化:一套基于Spring Boot+Vue+Shiro前后端分离的代码生成器
  • springboot-整合shirovue的验证登录和权限

    万次阅读 热门讨论 2018-11-20 01:03:52
    springboot-整合shirovue的验证登录和权限 文章目录springboot-整合shirovue的验证登录和权限1.配置1.1数据表这里权限控制有5张表,详情见代码中的test.sql文件1.2工程说明:1.3springboot下的shiro配置1.4...

    springboot-整合shiro和vue的验证登录和权限

    完整代码下载链接:

    https://github.com/2010yhh/springBoot-demos/tree/master/springboot-shiro

    环境

    idea2018,jdk1.8,

    springboot版本:springboot1.5.9.RELEASE

    durid连接

    1.配置

    1.1数据表

    这里权限控制有5张表,详情见代码中的test.sql文件

    项目中的用户权限可以是:菜单,按钮,api,url,数据等可以控制的资源
    

    在这里插入图片描述

    MD5 hash密码比对器,db中密码已md5字符串存储:

    1.2工程说明:

    在这里插入图片描述
    pom需要的shiro相关jar包:

     <!-- shiro ehcache -->
            <dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-ehcache</artifactId>
                <version>1.2.2</version>
            </dependency>
            <!-- shiro spring. -->
            <dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-spring</artifactId>
                <version>1.2.2</version>
            </dependency>
            <!-- cache -->
            <dependency>
                <groupId>net.sf.ehcache</groupId>
                <artifactId>ehcache</artifactId>
                <version>2.10.4</version>
            </dependency>
    

    1.3springboot下的shiro配置

    1)自定义ShiroConfig类详细见代码

    2)自定义Realm:

    /**
     * @Description: 自定义Realm,认证用户,授权
     * @Author: yanhonghai
     * @Date: 2018/9/17 0:56
     */
    public class Md5Realm extends AuthorizingRealm {
        private final static Logger logger = LoggerFactory.getLogger(Md5Realm.class);
        /**
         * 延迟加载bean,解决缓存Cache不能正常使用;事务Transaction注解不能正常运行
         */
        @Autowired
        @Lazy
        private UserServiceImpl userService;
    
        /**
         * 认证.登录
         * doGetAuthenticationInfo这个方法是在用户登录的时候调用的
         * 也就是执行SecurityUtils.getSubject().login()的时候调用;(即:登录验证)
         * 验证通过后会用户保存在缓存中的
         */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
            logger.info("##################执行Shiro登录认证##################");
            //获取用户输入的token
            UsernamePasswordToken utoken = (UsernamePasswordToken) token;
            String username = utoken.getUsername();
            //查询数据库
            User user = userService.findByUserName(username);
            //放入shiro.调用CredentialsMatcher检验密码
            if (user != null) {
                // 若存在,将此用户存放到登录认证info中,无需自己做密码对比,Shiro会为我们进行密码对比校验
                // return new SimpleAuthenticationInfo(user,user.getPassWord(),this.getClass().getName());
                //加SALT,这里的参数要给个唯一的;
                ByteSource credentialsSalt = ByteSource.Util.bytes(user.getUserName());
                //参数realmName: 当前 realm对象的name.调用父类的getName()方法即可
                return new SimpleAuthenticationInfo(user, user.getPassWord(), credentialsSalt, this.getClass().getName());
            }
            return null;
        }
    
        /**
         * 授权
         * doGetAuthorizationInfo方法是在我们调用
         * SecurityUtils.getSubject().isPermitted()这个方法,
         * 授权后用户角色及权限会保存在缓存中的
         *
         * @param principal
         * @return
         * @RequiresPermissions这个注解起始就是在执行SecurityUtils.getSubject().isPermitted()
         */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
            //获取session中的用户,以下3种都可以
            // User user=(User) principal.getPrimaryPrincipal();
            //String userName=(String) SecurityUtils.getSubject().getPrincipal();
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            User user = (User) principal.fromRealm(this.getClass().getName()).iterator().next();
            //查询数据库
            user = userService.findUserInfo(user.getUserName());
            logger.info("##################执行Shiro权限授权##################user info is:{}" + JSONObject.toJSONString(user));
            Set<String> userPermissions = new HashSet<String>();
            Set<String> userRoles = new HashSet<String>();
            for (Role role : user.getRoles()) {
                userRoles.add(role.getRoleName());
                List<Permission> rolePermissions = role.getPermissions();
                for (Permission permission : rolePermissions) {
                    userPermissions.add(permission.getPermName());
                }
            }
            //角色名集合
            info.setRoles(userRoles);
            //权限名集合,将权限放入shiro中,
            // 这里可以把url,按钮,菜单,api等当做资源来进行权限控制,从而对用户进行权限控制
            info.addStringPermissions(userPermissions);
            return info;
        }
    }
    

    1.4shiro登录验证的使用:

    项目中定义个登录接口,如下:

      /**
         * 登录方法
         * 在调用了login方法后,SecurityManager会收到AuthenticationToken,并将其发送给已配置的Realm执行必须的      认证检查
         * 每个Realm都能在必要时对提交的AuthenticationTokens作出反应
         * @param userName
         * @param passWord
         * @param rememberMe
         * @param session
         * @return
         * @throws AuthenticationException
         */
     @RequestMapping("/login")
        @ResponseBody
        public Object loginUser(@RequestParam String userName, @RequestParam String passWord, @RequestParam boolean rememberMe, HttpSession session) throws AuthenticationException {
            Map<String, Object> result = new HashMap<>();
            result.put("code", "200");
            result.put("msg", "登录成功");
            Subject subject = SecurityUtils.getSubject();
            //已经登录过
            /*if (subject.isAuthenticated()) {
                User user = (User) subject.getPrincipal();
                result.put("user", user);
                logger.info("subject.isAuthenticated,userName:{}, login success", user.getUserName());
                return result;
            }*/
            //勾选了记住我
           /* if (subject.isRemembered()) {
                User user = (User) subject.getPrincipal();
                result.put("user", user);
                logger.info("subject.isRemembered,userName:{},login success", user.getUserName());
                return result;
            }*/
            UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(userName, passWord, true);
            usernamePasswordToken.setRememberMe(rememberMe);
            try {
                subject.login(usernamePasswordToken);
                User user = (User) subject.getPrincipal();
                result.put("user", user);
                logger.info("userName:{},passWord:{} login success", userName, passWord);
            } catch (UnknownAccountException e) {
                //用户名不存在
                result.put("code", "-1");
                result.put("msg", "用户名不存在");
                logger.error("userName:{},passWord:{} login fail,error info is:{}", userName, passWord, e.getMessage());
            } catch (IncorrectCredentialsException e) {
                //密码错误
                result.put("code", "-1");
                result.put("msg", "用户名或密码错误");
                logger.error("userName:{},passWord:{} login fail,error info is:{}", userName, passWord, e.getMessage());
            } catch (LockedAccountException e) {
                //账户被锁定
                result.put("code", "-1");
                result.put("msg", "账户被锁定");
                logger.error("userName:{},passWord:{} login fail,error info is:{}", userName, passWord, e.getMessage());
    
            } catch (ExcessiveAttemptsException e) {
                //登录失败次数超过系统最大次数,请稍后重试
                result.put("code", "-1");
                result.put("msg", "登录失败次数超过系统最大次数,请稍后重试!");
                logger.error("userName:{},passWord:{} login fail,error info is:{}", userName, passWord, e.getMessage());
    
            } catch (DisabledAccountException e) {
                //验证未通过,帐号已经禁止登录
                result.put("code", "-1");
                result.put("msg", "验证未通过,帐号已经禁止登录!");
                logger.error("userName:{},passWord:{} login fail,error info is:{}", userName, passWord, e.getMessage());
    
            } catch (AuthenticationException e) {
                //出现其他异常
                result.put("code", "-1");
                result.put("msg", e.getMessage());
                logger.error("userName:{},passWord:{} login fail,error info is:{}", userName, passWord, e.getMessage());
            }
    
            return result;
        }
    

    1.5前端采用vue

    这里搞了个简单的测试demo,前端没有做任何其他控制和cookie设置。
    修改前端代码后打包:npm run dev(先npm install);然后将生产的dist下的index.html复制到resource/template下替换原来的,将static下的所有文件夹及文件复制到resource/static下替换原来的

    2.测试

    Shiro过滤器配置如下:

    /**
         * ShiroFilterFactoryBean,是个factorybean,为了生成ShiroFilter。
         * 它主要保持了三项数据,securityManager,filters,filterChainDefinitionManager
         *
         * @param manager
         * @return
         */
        @Bean
        public ShiroFilterFactoryBean shiroFilter(@Qualifier("securityManager") SecurityManager manager) {
            ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
            bean.setSecurityManager(manager);
            //配置登录的url和登录成功的url
            //setLoginUrl 如果不设置值,默认会自动寻找Web工程根目录下的"/login.jsp"页面 或 "/login" 映射
            //实际可以在前端控制登录成功后的跳转
            bean.setLoginUrl("/index");
            bean.setSuccessUrl("/home");
            // 设置无权限时跳转的 url;
            bean.setUnauthorizedUrl("/403");
            /**
             * Shiro 内置过滤器,过滤链定义,从上向下顺序执行
             *  常用的过滤器:
             *      anon:无需认证(登录)可以访问
             *      authc:必须认证才可以访问
             *      user:只要登录过,并且记住了密码,如果设置了rememberMe的功能可以直接访问
             *      perms:该资源必须得到资源权限才可以访问
             *      role:该资源必须得到角色的权限才可以访问
             */
            LinkedHashMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
    
            //anon表示可以匿名访问
            filterChainDefinitionMap.put("/index", "anon");
            filterChainDefinitionMap.put("/login", "anon");
            filterChainDefinitionMap.put("/static/**", "anon");
            filterChainDefinitionMap.put("/user/testDb","anon");
            //authc表示需要登录
            filterChainDefinitionMap.put("/user/**","authc");
            bean.setFilterChainDefinitionMap(filterChainDefinitionMap);
            return bean;
        }
    
    

    2.1)直接访问http://localhost:8090/user/testDb

    根据shiro过滤器配置,无需权限可以直接访问得到结果:
    在这里插入图片描述

    2.2)访问其他接口,会先跳转到登录页:
    在这里插入图片描述
    2.3)

    admin/123456这个用户设置了所有角色,所有权限
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    2.4)其他用户访问有权限的可以得到正常结果,访问该用户没有权限的接口,会报错提示没权限
    在这里插入图片描述

    后面再结合前端测试:密码输入次数限制;账号锁定等功能。

    展开全文
  • 这是一个Vue+Springboot+shiro的登录案例。前端采用Vue+Elementui,对于axios进行了封装,实现了前端的路由控制,登录状态检测等。后端采用Springboot,数据持久化工具采用Mybatis,对于返回的数据进行了封装,对于...
  • springboot+shiro+vue实现权限管理一 功能简介:1 介绍:二 开始接入:1 数据库设计2 导入依赖3 ShiroConfiguration : 设置拦截4 MyShiroRealm: 用户权限认证5 LoginService: 用户登录/退出6 权限使用7 权限...

    一 功能简介:

    1 介绍:

    Apache Shiro是Java的一个安全框架。对比另一个安全框架Spring Sercurity,它更简单和灵活。 Shiro可以帮助我们完成:认证、授权、加密、会话管理、Web集成、缓存等 2 shiro架构: 对于一个好的框架,从外部看来应该具有非常简单易于使用的API,且API契约明确;从内部来看的话,其应该有一个可扩展的架构,即非常容易插入用户自定义实现,因为任何框架都不能满足所有需求。

    二 开始接入:

    1 数据库设计

    manager:role 关系 n:n
    role:permission 关系 n:n
    在这里插入图片描述

    2 导入依赖

    <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
    </dependency>
    

    3 ShiroConfiguration : 设置拦截

    private String APP = "";  //项目前缀 - 过滤拦截的时候使用
    
    /**
     * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
     * 配置以下两个bean(DefaultAdvisorAutoProxyCreator(可选)和AuthorizationAttributeSourceAdvisor)即可实现此功能
     * 为了可以使用@RequiresPermissions标签
     * 必须放在最前面
     *
     * @return
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }
    
    //加入注解的使用,不加入这个注解不生效
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
    
    
    //将自己的验证方式加入容器
    @Bean
    public MyShiroRealm myShiroRealm() {
        MyShiroRealm myShiroRealm = new MyShiroRealm();
        return myShiroRealm;
    }
    
    
    //权限管理,配置主要是Realm的管理认证
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }
    
    //Filter工厂,设置对应的过滤条件和跳转条件
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        Map<String, String> map = new HashMap<String, String>();
        /**
         * 基于DefaultFilter
         anon:所有url都都可以匿名访问;
         authc: 需要认证才能进行访问;
         user:配置记住我或认证通过可以访问;
         */
    
        //登出
        map.put(APP+ "/logout", "logout");
        //对所有用户认证
    
        //不拦截
        map.put(APP+ "/index.html", "anon");
        map.put(APP+ "/v1/login/**", "anon");
    
        //拦截
        map.put(APP+ "/page/intercept/index.html", "authc");
        map.put(APP+ "/page/intercept/**", "authc");
    
        //权限放行
        map.put(APP+ "/page/intercept/dog3.jpg", "perms[permission:operlog_read]");
    
        map.put(APP+ "/swagger-ui.html", "perms[permission:permission_write]");
    
        //登录
        shiroFilterFactoryBean.setLoginUrl(APP+ "/page/login.html");    //拦截后跳转到此页面
    
        //首页,登录之后跳转
        shiroFilterFactoryBean.setSuccessUrl(APP+ "/page/intercept/index.html");  // 登陆成功后跳转的页面
    
        //错误页面,认证不通过跳转
        shiroFilterFactoryBean.setUnauthorizedUrl(APP+ "/page/error.html");   //找不到的页面指定跳转
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
        }
        
      }
    

    4 MyShiroRealm: 用户权限认证

    
    /**
     * Created by zhiji on 2018/10/25.
     * 进行权限信息处理
     */
    public class MyShiroRealm extends AuthorizingRealm {
    
    
        // 用于用户查询
        @Autowired
        private ManagerService managerService;
    
        /**
         * 1 用户访问URL的时候,查询用户权限,并绑定session
         *
         * @param authenticationToken
         * @return 用户信息
         * @throws AuthenticationException 捕获异常,用户是否登陆成功
         */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    
            long start = System.currentTimeMillis();
    
            //加这一步的目的是在Post请求的时候会先进认证,然后在到请求
            if (authenticationToken.getPrincipal() == null) {
                return null;
            }
            //获取用户信息
            String account = authenticationToken.getPrincipal().toString();
            ShiroManagerGetOutDTO shiroManagerGetInDTO = managerService.selectByAccount(account);
    
            if (shiroManagerGetInDTO == null) {
                //这里返回后会报出对应异常
                return null;
            } else {
                //这里验证authenticationToken和simpleAuthenticationInfo的信息
                SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(account, shiroManagerGetInDTO.getPassword().toString(), getName());
    
                long end = System.currentTimeMillis();
    
                System.out.println(MyShiroRealm.class + " doGetAuthenticationInfo 登录认证 ---------- 总耗时 " + (end - start) + "ms");
    
                return simpleAuthenticationInfo;
            }
        }
    
        /**
         * 2 用户登陆的时候,数据库查询用户信息
         * 增加角色
         *
         * @param principalCollection 传递过来的用户信息
         * @return
         */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    
            long start = System.currentTimeMillis();
    
            //1 获取登录用户名
            String account = (String) principalCollection.getPrimaryPrincipal();
    
            //2 查询用户名称
            ShiroManagerGetOutDTO manager = managerService.selectByAccount(account);
    
            if (StringUtils.isEmpty(manager))
                return null;
    
            //3 添加角色和权限
            SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
    
            ShiroRoleGetOutDTO role = manager.getShiroRoleGetInDTO();
            if (StringUtils.isEmpty(role))
                return null;
    
            authorizationInfo.addRole(role.getName());  // 给用户添加角色
    
            List<ShiroPermissionGetOutDTO> permissions = role.getShiroPermissionGetInDTOList();
            if (StringUtils.isEmpty(permissions) || permissions.size() <= 0)
                return null;
    
            for (ShiroPermissionGetOutDTO permission : permissions) {
                authorizationInfo.addStringPermission(permission.getPermission());  // 添加用户的权限
            }
    
            long end = System.currentTimeMillis();
    
            System.out.println(MyShiroRealm.class + " doGetAuthorizationInfo ---------- 总耗时 " + (end - start) + "ms");
    
            return authorizationInfo;
        }
    
        /**
         * 清除所有用户授权信息缓存.
         */
        public void clearCachedAuthorizationInfo(String principal) {
            SimplePrincipalCollection principals = new SimplePrincipalCollection(principal, getName());
            clearCachedAuthorizationInfo(principals);
        }
    
        /**
         * @return void    返回类型
         * @Title: clearAuthz
         * @Description: TODO 清楚缓存的授权信息
         */
        public void clearAuthz() {
            this.clearCachedAuthorizationInfo(SecurityUtils.getSubject().getPrincipals());
        }
    
    
    }
    
    

    5 LoginService: 用户登录/退出

        public void login(ShiroLoginInDTO manager) {
    
            ShiroLoginInOutDTO shiroLoginInOutInDTO = new ShiroLoginInOutDTO();
    
            //添加用户认证信息
            Subject subject = SecurityUtils.getSubject();
    
            String account = manager.getAccount();
            String password = AppMD5Util.MD5Repeated20(manager.getPassword());   //密码统一使用MD5加密
            UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(manager.getAccount(), password);
            subject.login(usernamePasswordToken);
            subject.getSession().setTimeout(properties.getPermissionSessionTimeout());   //用户有效登录时长: 1 hours
    
        }
    
        public void logout() {
    
            Subject subject = SecurityUtils.getSubject();
    
            subject.logout();   //用户退出
            subject.getSession().setTimeout(0);
    
        }
    

    6 权限使用

    在controller层加入相应的标签即可

    @RequiresPermissions(value = {“permission:app_read”, “permission:app_write”},logical = Logical.OR )
    @RequiresRoles(“admin”)
    在这里插入图片描述

    7 权限permission编码

    			0:无
                1:只读 read
                2:读写 write
                
     模块码	名称 编码 编码字符串
     10 	模块一
                 100 无权限
                 101 permission:permission_read
                 102 permission:permission_write
     11 	模块二    
                 110 无权限
                 111 permission:upload_read
                 112 permission:upload_write
     12 	模块三
                120 无权限
                121 permission:publicity_read
                122 permission:publicity_write
    

    代码待完善,持续更新。。。
    1 将用户token存储到redis中、可以多节点部署
    2 自定义token生成规则
    3 shiro全局异常捕获

    展开全文
  • Shiro+Vue+SpringBoot实现权限管理系统

    千次阅读 2019-07-10 17:20:41
    1.Shiro+Vue+SpringBoot前后端分离实现权限管理系统。 用户模块 2.角色模块 3.菜单列表 4.视频连接地址https://edu.csdn.net/course/detail/24806 5.学习交流可以加qq群 6.目前还有一点需要收尾处理,...

    1.Shiro+Vue+SpringBoot前后端分离实现权限管理系统。

     用户模块

    2.角色模块

    3.菜单列表

    4.视频连接地址 https://edu.csdn.net/course/detail/24806

    5.学习交流可以加qq群

    6.目前还有一点需要收尾处理,代码已上传到GitHub上。需要的同学可以给作者打赏作者5元,毕竟写作不易,作者也需要网站的运营服务器费用。谢谢大家理解和支持(等过了这段失业的时间,有钱运营网站了 会给大家免费的资源和视频教学课程)

    打赏请备注 邮箱。我将第一时间把源码发给您

    展开全文
  • Spring Boot-Shiro-Vue 提供一套基于SpringBoot-shiro-vue的权限管理指南。 前一级都对准控制,做到按钮/接口等级的权限 演示 admin / 123456管理员身份登录,可以添加用户,角色。 角色可以分配权限 控制菜单是否...
  • springBoot-shiro-vue-element-admin 最早:springboot-shiro 使用springBoot2.1.6 + shiro + redis + mysql的权限管理系统,账号: admin ,密码: 123456 ,如果使用 前端:vue-element-admin 使用的是vue2.6 + ...
  • springboot+vue+shiro功能权限

    千次阅读 2019-09-12 08:51:31
    一、数据库表设计 1.权限相关表 CREATE TABLE `t_sys_action` ( `id` varchar(32) NOT NULL COMMENT '主键', `name` varchar(32) DEFAULT NULL COMMENT '操作名称', `code` varchar(32) DEFAULT NULL COMMENT ...
  • 系统采用jeeplus框架(ssm+redis+shiro+mongodb+redis),默认是做了JSP未做前后端分离,由于业务需要已经多终端使用的需求(H5、小程序等),需要实现前后端分离。但是由于需要同时保留原版的未做前后端分离的UI 和...
  • 前后端分离项目越来越成为主流,目前应用较多的是前端为vue+elementUI 后端用SpringBoot。 一般的管理系统都要有登录和权限管理的功能,这里选用Apache的Shiro做为项目的安全框架。它是一个非常易用的安全框架,提供...
  • springboot+shiro+vue解决跨域访问问题

    千次阅读 2019-08-05 09:47:01
    package ... import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.C...
  • springboot+jwt+shiro实现web权限管理,该资源适用于初学者搭建开发环境
  • 基于webpack4.x搭建的vue 2.使用了AmazeUI和ElementUI(掺杂了一块 – !) 3.后台管理这块使用了markdown插件加单实现文章的录入和修改。 后端 1.Springboot 2.Shiro 3.Redis 4.项目构建:Maven 5.数据库ORM:Mybatis ...
  • springboot+shiro+vue前后端分离导致用户登录失效问题前端后分离、导致用户登录token失效 前端后分离、导致用户登录token失效 @Configuration public class CrossDomain extends WebMvcConfigurerAdapter { @...
  • 前端部分1.1 项目结构1.2 页面1.2.1 index.vue1.2.2 update.vue1.2.3 login.vue1.2.4 index.jsp配置1.3 配置axios1.4 处理跨域请求的2种方式1.后端controller中处理2.前端中处理2.后端部分2.1 项目结构2.2 重要代码 ...
  • 点击“终码一生”,关注,置顶公众号每日技术干货,第一时间送达!本文总结自实习中对项目的重构。原先项目采用 Springboot+freemarker 模版,开发过程中觉得前端逻辑写的实在恶...
  • 前段日子写过一篇关于SpringBoot+Shiro的简单整合的例子,那个例子并不适用于我们目前的前后端分离开发的趋势。我之前写过一个项目也是用到了Shiro的前后端分离,某度了许久也没找到解决方案,什么去掉shiroFilter....
  • GitHub代码后端地址:https://github.com/qiuxinfa/springboot-shiro-vue-stu GitHub代码前端地址:https://github.com/qiuxinfa/boot-shiro-vue-stu-client 这里主要讲讲利用AOP实现请求拦截,并进行日志记录和...
  • Springboot+vue博客管理系统 项目是前后端分离的一个项目,文章总体分为java后端接口和vue前端页面。 Java后端接口 1.前言 编译器使用的IDEA2021,一开始先创建新的项目骨架,直接选择Spring Initializr创建。数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,699
精华内容 2,279
关键字:

shirovue

vue 订阅