SpringBoot整合shiro

最新推荐文章于 2025-01-16 21:30:35 发布
原创 最新推荐文章于 2025-01-16 21:30:35 发布 · 203 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
整合

当前文章被收录于：

整合
3 篇文章 0 人学习
订阅专栏 查看详情
本文详细介绍如何在SpringBoot项目中整合Shiro框架，包括配置Shiro与MyBatis、数据库交互、权限控制及RememberMe功能，同时提供完整的代码示例。

SpringBoot 整合 Shiro

整合 mybatis

可以看这篇文章

https://blog.csdn.net/qq_30815637/article/details/97759047

shiro 基础整合

数据库
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for role_permission
-- ----------------------------
DROP TABLE IF EXISTS `role_permission`;
CREATE TABLE `role_permission`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `rid` int(11) NOT NULL,
  `pid` int(11) NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 9 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of role_permission
-- ----------------------------
INSERT INTO `role_permission` VALUES (1, 1, 1);
INSERT INTO `role_permission` VALUES (2, 1, 2);
INSERT INTO `role_permission` VALUES (3, 1, 3);
INSERT INTO `role_permission` VALUES (4, 1, 4);
INSERT INTO `role_permission` VALUES (5, 2, 1);
INSERT INTO `role_permission` VALUES (6, 2, 2);
INSERT INTO `role_permission` VALUES (7, 2, 3);
INSERT INTO `role_permission` VALUES (8, 3, 3);

-- ----------------------------
-- Table structure for syspermission
-- ----------------------------
DROP TABLE IF EXISTS `syspermission`;
CREATE TABLE `syspermission`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `modelname` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `permission` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of syspermission
-- ----------------------------
INSERT INTO `syspermission` VALUES (1, '商品添加', '/product/add');
INSERT INTO `syspermission` VALUES (2, '商品修改', '/product/update');
INSERT INTO `syspermission` VALUES (3, '商品查询', '/product/query');
INSERT INTO `syspermission` VALUES (4, '商品删除', '/product/delete');

-- ----------------------------
-- Table structure for sysrole
-- ----------------------------
DROP TABLE IF EXISTS `sysrole`;
CREATE TABLE `sysrole`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `rolename` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `roledesc` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sysrole
-- ----------------------------
INSERT INTO `sysrole` VALUES (1, 'admin', 'admin');
INSERT INTO `sysrole` VALUES (2, 'user', 'user');
INSERT INTO `sysrole` VALUES (3, 'vip', 'vip');

-- ----------------------------
-- Table structure for sysuser
-- ----------------------------
DROP TABLE IF EXISTS `sysuser`;
CREATE TABLE `sysuser`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `password` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sysuser
-- ----------------------------
INSERT INTO `sysuser` VALUES (1, 'lifanyu', '123456');
INSERT INTO `sysuser` VALUES (2, 'lVip', '123456');
INSERT INTO `sysuser` VALUES (3, 'LUser', '123456');

-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `uid` int(11) NOT NULL,
  `rid` int(11) NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user_role
-- ----------------------------
INSERT INTO `user_role` VALUES (1, 1, 1);
INSERT INTO `user_role` VALUES (2, 1, 2);
INSERT INTO `user_role` VALUES (3, 1, 3);
INSERT INTO `user_role` VALUES (4, 2, 2);
INSERT INTO `user_role` VALUES (5, 2, 3);
INSERT INTO `user_role` VALUES (6, 3, 3);

SET FOREIGN_KEY_CHECKS = 1;
工程目录

[外链图片转存失败(img-KOzO6eqx-1564651544229)(images/2019-07-30_215103.png)]

修改 pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lfy</groupId>
    <artifactId>springboot-shiro</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-shiro</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <thymeleaf.version>3.0.11.RELEASE</thymeleaf.version>
        <!-- 布局功能支持程序, Thymeleaf3主程序 需要 layout2 以上版本 -->
        <thymeleaf.layout-dialect.version>2.4.1</thymeleaf.layout-dialect.version>
    </properties>

    <dependencies>
        <!-- web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- 测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- shiro -->
        <!-- shiro 模块 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>
        <!-- Thymeleaf 模块 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <!--添加热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
            <scope>true</scope>
        </dependency>
        <!-- shiro + ehcache -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.2.5</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <!--热部署配置-->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!--fork:如果没有该项配置,整个devtools不会起作用-->
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>
配置 application.properties
server.port=8080

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql:///shiro

mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
mybatis.config-location=classpath:mybatis/mybatis-config.xml

spring.thymeleaf.cache=false
spring.thymeleaf.suffix=.html
spring.thymeleaf.prefix= classpath:/templates/
spring.thymeleaf.servlet.content-type=text/html
spring.thymeleaf.enabled=true
spring.thymeleaf.encoding=utf-8
spring.thymeleaf.mode=HTML
编写 Realm

MyRealm :

/**
 * 自定义 Realm
 */
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo
        (AuthenticationToken authenticationToken) throws AuthenticationException {
        //获取主体的身份
        String username = (String) authenticationToken.getPrincipal();
        System.out.println("---> Principal:"+username);
        //根据用户名查询用户信息
        SysUser existUser = userService.findUserByUserName(username);
        if(existUser == null){
            return null;
        }
        System.out.println("---> DataBase:"+existUser);
        //如果不为空 则构建 SimpleAuthenticationInfo
        //组装 authenticationInfo
        //参数一 : 数据库中的用户 参数二 : 数据库中的密码 参数三 : realm 的 name
        SimpleAuthenticationInfo authenticationInfo = 
            new SimpleAuthenticationInfo(existUser,existUser.getPassword(),this.getName());
        //返回认证信息到 Controller
        return authenticationInfo;
    }

    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo
        (PrincipalCollection principalCollection) {
        //访问 @RequirePermission 注解的 url 时触发
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        //得到要授权的用户信息
        SysUser user = (SysUser) principalCollection.getPrimaryPrincipal();
        //用户角色权限进行绑定
        for(SysRole role : user.getRoleList()) {
            authorizationInfo.addRole(role.getRolename());
            for(SysPermission permission : role.getPermissions()) {
                authorizationInfo.addStringPermission(permission.getPermission());
            }
        }
        return authorizationInfo;
    }

}
配置 Shiro
@Configuration
public class ShiroConfig {

    //配置加密方式
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        matcher.setHashAlgorithmName("md5");
        matcher.setHashIterations(2);
        return matcher;
    }

    //配置自定义 Realm
    @Bean
    public MyRealm myRealm(){
        return new MyRealm();
    }

    //配置安全管理器
    @Bean
    public SecurityManager securityManager(){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myRealm());
        return securityManager;
    }

    //DefaultAdvisorAutoProxyCreator，Spring的一个bean，由Advisor决定对哪些类的方法进行AOP代理。
    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
        defaultAAP.setProxyTargetClass(true);
        return defaultAAP;
    }

    //开启@RequirePermission注解的配置，要结合DefaultAdvisorAutoProxyCreator一起使用，或者导入aop的依赖
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

    //定义Spring MVC的异常处理器
    @Bean
    public SimpleMappingExceptionResolver createSimpleMappingExceptionResolver() {
        SimpleMappingExceptionResolver r = new SimpleMappingExceptionResolver();
        Properties mappings = new Properties();
        mappings.setProperty("DatabaseException", "databaseError");//数据库异常处理
        mappings.setProperty("UnauthorizedException","403");//处理shiro的认证未通过异常
        r.setExceptionMappings(mappings);  // None by default
        r.setDefaultErrorView("error");    // No default
        r.setExceptionAttribute("ex");     // Default is "exception"
        return r;
    }
	@Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 设置securityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 登录的url
        shiroFilterFactoryBean.setLoginUrl("/login");
        // 登录成功后跳转的url
        shiroFilterFactoryBean.setSuccessUrl("/index");
        // 未授权url
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");

        LinkedHashMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>();

        // 定义filterChain，静态资源不拦截
        filterChainDefinitionMap.put("/css/**", "anon");
        filterChainDefinitionMap.put("/js/**", "anon");
        filterChainDefinitionMap.put("/fonts/**", "anon");
        filterChainDefinitionMap.put("/img/**", "anon");
        
        // 配置退出过滤器，其中具体的退出代码Shiro已经替我们实现了
        filterChainDefinitionMap.put("/logout", "logout");
        filterChainDefinitionMap.put("/", "anon");
        // 除上以外所有url都必须认证通过才可以访问，未通过认证自动访问LoginUrl
        filterChainDefinitionMap.put("/**", "user");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }

}
编写 bean,dao,service,controller

SysUser.java :

package com.lfy.springbootshiro.bean;

import java.util.List;

/**
 * 用户类
 * @author 15099
 *
 */
public class SysUser {

    private int id;
    private String username;
    private String password;

    // 一个用户有多个角色
    private List<SysRole> roleList;

	// 省略 get set 方法
}

SysRole.java :

package com.lfy.springbootshiro.bean;

import java.util.List;

/**
 * 角色类
 */
public class SysRole {

    private int id;
    private String rolename;//角色名称
    private String roledesc;//角色描述

    //一个角色对应多个权限
    private List<SysPermission> permissions;

    // 省略 get set 方法
}

SysPermission.java :

package com.lfy.springbootshiro.bean;

import java.util.List;

public class SysPermission {

        private int id;
        private String modelname;
        private String permission;

        //一个权限可以被多个角色拥有
        //角色(*) -- 权限(*)
        private List<SysRole> roles;
		
    	// 省略 get set 方法
     
}

UserMapper.java :

@Mapper
@Repository
public interface UserMapper {
    //根据用户名查询用户信息
    SysUser findByUserName(String username);
}

UserMapper.xml :

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DOD Config 3.0//EN"
        "http://mybatis.org/schema/mybatis-3-mapper.dtd">

<mapper namespace="com.lfy.springbootshiro.dao.UserMapper">

    <select id="findByUserName" parameterType="String" resultMap="user" >
        select u.id u_id,username,password,r.id r_id ,rolename ,roledesc , p.id p_id ,modelname,permission from sysuser u
        INNER JOIN user_role ur on u.id = ur.uid
        INNER JOIN sysrole r ON ur.rid = r.id
        INNER JOIN role_permission rp ON r.id = rp.rid
        INNER JOIN syspermission p on rp.pid = p.id
        where u.username = #{name}
    </select>

    <resultMap id="user" type="com.lfy.springbootshiro.bean.SysUser">
        <id property="id" column="u_id"></id>
        <result property="username" column="username"/>
        <result property="password" column="password"/>
        <collection property="roleList" javaType="java.util.List" ofType="com.lfy.springbootshiro.bean.SysRole">
            <id property="id" column="r_id"/>
            <result property="rolename" column="rolename"/>
            <result property="roledesc" column="roledesc"/>
            <collection property="permissions" javaType="java.util.List" ofType="com.lfy.springbootshiro.bean.SysPermission">
                <id property="id" column="p_id"/>
                <result property="modelname" column="modelname"/>
                <result property="permission" column="permission"/>
            </collection>
        </collection>
    </resultMap>

</mapper>

IUserService.java :

public interface IUserService {
    SysUser findUserByUserName(String username);
}

UserServiceImpl.java :

@Service
public class UserService implements IUserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public SysUser findUserByUserName(String username) {
        return userMapper.findByUserName(username);
    }
}

UserController.java :

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping({"/","/index"})
    //@ResponseBody
    public String root(){
        return "index";
    }

    @RequestMapping("/login")
    public String login(HttpServletRequest request, Map<String, String> map) {
        System.out.println("login ... ");
        String exception = (String)request.getAttribute("shiroLoginFailure");
        System.out.println("exception"+ exception);
        String msg = "";
        if (exception != null) {
            if (UnknownAccountException.class.getName().equals(exception)) {
                System.out.println("UnknownAccountException -- > 账号不存在：");
                msg = "unknownAccount";
            } else if (IncorrectCredentialsException.class.getName().equals(exception)) {
                msg = "incorrectPassword";
            } else if ("kaptchaValidateFailed".equals(exception)) {
                System.out.println("kaptchaValidateFailed -- > 验证码错误");
                msg = "kaptchaValidateFailed -- > 验证码错误";
            } else {
                msg = "else >> "+exception;
                System.out.println("else -- >" + exception);
            }
        }
        map.put("msg", msg);

        //认证成功由shiro框架自行处理
        return "login";
    }

    @GetMapping("/user/{username}")
    @ResponseBody
    @RequiresPermissions("/user/add")
    public SysUser findUserByName(@PathVariable("username") String username){
        SysUser user = userService.findUserByUserName(username);
        return user;
    }

}
编写页面

login.html

<html lang="en" xmlns:th="http://www.thymeleaf.org">
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
</head>
<body>
    <form action="/login" method="post">
        用户名:<input type="text" name="username">
        密码 : <input type="password" name="password">
        <input type="submit" value="提交">
    </form>
</body>
</html>

index.html

<html lang="en" xmlns:th="http://www.thymeleaf.org">
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
</head>
<body>
    <h1>Index</h1>
    <a href="/logout">退出</a>
</body>
</html>

403.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>403</title>
</head>
<body>
    <h1>403</h1>
</body>
</html>
测试即可

shiro 整合 ehcache

添加依赖 : pom

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

添加缓存管理器到 shiroConfig 中

/**
* shiro缓存管理器
 */
@Bean
public EhCacheManager ehCacheManager(){
    System.out.println("ShiroConfiguration.getEhCacheManager()");
    EhCacheManager cacheManager = new EhCacheManager();
    cacheManager.setCacheManagerConfigFile("classpath:config/ehcache-shiro.xml");
    returncacheManager;
}

将缓存管理器注入到安全管理器中

//配置安全管理器
@Bean
public SecurityManager securityManager(){
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    securityManager.setRealm(myRealm());
    //注入 ehcacheManager
    securityManager.setCacheManager(ehCacheManager());
    return securityManager;
}

创建 ehcache 的配置文件 :

在 resources/config/ 创建 ehcache-shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache name="es">

    <diskStore path="java.io.tmpdir"/>

<!--
   name:缓存名称。
   maxElementsInMemory:缓存最大数目
   maxElementsOnDisk：硬盘最大缓存个数。
   eternal:对象是否永久有效，一但设置了，timeout将不起作用。
   overflowToDisk:是否保存到磁盘，当系统当机时
   timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
   timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
   diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
   diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
   diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
   memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
    clearOnFlush：内存数量最大时是否清除。
     memoryStoreEvictionPolicy:
        Ehcache的三种清空策略;
        FIFO，first in first out，这个是大家最熟的，先进先出。
        LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
        LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
-->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="false"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
    />


    <!-- 登录记录缓存锁定10分钟 -->
    <cache name="passwordRetryCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

</ehcache>

进行测试 , 访问两次 http://localhost:8080/user/lifanyu 只执行一次授权方法 . 说明成功.

shiro 实现 rememberMe

/**
* 配置cookie对象;
* rememberMeCookie()方法是设置Cookie的生成模版，比如cookie的name，cookie的有效时间等等。
*/
@Bean
public SimpleCookie rememberMeCookie(){
    System.out.println("ShiroConfiguration.rememberMeCookie()");
    //这个参数是cookie的名称，对应前端的checkbox的name = rememberMe
    SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
    //<!-- 记住我cookie生效时间30天 ,单位秒;-->
    simpleCookie.setMaxAge(259200);
    return simpleCookie;
}

/**
* 配置cookie管理对象
* @return
*/
@Bean
public CookieRememberMeManager rememberMeManager(){
    System.out.println("ShiroConfiguration.rememberMeManager()");
    CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
    cookieRememberMeManager.setCookie(rememberMeCookie());
    //rememberMe cookie加密的密钥 建议每个项目都不一样 默认AES算法 密钥长度(128 256 512 位)
    cookieRememberMeManager.setCipherKey(Base64.decode("2AvVhdsgUs0FSA3SDFAdag=="));
    return cookieRememberMeManager;
}

//配置到安全管理器中
@Bean
public SecurityManager securityManager(){
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    securityManager.setRealm(myRealm());
    //注入 ehcacheManager
    // securityManager.setCacheManager(ehCacheManager());
    securityManager.setRememberMeManager(rememberMeManager());
    return securityManager;
}

修改 controller 中的 login 方法

@PostMapping("/login")
public String login(@Valid SysUser user, BindingResult bindingResult,boolean 					rememberMe, RedirectAttributes redirectAttributes) {
    if (bindingResult.hasErrors()) {
        return "login";
    }
    String loginName = user.getUsername();
    System.out.println("rememberMe:"+rememberMe);
    UsernamePasswordToken token = new 																	UsernamePasswordToken(loginName,user.getPassword(),rememberMe);
    //获取当前的Subject
    Subject currentUser = SecurityUtils.getSubject();

    //验证是否登录成功
    if (currentUser.isAuthenticated()) {
        return "redirect:/index";
    } else {
        token.clear();
        return "redirect:/login";
    }
}

修改 login 页面

<html lang="en" xmlns:th="http://www.thymeleaf.org">
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
</head>
<body>
    <form action="/login" method="post">
        用户名:<input type="text" name="username">
        密码 : <input type="password" name="password">
        <!-- 注意 : name 为 rememberMe -->
        记住我 : <input type="checkbox" name="rememberMe">
        <input type="submit" value="提交">
    </form>
</body>
</html>

整合完成 .

修改 login 页面

<html lang="en" xmlns:th="http://www.thymeleaf.org">
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
</head>
<body>
    <form action="/login" method="post">
        用户名:<input type="text" name="username">
        密码 : <input type="password" name="password">
        <!-- 注意 : name 为 rememberMe -->
        记住我 : <input type="checkbox" name="rememberMe">
        <input type="submit" value="提交">
    </form>
</body>
</html>

整合完成 .
项目地址 : https://github.com/IvarLiFanYu/springboot-shiro

标签
#springboot #shiro
一篇文章带你搞定 SpringBoot 整合 Shiro
南淮北安的博客
10-02 2571
文章目录一、Shiro 和 SpringSecurity 比较二、原生的整合1. 环境搭建2. 创建 Realm3. 配置 ShiroConfig4. 配置 Controller三、使用 Shiro Starter 实现1. 环境搭建2. 配置 ShiroConfig3. 配置 Shiro 信息 一、Shiro 和 SpringSecurity 比较 在 Spring Boot 中做权限管理，一般来说，主流的方案是 Spring Security ，但是，仅仅从技术角度来说，也可以使用 Shiro。 一般来
SpringBoot整合Shiro
初学者
03-16 2678
Shiro简介   Apache Shiro是一个开源的轻量级的Java安全框架，它提供了身份认证、授权、密码管理、会话管理等操作。我们知道在Spring中也有一个跟它功能差不多的框架Spring Security，Shiro框架可以更加直观的提供安全性操作，在SSM框架中整合Shrio的配置步骤比较多。但是争对SpringBoot，在SpringBoot官方也提供了对应的启动器。这样的话化简了S...
springboot整合shiro（超详细，你想要的都在这了）
GOV_D的博客
12-08 1万+
Springboot整合Shiro 文章目录pom依赖前端页面(thymeleaf整合shiro)thymeleaf中shiro标签解释数据库理解shiro的几个组成部分编写Shiro配置类 pom依赖 <dependencies> <!--thymeleaf--> <dependency> <groupId>org.springframework.boot</groupId>
Ehcache配置问题(二)Element <cache> does not allow attribute "maxEntriesLocalHeap".
henry_chatter的博客
11-01 6097
<cache name="shiro-activeSessionCache" maxEntriesLocalHeap="2000" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="0" overflowToDisk="false" statis
springboot整合shiro实现权限控制
热门推荐
jiankang66的博客
05-24 4万+
Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码学和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。上个月写了一个在线教育的项目用到了shiro权限控制，这几天又复盘了一下，对其进行了深入探究，来总结一下。 下面所总结的有关shiro的代码已经传到我的github上，可以访问下面的......
【SpringBoot】Spring Boot 整合 Shiro
to_real的博客
09-18 490
在 Spring Boot 中做权限管理，一般来说，主流的方案是 Spring Security ，但是，仅仅从技术角度来说，也可以使用 Shiro。 今天松哥就来和大家聊聊 Spring Boot 整合 Shiro 的话题！ 一般来说，Spring Security 和 Shiro 的比较如下： Spring Security 是一个重量级的安全管理框架；Shiro 则是一个轻量级的安全管理框架 Spring Security 概念复杂，配置繁琐；Shiro 概念简单、配置简单 Spring S
Spring Boot整合Shiro
Rhine
12-11 1万+
记录一次简单易懂的Spring Boot整合Shiro的过程，实现用户认证、授权、密码加密、权限管理功能。
Spring Boot整合Shiro + Springboot +vue
weixin_41290863的博客
05-09 4026
目录 02 Spring Boot整合Shiro p1.shiro概述 1 什么是Shiro 2 Shiro核心组件 p2.Shiro实现登录认证 AccountRealm.java QueryWrapper 类名和表名是一一对应的 mapper报错解决 测试 pom.xml p3.Shiro实现请求授权 配置类 ShiroConfig **编写认证和授权规则: controller p4.Shiro整合Thymeleaf --认证完成，开始授权 13:52
Spring Boot 整合 Shiro详解
最新发布
ning的博客
01-16 2266
创建一个自定义Realm类，用于实现用户认证和授权的逻辑：java复制import orgthrow new UnknownAccountException("用户不存在");} }throw new UnknownAccountException("用户不存在");} }throw new UnknownAccountException("用户不存在");
Springboot整合shiro
chao的博客
07-10 2770
是一款主流的Java安全框架，不依赖任何容器，可以运行在Java SE和Java EE项目中，它的主要作用是对访问系统的用户进行身份认证、授权、会话管理、加密等操作。Shiro 就是用来解决安全管理的系统化框架。Shiro是基于session的身份认证和访问控制框架。RBAC是Role-Based Access Control（基于角色的访问控制）的缩写。它是一种广泛应用于安全管理中的访问控制模型。RBAC模型通过授予用户不同的角色，并将角色与权限进行关联，来管理对资源的访问。
springboot整合shiro相关依赖和配置整理
weixin_44105802的博客
06-10 3045
springboot整合shiro 一、shiro快速开始 去github下载shiro，找到samples/quickstart文件夹。用idea打开它，点进shiro.ini文件。这个时候idea会提示下载插件，下载它。 二、新建一个spring boot项目复制如下依赖 这些都是我整合好的，版本的话你可以自己控制。 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://mav...
SpringBoot之整合Shiro
Fortuneteller的博客
06-04 272
本文主要内容：SpringBoot整合Shiro ###Shiro基本介绍 1.基本概念：Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理 2.Shiro的三大核心组件：Subject, SecurityManager和Realms 1. Subject：是一个安全术语，其基本意思是“当前的操作用户”，称之为“用户”并不准确，因为“用户”一词通常跟人相关，但是Subject也可以是第三方进程、后台帐户（Daemon Account）、定时作业（Corn Job）或其他类似事
SpringBoot之整合Shiro(最详细)
m0_67392273的博客
06-12 2万+
pom.xml 2.3 创建前端页面 在webapp文件夹中创建index.jsp和login.jsp index.jsp login.jsp 2.4 配置视图信息 application.properties 2.5 解决IDEA冲突问题 JSP 与IDEA 与SpringBoot存在一定的不兼容，修改此配置即可解决 pom.xml 3.2 自定义Realm 在shiro文件夹下创建realm文件夹 3.3 Shiro配置 在config文件夹中创建ShiroConfig.java 3.4 启动测试 输入
Springboot整合Shiro框架入门
qq_42640067的博客
09-25 2140
Springboot中集成Shiro框架1、快速开始demo2、Springboot集成Shiro2.1、环境搭建2.2、shiro的拦截2.3、shiro的认证2.4、整合mybatis2.5、shiro进行授权2.6、shiro整合thymeleaf 1、快速开始demo 来到shiro的官网：shiro官方网站： 下载官方在git仓库上提供的源码，下载后解压： 官方提供了在多种场景下使用的demo，等一下会用到sample里面的东西。下面直接按官方推荐的10分钟入门demo进行测试。 创建一
springboot整合shiro实现登录验证
c1225992531的博客
08-02 8548
springboot整合shiro实现登录验证 今天第一次接触springboot，本来是要学习springboot和shiro整合的，但是由于springboot结构还不太了解，所以先来了解一下springboot。 springboot可以快速创建一个机遇spring的项目，而且让这个项目跑起来只需要很少的配置就可以了，主要有以下核心功能： 1.独立运行的spring项目：springboo...
SpringBoot与Shiro整合
fangliangke的博客
02-01 6503
本文章介绍了Spring boot下shiro与thymeleaf、mybatis的整合过程，Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值