• Springboot整合shiro

    导入依赖

    1.    
    2.         <dependency>
    3.             <groupId>org.springframework.bootgroupId>
    4.             <artifactId>spring-boot-starter-webartifactId>
    5.         dependency>
    6. ​
    8.         <dependency>
    9.             <groupId>org.apache.shirogroupId>
    10.             <artifactId>shiro-spring-boot-web-starterartifactId>
    11.             <version>1.12.0version>
    12.         dependency>

    配置类

    1. package com.qf.shiro2302.config;
    2. ​
    3. import com.qf.shiro2302.entity.User;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.apache.shiro.authc.AuthenticationException;
    6. import org.apache.shiro.authc.AuthenticationInfo;
    7. import org.apache.shiro.authc.AuthenticationToken;
    8. import org.apache.shiro.authc.SimpleAuthenticationInfo;
    9. import org.apache.shiro.authz.AuthorizationInfo;
    10. import org.apache.shiro.authz.SimpleAuthorizationInfo;
    11. import org.apache.shiro.realm.AuthorizingRealm;
    12. import org.apache.shiro.realm.Realm;
    13. import org.apache.shiro.spring.web.config.DefaultShiroFilterChainDefinition;
    14. import org.apache.shiro.spring.web.config.ShiroFilterChainDefinition;
    15. import org.apache.shiro.subject.PrincipalCollection;
    16. import org.springframework.context.annotation.Bean;
    17. import org.springframework.context.annotation.Configuration;
    18. ​
    19. import java.util.Arrays;
    20. import java.util.List;
    21. ​
    22. @Configuration
    23. @Slf4j
    24. public class ShiroConfig {
    25. ​
    26. ​
    27. ​
    28.     @Bean
    29.     public Realm realm(){
    30.         AuthorizingRealm authorizingRealm = new AuthorizingRealm() {
    31. ​
    32.             /**
    33.              *
    34.              * @param token 这的token就是调用login方法时，传入的token对象
    35.              * @return AuthenticationInfo 对象中，封装了用户的身份信息（principals），密码（credentials），提供信息的realm的名字
    36.              * @throws AuthenticationException
    37.              */
    38.             @Override
    39.             protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    40.                 System.out.println("===========获取身份信息===============");
    41.                 //查询数据库获取当前用户名对应的User对象
    42.                 String username = (String) token.getPrincipal();
    43.                 System.out.println("username="+username);
    44.                 System.out.println("this.getName()={}"+this.getName());
    45.                 User user=getUserFromDB(username);
    46. ​
    47.                 //需要返回shiro规定的AuthenticationInfo类型的对象
    48.                 //这个对象中，包含了用户的身份认证信息
    49.                 // SimpleAuthenticationInfo的构造函数中的第一个参数，principals代表用户的身份信息
    50.                 // 一般可以使用 user对象，或者使用用户名也可以
    51.                 // 第三个参数，代表当前realm的名字，固定写法
    52.                 //Authentication 证明的意思
    53.                 SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(user,user.getPassword(),this.getName());
    54. ​
    55.                 return authenticationInfo;
    56.             }
    57. ​
    58.             @Override
    59.             protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    60.                 System.out.println("============获取授权===============");
    61. ​
    62.                 // 从数据库表中查询当前用户具有的角色和权限字符串
    63.                 User user = (User) principalCollection.getPrimaryPrincipal();
    64. ​
    65.                 List roles= getRolesFromDB(user);
    66.                 List permissions= getPermissionFromDB(user);
    67. ​
    68.                 // 按照约定返回AuthorizationInfo对象
    69.                 SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
    70.                 // 放入从数据库中查询到的当前用户的角色信息
    71. //                authorizationInfo.addRole("test");
    72.                 authorizationInfo.addRoles(roles);
    73. ​
    74.                 // 放入从数据库中查询到的当前用户的权限信息
    75. //             authorizationInfo.addStringPermission("document:read");
    76.                 authorizationInfo.addStringPermissions(permissions);
    77.                 return authorizationInfo;
    78.             }
    79.         };
    80. ​
    81. ​
    82.         return authorizingRealm;
    83. ​
    84. ​
    85.     }
    86. ​
    87.     private List getRolesFromDB(User user) {
    88.         return Arrays.asList("test","admin");
    89.     }
    90. ​
    91.     private List getPermissionFromDB(User user) {
    92.         return Arrays.asList("document:read","document:write");
    93.     }
    94. ​
    95.     private User getUserFromDB(String username) {
    96.         User user = new User(100, "数据库用户", "123456", "123@qq.com");
    97.         return user;
    98.     }
    99. ​
    100.     @Bean
    101.     public ShiroFilterChainDefinition shiroFilterChainDefinition() {
    102.         //ShiroFilterChainDefinition 此接口就一个实现类  默认Shiro过滤器链定义类
    103.         DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
    104. ​
    105.         // 让登录接口直接被shiro的过滤器放行
    106.         //第一个参数：接口的路径
    107.         //第二个参数：shiro内部的过滤器的名字，anon代表无需登录即可访问的特殊的过滤器,注意过滤器的名字是固定的，不能乱写
    108.         chainDefinition.addPathDefinition("/login/dologin", "anon");
    109.         // 放行springboot的错误页面的请求url  这个页面就是个response拼接的页面
    110.         chainDefinition.addPathDefinition("/error", "anon");
    111. ​
    112. ​
    113.         //增加角色或者权限,对于某些请求
    114.         // logged in users with the 'test' role
    115. //        chainDefinition.addPathDefinition("/test/**", "authc, roles[test,admin], perms[document:read,document:write]");  这个如果改成anon，就不能加后面的角色或者权限，否则，将会被认为需要登录，重定向到登录页
    116. ​
    117.         // all other paths require a logged in user
    118.         chainDefinition.addPathDefinition("/**", "authc");
    119.         return chainDefinition;
    120.     }
    121. }

    调用接口

    1. package com.qf.shiro2302.controller;
    2. ​
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.apache.shiro.SecurityUtils;
    5. import org.apache.shiro.authc.AuthenticationToken;
    6. import org.apache.shiro.authc.UsernamePasswordToken;
    7. import org.apache.shiro.subject.Subject;
    8. import org.springframework.web.bind.annotation.PostMapping;
    9. import org.springframework.web.bind.annotation.RequestMapping;
    10. import org.springframework.web.bind.annotation.RestController;
    11. ​
    12. @RestController
    13. @RequestMapping("/login")
    14. @Slf4j
    15. public class LoginController {
    16. ​
    17.     @PostMapping("/dologin")
    18.     public String dologin(String username,String password){
    19. ​
    20.         //使用Shiro进行登录处理
    21.         Subject subject = SecurityUtils.getSubject();//获取shiro核心对象
    22.        //为了调用shiro的登录方法，需要准备一个Token对象
    23.         UsernamePasswordToken token = new UsernamePasswordToken(username,password);
    24.         System.out.println(token);
    25.         subject.login(token);//使用shiro登录流程
    26. ​
    27.         return "登陆成功 ";
    28. ​
    29. ​
    30.     }
    31. ​
    32. }

    获取ShiroSession中的用户，注解添加权限

    1. package com.qf.shiro2302.controller;
    2. ​
    3. import com.qf.shiro2302.entity.User;
    4. import org.apache.shiro.SecurityUtils;
    5. import org.apache.shiro.authz.annotation.RequiresPermissions;
    6. import org.apache.shiro.authz.annotation.RequiresRoles;
    7. import org.apache.shiro.subject.Subject;
    8. import org.springframework.stereotype.Controller;
    9. import org.springframework.web.bind.annotation.RequestMapping;
    10. import org.springframework.web.bind.annotation.RestController;
    11. ​
    12. @RestController
    13. @RequestMapping("/test")
    14. public class TestController {
    15. ​
    16. ​
    17.     @RequiresRoles({"test","admin"})
    18.     @RequiresPermissions({"document:read","document:write"})
    19.     @RequestMapping("/test1")
    20.     public String hello1(){
    21.         return "hello shiro !!!";
    22.     }
    23. ​
    24. ​
    25.     @RequestMapping("/test2")
    26.     public User hello2(){
    27.         //如果使用shiro获取当前登录用户的身份信息
    28.         Subject subject = SecurityUtils.getSubject();
    29.         User principal = (User) subject.getPrincipal();
    30.         System.out.println(principal);
    31.         return principal;
    32.     }
    33. }
    1. shiro:
    2.   loginUrl: /login.html
    3.   #配置没登陆的时候重定向的页面。这个请求是可以放行的

    优化整合shiro，登录密码MD5Hash加密，内置处理

    1.配置类

    1. package com.qf.shiroHomework.config;
    2. ​
    3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    4. import com.qf.shiroHomework.entity.*;
    5. import com.qf.shiroHomework.mapper.TPersMapper;
    6. import com.qf.shiroHomework.mapper.TRoleMapper;
    7. import com.qf.shiroHomework.mapper.TRolePermsMapper;
    8. import com.qf.shiroHomework.mapper.TUserRoleMapper;
    9. import com.qf.shiroHomework.service.ITUserService;
    10. import lombok.extern.slf4j.Slf4j;
    11. import org.apache.shiro.authc.AuthenticationException;
    12. import org.apache.shiro.authc.AuthenticationInfo;
    13. import org.apache.shiro.authc.AuthenticationToken;
    14. import org.apache.shiro.authc.SimpleAuthenticationInfo;
    15. import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
    16. import org.apache.shiro.authz.AuthorizationInfo;
    17. import org.apache.shiro.authz.SimpleAuthorizationInfo;
    18. import org.apache.shiro.realm.AuthorizingRealm;
    19. import org.apache.shiro.realm.Realm;
    20. import org.apache.shiro.spring.web.config.DefaultShiroFilterChainDefinition;
    21. import org.apache.shiro.spring.web.config.ShiroFilterChainDefinition;
    22. import org.apache.shiro.subject.PrincipalCollection;
    23. import org.apache.shiro.util.ByteSource;
    24. import org.springframework.beans.factory.annotation.Autowired;
    25. import org.springframework.context.annotation.Bean;
    26. import org.springframework.context.annotation.Configuration;
    27. ​
    28. import java.util.ArrayList;
    29. import java.util.Arrays;
    30. import java.util.List;
    31. import java.util.stream.Collectors;
    32. import java.util.stream.IntStream;
    33. ​
    34. @Configuration
    35. @Slf4j
    36. public class ShiroConfig {
    37. ​
    38.     @Autowired
    39.     private ITUserService itUserService;
    40.     @Autowired
    41.     private TUserRoleMapper tUserRoleMapper;
    42.     @Autowired
    43.     private TRolePermsMapper tRolePermsMapper;
    44.     @Autowired
    45.     private TPersMapper tPersMapper;
    46.     @Autowired
    47.     private TRoleMapper tRoleMapper;
    48. ​
    49.     //将Realm对象放入IOC容器里
    50.     @Bean
    51.     public Realm realm(){
    52.         AuthorizingRealm authorizingRealm = new AuthorizingRealm() {
    53. ​
    54.             /**
    55.              *
    56.              * @param token 这的token就是调用login方法时，传入的token对象
    57.              * @return AuthenticationInfo 对象中，封装了用户的身份信息（principals），密码（credentials），提供信息的realm的名字
    58.              * @throws AuthenticationException
    59.              */
    60.             @Override
    61.             protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    62.                 System.out.println("===========获取身份信息===============");
    63.                 //获取身份信息
    64.                 String username = (String) token.getPrincipal();
    65. ​
    66.                 QueryWrapper wrapper = new QueryWrapper<>();
    67.                 wrapper.eq("username",username);
    68.                 TUser user = itUserService.getOne(wrapper);
    69. ​
    70.                 // 需要返回shiro规定的AuthenticationInfo类型的对象
    71.                 // 这个对象中，包含了用户的身份认证信息
    72.                 // SimpleAuthenticationInfo的构造函数中的第一个参数，principals代表用户的身份信息
    73.                 // 一般可以使用 user对象，或者使用用户名也可以
    74.                 // 第三个参数： 盐
    75.                 // 第四个参数，代表当前realm的名字，就是一个标识,标识是这个Bean调用的这个方法，没有作用,固定写法
    76. ​
    77.                 SimpleAuthenticationInfo authenticationInfo=new SimpleAuthenticationInfo(user,user.getPassword(), ByteSource.Util.bytes(user.getSalt()),this.getName());
    78. ​
    79.                 return authenticationInfo;
    80.             }
    81. ​
    82.             @Override
    83.             protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    84.                 TUser user = (TUser) principalCollection.getPrimaryPrincipal();
    85.                 SimpleAuthorizationInfo authorizationInfo=new SimpleAuthorizationInfo();
    86.                 log.info("用户角色={}",getRolesFromDB(user));
    87.                 log.info("用户权限={}",getPermissionFromDB(user));
    88.                 authorizationInfo.addRoles(getRolesFromDB(user));
    89.                 authorizationInfo.addStringPermissions(getPermissionFromDB(user));
    90.                 return authorizationInfo;
    91.             }
    92.         };
    93. ​
    94.         // 把HashedCredentialsMatcher对象设置到authorizingRealm对象中
    95.         authorizingRealm.setCredentialsMatcher(hashedCredentialsMatcher());
    96. ​
    97.         return authorizingRealm;
    98.     }
    99. ​
    100. ​
    101.     @Bean
    102.     public HashedCredentialsMatcher hashedCredentialsMatcher(){
    103. ​
    104.         HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
    105.       //设置算法名称
    106.         matcher.setHashAlgorithmName("md5");
    107.         //设置hash次数
    108.         matcher.setHashIterations(1024);
    109.         return matcher;
    110. ​
    111. ​
    112.     }
    113. ​
    114. ​
    115. ​
    116. ​
    117.     //配置Shiro过滤器链
    118.     @Bean
    119.     public ShiroFilterChainDefinition shiroFilterChainDefinition(){
    120.         DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
    121.         chainDefinition.addPathDefinition("/register.html","anon");
    122.         chainDefinition.addPathDefinition("/error/500.html","anon");
    123.         chainDefinition.addPathDefinition("/error","anon");
    124.         chainDefinition.addPathDefinition("/user/register","anon");
    125.         chainDefinition.addPathDefinition("/user/login","anon");
    126.         chainDefinition.addPathDefinition("/user/**","authc");
    127.         chainDefinition.addPathDefinition("/**","authc");
    128. ​
    129. ​
    130.         return chainDefinition;
    131. ​
    132.     }
    133. ​
    134.     public List getPermissionFromDB(TUser user) {
    135.         if (user.getPerms()!=null){
    136.             return user.getPerms();
    137.         }
    138. ​
    139. ​
    140.         Integer id = user.getId();
    141.         //通过用户ID找到角色
    142. ​
    143.         QueryWrapper wrapper1 = new QueryWrapper<>();
    144.         wrapper1.eq("userid",id);
    145.         TUserRole tUserRole = tUserRoleMapper.selectOne(wrapper1);
    146.         Integer roleid = tUserRole.getRoleid();
    147.         System.out.println(roleid);
    148. ​
    149. ​
    150.         QueryWrapper wrapper = new QueryWrapper<>();
    151.         wrapper.select("permsid").eq("roleid",roleid);
    152.         List permsidList = tRolePermsMapper.selectObjs(wrapper);
    153.         System.out.println(permsidList);
    154.         List integers = permsidList.stream().map(o -> {
    155.                     return (Integer) o;
    156.                 })
    157.                 .collect(Collectors.toList());
    158.         List tPers = tPersMapper.selectBatchIds(integers);
    159.         System.out.println(tPers);
    160.         ArrayList strings = new ArrayList<>();
    161.         for (TPers tPer : tPers) {
    162.             strings.add(tPer.getName());
    163.         }
    164.         user.setPerms(strings);
    165. ​
    166.         return strings;
    167.     }
    168. ​
    169.     public List getRolesFromDB(TUser user) {
    170. ​
    171.         if (user.getRoleName()!=null){
    172.             return user.getRoleName();
    173.         }
    174. ​
    175.         Integer id = user.getId();
    176.         //通过用户ID找到角色
    177.         QueryWrapper wrapper1 = new QueryWrapper<>();
    178.         wrapper1.eq("userid",id);
    179.         TUserRole tUserRole = tUserRoleMapper.selectOne(wrapper1);
    180.         Integer roleid = tUserRole.getRoleid();
    181.         QueryWrapper wrapper = new QueryWrapper<>();
    182.         wrapper.select("name").eq("id",roleid);
    183.         List roles = tRoleMapper.selectObjs(wrapper);
    184.         List strings = roles.stream().map(o -> {
    185.                     return (String) o;
    186.                 })
    187.                 .collect(Collectors.toList());
    188.         user.setRoleName(strings);
    189.         return strings;
    190.     }
    191. ​
    192. }
      193.  

      实体类
       

      1. package com.qf.shiroHomework.entity;
      2. ​
      3. import com.baomidou.mybatisplus.annotation.IdType;
      4. import com.baomidou.mybatisplus.annotation.TableField;
      5. import com.baomidou.mybatisplus.annotation.TableId;
      6. import com.baomidou.mybatisplus.annotation.TableName;
      7. import java.io.Serializable;
      8. import java.util.List;
      9. ​
      10. import lombok.*;
      11. ​
      12. /**
      13.  * 
      14.  * 
      15.  * 
      16.  *
      17.  * @author jmj
      18.  * @since 2023-08-10
      19.  */
      20. @NoArgsConstructor
      21. @AllArgsConstructor
      22. @Data
      23. @TableName("t_user")
      24. public class TUser implements Serializable {
      25. ​
      26.     private static final long serialVersionUID = 1L;
      27. ​
      28.     @TableId(value = "id", type = IdType.AUTO)
      29.     private Integer id;
      30. ​
      31.     private String username;
      32. ​
      33.     private String password;
      34. ​
      35.     private String salt;
      36. ​
      37.     @TableField(exist = false) // 说明当前这个属性在数据库表中没有对应的字段，让mp生成sql时忽略这个属性
      38.     private List roleName;
      39.     @TableField(exist = false)
      40.     private List perms;
      41. ​
      42. ​
      43. ​
      44. ​
      45. }
       

      Controller
       

      1. //复杂密码匹配器
      2.     @PostMapping("/login")
      3.     public String login(TUser user){
      4.         //使用Shiro进行登录处理
      5.         Subject subject = SecurityUtils.getSubject();//获取shiro核心对象
      6.         //为了调用shiro的登录方法，需要准备一个Token对象
      7. ​
      8.         UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(user.getUsername(), user.getPassword());
      9. ​
      10.         subject.login(usernamePasswordToken);
      11. ​
      12.         return "redirect:/show.html";
      13. ​
      14.     }
       

      以前手写MD5处理的方法
       

      1. //    简单密码匹配器方案
      2. //    @PostMapping("/login")
      3. //    public String login(TUser user){
      4. //        //使用Shiro进行登录处理
      5. //        Subject subject = SecurityUtils.getSubject();//获取shiro核心对象
      6. //        //为了调用shiro的登录方法，需要准备一个Token对象
      7. //        //添加Where 条件
      8. //        QueryWrapper wrapper = new QueryWrapper<>();
      9. //        wrapper.eq("username",user.getUsername());
      10. //        TUser u = itUserService.getOne(wrapper);
      11. //        if (u==null){
      12. //            return "redirect:/index.html";
      13. //        }else {
      14. //
      15. //            //MD5加密
      16. //            Md5Hash md5Hash = new Md5Hash(user.getPassword(), u.getSalt(), 1024);
      17. //            String newPassword = md5Hash.toHex();
      18. //
      19. //
      20. //            UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(user.getUsername(), newPassword);
      21. //
      22. //            subject.login(usernamePasswordToken);
      23. //        }
      24. //
      25. //            return "redirect:/show.html";
      26. //
      27. //    }
       

      
                
                    
                

                
    193. 

                    相关阅读:
      
                    
C++智能指针之shared_ptr                            
      
vue3 defineProps defineEmits defineExpose                            
      
基于jenkins进行定制化开发                            
      
Gomodule和GoPath                            
      
JVM类加载机制                            
      
ms17-010（永恒之蓝）漏洞复现                            
      
PromptPort：为大模型定制的创意AI提示词工具库                            
      
Spring Cloud Alibaba 工程搭建                            
      
数字孪生与GIS数据为何高度互补？二者融合后能达到什么样的效果？                            
      
求各区域热门商品Top3 - HiveSQL                            
      
                          
                
      194. 
                
    194. 
                    原文地址：https://blog.csdn.net/qq_53374893/article/details/132649858
                
      195.