SpringBoot整合Shiro实现权限控制，验证码

最新推荐文章于 2022-12-12 11:56:29 发布
最新推荐文章于 2022-12-12 11:56:29 发布
阅读量406 收藏 1
点赞数
文章标签： java 数据库 前端 ViewUI
原文链接：http://www.cnblogs.com/telwanggs/p/10809591.html
版权

本文介绍 SpringBoot 整合 shiro，相对于 Spring Security 而言，shiro 更加简单，没有那么复杂。

目前我的需求是一个博客系统，有用户和管理员两种角色。一个用户可能有多个角色，每个角色可能有多个权限，每个角色关联不同的菜单(也可以权限和菜单关联)。

本文主要介绍 Shiro 的使用，这里只介绍用户和角色，不需要权限也行。

一、数据库设计

三张表：user、role、user_role

 
  1. -- ----------------------------
  2. --  Table structure for `role`
  3. -- ----------------------------
  4. DROP TABLE IF EXISTS `role`;
  5. CREATE TABLE `role` (
  6.   `id` int(11) NOT NULL AUTO_INCREMENT,
  7.   `description` varchar(255) DEFAULT NULL,
  8.   `role` varchar(255) DEFAULT NULL,
  9.   PRIMARY KEY (`id`)
  10. ) ENGINE=MyISAM AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
  12. -- ----------------------------
  13. --  Table structure for `user`
  14. -- ----------------------------
  15. DROP TABLE IF EXISTS `user`;
  16. CREATE TABLE `user` (
  17.   `id` int(10) NOT NULL AUTO_INCREMENT,
  18.   `password` varchar(100) NOT NULL,
  19.   `username` varchar(20) NOT NULL COMMENT '用于登录的账号',
  20.   `display_name` varchar(20) DEFAULT NULL COMMENT '显示的用户名',
  21.   `email` varchar(100) DEFAULT NULL COMMENT '电子邮箱',
  22.   `url` varchar(255) DEFAULT NULL COMMENT '个人主页',
  23.   `avatar` varchar(255) DEFAULT NULL COMMENT '头像',
  24.   `profile` varchar(255) DEFAULT NULL COMMENT '简介',
  25.   `create_time` datetime DEFAULT NULL,
  26.   `last_login_time` datetime DEFAULT NULL,
  27.   `status` tinyint(1) NOT NULL DEFAULT '1' COMMENT '正常1，禁止登录0, 已删除-1',
  28.   PRIMARY KEY (`id`),
  29.   UNIQUE KEY `uq_user_username` (`username`) USING BTREE,
  30.   UNIQUE KEY `uq_user_displayname` (`display_name`) USING BTREE,
  31.   UNIQUE KEY `uq_user_email` (`email`) USING BTREE
  32. ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4;
  34. -- ----------------------------
  35. --  Table structure for `user_role`
  36. -- ----------------------------
  37. DROP TABLE IF EXISTS `user_role`;
  38. CREATE TABLE `user_role` (
  39.   `role_id` int(11) NOT NULL,
  40.   `user_id` int(11) NOT NULL,
  41.   KEY `role_id` (`role_id`),
  42.   KEY `user_id` (`user_id`)
  43. ) ENGINE=MyISAM DEFAULT CHARSET=utf8;
  45. SET FOREIGN_KEY_CHECKS = 1;

 

二、SpringBoot 整合 Shiro

1、添加 shiro 依赖

 
  1. <!--Shiro-->
  2. <dependency>
  3.     <groupId>org.apache.shiro</groupId>
  4.     <artifactId>shiro-spring</artifactId>
  5.     <version>1.4.0</version>
  6. </dependency>

 

2、MyShiroRealm.java

 
  1. package com.liuyanzhao.blog.web.config;
  3. import com.liuyanzhao.blog.api.model.Role;
  4. import com.liuyanzhao.blog.api.model.User;
  5. import com.liuyanzhao.blog.api.service.RoleService;
  6. import com.liuyanzhao.blog.api.service.UserService;
  7. import com.liuyanzhao.blog.api.util.Response;
  8. import com.liuyanzhao.blog.web.enums.UserStatus;
  9. import org.apache.shiro.authc.*;
  10. import org.apache.shiro.authz.AuthorizationInfo;
  11. import org.apache.shiro.authz.SimpleAuthorizationInfo;
  12. import org.apache.shiro.realm.AuthorizingRealm;
  13. import org.apache.shiro.subject.PrincipalCollection;
  14. import org.springframework.beans.factory.annotation.Autowired;
  16. import java.util.List;
  18. /**
  19.  * @author 言曌
  20.  * @date 2018/9/1 上午10:47
  21.  */
  23. public class MyShiroRealm extends AuthorizingRealm {
  25.     @Autowired
  26.     private UserService userService;
  28.     @Autowired
  29.     private RoleService roleService;
  31.     public static final String SALT = "com.liuyanzhao";
  33.     @Override
  34.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  35.         System.out.println("权限配置-->MyShiroRealm.doGetAuthorizationInfo()");
  36.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
  37.         User user = (User) principals.getPrimaryPrincipal();
  38.         List<Role> roleList = roleService.listRolesByUser(user);
  39.         for (Role role : roleList) {
  40.             authorizationInfo.addRole(role.getRole());
  41.         }
  42.         return authorizationInfo;
  43.     }
  45.     @Override
  46.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
  47.             throws AuthenticationException {
  48.         System.out.println("MyShiroRealm.doGetAuthenticationInfo()");
  49.         //获取用户的输入的账号.
  50.         String username = (String) token.getPrincipal();
  51.         System.out.println(token.getCredentials());
  52.         //通过username从数据库中查找 User对象，如果找到，没找到.
  53.         //实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
  54.         Response<User> response = userService.getUserByUsername(username);
  55.         if (!response.getSuccess()) {
  56.             return null;
  57.         }
  58.         User user = response.getData();
  59.         if (UserStatus.LOCKED.getCode().equals(user.getStatus())) {
  60.             throw new LockedAccountException(username + "账号被锁定，请联系管理员！");
  61.         }
  62.         SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
  63.                 user,
  64.                 user.getPassword(),
  65.                 getName()
  66.         );
  67.         return authenticationInfo;
  68.     }
  69. }

这个是自定义验证账号密码和验证是否有权限。

其中 UserService 和 RoleService 这里就不用给了，一个是根据用户名获得用户，一个是根据获得用户的权限列表。

 

3、ShiroConfig.java

 
  1. package com.liuyanzhao.blog.web.config;
  3. import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
  4. import org.apache.shiro.mgt.SecurityManager;
  5. import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
  6. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
  7. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
  12. import java.util.LinkedHashMap;
  13. import java.util.Map;
  14. import java.util.Properties;
  16. /**
  17.  * @author 言曌
  18.  * @date 2018/8/20 上午6:19
  19.  */
  21. @Configuration
  22. public class ShiroConfig {
  25.     @Bean
  26.     public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
  27.         System.out.println("ShiroConfiguration.shirFilter()");
  28.         ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
  29.         shiroFilterFactoryBean.setSecurityManager(securityManager);
  30.         //拦截器.
  31.         Map<String,String> filterChainDefinitionMap = new LinkedHashMap<String,String>();
  32.         // 配置不会被拦截的链接 顺序判断
  33.         filterChainDefinitionMap.put("/css/**", "anon");
  34.         filterChainDefinitionMap.put("/js/**", "anon");
  35.         filterChainDefinitionMap.put("/img/**", "anon");
  36.         filterChainDefinitionMap.put("/components/**", "anon");
  37.         filterChainDefinitionMap.put("/favicon.ico", "anon");
  38.         //配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了
  39.         filterChainDefinitionMap.put("/logout", "logout");
  40.         //<!-- 过滤链定义，从上向下顺序执行，一般将/**放在最为下边 -->:这是一个坑呢，一不小心代码就不好使了;
  41.         //<!-- authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问-->
  42.         filterChainDefinitionMap.put("/admin/**", "authc");
  43.         filterChainDefinitionMap.put("/user/**", "authc");
  44.         filterChainDefinitionMap.put("/**", "anon");
  45.         shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
  47.         // 如果不设置默认会自动寻找Web工程根目录下的"/login"页面
  48.         shiroFilterFactoryBean.setLoginUrl("/login");
  49.         // 登录成功后要跳转的链接
  50.         shiroFilterFactoryBean.setSuccessUrl("/");
  51.         //未授权界面;
  52.         shiroFilterFactoryBean.setUnauthorizedUrl("/403");
  54.         return shiroFilterFactoryBean;
  55.     }
  57.     /**
  58.      * 凭证匹配器
  59.      * （由于我们的密码校验交给Shiro的SimpleAuthenticationInfo进行处理了
  60.      * ）
  61.      * @return
  62.      */
  63.     @Bean
  64.     public HashedCredentialsMatcher hashedCredentialsMatcher(){
  65.         HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
  66.         //散列算法:这里使用MD5算法;
  67.         hashedCredentialsMatcher.setHashAlgorithmName("md5");
  68.         //散列的次数，比如散列两次，相当于 md5(md5(""));
  69.         hashedCredentialsMatcher.setHashIterations(2);
  70.         return hashedCredentialsMatcher;
  71.     }
  73.     @Bean
  74.     public MyShiroRealm myShiroRealm(){
  75.         MyShiroRealm myShiroRealm = new MyShiroRealm();
  76.         myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
  77.         return myShiroRealm;
  78.     }
  81.     @Bean
  82.     public SecurityManager securityManager(){
  83.         DefaultWebSecurityManager securityManager =  new DefaultWebSecurityManager();
  84.         //设置realm
  85.         securityManager.setRealm(myShiroRealm());
  86.         return securityManager;
  87.     }
  91.     /**
  92.      *  开启shiro aop注解支持.
  93.      *  使用代理方式;所以需要开启代码支持;
  94.      * @param securityManager
  95.      * @return
  96.      */
  97.     @Bean
  98.     public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
  99.         AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
  100.         authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
  101.         return authorizationAttributeSourceAdvisor;
  102.     }
  104.     @Bean(name="simpleMappingExceptionResolver")
  105.     public SimpleMappingExceptionResolver
  106.     createSimpleMappingExceptionResolver() {
  107.         SimpleMappingExceptionResolver r = new SimpleMappingExceptionResolver();
  108.         Properties mappings = new Properties();
  109.         //数据库异常处理
  110.         mappings.setProperty("DatabaseException", "databaseError");
  111.         mappings.setProperty("UnauthorizedException","403");
  112.         r.setExceptionMappings(mappings);
  113.         r.setDefaultErrorView("error");
  114.         r.setExceptionAttribute("message");
  115.         return r;
  116.     }
  117. }

这里补充一下链接器链，是按顺序匹配的。必须使用LinkedHashMap，因为HashMap遍历是无序的。

目前我是放行除 /admin/** 和 /user/** 之外所有的页面，通常情况下是放行匿名的页面，其他的一律需要授权验证，如

filterChainDefinitionMap.put("/**", "authc");

 

4、LoginParam.java

 
  1. package com.liuyanzhao.blog.web.param;
  3. import lombok.Data;
  5. import java.io.Serializable;
  7. /**
  8.  * 登录参数
  9.  * @author 言曌
  10.  * @date 2018/9/9 上午11:42
  11.  */
  12. @Data
  13. public class LoginParam implements Serializable{
  15.     private static final long serialVersionUID = 166457193110647497L;
  17.     private String username;
  19.     private String password;
  21.     private String captchaCode;
  23.     private boolean rememberMe;
  25.     private String CSRFToken;
  26. }

 

5、LoginController.java

 
  1. /**
  2.      * 登录页面
  3.      *
  4.      * @return
  5.      */
  6.     @GetMapping("/login")
  7.     public String loginPage() {
  8.         return "login";
  9.     }
  12.     /**
  13.      * 登录提交
  14.      *
  15.      * @param loginParam
  16.      * @param model
  17.      * @return
  18.      * @throws Exception
  19.      */
  20.     @PostMapping("/login")
  21.     public String login(LoginParam loginParam,
  22.                         Model model) throws Exception {
  23.         //1、验证用户名和密码
  24.         org.apache.shiro.subject.Subject subject = SecurityUtils.getSubject();
  25.         UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(loginParam.getUsername(), loginParam.getPassword(), loginParam.isRememberMe());
  26.         String msg = "";
  27.         try {
  28.             subject.login(usernamePasswordToken);
  29.             return "redirect:/";
  30.         } catch (UnknownAccountException e) {
  31.             log.info("UnknownAccountException -- > 账号不存在：");
  32.             msg = "账号不存在!";
  33.         } catch (IncorrectCredentialsException e) {
  34.             log.info("IncorrectCredentialsException -- > 密码不正确：");
  35.             msg = "密码不正确!";
  36.         } catch (LockedAccountException e) {
  37.             log.info("LockedAccountException -- > 账号被锁定");
  38.             msg = "账号被锁定!";
  39.         } catch (Exception e) {
  40.             log.info(e.getMessage());
  41.         }
  42.         model.addAttribute("msg", msg);
  43.         return "login";
  44.     }

 

6、login.html

 
  1. <form name="loginform" id="loginform" action="/login" method="post">
  2.     <p>
  3.         <label for="username">用户名或电子邮件地址<br/>
  4.             <input type="text" name="username" id="username" class="input" size="20" required/>
  5.         </label>
  6.     </p>
  7.     <p>
  8.         <label for="password">密码<br/>
  9.             <input type="password" name="password" id="password" class="input" size="20" required/>
  10.         </label>
  11.     </p>
  12.     <p th:if="${msg}">
  13.         <label for="captchaCode">验证码<br/>
  14.             <input type="text" name="captchaCode" id="captchaCode" class="input" size="20"
  15.                    style="float:left;width: 40%; " required/>
  16.             <img src="/img/getKaptchaImage" alt="" style="float:left;padding-top: 3px;">
  17.             <span>换一张</span>
  18.         </label>
  19.     </p>
  20.     <input type="hidden" name="CSRFToken" th:value="${session.CSRFToken}">
  21.     <div style="clear: both;"></div>
  22.     <p class="forgetmenot">
  23.         <label for="rememberme">
  24.         <input name="rememberMe" type="checkbox" id="rememberMe"
  25.                checked="checked"> 记住我的登录信息</label>
  26.     </p>
  27.     <p class="submit">
  28.         <input type="submit" class="button button-primary button-large" value="登录"/>
  29.     </p>
  30.     <br>
  31. </form>

这里主要关注 form 表单提交的 username 和 password 即可，其中 CSRF 防护忽略，rememberMe 下面要用到。

 

三、添加 kaptcha 验证码

1、添加验证码依赖

 
  1. <!--验证码-->
  2. <dependency>
  3.     <groupId>com.github.penggle</groupId>
  4.     <artifactId>kaptcha</artifactId>
  5.     <version>2.3.2</version>
  6. </dependency>

 

2、验证码配置类

 
  1. package com.liuyanzhao.blog.web.config;
  3. import com.google.code.kaptcha.impl.DefaultKaptcha;
  4. import com.google.code.kaptcha.util.Config;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  8. import java.util.Properties;
  10. /**
  11.  * 验证码图片样式配置
  12.  * @author 言曌
  13.  * @date 2018/9/2 上午10:23
  14.  */
  16. @Configuration
  17. public class KaptchaConfig {
  18.     @Bean(name="captchaProducer")
  19.     public DefaultKaptcha getKaptchaBean(){
  20.         DefaultKaptcha defaultKaptcha=new DefaultKaptcha();
  21.         Properties properties=new Properties();
  22.         //验证码字符范围
  23.         properties.setProperty("kaptcha.textproducer.char.string", "23456789");
  24.         //图片边框颜色
  25.         properties.setProperty("kaptcha.border.color", "245,248,249");
  26.         //字体颜色
  27.         properties.setProperty("kaptcha.textproducer.font.color", "black");
  28.         //文字间隔
  29.         properties.setProperty("kaptcha.textproducer.char.space", "1");
  30.         //图片宽度
  31.         properties.setProperty("kaptcha.image.width", "100");
  32.         //图片高度
  33.         properties.setProperty("kaptcha.image.height", "35");
  34.         //字体大小
  35.         properties.setProperty("kaptcha.textproducer.font.size", "30");
  36.         //session的key
  37. //        properties.setProperty("kaptcha.session.key", "code");
  38.         //长度
  39.         properties.setProperty("kaptcha.textproducer.char.length", "4");
  40.         //字体
  41.         properties.setProperty("kaptcha.textproducer.font.names", "宋体,楷体,微软雅黑");
  42.         Config config=new Config(properties);
  43.         defaultKaptcha.setConfig(config);
  44.         return defaultKaptcha;
  45.     }
  46. }

 

3、验证码控制器

 
  1. package com.liuyanzhao.blog.web.controller.common;
  3. import com.google.code.kaptcha.Constants;
  4. import com.google.code.kaptcha.Producer;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Controller;
  8. import org.springframework.web.bind.annotation.GetMapping;
  10. import javax.imageio.ImageIO;
  11. import javax.servlet.ServletOutputStream;
  12. import java.awt.image.BufferedImage;
  14. /**
  15.  * 验证码控制器
  16.  * @author 言曌
  17.  * @date 2018/9/2 上午10:41
  18.  */
  20. @Controller
  21. @Slf4j
  22. public class KaptchaController extends BaseController {
  24.     @Autowired
  25.     private Producer captchaProducer;
  28.     @GetMapping("/img/getKaptchaImage")
  29.     public void getKaptchaImage() throws Exception {
  30.         response.setDateHeader("Expires", 0);
  31.         // Set standard HTTP/1.1 no-cache headers.
  32.         response.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
  33.         // Set IE extended HTTP/1.1 no-cache headers (use addHeader).
  34.         response.addHeader("Cache-Control", "post-check=0, pre-check=0");
  35.         // Set standard HTTP/1.0 no-cache header.
  36.         response.setHeader("Pragma", "no-cache");
  37.         // return a jpeg
  38.         response.setContentType("image/jpeg");
  39.         // create the text for the image
  40.         String capText = captchaProducer.createText();
  41.         //将验证码存到session
  42.         session.setAttribute(Constants.KAPTCHA_SESSION_KEY, capText);
  43.         log.info(capText);
  44.         // create the image with the text
  45.         BufferedImage bi = captchaProducer.createImage(capText);
  46.         ServletOutputStream out = response.getOutputStream();
  47.         // write the data out
  48.         ImageIO.write(bi, "jpg", out);
  49.         try {
  50.             out.flush();
  51.         } finally {
  52.             out.close();
  53.         }
  54.     }
  55. }

 

4、修改 LoginController.java

 
  1. /**
  2.  * 登录提交
  3.  *
  4.  * @param loginParam
  5.  * @param model
  6.  * @return
  7.  * @throws Exception
  8.  */
  9. @PostMapping("/login")
  10. public String login(LoginParam loginParam,
  11.                     Model model) throws Exception {
  13.     //1、检验验证码
  14.     if (loginParam.getCaptchaCode() != null) {
  15.         String inputCode = request.getParameter("captchaCode");
  16.         String captchaSession = (String) session.getAttribute(Constants.KAPTCHA_SESSION_KEY);
  17.         if (!Objects.equals(inputCode, captchaSession)) {
  18.             log.info("验证码错误，用户输入：{}, 正确验证码：{}", inputCode, captchaSession);
  19.             model.addAttribute("msg", "验证码不正确!");
  20.             CsrfTokenUtil.refreshToken(request);
  21.             return "login";
  22.         }
  23.     }
  25.     //2、验证用户名和密码
  26.     org.apache.shiro.subject.Subject subject = SecurityUtils.getSubject();
  27.     UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(loginParam.getUsername(), loginParam.getPassword());
  28.     String msg = "";
  29.     try {
  30.         subject.login(usernamePasswordToken);
  31.         return "redirect:/";
  32.     } catch (UnknownAccountException e) {
  33.         log.info("UnknownAccountException -- > 账号不存在：");
  34.         msg = "账号不存在!";
  35.     } catch (IncorrectCredentialsException e) {
  36.         log.info("IncorrectCredentialsException -- > 密码不正确：");
  37.         msg = "密码不正确!";
  38.     } catch (LockedAccountException e) {
  39.         log.info("LockedAccountException -- > 账号被锁定");
  40.         msg = "账号被锁定!";
  41.     } catch (Exception e) {
  42.         log.info(e.getMessage());
  43.     }
  44.     model.addAttribute("msg", msg);
  45.     CsrfTokenUtil.refreshToken(request);
  46.     return "login";
  47. }

 

 

四、配置记住我

1、修改 ShiroConfig.java

 
  1. /**
  2.     * cookie对象;
  3.     * rememberMeCookie()方法是设置Cookie的生成模版，比如cookie的name，cookie的有效时间等等。
  4.     * @return
  5.     */
  6.    @Bean
  7.    public SimpleCookie rememberMeCookie(){
  8.        //System.out.println("ShiroConfiguration.rememberMeCookie()");
  9.        //这个参数是cookie的名称，对应前端的checkbox的name = rememberMe
  10.        SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
  11.        //<!-- 记住我cookie生效时间30天 ,单位秒;-->
  12.        simpleCookie.setMaxAge(259200);
  13.        return simpleCookie;
  14.    }
  16.    /**
  17.     * cookie管理对象;
  18.     * rememberMeManager()方法是生成rememberMe管理器，而且要将这个rememberMe管理器设置到securityManager中
  19.     * @return
  20.     */
  21.    @Bean
  22.    public CookieRememberMeManager rememberMeManager(){
  23.        //System.out.println("ShiroConfiguration.rememberMeManager()");
  24.        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
  25.        cookieRememberMeManager.setCookie(rememberMeCookie());
  26.        //rememberMe cookie加密的密钥 建议每个项目都不一样 默认AES算法 密钥长度(128 256 512 位)
  27.        cookieRememberMeManager.setCipherKey(Base64.decode("2AvVhdsgUs0FSA3SDFAdag=="));
  28.        return cookieRememberMeManager;
  29.    }
  32.    @Bean
  33.    public SecurityManager securityManager(){
  34.        DefaultWebSecurityManager securityManager =  new DefaultWebSecurityManager();
  35.        //设置realm
  36.        securityManager.setRealm(myShiroRealm());
  37.        //用户授权/认证信息Cache, 采用EhC//注入记住我管理器
  38.        securityManager.setRememberMeManager(rememberMeManager());
  39.        return securityManager;
  40.    }

 

2、修改 LoginController.java

主要是修改

 
  1. UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(loginParam.getUsername(), loginParam.getPassword(), loginParam.isRememberMe());

最终如下

 
  1. /**
  2.  * 登录提交
  3.  *
  4.  * @param loginParam
  5.  * @param model
  6.  * @return
  7.  * @throws Exception
  8.  */
  9. @PostMapping("/login")
  10. public String login(LoginParam loginParam,
  11.                     Model model) throws Exception {
  13.     //1、检验验证码
  14.     if (loginParam.getCaptchaCode() != null) {
  15.         String inputCode = request.getParameter("captchaCode");
  16.         String captchaSession = (String) session.getAttribute(Constants.KAPTCHA_SESSION_KEY);
  17.         if (!Objects.equals(inputCode, captchaSession)) {
  18.             log.info("验证码错误，用户输入：{}, 正确验证码：{}", inputCode, captchaSession);
  19.             model.addAttribute("msg", "验证码不正确!");
  20.             CsrfTokenUtil.refreshToken(request);
  21.             return "login";
  22.         }
  23.     }
  25.     //2、验证用户名和密码
  26.     org.apache.shiro.subject.Subject subject = SecurityUtils.getSubject();
  27.     UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(loginParam.getUsername(), loginParam.getPassword(), loginParam.isRememberMe());
  28.     String msg = "";
  29.     try {
  30.         subject.login(usernamePasswordToken);
  31.         return "redirect:/";
  32.     } catch (UnknownAccountException e) {
  33.         log.info("UnknownAccountException -- > 账号不存在：");
  34.         msg = "账号不存在!";
  35.     } catch (IncorrectCredentialsException e) {
  36.         log.info("IncorrectCredentialsException -- > 密码不正确：");
  37.         msg = "密码不正确!";
  38.     } catch (LockedAccountException e) {
  39.         log.info("LockedAccountException -- > 账号被锁定");
  40.         msg = "账号被锁定!";
  41.     } catch (Exception e) {
  42.         log.info(e.getMessage());
  43.     }
  44.     model.addAttribute("msg", msg);
  45.     CsrfTokenUtil.refreshToken(request);
  46.     return "login";
  47. }

 

3、login.html 添加记住我的复选框

name为之前填的 rememberMe

 

4、修改 ShiroConfig.java

上面的配置后，当登录后，会创建rememberMe的 cookie，退出浏览器，cookie依然存在。

但是我们访问需要登录(authc)的页面会被拦截到登录页面

解决办法是修改 authc 为 user

我们要修改

 
  1. filterChainDefinitionMap.put("/admin/**", "authc");
  2. filterChainDefinitionMap.put("/user/**", "authc");

为

 
  1. filterChainDefinitionMap.put("/admin/**", "user");
  2. filterChainDefinitionMap.put("/user/**", "user");

 

然后再次尝试，发现可以访问。

 

五、效果图如下

首次登录无需验证码，登录错误需要验证码

 

 

 

 

转载于:https://www.cnblogs.com/telwanggs/p/10809591.html

dhptkq9465
关注
【SpringBoot】23、SpringBoot中整合Shiro实现权限管理
Asurplus
07-12 21万+
之前在 SSM 项目中使用过 shiro，发现 shiro 的权限管理做的真不错，但是在 SSM 项目中的配置太繁杂了，于是这次在 SpringBoot 中使用了 shiro，下面一起看看吧 一、简介 Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。 三个核心组件： 1、Subject： 即“当前操作用户”。但是，在 Shiro 中，Subje
springboot整合shiro实现登录验证
c1225992531的博客
08-02 8381
springboot整合shiro实现登录验证 今天第一次接触springboot，本来是要学习springboot和shiro整合的，但是由于springboot结构还不太了解，所以先来了解一下springboot。 springboot可以快速创建一个机遇spring的项目，而且让这个项目跑起来只需要很少的配置就可以了，主要有以下核心功能： 1.独立运行的spring项目：springboo...
springboot+kaptcha生成数学运算验证码和字符验证码
想吃凤梨酥的博客
05-09 820
使用以下代码只需要复制粘贴，修改一处文本生成器路径即可，文中有交代。 添加kaptcha依赖 <dependency> <groupId>com.github.penggle</groupId> <artifactId>kaptcha</artifactId> <version>2.3.2</version> </dependency> 编写验证码文本生成器，为了给数据运算验证码
springboot + shiro 验证码与记住登录
weixin_33860528的博客
04-23 492
源码项目地址 验证码实现 关于kaptcha kaptcha 是一个很有用的验证码生成工具。有了它，你能够生成各种样式的验证码，由于它是可配置的。使用kaptcha能够方便的配置： 验证码的字体 验证码字体的大小 验证码字体的字体颜色 验证码内容的范围(数字，字母，中文汉字！) 验证码图片的大小。边框，边框粗细，边框颜色 验证码的干扰线(能够自己继承com.google.code.kaptcha...
SpringBoot学习：整合shiro（验证码功能和登录次数限制功能）
期待破茧成蝶
04-08 5078
（一）验证码 首先login.jsp里增加了获取验证码图片的标签： 登录页面---- /login" method="post"> 用户名 : 密码: 验证码： gif/getGifCode"> 记住我 ${message } 获取图片是
springboot + shiro 实现验证码
快乐的小三菊的博客
06-02 1017
背景： 验证码是有效防止暴力破解的一种手段，常用做法是在服务端产生一串随机字符串与当前用户会话关联（我们通常说的放入 Session），然后向终端用户展现一张经过“扰乱”的图片，只有当用户输入的内容与服务端产生的内容相同时才允许进行下一步操作。 与其说在 shiro 中添加验证码，不如说是在 web 服务登录中添加验证码功能，因为这个功能和 shiro 完全没有任何关系，网上大都是实现 FormAuthenticationFilter 然后在 filter 中进行验证码校验，...
springboot+shiro实现验证码
01-24 609
shiro使用FormAuthenticationFilter进行表单认证，验证校验的功能应该加在FormAuthenticationFilter中，在认证之前进行验证码校验。 需要写FormAuthenticationFilter的子类，继承FormAuthenticationFilter...
springboot+shiro+layuimini实现后台管理系统的权限控制
08-02
2. **组件交互**：通过LayuiMini的API，可以实现与后端Shiro权限控制的联动，例如根据用户权限动态加载菜单或按钮。 3. **美化界面**：LayuiMini的样式和图标设计使得后台系统具有良好的用户体验，提高工作效率。 ...
springboot整合shiro进行安全登录，并且进行权限验证
weixin_71787144的博客
12-12 462
笔记
springboot整合shiro
11-27
以上就是SpringBoot整合Shiro的基本流程和关键点。这个过程中涉及到了SpringBoot的自动配置、Shiro的核心组件使用、权限控制策略、以及密码加密等知识点。通过这样的整合，你可以构建出一套高效且易于维护的权限管理...
SpringBoot+Shiro登录验证码制作
12-21
用户登录常常要做防机器验证，所以使用到了随机验证码，防止机器刷 1.直接java内部自带的就行啦，也不需要用外部生成的api 生成验证码的工具类的写法： import javax.imageio.ImageIO; import java.awt.*; import java.awt.image.BufferedImage; import java.io.*; import java.util.Random; /** * @author lrx * @description: TODO 验证码生成工具类 * @date 2020/4/24 14:51 */ public class C
SpringBoot + shiro Demo 简单登录验证权限验证
02-08
SpringBoot ，Shiro 密码加密，登录验证，权限控制demo
springboot 使用shiro集成阿里云短信验证码
tang_seven的博客
11-25 1462
基于springboot，使用shiro多个realm的方法，集成阿里云的sms短息验证码服务，使用手机的短信验证码验证
SpringBoot+shiro 实现登录缓存和验证码
qq_37950416的博客
07-17 725
登录后 登录缓存 退出浏览器后再重新进入 http://localhost:8080/south/index.html不需要登录 便可进入index.html页面 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" .
Spring Boot +Shiro 验证码Filter和限制密码错误次数
LJY_SUPER的博客
09-05 2390
验证码校验CustomFormAuthenticationFilter 将我们自己实现的Filter，放到ShiroFilterFactoryBean中。 ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean(); Map<String, Filter> filters = shiroF
SpringBoot2.0 整合 Shiro+JWT+Redis 实现图形、短信验证码登陆
m0_67394360的博客
04-08 1242
这里使用到了Redis来实现JWT的过期刷新，话不多说，具体的实现代码如下 1.自定义AuthenticationToken类 public final class JwtToken implements AuthenticationToken { private static final long serialVersionUID = 1L; private String jwttoken; public JwtToken(String jwttoken) { super(); thi..
Springboot 整合 Shiro 实现登录认证和权限校验
古小龙
07-04 717
shiro介绍： Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。 三个核心组件：Subject, SecurityManager 和 Realms. Subject：即“当前操作用户”。但是，在Shiro中，Sub...
springboot+shiro实现权限校验及shiro讲解
baoaibao的博客
05-12 1222
背景 笔者在学习了张开涛老师讲解的shiro课程后，对其述内容做了自己的总结。由于张开涛–跟我学shiro一文中利用shiro配置文件简单的写了一个小Demo，所以笔者结合自己的理解采用springboot+mybatis+shiro的框写了一个单系统下、前后端分离的Demo。如有理解错误的地方，欢迎大家指正。 shiro简介 shiro是Apache旗下提供的一套JAVA安全框架，主要用于权限校验。其实spring也提供了一套权限架构即：Spring Security。在实际开发项目中，shiro所提供的
SpringBoot 实战系列之四：SpringBoot+Shiro的安全认证和授权
Peter_Changyb的博客
08-21 658
Shiro是一个安全框架，是Apache的一个子项目。shiro提供了：认证、授权、加密、会话管理、与web集成、缓存等模块。 先介绍概念： Subject：主体，可以看到主体可以是任何与应用交互的“用户”。 SecurityManager：相当于 SpringMVC 中的 DispatcherServlet 或者 Struts2 中的FilterDispatcher。它是 Shiro 的核心，所有具体的交互都通过 SecurityManager 进行控制。它管理着所有 Subject、且负
springboot整合shiro实现登录
最新发布
09-26
要实现springboot整合shiro实现登录，你需要按照以下步骤进行操作： 1. 引入相关依赖：在项目的pom.xml文件中添加spring-boot-starter-web和spring-boot-starter-thymeleaf依赖。 2. 创建ShiroConfig类：在项目的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值