Shiro框架

shiro

shiro是什么

Apache Shiro 是一个功能强大且易于使用的 Java 安全(权限)框架。Shiro 可以完成：认证、授权、加密、会话管理、与 Web 集成、缓存 等。借助 Shiro 您可以快速轻松地保护任何应用程序——从最小的移动应用程序到最大的 Web 和企业应用程序。

官网 https://shiro.apache.org

基本使用

1.引入依赖

<dependencies>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.9.0</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

2.shiro.ini文件

• Shiro获取权限相关信息可以通过数据库获取，也可以通过ini配置文件获取

[users]
zhangsan=z3
lisi=l4

3.测试

@Test
    void login(){
//        1.初始化获取SecurityManager
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);
//        2.获取subject对象
        Subject subject = SecurityUtils.getSubject();
//        3.创建token对象，web应用用户名密码从页面传递
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken("zhangsan", "z3");
//        4.完成登录
        subject.login(usernamePasswordToken);
        System.out.println(usernamePasswordToken);
    }

角色 授权

测试

    @Test
    void testLogin(){
        //        1.初始化获取SecurityManager
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        assert securityManager != null;
        SecurityUtils.setSecurityManager(securityManager);
//        2.获取subject对象
        Subject subject = SecurityUtils.getSubject();
//        3.创建token对象，web应用用户名密码从页面传递
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken("zhangsan", "z3");
//        4.完成登录
        subject.login(usernamePasswordToken);
        System.out.println(usernamePasswordToken);
        System.out.println("admin:"+subject.hasRole("admin"));
        System.out.println("root:"+subject.hasRole("root"));
        System.out.println("user:"+subject.hasRole("user"));
        System.out.println("user:add:"+subject.isPermitted("user:add"));
        System.out.println("user:update:"+subject.isPermitted("user:update"));
       
 //        无此权限直接抛出异常
        subject.checkPermission("user:update");

加密

实际系统开发中，一些敏感信息需要进行加密，比如说用户的密码。Shiro 内嵌很多 常用的加密算法，比如 MD5 加密。Shiro 可以很简单的使用信息加密。

@Test
void testMD5(){
    String password = "password";
    Md5Hash md5Hash = new Md5Hash(password);
    System.out.println("md5Hash = " + md5Hash.toHex());
    Md5Hash saltMd5Hash = new Md5Hash(password, "salt");
    System.out.println("saltMd5Hash = " + saltMd5Hash);
    Md5Hash saltMd5Hash3 = new Md5Hash(password, "salt", 3);
    System.out.println("saltMd5Hash3 = " + saltMd5Hash3);
    SimpleHash simpleHash = new SimpleHash("MD5", password, "salt", 3);
    System.out.println("simpleHash = " + simpleHash);
    assert simpleHash.equals(saltMd5Hash3);
}

整合springboot

1. 引入依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
    </parent>
<dependencies>
	<dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring-boot-web-starter</artifactId>
        <version>1.9.0</version>
    </dependency>
    <!--mybatis-plus-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.0.5</version>
    </dependency>
    <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

2. 配置文件

# mybatis配置
mybatis-plus:
  configuration:
  # 日志
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath:mapper/*.xml


spring:
# 数据库配置
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/shirodb?characterEncoding=utf-8&useSSL=false
    password: password
    username: username
# json格式
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

shiro:
# 登录接口
  loginUrl: /myController/login

3. 启动类

@SpringBootApplication
@MapperScan("com.fate.shiro.mapper")
public class ShiroApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShiroApplication.class, args);
    }
}

登录认证实现

后端接口服务实现

1. 数据库表

create table user
(
    id   bigint auto_increment comment '编号'
        primary key,
    name varchar(30) null comment '用户名',
    pwd  varchar(50) null comment '密码',
    rid  bigint      null comment '角色编号'
)
    comment '用户表' charset = utf8;

2. entity dao service controller基本框架搭建

3. 编写userservice(此处只写明impl)

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User>
    implements UserService{

    /**
     * 根据用户名得到用户信息
     *
     * @param name 名字
     * @return {@link User}
     */
    @Override
    public User getUserInfoByName(String name) {
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getName,name);
        return baseMapper.selectOne(queryWrapper);
    }
}

4. 自定义realm

@Component
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;
    /**
     * 自定义授权
     *
     * @param principals 权限
     * @return {@link AuthorizationInfo}
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }


    /**
     * 自定义身份验证
     *
     * @param token 令牌
     * @return {@link AuthenticationInfo}
     * @throws AuthenticationException 身份验证异常
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
//        1. 获取用户身份信息
        String name = token.getPrincipal().toString();
//        2. 调用业务层获取用户信息
        User user = userService.getUserInfoByName(name);
//        3. 非空判断,将数据封装返回
        if (user != null) {
            return new SimpleAuthenticationInfo(
                    token.getPrincipal(),
                    user.getPwd(),
                    ByteSource.Util.bytes("salt"),
                    name
            );
        }
        return null;
    }
}

5. 配置类

@Slf4j
@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager() {
//        1. 创建DefaultWebSecurityManager对象
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
//        2. 创建加密对象,配置相关属性
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
//          2.1  加密
        matcher.setHashAlgorithmName("md5");
        matcher.setHashIterations(3);
//        3. 将加密对象存储到myRealm中
        myRealm.setCredentialsMatcher(matcher);
//        4. 将myRealm存入DefaultWebSecurityManager对象
        defaultWebSecurityManager.setRealm(myRealm);
//        5. 返回DefaultWebSecurityManager
        log.info("DefaultWebSecurityManager 初始化成功");
        return defaultWebSecurityManager;
    }

    @Bean
    public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
        DefaultShiroFilterChainDefinition defaultShiroFilterChainDefinition = new DefaultShiroFilterChainDefinition();
//        无需认证
        defaultShiroFilterChainDefinition.addPathDefinition("/myController/userLogin","anon");
        defaultShiroFilterChainDefinition.addPathDefinition("/login","anon");
//        需要认证
        defaultShiroFilterChainDefinition.addPathDefinition("/**","authc");
        return defaultShiroFilterChainDefinition;
    }

}

6. 编写controller

@RestController
@RequestMapping("myController")
public class MyController {

    /**
     * 登录
     * @param username 用户名
     * @param password 密码
     * @return {@link String}
     */
    @GetMapping("userLogin")
    public String login(@RequestParam("username") String username, @RequestParam("password") String password){
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, password);
        try{
            subject.login(usernamePasswordToken);
            return "success";
        }catch (Exception e) {
            e.printStackTrace();
            return "error";
        }
    }
}

整合前端

编写login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Shiro 登录认证</h1>
    <br>
    <form action="/myController/userLogin">
        <div>用户名：<input type="text" name="name" value=""></div>
        <div>密码：<input type="password" name="pwd" value=""></div>
        <div><input type="submit" value="登录"></div>
    </form>
</body>
</html>

添加main界面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8"> 
<title>Title</title>
</head> 
<body>
<h1> 
<br>
Shiro 登录认证后主页面</h1>
登录用户为： <span th:text="${session.user}"></span>
</body>

继续编写controller

//跳转登录页面
@GetMapping("login") 
public String login(){ 
	return "login"; 
}
//登录认证
@GetMapping("userLogin")
public String userLogin(String name, String pwd, HttpSession 
session){
//1 获取  Subject 对象
	Subject subject = SecurityUtils.getSubject();
//2 封装请求数据到 token 对象中
	AuthenticationToken token = new 		UsernamePasswordToken(name,pwd); 
//3 调用  login 方法进行登录认证
	try {
		subject.login(token);
			session.setAttribute("user",token.getPrincipal().toString()); 
		return "main";
	} catch (AuthenticationException e) { 
		e.printStackTrace();
		System.out.println("登录失败"); 
	return "登录失败";
	} 
}

多个 realm 的认证策略设置

1. 在所有 Realm 被调用之前

2. 在调用 Realm 的 getAuthenticationInfo 方法之前

3. 在调用 Realm 的 getAuthenticationInfo 方法之后

4. 在所有 Realm 被调用之后

Shiro 中定义了 3 种认证策略的实现：

AuthenticationStrategy class	描述
AtLeastOneSuccessfulStrategy	只要有一个（或更多）的 Realm 验证成功，那么认证将视为成功
FirstSuccessfulStrategy	第一个 Realm 验证成功，整体认证将视为成功，且后续 Realm 将被忽略
AllSuccessfulStrategy	所有 Realm 成功，认证才视为成功

ModularRealmAuthenticator 内置的认证策略默认实现是 AtLeastOneSuccessfulStrategy 方式。可以通过配置修改策略

代码实现

@Bean
public DefaultWebSecurityManager defaultWebSecurityManager(){ 
//1 创建  defaultWebSecurityManager 对象
	DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
//2 创建认证对象，并设置认证策略
	ModularRealmAuthenticator modularRealmAuthenticator = new 
ModularRealmAuthenticator();
	modularRealmAuthenticator.setAuthenticationStrategy(new 
AllSuccessfulStrategy());
	defaultWebSecurityManager.setAuthenticator(modularRealmAuthenticator) 
;
//3 封装  myRealm 集合
    List<Realm> list = new ArrayList<>(); 
	list.add(myRealm);
	list.add(myRealm2);
//4 将 myRealm 存入 defaultWebSecurityManager 对象
	defaultWebSecurityManager.setRealms(list);
//5 返回
	return defaultWebSecurityManager;
}

remember me

代码实现

修改配置类

@Configuration
public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;

    //配置 SecurityManager
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager() {
//1 创建  defaultWebSecurityManager 对象
        DefaultWebSecurityManager defaultWebSecurityManager = new
                DefaultWebSecurityManager();
//2 创建加密对象，并设置相关属性 
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
//2.1 采用  md5 加密
        matcher.setHashAlgorithmName("md5");
//2.2 迭代加密次数
        matcher.setHashIterations(3);
//3 将加密对象存储到  myRealm 中
        myRealm.setCredentialsMatcher(matcher);
//4 将  myRealm 存入 defaultWebSecurityManager 对象 
        defaultWebSecurityManager.setRealm(myRealm);
//4.5 设置  rememberMe
        defaultWebSecurityManager.setRememberMeManager(rememberMeManager());
//5 返回
        return defaultWebSecurityManager;
    }

    //cookie 属性设置
    public SimpleCookie rememberMeCookie() {
        SimpleCookie cookie = new SimpleCookie("rememberMe");
//设置跨域
//cookie.setDomain(domain);
        cookie.setPath("/");
        cookie.setHttpOnly(true);
        cookie.setMaxAge(30 * 24 * 60 * 60);
        return cookie;
    }

    //创建 Shiro 的  cookie 管理对象
    public CookieRememberMeManager rememberMeManager() {
        CookieRememberMeManager cookieRememberMeManager = new
                CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        cookieRememberMeManager.setCipherKey("1234567890987654".getBytes());
        return cookieRememberMeManager;
    }

    //配置 Shiro 内置过滤器拦截范围
    @Bean
    public DefaultShiroFilterChainDefinition
    shiroFilterChainDefinition() {
        DefaultShiroFilterChainDefinition definition = new
                DefaultShiroFilterChainDefinition();
//设置不认证可以访问的资源
        definition.addPathDefinition("/myController/userLogin", "anon");
        definition.addPathDefinition("/myController/login", "anon");
//设置需要进行登录认证的拦截范围
        definition.addPathDefinition("/**", "authc");
//添加存在用户的过滤器（rememberMe） 
        definition.addPathDefinition("/**", "user");
        return definition;
    }
}

修改controller

@GetMapping("userLogin")
    public String userLogin(String name, String pwd, @RequestParam(defaultValue =
            "false") boolean rememberMe, HttpSession session) {
//1 获取  Subject 对象
        Subject subject = SecurityUtils.getSubject();
//2 封装请求数据到  token 对象中
        AuthenticationToken token = new UsernamePasswordToken(name, pwd, rememberMe);
//3 调用  login 方法进行登录认证
        try {
            subject.login(token);
            session.setAttribute("user", token.getPrincipal().toString());
            return "main";
        } catch (AuthenticationException e) {
            e.printStackTrace();
            System.out.println("登录失败");
            return "登录失败";
        }
    }

    //登录认证验证  rememberMe
    @GetMapping("userLoginRm")
    public String userLogin(HttpSession session) {
        session.setAttribute("user", "rememberMe");
        return "main";
    }

改造login页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Shiro 登录认证</h1>
    <br>
    <form action="/myController/userLogin">
        <div>用户名：<input type="text" name="name" value=""></div>
        <div>密码：<input type="password" name="pwd" value=""></div>
        <div>记住用户：<input type="checkbox" name="rememberMe" value="true"></div>
        <div><input type="submit" value="登录"></div>
    </form>
</body>
</html>

退出登陆

前端

<body>
<h1>Shiro 登录认证后主页面</h1> 
<br>
登录用户为：<span th:text="${session.user}"></span> 
<br>
<a href="/logout">登出</a> 
</body>

1. 配置类中添加logout过滤器

@Bean
public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){ 
DefaultShiroFilterChainDefinition definition = new 
DefaultShiroFilterChainDefinition();
//设置不认证可以访问的资源
definition.addPathDefinition("/myController/userLogin","anon"); 
definition.addPathDefinition("/myController/login","anon"); 
//配置登出过滤器
definition.addPathDefinition("/logout","logout"); 
//设置需要进行登录认证的拦截范围
definition.addPathDefinition("/**","authc"); 
//添加存在用户的过滤器（rememberMe） 
definition.addPathDefinition("/**","user"); 
return  definition;
}

授权、角色认证

通过给接口服务方法添加注解可以实现权限校验，可以加在控制器方法上，也可以加
在业务方法上，一般加在控制器方法上。常用注解如下：

@RequiresAuthentication
验证用户是否登录，等同于方法subject.isAuthenticated()

@RequiresUser
验证用户是否被记忆：
登录认证成功subject.isAuthenticated()为true
登录后被记忆subject.isRemembered()为true

@RequiresGuest
验证是否是一个guest的请求，是否是游客的请求
此时subject.getPrincipal()为null

@RequiresRoles
验证subject是否有相应角色，有角色访问方法，没有则会抛出异常
AuthorizationException。
例如：@RequiresRoles(“aRoleName”)
void someMethod();
只有subject有aRoleName角色才能访问方法someMethod()

@RequiresPermissions
验证subject是否有相应权限，有权限访问方法，没有则会抛出异常
AuthorizationException。
例如：
@RequiresPermissions (“file:read”,”wite:aFile.txt”)
void someMethod();
subject必须同时含有file:read和wite:aFile.txt权限才能访问方someMethod()

授权验证-获取角色进行验证

controller

前端

现象 访问报错 没有权限

修改MyRealm

@Override
protected AuthorizationInfo 
doGetAuthorizationInfo(PrincipalCollection principalCollection) { 
	System.out.println("进入自定义授权方法");
//1 创建对象，存储当前登录的用户的权限和角色
	SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(); 
//2 存储角色
	info.addRole("admin"); 
//返回
	return info; 
}

成功访问

实战 从数据库获取角色

1. 添加数据库表

CREATE TABLE `role` (
    `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号', 
	`name` VARCHAR(30) DEFAULT NULL COMMENT '角色名',
	`desc` VARCHAR(50) DEFAULT NULL COMMENT '描述',
	`realname` VARCHAR(20) DEFAULT NULL COMMENT '角色显示名', 
	PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='角色表';

CREATE TABLE `role_user` (
`id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号', 
`uid` BIGINT(20)  DEFAULT NULL COMMENT '用户  id',
`rid` BIGINT(20)  DEFAULT NULL COMMENT '角色  id', 
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='角色用户映射表';

2. mapper

@Repository
public interface UserMapper extends BaseMapper<User> {
@Select("SELECT NAME FROM role WHERE id IN (SELECT rid FROM 
role_user WHERE uid=(SELECT id FROM USER WHERE NAME=#{principal}))")
List<String> getUserRoleInfoMapper(@Param("principal") String 
principal);
}

3. service

@Override
public List<String> getUserRoleInfo(String principal) { 
return userMapper.getUserRoleInfoMapper(principal);
}

4. MyRealm 方法改造

@Override
protected AuthorizationInfo 
doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("进入自定义授权方法"); 
//获取当前用户身份信息
String principal = 
principalCollection.getPrimaryPrincipal().toString();
//调用接口方法获取用户的角色信息
List<String> roles = userService.getUserRoleInfo(principal); 
System.out.println("当前用户角色信息："+roles);
//创建对象，存储当前登录的用户的权限和角色
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(); 
//存储角色
}
info.addRoles(roles);
//返回 
return info;
}

授权验证-获取权限进行验证

1. 添加数据库表

CREATE TABLE `permissions` (
`id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号', 
`name` VARCHAR(30) DEFAULT NULL COMMENT '权限名',
`info` VARCHAR(30) DEFAULT NULL COMMENT '权限信息', 
`desc` VARCHAR(50) DEFAULT NULL COMMENT '描述', 
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='权限表';

CREATE TABLE `role_ps` (
`id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '编号', 
`rid` BIGINT(20)  DEFAULT NULL COMMENT '角色  id',
`pid` BIGINT(20)  DEFAULT NULL COMMENT '权限  id', 
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='角色权限映射表';

2. mapper

@Select({
"<script>",
"select info FROM permissions WHERE id IN ", 
"(SELECT pid FROM role_ps WHERE rid IN (", 
"SELECT id FROM role WHERE NAME IN ",
"<foreach collection='roles' item='name' open='(' separator=',' close=')'>",
"#{name}", 
"</foreach>", 
"))",
"</script>"
})
List<String> getUserPermissionInfoMapper(@Param("roles")List<String> 
roles);

3. service

@Override
public List<String> getUserPermissionInfo(List<String> roles) { 
return userMapper.getUserPermissionInfoMapper(roles);
}

4. MyRealm

//自定义授权方法：获取当前登录用户权限信息，返回给 Shiro 用来进行授权对比
@Override
protected AuthorizationInfo 
doGetAuthorizationInfo(PrincipalCollection principalCollection) { 
System.out.println("进入自定义授权方法");
//获取当前用户身份信息
String principal = 
principalCollection.getPrimaryPrincipal().toString();
    //调用接口方法获取用户的角色信息
List<String> roles = userService.getUserRoleInfo(principal); 
System.out.println("当前用户角色信息："+roles);
//调用接口方法获取用户角色的权限信息
List<String> permissions = 
userService.getUserPermissionInfo(roles);
System.out.println("当前用户权限信息："+permissions); 
//创建对象，存储当前登录的用户的权限和角色
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(); 
//存储角色
info.addRoles(roles);
//存储权限信息
info.addStringPermissions(permissions);
//返回 
return info;
}

5. controller

//登录认证验证权限
@RequiresPermissions("user:delete") 
@GetMapping("userPermissions")
@ResponseBody
public String userLoginPermissions() { 
System.out.println("登录认证验证权限"); 
return "验证权限成功";
}

6. main.html

<body>
<h1>Shiro 登录认证后主页面</h1> 
<br>
登录用户为：<span th:text="${session.user}"></span> 
<br>
<a href="/logout">登出</a> 
<br>
<a href="/myController/userLoginRoles">测试授权-角色验证</a> 
<br>
<a href="/myController/userPermissions">测试授权-权限验证</a> 
</body>

现象 有相应的角色 或者权限才能访问

@RequiresPermissions(“user:delete”)

@RequiresRoles(“admin”)

前端页面授权验证

添加依赖

<dependency>
    <groupId>com.github.theborakompanioni</groupId> 
    <artifactId>thymeleaf-extras-shiro</artifactId> 
    <version>2.0.0</version>
</dependency>

配置类

用于解析 thymeleaf 中的 shiro:相关属性

@Bean
public ShiroDialect shiroDialect(){
return new ShiroDialect(); 
}

Thymeleaf 中常用的 shiro:属性

1. guest 标签

<shiro:guest>
</shiro:guest>

用户没有身份验证时显示相应信息，即游客访问信息。

2. user 标签

<shiro:user> 
</shiro:user>

用户已经身份验证/记住我登录后显示相应的信息。

3. authenticated 标签

<shiro:authenticated> 
</shiro:authenticated>

用户已经身份验证通过，即 Subject.login 登录成功，不是记住我登录的。

4. notAuthenticated 标签

<shiro:notAuthenticated> 
</shiro:notAuthenticated>

用户已经身份验证通过，即没有调用 Subject.login 进行登录，包括记住我自动登录的
也属于未进行身份验证。

5. principal 标签

<shiro: principal/>
<shiro:principal property="username"/>

相当于((User)Subject.getPrincipals()).getUsername()。

6. lacksPermission 标签

<shiro:lacksPermission name="org:create"> 
</shiro:lacksPermission>

如果当前 Subject 没有权限将显示 body 体内容。

7. hasRole 标签

<shiro:hasRole name="admin"> 
</shiro:hasRole>

如果当前 Subject 有角色将显示 body 体内容。

8. hasAnyRoles 标签

<shiro:hasAnyRoles name="admin,user"> 
</shiro:hasAnyRoles>

如果当前 Subject 有任意一个角色（或的关系）将显示 body 体内容。

9. lacksRole 标签

<shiro:lacksRole name="abc"> 
</shiro:lacksRole>

如果当前 Subject 没有角色将显示 body 体内容。

10. hasPermission 标签

<shiro:hasPermission name="user:create"> 
</shiro:hasPermission>

如果当前 Subject 有权限将显示 body 体内容

shiro整合EhCache

1 添加依赖

commons-io主要是为了使用里面的工具类。本质和当前整合功能没有关系。

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-ehcache</artifactId>
    <version>1.4.2</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

2 编写ehcache缓存配置

在resources下新建ehcache/ehcache-shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache name="ehcache" updateCheck="false">
 
<!-- 磁盘缓存位置 -->
<diskStore path="java.io.tmpdir"/>
<!-- 默认缓存 -->
<defaultCache
        maxEntriesLocalHeap="1000"
        eternal="false"
        timeToIdleSeconds="3600"
        timeToLiveSeconds="3600"
        overflowToDisk="false">
</defaultCache>
 
<!-- 登录记录缓存 锁定10分钟 -->
<cache name="loginRecordCache"
       maxEntriesLocalHeap="2000"
       eternal="false"
       timeToIdleSeconds="600"
       timeToLiveSeconds="0"
       overflowToDisk="false"
       statistics="true">
</cache>
 
</ehcache>

3 修改配置文件

@Bean
public DefaultWebSecurityManager securityManager() {
    DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
    HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
    hashedCredentialsMatcher.setHashAlgorithmName("md5");
    hashedCredentialsMatcher.setHashIterations(2);
    myRealm.setCredentialsMatcher(hashedCredentialsMatcher);
    manager.setRealm(myRealm);
    manager.setRememberMeManager(rememberMeManager());
    manager.setCacheManager(getEhCacheManager());
    return manager;
}
 
@Bean
public EhCacheManager ehCacheManager(){
    EhCacheManager ehCacheManager = new EhCacheManager();
    InputStream is = null;
    try {
        is = ResourceUtils.getInputStreamForPath("classpath:ehcache/ehcache-shiro.xml");
    } catch (IOException e) {
        e.printStackTrace();
    }
    net.sf.ehcache.CacheManager cacheManager = new net.sf.ehcache.CacheManager(is);
    ehCacheManager.setCacheManager(cacheManager);
    return ehCacheManager;
}

现象 再请求要权限或者角色的请求 认证和授权就不会再进去了

整合SpringBoot缓存之Redis

参考文章链接

https://blog.csdn.net/lizongxiao/article/details/109137226#t6