SpringBoot学习小结之权限控制Shiro

最新推荐文章于 2025-04-14 19:33:14 发布
最新推荐文章于 2025-04-14 19:33:14 发布
阅读量1.3k 收藏
点赞数 1
分类专栏： springboot java 文章标签： spring boot 学习 java shiro spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_23091073/article/details/125241300
版权

文章目录

前言

Shiro是 Apache下一个功能强大、灵活的轻量级java开源安全框架，可用来实现用户身份验证、权限授权、session管理和密码加密等功能。下图是Shiro的重点

Shiro_feature

主要概念

  • Authentication: 身份验证，有时也会简称登录
  • Authorization: 授权，即权限验证，验证已登录用户拥有的权限
  • Session Management: 会话管理，shiro自定义了一套session, 即使在非web环境中也能使用session
  • Cryptography: 加密，通过加密算法加密数据，使用户数据更安全

支持功能

  • Web Support: web支持，Shiro能够很容易集成到web环境中
  • Caching: 缓存，主要用于用户，授权等信息的获取。缓存用户，权限信息，减少访问数据库次数，增加访问速度
  • Concurrency: 并发，支持多线程并发权限，即一个线程中开启另一个线程，能够传播权限过去
  • Testing: 测试，测试支持可以帮助编写单元和集成测试，并确保代码如预期一样安全
  • Run As: 允许用户假定另一个用户的身份（如果允许的话）的功能，有时在管理场景中很有用
  • Remember Me: 记住我，很常见功能，用户在登录成功后退出，一段时间内再次访问(使用同一个浏览器)无需再登录

身份验证和授权功能具有可插拔性和灵活性，方便开发人员自定义自己的角色权限规则

shiro和Spring Security对比

ShiroSpring Security
API简单，易于理解和阅读较复杂
依赖环境不依赖于Spring，可以在Java SE和Java EE环境下使用Spring下子项目，依赖Spring，除了Spring其他地方不能用
JSP提供了一套标签库能够在Jsp中使用无

一、初步使用

1.1 Pom依赖

	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
	</parent>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <version>2.1.4.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-web-starter</artifactId>
            <version>1.9.0</version>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>30.0-jre</version>
        </dependency>

        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.19.2</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

1.2 实体类

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    private String username;
    
    private String password;
    
    private String salt;
    
    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
    private LocalDate birthdate;
    
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private LocalDateTime lastLoginTime;

    @Builder.Default
    @ToString.Exclude
    @EqualsAndHashCode.Exclude
    @JsonIgnore
    @ManyToMany
    @JoinTable(name = "user_role",
            joinColumns = {@JoinColumn(name = "user_id", referencedColumnName = "id")},
            inverseJoinColumns = {@JoinColumn(name = "role_id", referencedColumnName = "id")})
    private Set<Role> roles = Sets.newHashSet();
}

@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;
    
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private LocalDateTime createTime;

    @Builder.Default
    @ToString.Exclude
    @EqualsAndHashCode.Exclude
    @JsonIgnore
    @ManyToMany(mappedBy = "roles")
    private Set<User> users = Sets.newHashSet();

    @Builder.Default
    @ToString.Exclude
    @EqualsAndHashCode.Exclude
    @ManyToMany
    @JoinTable(name = "role_permission",
            joinColumns = {@JoinColumn(name = "role_id", referencedColumnName = "id")},
            inverseJoinColumns = {@JoinColumn(name = "permission_id", referencedColumnName = "id")})
    private Set<Permission> permissions = Sets.newHashSet();

}

@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Permission {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    private String name;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private LocalDateTime createTime;

    @Builder.Default
    @ToString.Exclude
    @JsonIgnore
    @ManyToMany(mappedBy = "permissions")
    private Set<Role> roles = Sets.newHashSet();
}

1.3 Dao

public interface UserDao extends JpaRepository<User, Integer> {
    User findByUsername(String username);

    @Query("select u from User u join  u.roles r where r.id = :roleId")
    List<User> findUsersByRoleId(@Param("roleId")Integer roleId);

    @Query("select distinct p.name from Permission p left join p.roles r join  r.users u where u.username = :username")
    Set<String> findPermission(@Param("username")String username);
}

public interface RoleDao extends JpaRepository<Role, Integer> {
	Role findRoleByName(String name);
}


public interface PermissionDao extends JpaRepository<Permission, Integer> {
}

1.4 Controller

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserDao userDao;

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

    @RequiresPermissions("role:list")
    @GetMapping("/findAllRole")
    public Set<Role> findAllRole(@LoginUser User user){

        logger.info("{}", user.getUsername());
        Optional<User> userOption = userDao.findById(user.getId());
        return userOption.map(User::getRoles).orElse(Sets.newHashSet());
    }
    
    @RequiresPermissions("user:list")
    @GetMapping("/list")
    public ResponseEntity userList() {
        return ResponseEntity.ok(userDao.findAll());
    }

    @PostMapping("/login")
    public ResponseEntity login(@RequestBody User user){

        logger.info("user:{}", user);
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(), user.getPassword());

        try {
            subject.login(token);
        } catch ( UnknownAccountException  uae) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("用户名错误");
        } catch (IncorrectCredentialsException ice) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("密码错误");
        }

        Session session = SecurityUtils.getSubject().getSession();
        session.setAttribute("loginUser", subject.getPrincipal());

        return ResponseEntity.ok().body("登录成功");
    }

    @GetMapping("/unauth")
    public ResponseEntity unauth() {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未登录");
    }

}

1.5 配置

  1. web配置

    @Configuration
public class WebConfig extends WebMvcConfigurationSupport {

    @Bean
    public LoginUserArgumentResolver loginUserArgumentResolver() {
        return new LoginUserArgumentResolver();
    }

    @Bean
    public RequestJsonArgumentResolver jsonPathArgumentResolver() {
        return new RequestJsonArgumentResolver();
    }

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(loginUserArgumentResolver());
        argumentResolvers.add(jsonPathArgumentResolver());
        super.addArgumentResolvers(argumentResolvers);
    }

	// 解决RestController只返回字符串中文乱码问题
    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        List<StringHttpMessageConverter> stringHttpMessageConverters = converters.stream()
                .filter(converter -> converter.getClass().equals(StringHttpMessageConverter.class))
                .map(converter -> (StringHttpMessageConverter) converter)
                .collect(Collectors.toList());

        if (stringHttpMessageConverters.isEmpty()) {
            converters.add(new StringHttpMessageConverter(StandardCharsets.UTF_8));
        } else {
            stringHttpMessageConverters.forEach(converter -> converter.setDefaultCharset(StandardCharsets.UTF_8));
        }
    }
}

  2. Shiro配置

    @Configuration
public class ShiroConfig {

    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName(Md5Hash.ALGORITHM_NAME);
        hashedCredentialsMatcher.setHashIterations(1024);
        return hashedCredentialsMatcher;
    }

    @Bean
    public Realm authorizer() {
        LoginRealm loginRealm = new LoginRealm();
        loginRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return loginRealm;
    }

    @Bean
    public SessionsSecurityManager securityManager(Realm authorizer){
        return new DefaultWebSecurityManager(authorizer);
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //用户未认证登录的页面
        shiroFilterFactoryBean.setLoginUrl("/user/login");
        //用户认证成功登录的页面
        shiroFilterFactoryBean.setSuccessUrl("/user/findAllRole");
        //用户没有该权限的展示页面
        shiroFilterFactoryBean.setUnauthorizedUrl("/user/unauth");

        Map<String, String> map = Maps.newHashMap();

        map.put("/user/login", "anon");

        map.put("/user/**","authc");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

    // shiro 注解支持
    @Bean
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }

}

  3. 全局异常处理

    @RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(AuthorizationException.class)
    public ResponseEntity authorizationException() {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("没有权限");
    }
}

1.6 Realm

@Component
public class LoginRealm extends AuthorizingRealm {

    @Autowired
    private UserDao userDao;

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

    // 鉴权
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        logger.info("开始鉴权:{}", principals);
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        User sessionUser = (User) principals.getPrimaryPrincipal();
        Set<String> collect = userDao.findPermission(sessionUser.getUsername());
        authorizationInfo.setStringPermissions(collect);
        return authorizationInfo;
    }

    // 登录验证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;

        String username = token.getUsername();

        User user = userDao.findByUsername(username);

        if (user == null) {
            throw new UnknownAccountException();
        }
        String password = user.getPassword();
        String salt = user.getSalt();

        // new Md5Hash(password, salt, 1024);

        return new SimpleAuthenticationInfo(user, password, ByteSource.Util.bytes(salt), getName());

    }
}

1.7 自定义注解LoginUser

实现在Controller层参数注入已登录用户

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginUser {
}

public class LoginUserArgumentResolver implements HandlerMethodArgumentResolver {

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.getParameterType().isAssignableFrom(User.class) &&
                parameter.hasParameterAnnotation(LoginUser.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        return SecurityUtils.getSubject().getPrincipal();
    }
}

1.8 自定义注解RequestJson

用于请求时，除了RequestBody外，可以额外接收json数据

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestJson {
}

public class RequestJsonArgumentResolver implements HandlerMethodArgumentResolver {


    private ObjectMapper objectMapper = new ObjectMapper();


    @Override
    public boolean supportsParameter(MethodParameter parameter) {

        return parameter.hasParameterAnnotation(RequestJson.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {


        HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);

        assert servletRequest != null;
        String body = (String)servletRequest.getAttribute("request_body");
        JsonNode jsonNode = objectMapper.readTree(body);
        JsonNode value = jsonNode.findValue(parameter.getParameterName());

        return objectMapper.convertValue(value, parameter.getParameterType());

    }
}

由于RequestBody处理json数据会读取流，而流只能被读取一次，所以需要过滤器复制一下body数据

@Component
@WebFilter(urlPatterns = "/*")
public class CachingRequestBodyFilter implements Filter {
    private static final Logger logger = LoggerFactory.getLogger(CachingRequestBodyFilter.class);

    @Override
    public void init(FilterConfig filterConfig) {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        String contentType = request.getContentType();
        if (!StringUtils.isEmpty(contentType) && contentType.startsWith(MediaType.APPLICATION_JSON_VALUE)) {
            CachingRequestBodyWrapper requestWrapper = new CachingRequestBodyWrapper((HttpServletRequest) request);

            String body = new String(requestWrapper.getBody(), requestWrapper.getCharacterEncoding());

            request.setAttribute("request_body", body);

            chain.doFilter(requestWrapper, response);
        } else {
            chain.doFilter(request, response);
        }

    }

    @Override
    public void destroy() {
    }
}

public class CachingRequestBodyWrapper extends HttpServletRequestWrapper {

    private byte[] body;

    private BufferedReader reader;

    private ServletInputStream inputStream;

    public CachingRequestBodyWrapper(HttpServletRequest request) throws IOException{
        super(request);
        loadBody(request);
    }

    private void loadBody(HttpServletRequest request) throws IOException{
        body = IOUtils.toByteArray(request.getInputStream());
        inputStream = new RequestCachingInputStream(body);
    }

    public byte[] getBody() {
        return body;
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        if (inputStream != null) {
            return inputStream;
        }
        return super.getInputStream();
    }

    @Override
    public BufferedReader getReader() throws IOException {
        if (reader == null) {
            reader = new BufferedReader(new InputStreamReader(inputStream, getCharacterEncoding()));
        }
        return reader;
    }

    private static class RequestCachingInputStream extends ServletInputStream {

        private final ByteArrayInputStream inputStream;

        public RequestCachingInputStream(byte[] bytes) {
            inputStream = new ByteArrayInputStream(bytes);
        }

        @Override
        public int read() {
            return inputStream.read();
        }

        @Override
        public boolean isFinished() {
            return inputStream.available() == 0;
        }

        @Override
        public boolean isReady() {
            return true;
        }

        @Override
        public void setReadListener(ReadListener readlistener) {
        }
    }
}

1.9 测试 

@SpringBootTest
//@Transactional
class DemoShiroApplicationTests {

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

    @Autowired
    private UserDao userDao;

    @Autowired
    private RoleDao roleDao;

    @Autowired
    private PermissionDao permissionDao;

    @Autowired
    AbstractShiroFilter shiroFilter;

    @Autowired
    private WebApplicationContext webApplicationContext;

    @Autowired
    private DefaultSecurityManager securityManager;
    private MockMvc mockMvc;

    @BeforeEach
    void setUp() {
        Permission p1 = Permission.builder().name("user:list").createTime(LocalDateTime.now()).build();
        Permission p2 = Permission.builder().name("user:add").createTime(LocalDateTime.now()).build();
        Permission p3 = Permission.builder().name("role:list").createTime(LocalDateTime.now()).build();

        permissionDao.saveAll(Sets.newHashSet(p1, p2, p3));

        Role r1 = Role.builder().name("管理员").createTime(LocalDateTime.now()).build();
        Role r2 = Role.builder().name("前端组").createTime(LocalDateTime.now()).build();
        Role r3 = Role.builder().name("后端组").createTime(LocalDateTime.now()).build();



        r1.setPermissions(Sets.newHashSet(p1, p2, p3));
        r2.setPermissions(Sets.newHashSet(p1));
        r3.setPermissions(Sets.newHashSet(p1, p2));

        roleDao.saveAll(Sets.newHashSet(r1, r2, r3));


        User u1 = User.builder().username("test").salt("1v3v").password(new Md5Hash("testtest", "1v3v", 1024).toString())
                .birthdate(LocalDate.of(1999, 2, 2)).lastLoginTime(LocalDateTime.now()).valid(true).build();

        User u2 = User.builder().username("admin").salt("qwerty").password(new Md5Hash("adminadmin", "qwerty", 1024).toString())
                .birthdate(LocalDate.of(1998, 1, 1)).lastLoginTime(LocalDateTime.now()).valid(true).build();

        u1.setRoles(Sets.newHashSet(r1, r2));
        u2.setRoles(Sets.newHashSet(r3));
        userDao.saveAll(Sets.newHashSet(u1, u2));

        mockMvc = MockMvcBuilders
                .webAppContextSetup(webApplicationContext)
            	// mockmvc不会经过过滤器拦截器，需要手动添加
                .addFilters(new CachingRequestBodyFilter(), new KickoutSessionControlFilter(), shiroFilter)
                .build();

        SecurityUtils.setSecurityManager(securityManager);
    }

    @Test
    void testUserDao() {
        Set<String> test = userDao.findPermission("admin");
        assertThat(test, is(equalTo(Sets.newHashSet("user:list", "user:add"))));
        logger.info("{}", test);
    }

    @Test
    void testRoleDao() {

        Role role = roleDao.findRoleByName("前端组");
        List<User> users = userDao.findUsersByRoleId(role.getId());

        logger.info("{}", users);
        users.forEach(u -> u.getRoles().remove(role));
        userDao.saveAll(users);

        roleDao.delete(role);
        List<Role> roles = roleDao.findAll();

        assertThat(roles, is(hasSize(2)));
    }

    @Test
    void testShiroLogin() throws Exception {
        String loginSuccess = mockMvc.perform(MockMvcRequestBuilders.post("/user/login")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\n" +
                        "    \"username\": \"test\",\n" +
                        "    \"password\": \"testtest\",\n" +
                        "    \"rememberMe\": false\n" +
                        "}"))
                .andExpect(status().isOk())
//                .andDo(print())
                .andReturn()
                .getResponse()
                .getContentAsString();

        assertThat(loginSuccess, is(equalTo("登录成功")));
    }

}

二、额外功能

2.1 记住我

开启RememberMe功能需要修改几个地方

  1. User类实现序列化

    public class User implements Serializable {
    ...
}

  2. Shiro配置需要加上以下

    @Bean
public Cookie sessionCookieTemplate() {
    SimpleCookie cookie = new SimpleCookie();
    cookie.setMaxAge(7 * 24 * 60 * 60);
    return cookie;
}

@Bean
public CookieRememberMeManager rememberMeManager(Cookie sessionCookieTemplate) {
    CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
    cookieRememberMeManager.setCookie(sessionCookieTemplate);
    // rememberMe cookie加密的密钥
    // 这个密钥一定要修改为自己的，2016年曾曝出一个反序列化漏洞，就是因为Shiro 1.2.4之前这个秘钥是固定的
    cookieRememberMeManager.setCipherKey(Base64.decode("4AvVh12f32vb3ebLUsEVE21prsdag=="));
    return cookieRememberMeManager;
}

  3. UserController

    login增加一个rememberMe 参数，UsernamePasswordToken也要加上

    public ResponseEntity login(@RequestBody User user, @RequestJson Boolean rememberMe){
	...
        UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(), user.getPassword(), rememberMe);
    ...
}

2.2 缓存

由于每次鉴权都会走数据库访问，人数多的话会造成数据库压力，所以需要缓存

开启缓存功能需要在配置文件中修改Realm，添加一个Bean CacheManager

@Bean
public Realm authorizer() {
    LoginRealm loginRealm = new LoginRealm();
    loginRealm.setCredentialsMatcher(hashedCredentialsMatcher());

    loginRealm.setCacheManager(shiroCacheManager());
    loginRealm.setAuthorizationCachingEnabled(true);
    loginRealm.setAuthorizationCacheName("userAuthorizationCache");
    loginRealm.setAuthenticationCachingEnabled(true);
    loginRealm.setAuthenticationCacheName("userAuthenticationCache");

    return loginRealm;
}

@Bean
public CacheManager shiroCacheManager() {
    return new MemoryConstrainedCacheManager();
}

当修改某个用户权限时，这时就应该清空缓存，可以考虑使用aop来实现这个功能

2.3 登录次数控制

登录次数限制这种场景很常见，使用Shiro可以通过密码比较器来实现

  1. User表增加字段private Boolean valid, 用来控制用户账号锁定场景

  2. Reaml 也要增加一个用户被锁定的情况

    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;

        String username = token.getUsername();

        User user = userDao.findByUsername(username);

        if (user == null) {
            throw new UnknownAccountException();
        }
		// 新增用户被锁定的情况
        if (!user.getValid()) {
            throw new LockedAccountException();
        }

        String password = user.getPassword();
        String salt = user.getSalt();
    
        return new SimpleAuthenticationInfo(user, password, ByteSource.Util.bytes(salt), getName());

    }

  3. 密码比较器

    @Component
public class RetryLimitHashedCredentialsMatcher extends HashedCredentialsMatcher {

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


    @Autowired
    private UserDao userDao;

    private Cache<String, AtomicInteger> passwordRetryCache;
    
    private static final Integer DEFAULT_RETRY_NUM = 3;
    
    private Integer retryLimitNum = DEFAULT_RETRY_NUM;

    public RetryLimitHashedCredentialsMatcher(CacheManager cacheManager) {
        passwordRetryCache = cacheManager.getCache("passwordRetryCache");
    }
    public void setRetryLimitNum(Integer num) {
        this.retryLimitNum = num;
    }

    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        // 获取登录用户的用户名
        String username = (String)token.getPrincipal();
        // 获取用户登录次数
        AtomicInteger retryCount = passwordRetryCache.get(username);

        if (retryCount == null) {
            // 如果用户没有登陆过,登陆次数加1 并放入缓存
            retryCount = new AtomicInteger(0);
            passwordRetryCache.put(username, retryCount);
        }
        if (retryCount.incrementAndGet() > retryLimitNum) {
            // 如果用户登陆失败次数大于3次 抛出锁定用户异常  并修改数据库字段
            User user = userDao.findByUsername(username);
            if (user != null){
                // 修改数据库的状态字段为锁定
                user.setValid(false);
                userDao.save(user);
                logger.info("锁定用户" + user.getUsername());
            }

            // 抛出用户锁定异常
            throw new LockedAccountException();
        }
        // 判断用户账号和密码是否正确
        boolean matches = super.doCredentialsMatch(token, info);
        if (matches) {
            // 如果正确,从缓存中将用户登录计数 清除
            passwordRetryCache.remove(username);
        }
        return matches;
    }
}

  4. 修改shiro配置

    @Bean
public HashedCredentialsMatcher hashedCredentialsMatcher() {
    RetryLimitHashedCredentialsMatcher retryLimitHashedCredentialsMatcher = new RetryLimitHashedCredentialsMatcher(shiroCacheManager());
    retryLimitHashedCredentialsMatcher.setHashAlgorithmName(Md5Hash.ALGORITHM_NAME);
    retryLimitHashedCredentialsMatcher.setHashIterations(1024);
    retryLimitHashedCredentialsMatcher.setRetryLimitNum(5);
    return retryLimitHashedCredentialsMatcher;
}

  5. 增加一个全局异常处理

    @ExceptionHandler(LockedAccountException.class)
public ResponseEntity LockedAccountException() {
    return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("账户已被锁定，请联系管理员");
}

2.4 登录人数控制

这个场景也很常见，允许一个账户同时在线几个人。shiro可以使用过滤器来实现这个功能

  1. 过滤器KickoutSessionControlFilter

    @Setter
public class KickoutSessionControlFilter extends AccessControlFilter {

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

    // 踢出后到的地址
    private String kickoutUrl;

    // 踢出之前登录的或者之后登录的用户, 默认踢出之前登录的用户
    private boolean kickoutAfter = false;

    // 同一个帐号最大会话数 默认1
    private int maxSession = 1;

    private SessionManager sessionManager;

    private Cache<String, Deque<Serializable>> cache;

    public void setCacheManager(CacheManager cacheManager) {
        this.cache = cacheManager.getCache("shiro-kickout-session");
    }

    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
        return false;
    }

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        Subject subject = getSubject(request, response);

        if (!subject.isAuthenticated() && !subject.isRemembered()) {
            // 如果没有登录，直接进行之后的流程
            return true;
        }
        Session session = subject.getSession();
        String username = subject.getPrincipal().toString();
        Serializable sessionId = session.getId();

        // 初始化用户的队列放到缓存里
        Deque<Serializable> deque = cache.get(username);
        if (deque == null) {
            deque = new LinkedList<Serializable>();
            cache.put(username, deque);
        }

        // 如果队列里没有此sessionId，且用户没有被踢出；放入队列
        if (!deque.contains(sessionId) && session.getAttribute("kickout") == null) {
            deque.push(sessionId);
            // 将用户的sessionId队列缓存
            cache.put(username, deque);
        }

        // 如果队列里的sessionId数超出最大会话数，开始踢人
        while (deque.size() > maxSession) {
            Serializable kickoutSessionId = null;
            // 如果踢出后者
            if (kickoutAfter) {
                kickoutSessionId = deque.removeFirst();
            } else {
                // 否则踢出前者
                kickoutSessionId = deque.removeLast();
            }
            
            try {
                Session kickoutSession = sessionManager.getSession(new WebSessionKey(kickoutSessionId, request, response));
                if (kickoutSession != null) {
                    // 设置会话的 kickout 属性表示踢出了
                    kickoutSession.setAttribute("kickout", true);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 如果被踢出了，直接退出，重定向到踢出后的地址
        if (session.getAttribute("kickout") != null) {
            // 会话被踢出了
            try {
                subject.logout();
            } catch (Exception e) {
            }
            // 这里还可以根据是否ajax请求自定义返回数据
            WebUtils.issueRedirect(request, response, kickoutUrl);

            return false;
        }
        return true;
    }
}

  2. 配置文件修改

    @Bean
public KickoutSessionControlFilter kickoutSessionControlFilter(SessionManager sessionManager){
    KickoutSessionControlFilter kickoutSessionControlFilter = new KickoutSessionControlFilter();
    // 用于根据会话ID，获取会话进行踢出操作的；
    kickoutSessionControlFilter.setSessionManager(sessionManager);
    // 使用cacheManager获取相应的cache来缓存用户登录的会话；用于保存用户—会话之间的关系的；
    kickoutSessionControlFilter.setCacheManager(shiroCacheManager());
    // 是否踢出后来登录的，默认是false；即后者登录的用户踢出前者登录的用户；
    kickoutSessionControlFilter.setKickoutAfter(false);
    // 同一个用户最大的会话数，默认1；比如2的意思是同一个用户允许最多同时两个人登录；
    kickoutSessionControlFilter.setMaxSession(1);
    // 被踢出后重定向到的地址
    kickoutSessionControlFilter.setKickoutUrl("/");
    return kickoutSessionControlFilter;
}

@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager, KickoutSessionControlFilter kickoutSessionControlFilter) {
    
    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
	// 增加kickout定义
    LinkedHashMap<String, Filter> filtersMap = new LinkedHashMap<>();
    filtersMap.put("kickout", kickoutSessionControlFilter);
    shiroFilterFactoryBean.setFilters(filtersMap);

    shiroFilterFactoryBean.setSecurityManager(securityManager);
    //用户未认证登录的页面
    shiroFilterFactoryBean.setLoginUrl("/user/login");
    //用户认证成功登录的页面
    shiroFilterFactoryBean.setSuccessUrl("/user/findAllRole");
    //用户没有该权限的展示页面
    shiroFilterFactoryBean.setUnauthorizedUrl("/user/unauth");

    Map<String, String> map = Maps.newHashMap();

    map.put("/user/login", "anon");
    
	//增加一个kickout过滤器
    map.put("/user/**","kickout, user");

    shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
    return shiroFilterFactoryBean;
}

三、源码分析

3.1 login分析

下图是从源码绘制login的流程，看一下shiro是如何实现对用户名和密码验证的登录过程。

从UserController开始，通过Subject调用，经过一系列类，调用到AuthenticatingRealm这个类，这个是LoginRealm继承的类，从源码可以看到会尝试从缓存中取，没有的话会从自定义的LoginRealm中得到info(在LoginRealm会从数据库得到用户账号和密码，盐), 接着会执行assertCredentialsMatch这个方法，开始对用户名密码进行加密验证

UserController DelegatingSubject ModularRealmAuthenticator AuthenticatingRealm LoginRealm RetryLimitHashedCredentialsMatcher login subject.login login(token) doSingleRealmAuthentication getAuthenticationInfo getAuthenticationInfo doGetAuthenticationInfo assertCredentialsMatch doCredentialsMatch UserController DelegatingSubject ModularRealmAuthenticator AuthenticatingRealm LoginRealm RetryLimitHashedCredentialsMatcher login分析

3.2 filter

Shiro是通过过滤器实现用户权限，自带以下过滤器

Filter NameClass含义
anonorg.apache.shiro.web.filter.authc.AnonymousFilter允许立即访问
authcorg.apache.shiro.web.filter.authc.FormAuthenticationFilter要求用户身份验证
authcBasicorg.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter要求用户http basic认证
authcBearerorg.apache.shiro.web.filter.authc.BearerHttpAuthenticationFilter要求用户http bear认证(jwt)
invalidRequestorg.apache.shiro.web.filter.InvalidRequestFilter非法请求过滤，路径包含分号，反斜杠，非ASCII字符即为非法请求
logoutorg.apache.shiro.web.filter.authc.LogoutFilter当前用户退出
noSessionCreationorg.apache.shiro.web.filter.session.NoSessionCreationFilter在请求期间禁用创建新会话
permsorg.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter要求用户有对应权限
portorg.apache.shiro.web.filter.authz.PortFilter要求请求位于特定端口
restorg.apache.shiro.web.filter.authz.HttpMethodPermissionFilter将请求方法GET, POST, PUT, DELETE转化为’create’, edit’, 'delete’等更友好动词映射到请求路径已配置权限上
rolesorg.apache.shiro.web.filter.authz.RolesAuthorizationFilter要求用户有对应角色
sslorg.apache.shiro.web.filter.authz.SslFilterhttps ssl过滤
userorg.apache.shiro.web.filter.authc.UserFilter已验证或通过记住我功能的用户可通过

四、错误及解决方法

  1. 权限始终未进入鉴权方法

    解决方法：经过debug发现，是我的LoginRealm继承的Realm错了，我继承的是AuthenticatingRealm，实际应该是AuthorizingRealm，这两个太像了

  2. 中文乱码

    使用RestController时，只返回字符串的话，不会转为json格式，而是会返回文本，而StringHttpMessageConverter默认使用的编码是ISO_8859_1，所以需要改下编码

    解决方法：见 1.5配置

  3. 测试时发生异常java.lang.IllegalArgumentException: SessionContext must be an HTTP compatible implementation

    经测试发现需要加上shiro的filter

    解决方法：见 1.9测试

参考

  1. https://shiro.apache.org/spring-boot.html
  2. https://shiro.apache.org/documentation.html
  3. 跟我学shiro
  4. [SpringBoot]请求返回字符串中文乱码的解决探讨
  5. springboot + shiro 实现限制用户登录次数
springboot-权限控制shiro(一)
软件老王
07-24 425
1. 场景描述 （1）权限控制是IT项目特别是企业项目，绕不开的重要模块，接下来结合springboot介绍下权限控制框架shiro。 （2）springboot集成shiro的东西有点多，一篇博客完全介绍清楚有点费劲，拟分成3篇吧，第一篇介绍概念、原理；第二篇介绍搭建代码，详细介绍shiro框架；第三篇结合mybatis，搭建可运行项目。 2. 解决方案 2.1 简介 目前的权限控制，很多公司或...
SpringBoot2.x系列教程（六十九）Spring Boot整合Shiro，两种方式实战总结（含源码）
程序新视界
01-27 957
Shiro是历史悠久的权限管理框，简单易用，易用集成，同时权限管理也是每个项目必不可少的功能。Spring Boot是Java领域炙手可热的脚手架框架。今天这篇文章就带大家将这两个框架进行整合。 通常Spring Boot中整合Shiro，有两种方案：第一，基于原生API进行整合；第二，基于Shiro官方Starter整合。 整体而言，官方Starter整合并没有方便很多，因此，本文主要以原则API进行整合， 下面就来看看具体的整合方式。 创建Spring Boot项目 创建Spring Boot项目通常有
springBoot+security+mybatis 实现用户权限的数据库动态管理
05-03
NULL 博文链接：https://veiking.iteye.com/blog/2429172
Spring Boot 实现权限管理（上）
最新发布
2201_75435513的博客
04-14 547
权限管理的本质，就是一系列挡在控制器前面的过滤器，实现权限管理，也就是设置并实现过滤器的过程。
SpringBoot+Vue 10--数据权限控制
AMWICD的博客
04-26 849
基本准备 根据用户身份控制内容显示 管理员可以对书籍进行增删改查，但是用户不能
SpringBoot项目实战：权限控制到数据操作
weixin_42576186的博客
09-29 1958
本文还有配套的精品资源，点击获取 简介：SpringBoot是Pivotal团队推出的框架，目的是简化基于Spring的应用开发。它通过自动配置和内嵌式Web服务器等特性，提供快速开发独立生产级别应用程序的能力。项目中包含权限控制、登录验证、文件上传及CRUD操作等核心功能，是学习和实践SpringBoot的优秀示例。 1. SpringBoot框架概述与核心理念...
Springboot+Shiro实现权限控制
Rolandcoder的博客
12-03 4036
在一个系统中，不同的用户会对应着不同的角色，不同的角色会被赋予不同的权限。不同角色的用户登陆会看到不同的界面，也就是意味着可以使用不同的功能。可以使用Spring security或者Shiro,但是Shiro相对于Spring security来说更轻量一些，更容易上手，因此选择了后者。 首先，在Springboot工程的pom文件里添加shiro依赖，如下：     &lt;depend...
SpringBoot与Shiro整合-权限管理实战视频+源码
02-25
### SpringBoot与Shiro整合-权限管理实战视频+源码 #### 一、Spring Boot简介 Spring Boot是由Pivotal团队提供的全新框架，其设计目标是简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式（比如...
springboot权限控制 会话
08-26
- *1* *2* [SpringBoot学习小结之权限控制Shiro](https://blog.youkuaiyun.com/qq_23091073/article/details/125241300)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
Springboot整合shiro+jwt上手教程
一条会编程的鱼
04-23 744
目录前言开源依赖maven依赖Shiro配置类配置Realm自定义Filter用到的工具类测试小结 前言 为啥要写这一篇文章呢？无他，网上水文太多了。摸了一周的鱼，终于配置出来了自己理想的效果。 在工作中，权限是一个后台系统的重中之重。在Java中，我们可以选择Shiro和SpringSecurity这两款权限框架。我个人来说是比较喜欢Shiro这款。 网上搜了很多教程，要么就是版本比较老，要么就是配置不生效。所以，求人不如求己，万事开头难，男上加男，迎男而上，满身大汉。。。。扯远了 进入正题… 开源依赖
vue+springboot前后端分离小结（后端篇）
qq_41109942的博客
06-10 1077
学习前后端分离有一阵子了，到了疲倦期，是时候整理整理这两个月学到的东西了。这是后端篇，这几天期末考试，看情况再整理前端篇。 前后端分离，顾名思义就是前端一套，后端一套，只用http请求，连接两端，前端负责显示渲染数据，后端负责操作数据。 后端开发：开发工具：idea，技术栈：springboot，jpa，shiro。 后端接口开发 一、创建Spring Initializr项目 在web里选spring web，在SQL里选Spring Data JPA 二、把各个包建好（pojo，dao，service…
SpringBoot 权限控制（菜单控制，页面元素控制，url控制）
04-13
基于RBAC思想的权限控制，可先建立完整的库，也可以使用使用代码生成，包中提供两种方式， 代码先后顺序 菜单控制----》元素控制-------》url控制
springboot权限控制系统
09-21
项目基于jdk1.8整合了springboot+mvc+mybatis(通用mapper)+druid+jsp+bootstrap等技术,springboot+Listener(监听器),Filter(过滤器),Interceptor(拦截器),Servlet,springmvc静态资源,文件上传下载,多数据源切换,缓存,quartz定时任务(没有具体业务实现)等技术点都在项目中实现了,可谓是麻雀虽小五脏俱全!项目也整合了redis做缓存,把pom.xml中spring-boot-starter-data-redis和com.xe.demo.common.support.redis包下的注释去掉,即可开启redis支持.
springboot 实现权限管理（一）
qq_44654974的博客
01-22 1万+
一、背景 1、 为什么进行权限管理？ 生活在形形色色的世界之中，我们各自扮演着各自的角色，拥有不同的权利和义务。映射在计算机系统之中，也一样需要 角色、权限 来进行对用户的分类，限制访问资源，保证资源地合理被使用，使人各司其职。 2、应用场景 假设 管理员可以对用户进行CRUD的管理，而普通用户往往只拥有对资源的查看，无法进行删除等高级权限。 3、SpringBoot实现主要的方式 （1）采用注解+拦截器 （2）Shiro框架 （3）Spring Security 4、重点理解 （1）理解用户、角色、权限
使用SpringBoot进行数据库安全与权限控制策略
AI天才研究院
01-25 1084
1.背景介绍 数据库安全与权限控制策略是现代应用程序开发中的一个重要方面。在本文中，我们将探讨如何使用Spring Boot进行数据库安全与权限控制策略的实现。 1. 背景介绍 随着互联网的发展，数据库安全和权限控制变得越来越重要。数据库安全涉及到保护数据的完整性、可用性和机密性。权限控制则涉及到确保用户只能访问他们拥有权限的数据。 Spring Boot是一个用于构建新型Spring应用...
java(springboot) mybatis 数据权限详细实现（图文）
热门推荐
cyy9487的博客
05-18 1万+
一、啥子是数据权限？ 嗯，数据权限？有些朋友可能会问了，“嗯，数据还有权限？”.
springboot 数据权限_springBoot+springSecurity 数据库动态管理用户、角色、权限
weixin_34163098的博客
01-21 3292
使用spring Security3的四种方法概述那么在Spring Security3的使用中，有4种方法：一种是全部利用配置文件，将用户、权限、资源(url)硬编码在xml文件中，已经实现过，并经过验证；二种是用户和权限用数据库存储，而资源(url)和权限的对应采用硬编码配置，目前这种方式已经实现，并经过验证。三种是细分角色和权限，并将用户、角色、权限和资源均采用数据库存储，并且自定义过滤器，...
SpringBoot整合Shiro实现权限控制
yuwenS的博客
07-10 933
文章目录1、SpringBoot整合Shiro1.1、shiro简介1.2、代码的具体实现1.2.1、Maven的配置1.2.2、整合需要实现的类1.2.3、项目结构1.2.4、ShiroConfig的实现1.2.5、CustomerRealm的实现1.2.6、shiro缓存配置1.2.7、主页index.html的设置1.3、简单测试1.3.1、admin角色所有权限测试1.3.2、无角色有权限测试1.3.3、无角色无权限测试1.4 项目源码 1、SpringBoot整合Shiro Apache Shi
SpringBoot项目使用切面编程实现数据权限管理
weixin_44792849的博客
03-26 2993
springboot项目使用切面编程实现数据权限管理
Springboot与Shiro整合实现应用权限控制教程
- `Controller` 类: 含有业务逻辑处理方法的控制器类，将通过 Shiro 注解来控制权限。 - `ShiroFilterChainDefinition`: 定义 Shiro 过滤器链的配置类。 使用本教程和源代码，开发者可以快速搭建一个基本的 Spring ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

aabond

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值