springboot整合shiro

已于 2022-10-25 21:44:04 修改
阅读量100 收藏
点赞数
分类专栏： spring boot 文章标签： spring boot java shiro
于 2021-11-07 17:56:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/worilb/article/details/121182774
版权

文章目录

1.测试jsp

先导入jsp解析依赖：

     <!--JSP解析依赖-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

在这里插入图片描述
在这里插入图片描述
出现上图的问题是因为IDEA与JSP兼容性不好，做个配置可以解决
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.配置shiro

引入shiro依赖

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

编写shiro配置类：
在这里插入图片描述
自定义realm：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
shiro过滤器说明：
在这里插入图片描述

3.使用固定用户名和密码登陆

在这里插入图片描述
编写登陆接口：

@Controller
@RequestMapping("user")
public class UserController {


    /**
     * 用来处理身份认证
     * @param username
     * @param password
     * @return
     */
    @RequestMapping("login")
    public String login(String username, String password) {
        try {
            //获取主体对象
            Subject subject = SecurityUtils.getSubject();
            //用户名和密码鉴权
            subject.login(new UsernamePasswordToken(username, password));
            return "redirect:/index.jsp";
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误!");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误!");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }

        return "redirect:/login.jsp";
    }


}

在这里插入图片描述
在这里插入图片描述
添加退出功能
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.连接数据库认证（重点md5+salt）

引入mybatis-plus及Mysql相关依赖：

<!--        mybatis-plus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3.4</version>
        </dependency>

        <!--mysql-connector-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- druid-spring-boot-starter -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.6</version>
        </dependency>

建表语句：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_perms
-- ----------------------------
DROP TABLE IF EXISTS `t_perms`;
CREATE TABLE `t_perms` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `name` varchar(80) DEFAULT NULL,
  `url` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_role
-- ----------------------------
DROP TABLE IF EXISTS `t_role`;
CREATE TABLE `t_role` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `name` varchar(60) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_role_perms
-- ----------------------------
DROP TABLE IF EXISTS `t_role_perms`;
CREATE TABLE `t_role_perms` (
  `id` int(6) NOT NULL,
  `roleid` int(6) DEFAULT NULL,
  `permsid` int(6) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
  `id` int(6) NOT NULL AUTO_INCREMENT,
  `username` varchar(40) DEFAULT NULL,
  `password` varchar(40) DEFAULT NULL,
  `salt` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_user_role
-- ----------------------------
DROP TABLE IF EXISTS `t_user_role`;
CREATE TABLE `t_user_role` (
  `id` int(6) NOT NULL,
  `userid` int(6) DEFAULT NULL,
  `roleid` int(6) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

SET FOREIGN_KEY_CHECKS = 1;

在这里插入图片描述
用户实体类：

@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_user")
public class User implements Serializable {
    @TableId(value = "id",type = IdType.AUTO)
    private String id;
    private String username;
    private String password;
    private String salt;

    //定义角色集合
    private List<Role> roles;

}

资源实体类：

@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_perms")
public class Perms implements Serializable {
    @TableId(value = "id",type = IdType.AUTO)
    private String id;
    private String name;
    private String url;
}

角色实体类：

@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_role")
public class Role implements Serializable {
    @TableId(value = "id",type = IdType.AUTO)
    private String id;
    private String name;

    //定义权限的集合
    private List<Perms> perms;

}

用户Mapper:

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

用户Service:

public interface UserService extends IService<User> {
    void register(User user);
}

用户Service实现:

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

    @Override
    @Transactional
    public void register(User user) {
        //1.生成随机盐
        String salt = SaltUtils.getSalt(8);
        //2.将随机盐保存到数据
        user.setSalt(salt);
        //3.明文密码进行md5 + salt + hash散列
        Md5Hash md5Hash = new Md5Hash(user.getPassword(),salt,1024);
        user.setPassword(md5Hash.toHex());
        baseMapper.insert(user);

    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
进行登陆：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5.授权

5.1页面授权

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
将首页写详细些：

<%@page contentType="text/html;utf-8" pageEncoding="utf-8" isELIgnored="false" %>
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
<%--    受限资源--%>
<h1>系统主页</h1>
<a href="${pageContext.request.contextPath}/user/logout">退出登录</a>
<ul>

<%--    用户管理模块需要user或admin角色--%>
    <shiro:hasAnyRoles name="user,admin">
        <li><a href="">用户管理</a>
            <ul>
<%--                添加删除等操作需要的权限--%>
                <shiro:hasPermission name="user:add:*">
                    <li><a href="">添加</a></li>
                </shiro:hasPermission>
                <shiro:hasPermission name="user:delete:*">
                    <li><a href="">删除</a></li>
                </shiro:hasPermission>
                <shiro:hasPermission name="user:update:*">
                    <li><a href="">修改</a></li>
                </shiro:hasPermission>
                <shiro:hasPermission name="user:find:*">
                    <li><a href="">查询</a></li>
                </shiro:hasPermission>
            </ul>
        </li>
    </shiro:hasAnyRoles>
    <shiro:hasAnyRoles name="user,admin">
        <li><a href="">订单管理</a></li>
        <ul>
            <shiro:hasPermission name="order:add:*">
                <li><a href="">添加</a></li>
            </shiro:hasPermission>
            <shiro:hasPermission name="order:delete:*">
                <li><a href="">删除</a></li>
            </shiro:hasPermission>
            <shiro:hasPermission name="order:update:*">
                <li><a href="">修改</a></li>
            </shiro:hasPermission>
            <shiro:hasPermission name="order:find:*">
                <li><a href="">查询</a></li>
            </shiro:hasPermission>
        </ul>
    </shiro:hasAnyRoles>
    <shiro:hasRole name="admin">
        <li><a href="">商品管理</a></li>
        <li><a href="">物流管理</a></li>
    </shiro:hasRole>

    <shiro:hasRole name="user">
        <li><a href="">仅普通用户可见</a></li>
        <li><a href="">公共资源</a></li>
    </shiro:hasRole>
</ul>
</body>
</html>

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5.2 代码控制权限

以上都是前端控制页面可见性而已，接下来我们在后台授权。
先使用代码授权方式：
订单保存接口

@Controller
@RequestMapping("order")
public class OrderController {
    @RequestMapping("save")
    public String save(){
        System.out.println("进入方法");

        //基于角色
        //获取主体对象
        Subject subject = SecurityUtils.getSubject();
        //代码方式
        if (subject.hasRole("root")) {
            System.out.println("保存订单!");
        }else{
            System.out.println("无权访问!");
        }
        //基于权限字符串
        //....
        return "redirect:/index.jsp";
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5.3注解控制权限

将订单保存接口修改

@RequiresRoles(value={"admin","user"})//用来判断角色  同时具有 admin user
    @RequiresPermissions("order:add:*") //用来判断权限字符串
    @RequestMapping("save")
    public String save(){
        System.out.println("进入方法");
        return "redirect:/index.jsp";
    }

在这里插入图片描述

5.4数据控动态权限

mapper添加查询方法：

@Mapper
public interface UserMapper extends BaseMapper<User> {

    //根据用户名查询所有角色
    User findRolesByUserName(String username);
    //根据角色id查询权限集合
    List<Perms> findPermsByRoleId(String id);

}

编写xml文件（联查在xml中写语句较好）：

    <resultMap id="userMap" type="User">
        <id column="uid" property="id"/>
        <result column="username" property="username"/>
        <!--角色信息-->
        <collection property="roles" javaType="list" ofType="Role">
            <id column="id" property="id"/>
            <result column="rname" property="name"/>
        </collection>
    </resultMap>

    <select id="findRolesByUserName" parameterType="String" resultMap="userMap">
        SELECT u.id uid,u.username,r.id,r.NAME rname
        FROM t_user u
                 LEFT JOIN t_user_role ur
                           ON u.id=ur.userid
                 LEFT JOIN t_role r
                           ON ur.roleid=r.id
        WHERE u.username=#{username}
    </select>

    <select id="findPermsByRoleId" parameterType="String" resultType="Perms">
        SELECT p.id,p.NAME,p.url,r.NAME
        FROM t_role r
                 LEFT JOIN t_role_perms rp
                           ON r.id=rp.roleid
                 LEFT JOIN t_perms p ON rp.permsid=p.id
        WHERE r.id=#{id}
    </select>

</mapper>

service及实现类:

public interface UserService extends IService<User> {
    void register(User user);

    /**
     * 根据用户名查询用户
     * @param username
     * @return
     */
    User findByUserName(String username);


    /**
     * 根据用户名查询所有角色
     * @param username
     * @return
     */
    User findRolesByUserName(String username);

    /**
     * 根据角色id查询权限集合
     * @param id
     * @return
     */
    List<Perms> findPermsByRoleId(String id);



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

    @Override
    @Transactional
    public void register(User user) {
        //1.生成随机盐
        String salt = SaltUtils.getSalt(8);
        //2.将随机盐保存到数据
        user.setSalt(salt);
        //3.明文密码进行md5 + salt + hash散列
        Md5Hash md5Hash = new Md5Hash(user.getPassword(),salt,1024);
        user.setPassword(md5Hash.toHex());
        baseMapper.insert(user);

    }

    @Override
    public User findByUserName(String username) {
        QueryWrapper<User> wrapper = new QueryWrapper();
        wrapper.lambda().select(User::getId,User::getPassword,User::getUsername,User::getSalt).eq(User::getUsername,username);
        return baseMapper.selectOne(wrapper);
    }

    @Override
    public User findRolesByUserName(String username) {
        return baseMapper.findRolesByUserName(username);
    }

    @Override
    public List<Perms> findPermsByRoleId(String id) {
        return baseMapper.findPermsByRoleId(id);
    }


}

数据库中自己添加演示数据
在这里插入图片描述
将授权改为数据库动态授权

 /**
     * 授权
     * @param principals
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //身份信息
        String principal = (String) principals.getPrimaryPrincipal();
        User user = userService.findRolesByUserName(principal);

        System.out.println("user:"+user);

        //授权角色信息
        if(!CollectionUtils.isEmpty(user.getRoles())){

            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();

            user.getRoles().forEach(role->{
                simpleAuthorizationInfo.addRole(role.getName()); //添加角色信息

                //权限信息
                List<Perms> perms = userService.findPermsByRoleId(role.getId());
                System.out.println("perms:"+perms);

                if(!CollectionUtils.isEmpty(perms) && perms.get(0)!=null ){
                    perms.forEach(perm->{
                        simpleAuthorizationInfo.addStringPermission(perm.getName());
                    });
                }
            });
            return simpleAuthorizationInfo;
        }
        return null;
    }

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

6.实现缓存

6.1 EhCache缓存

引入EhCache依赖：

		<dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.7.1</version>
        </dependency>

开启缓存管理器：
在这里插入图片描述

完整代码：

@Configuration
public class ShiroConfig {
    //1.创建shiroFilter
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){

        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);

        Map<String,String> map = new HashMap<String,String>();
        map.put("/**","authc"); //所有路径需要认证授权
        map.put("/user/login","anon");//登录路径不用认证和授权，anon表示允许匿名访问
        map.put("/register.jsp","anon"); //注册页面无需认证
        map.put("/user/register","anon"); //注册接口无需认证
        //默认认证界面路径---当认证不通过时跳转
//        shiroFilterFactoryBean.setLoginUrl("/login.jsp");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }

    //2.创建安全管理器
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(Realm realm){
        Package aPackage = realm.getClass().getPackage();
        System.out.println(aPackage.getName());
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        //给安全管理器设置
        defaultWebSecurityManager.setRealm(realm);

        return defaultWebSecurityManager;
    }

    //3.创建自定义realm
    @Bean("realm")
    public Realm getRealm(){
        CustomerRealm customerRealm = new CustomerRealm();


        //设置hashed凭证匹配器
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();

        //设置md5加密
        credentialsMatcher.setHashAlgorithmName("MD5");
        //设置散列次数
        credentialsMatcher.setHashIterations(1024);

        customerRealm.setCredentialsMatcher(credentialsMatcher);


        //开启缓存管理器
        customerRealm.setCachingEnabled(true);
        customerRealm.setAuthorizationCachingEnabled(true);
        customerRealm.setAuthorizationCachingEnabled(true);
        customerRealm.setCacheManager(new EhCacheManager());

        return customerRealm;
    }

}

在这里插入图片描述

6.2 redis缓存

引入redis依赖：

 <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

配置redis:
在这里插入图片描述

编写自定义缓存管理器：

//自定义shiro缓存管理器
public class RedisCacheManager implements CacheManager {

    //参数1:认证或者是授权缓存的统一名称
    @Override
    public <K, V> Cache<K, V> getCache(String cacheName) throws CacheException {
        System.out.println(cacheName);
        return new RedisCache<K,V>(cacheName);
    }
}

自定义缓存管理实现类：

//自定义redis缓存的实现
public class RedisCache<k,v> implements Cache<k,v> {



    private String cacheName;

    public RedisCache() {
    }

    public RedisCache(String cacheName) {
        this.cacheName = cacheName;
    }

    @Override
    public v get(k k) throws CacheException {
        System.out.println("get key:"+k);
        return (v) getRedisTemplate().opsForHash().get(this.cacheName,k.toString());
    }

    @Override
    public v put(k k, v v) throws CacheException {
        System.out.println("put key: "+k);
        System.out.println("put value:"+v);
        getRedisTemplate().opsForHash().put(this.cacheName,k.toString(),v);
        return null;
    }

    @Override
    public v remove(k k) throws CacheException {
        System.out.println("=============remove=============");
        return (v) getRedisTemplate().opsForHash().delete(this.cacheName,k.toString());
    }

    @Override
    public void clear() throws CacheException {
        System.out.println("=============clear==============");
        getRedisTemplate().delete(this.cacheName);
    }

    @Override
    public int size() {
        return getRedisTemplate().opsForHash().size(this.cacheName).intValue();
    }

    @Override
    public Set<k> keys() {
        return getRedisTemplate().opsForHash().keys(this.cacheName);
    }

    @Override
    public Collection<v> values() {
        return getRedisTemplate().opsForHash().values(this.cacheName);
    }

    private RedisTemplate getRedisTemplate(){
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

在这里插入图片描述
获取BEAN工具类：

@Component
public class ApplicationContextUtils implements ApplicationContextAware {

    private static ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }

    //根据bean名字获取工厂中指定bean 对象
    public static Object getBean(String beanName){
        System.out.println("beanName"+beanName);
        Object object=context.getBean(beanName);
        System.out.println("object"+object);
        return context.getBean(beanName);
    }
}

在这里插入图片描述
在这里插入图片描述

7. 添加验证码

7.1 引入Hutool依赖：

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.7.17</version>
</dependency>

7.2 编写获取验证码接口：

 @RequestMapping("getImage")
    public void getImage(HttpSession session, HttpServletResponse response) throws IOException {

        LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(200, 100);
        //生成验证码
        String code = lineCaptcha.getCode();
        //验证码放入session
        session.setAttribute("code",code);
        //验证码存入图片
        ServletOutputStream os = response.getOutputStream();
        response.setContentType("image/png");
        lineCaptcha.write(os);
        //输出流自己关
        os.close();
    }

7.3 放行验证码并在登录页添加验证码：

在这里插入图片描述

<%@page contentType="text/html;utf-8" pageEncoding="utf-8" isELIgnored="false" %>
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
<h1>登录</h1>
<form action="${pageContext.request.contextPath}/user/login" method="post">
    用户名:<input type="text" name="username" > <br/>
    密  码: <input type="text" name="password"> <br>
    请输入验证码: <input type="text" name="code"><img src="${pageContext.request.contextPath}/user/getImage" alt=""><br>
    <input type="submit" value="登录">
</form>
</body>
</html>

在这里插入图片描述

7.4 登录接口添加验证码验证：

 /**
     * 用来处理身份认证
     * @param username
     * @param password
     * @return
     */
    @RequestMapping("login")
    public String login(HttpSession session, String username,String code, String password) {
        //比较验证码
        String codes = (String) session.getAttribute("code");
        try {
            if (codes.equalsIgnoreCase(code)) {
                //获取主体对象
                Subject subject = SecurityUtils.getSubject();
                //用户名和密码鉴权
                subject.login(new UsernamePasswordToken(username, password));
                return "redirect:/index.jsp";
            }else {
                throw new RuntimeException("验证码错误!");
            }

        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误!");
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密码错误!");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }

        return "redirect:/login.jsp";
    }

在这里插入图片描述

spring-shiro最基本的配置，就这一篇入门
低调的http://
04-04 5334
Apache Shiro是一个强大的，易用的Java安全框架。它被用作于认证，授权，加密，session管理。依赖于Shiro简单易懂的API，就可以快速的构建包括手机，大型web和商业应用。今天小编就带大家入门shiro,你会发现shiro并没有你想的那么难。
springboot整合shiro（超详细，你想要的都在这了）
web18224617243的博客
04-26 559
Springboot整合Shiro 文章目录 pom依赖 前端页面(thymeleaf整合shiro) thymeleaf中shiro标签解释 数据库（整合mybatis) 理解shiro的几个组成部分 编写Shiro配置类(shiroConfig.class) controller 记住我 开启缓存 拓展功能 pom依赖 <dependencies> <!--thymeleaf--> <dependency>
SpringBoot整合Shiro
whs_8792的博客
11-04 1037
Shiro是一个开源的Java安全框架，它提供了身份认证、授权、加密和会话管理等功能，可以帮助我们快速地构建安全可靠的应用程序。
Springboot整合Shiro
不惧困难 顽强拼搏
07-07 924
springboot整合shiro完成登录，权限。完成前后端分离。shiro权限对象缓存到redis中+使用Swagger2接口文档测试
Springboot整合shiro
chao的博客
07-10 2566
是一款主流的Java安全框架，不依赖任何容器，可以运行在Java SE和Java EE项目中，它的主要作用是对访问系统的用户进行身份认证、授权、会话管理、加密等操作。Shiro 就是用来解决安全管理的系统化框架。Shiro是基于session的身份认证和访问控制框架。RBAC是Role-Based Access Control（基于角色的访问控制）的缩写。它是一种广泛应用于安全管理中的访问控制模型。RBAC模型通过授予用户不同的角色，并将角色与权限进行关联，来管理对资源的访问。
SpringBoot 整合 Shiro
qq_70503022的博客
05-16 287
*** 鉴权操作* @param principalCollection 前端传过来的登录凭证* @return 返回鉴权对象 AuthorizationInfo} /*** ⽤户认证* @param authenticationToken 认证 token* @return 返回认证对象 AuthenticationInfo// 1. 获取登录凭证 String username = authenticationToken . getPrincipal() . toString()
SpringBoot整合shiro
m0_50837402的博客
07-06 1092
第一步 展示项目结构 第二步 编写yml文件,这里的配置文件配置了数据源和项目名端口号之类。大家可自行设置编写Shiro的配置文件,这里的@Configuration,相当于spring里的spring-shiro.xml。里面配置了安全管理器,自定义realm 第四步 自定义的realm,里面的doGetAuthenticationInfo是shiro里的认证方法,其中subject.login()。这一句后面会跳转到这里做安全认证 第五步 编写controller,service,dao.开始实现 .
SpringBoot入门实战：SpringBoot整合Shiro
最新发布
2403_88996764的博客
11-20 1044
SpringBoot是Spring公司推出的一款快速开发框架，它可以帮助开发者快速搭建Spring应用程序，同时提供了许多内置的功能，如数据库连接、缓存、日志等。Shiro是一个基于Java的安全框架，它提供了身份验证、授权、会话管理等功能。在本文中，我们将介绍如何将SpringBoot与Shiro整合，以实现安全的应用程序开发。
springBoot 整合shiro
nove2的博客
09-14 320
spring-boot集成shiro的步骤及代码解析
SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录
06-19
SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 ...
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新 前端代码为一个博客页面，使用了Semantic UI框架结合thymeleaf模板 SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ ...
Springboot整合Shiro的代码实例
08-25
Springboot 整合 Shiro 的代码实例 Springboot 整合 Shiro 的代码实例是指在 Springboot 项目中集成 Shiro 框架来实现身份验证和授权管理的过程。Shiro 是一个功能强大且灵活的身份验证和授权框架，可以帮助开发者...
springboot拦截器
热门推荐
作为一个长者,有必要记录下人生经验
02-27 2万+
1.什么是拦截器 拦截器（Interceptor）类似于Servlet中的过滤器，主要用于拦截客户请求并做出相应的处理。与过滤器有如下区别： 1.过滤器只能在容器初始化时被调用一次，在action的生命周期中，而拦截器可以多次被调用。 2.过滤器可以对几乎所有的请求起作用，拦截器只能对action请求起作用。 3.过滤器不能访问action上下文、值栈里的对象，而拦截器可以访问。 4.过滤器依赖于servlet容器，而拦截器不依赖于servlet容器。 5.过滤器是基于函数回调，而拦截器是基于java的反射
springboot以http请求访问本地图片
作为一个长者,有必要记录下人生经验
02-17 8317
如下图，本机(服务器)存储的图片想要在浏览器上通过Url地址访问： 实现很简单，只需要利用拦截器将本机地址映射成url路径就行： @Configuration public class FilePathConfig implements WebMvcConfigurer { @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHan
springboot接收复杂参数(同时接收JSON与文件)
作为一个长者,有必要记录下人生经验
11-17 6588
我们平时传递json用@RequestBody接收，上传文件用@RequestParam接收，如果要同时上传两者，用前面的注解就办不到了,这时候可以用@RequestPart代替。注意传参方式，json字符串要设置Content-Type，application/json有些场景不生效，可以用application/problem+json。
springboot热部署 class XX cannot be cast to class XX 解决
作为一个长者,有必要记录下人生经验
03-02 5885
当我们用devtools进行热加载时，有时会出现class XX cannot be cast to class XX ，XX is in unnamed module of loader org.springframework.boot.devtools.restart.classloader.RestartClassLoader，而XX是同一个类。
springboot中面向切面编程(AOP)
作为一个长者,有必要记录下人生经验
02-27 5599
1.什么是AOP AOP就是通过动态为项目中某些类在运行过程中动态创建代理对象，在对象中完成附加功能，保证在处理业务时更加专注于自己的业务逻辑开发。 有以下几个概念： 1.通知(Advice)——给目标方法添加额外操作称之为通知，也可以称为增强 2.连接点(Joinpoint)——就是可以增强的地方(方法的前后某个阶段) 3.切入点(Pointcut)——实际增强的地方 4.切面(Aspect)——封装了通知和切入点用来横向插入的类 5.代理(Proxy)——将通知应用到目标类动态创建的对象 6.织入(We
springboot 整合 shiro
08-20
在Spring Boot中整合Shiro，需要进行以下几个步骤: 1. 在application.properties文件中配置Shiro相关的属性，如服务器端口号、上下文路径、视图前缀和后缀等。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [SpringBoot之整合Shiro(最详细)](https://blog.youkuaiyun.com/m0_67392273/article/details/125243717)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值