shrio--------(5)springboot整合shrio

最新推荐文章于 2022-09-04 13:39:48 发布
最新推荐文章于 2022-09-04 13:39:48 发布
阅读量271 收藏 5
点赞数 1
文章标签： springboot整合shrio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenge1477/article/details/98353718
版权

SpringBoot整合Shrio

添加maven的依赖

<?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.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.xhrtas</groupId>
    <artifactId>rtas</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rtas</name>
    <description>RTAS数据库分析系统</description>
    <packaging>war</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <skipTests>true</skipTests>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
            <version>8.0.15</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <!-- 排除springboot默认的logback日志框架 -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- 引入log4j日志依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.3.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>

        <!--Spring MVC数据校验-->
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>2.0.1.Final</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.4.1.Final</version>
        </dependency>

        <!-- apache 工具类 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring-boot-web-starter -->
        <!--        <dependency>-->
        <!--            <groupId>org.apache.shiro</groupId>-->
        <!--            <artifactId>shiro-spring-boot-web-starter</artifactId>-->
        <!--            <version>1.4.0</version>-->
        <!--        </dependency>-->

        <!--poi读取excel-->
        <!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
        <!--读取excel文件-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.10-FINAL</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.10-FINAL</version>
        </dependency>

        <!--Bouncy Caslte Provider-->
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk16</artifactId>
            <version>1.45</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.github.penggle/kaptcha -->
        <dependency>
            <groupId>com.github.penggle</groupId>
            <artifactId>kaptcha</artifactId>
            <version>2.3.2</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.57</version>
        </dependency>

        <!--用于写入csv-->
        <!-- https://mvnrepository.com/artifact/net.sourceforge.javacsv/javacsv -->
        <dependency>
            <groupId>net.sourceforge.javacsv</groupId>
            <artifactId>javacsv</artifactId>
            <version>2.0</version>
        </dependency>

        <!--shrio-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.4.0</version>
        </dependency>

    </dependencies>

    <build>
<!--        <resources>-->
<!--            <resource>-->
<!--                <directory>src/main/java</directory>-->
<!--                <includes>-->
<!--                    <include>**/mapper/*.xml</include>-->
<!--                    <include>**/application.yml</include>-->
<!--                </includes>-->
<!--            </resource>-->
<!--        </resources>-->
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <configuration>
                    <warName>rtas</warName>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>${maven-surefire-plugin.version}</version>
                <configuration>
                    <!-- Force alphabetical order to have a reproducible build -->
                    <runOrder>alphabetical</runOrder>
                    <useSystemClassLoader>false</useSystemClassLoader>
                </configuration>
            </plugin>

            <!--这里相当于将第三方依赖在打包的时候,将第三方jar包放到了target下指定的lib文件夹里，但是没有打到jar包内。-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>3.0.1</version>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <overWriteReleases>false</overWriteReleases>
                            <overWriteSnapshots>false</overWriteSnapshots>
                            <overWriteIfNewer>true</overWriteIfNewer>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- 将第三方jar包一起并入到项目jar包中 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass></mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id> <!-- this is used for inheritance merges -->
                        <phase>package</phase> <!-- 指定在打包节点执行jar包合并操作 -->
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

springboot的yml配置文件

# REDIS (RedisProperties)
# redis-cli -h 47.92.253.74 -p 6379 -a xhu-rtas-redis
spring:
#  profiles:
#    active: @env@
  redis:
    # Redis数据库索引（默认为0）
    database: 0
    # Redis服务器地址
    host: 47.111.151.251
    #host: 127.0.0.1
    # Redis服务器连接端口,需要开通端口
    port: 6379
    # Redis服务器连接密码（默认为空）
    password: xhu-rtas-redis
    pool:
      # 连接池最大连接数（使用负值表示没有限制）
      max-active: 10
      # 连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: -1
      # 连接池中的最大空闲连接
      max-idle: 10
      # 连接池中的最小空闲连接
      min-idle: 0
    # 连接超时时间（毫秒）
    timeout: 20000

server:
  port: 8080
  servlet:
    context-path: /rtas

jdbc:
  driver: com.mysql.cj.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/rtas_shrio?useUnicode=true&charactorEncoding=utf8&useSSL=false&zeroDateTimeBehavior=convertToNull&serverTimezone=GMT%2B8
  username: root
  password: 123456
  #password: xhu-rtas-mysql


#  mybatis
mybatis_config_file: mybatis-config.xml
mapper_path: mapper/**.xml
entity_package: com.xhrtas.rtas.repository.domain


# 线程池配置
executor:
  core_pool_size: 5
  max_pool_size: 10
  queue_capacity: 1000
  thread_name_prefix: async-service-
  keep_alive_seconds: 5

# 图形验证码
kaptcha:
  border: "yes"
  border.color: 105,179,90
  textproducer:
    font:
      color: blue
      size: 30
      names: 宋体,楷体,微软雅黑
    char:
      length: 4
  image:
    width: 120
    height: 67
  session:
    key: code

#Shrio配置
shrio:
  hashedCredentialsMatcher:
    hashAlgorithmName: md5
    hashIterations: 2
  shiroFilter:
    loginUrl: /user/authc
    unauthorizedUrl: /user/authc
    filterChainDefinitionMap:
      anon:
        image: /img/**
        login: /user/login
        static: /static/
      authc:
        other: /**

整合带有缓存的shrio

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
        缓存对象存放路径
        java.io.tmpdir：默认的临时文件存放路径。
        user.home：用户的主目录。
        user.dir：用户的当前工作目录，即当前程序所对应的工作路径。
        其它通过命令行指定的系统属性，如“java –DdiskStore.path=D:\\abc ……”。
    -->
    <diskStore path="java.io.tmpdir"/>
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="0"
            timeToLiveSeconds="0"
            overflowToDisk="false"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
    />

    <!-- 授权缓存 -->
    <cache name="authorizationCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="0"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

    <!-- 认证缓存 -->
    <cache name="authenticationCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="0"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

</ehcache>

Shrio的配置

shrio配置


@Configuration
public class ShrioConfiguration {
    /**
     * 加密方式
     */
    @Value("${shrio.hashedCredentialsMatcher.hashAlgorithmName}")
    private String hashAlgorithmName;

    /**
     * 加密迭代次数
     */
    @Value("${shrio.hashedCredentialsMatcher.hashIterations}")
    private int hashIterations;

    /**
     * 登陆url
     */
    @Value("${shrio.shiroFilter.loginUrl}")
    private String loginUrl;

    /**
     * 认证失败的url
     */
    @Value("${shrio.shiroFilter.unauthorizedUrl}")
    private String unauthorizedUrl;

    /**
     * 放行image验证码
     */
    @Value("${shrio.shiroFilter.filterChainDefinitionMap.anon.image}")
    private String image;

    /**
     * 放行登陆方法
     */
    @Value("${shrio.shiroFilter.filterChainDefinitionMap.anon.login}")
    private String login;

    /**
     * 放行静态资源
     */
    @Value("${shrio.shiroFilter.filterChainDefinitionMap.anon.static}")
    private String staticStr;

    /**
     * 需要认证的资源
     */
    @Value("${shrio.shiroFilter.filterChainDefinitionMap.authc.other}")
    private String other;


    /**
     * 密码校验规则HashedCredentialsMatcher
     * 这个类是为了对密码进行编码的 ,
     * 防止密码在数据库里明码保存 , 当然在登陆认证的时候 ,
     * 这个类也负责对form里输入的密码进行编码
     * 处理认证匹配处理器：如果自定义需要实现继承HashedCredentialsMatcher
     */
    @Bean("hashedCredentialsMatcher")
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        //指定加密方式为MD5
        credentialsMatcher.setHashAlgorithmName(hashAlgorithmName);
        //加密次数
        credentialsMatcher.setHashIterations(hashIterations);
        credentialsMatcher.setStoredCredentialsHexEncoded(true);
        return credentialsMatcher;
    }


    @Bean("authRealm")
    @DependsOn("lifecycleBeanPostProcessor")//可选
    public AuthRealm authRealm(@Qualifier("hashedCredentialsMatcher") HashedCredentialsMatcher matcher) {
        AuthRealm authRealm = new AuthRealm();
        authRealm.setCredentialsMatcher(matcher);
        authRealm.setCachingEnabled(true);
        //启用授权缓存，即缓存AuthorizationInfo信息，默认false
        authRealm.setAuthorizationCachingEnabled(true);
        //缓存AuthorizationInfo信息的缓存名称  在ehcache-shiro.xml中有对应缓存的配置
        authRealm.setAuthorizationCacheName("authorizationCache");
        return authRealm;
    }


    /**
     * 定义安全管理器securityManager,注入自定义的realm
     * @param authRealm
     * @return
     */
    @Bean("securityManager")
    public SecurityManager securityManager(@Qualifier("authRealm") AuthRealm authRealm) {
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        //配置 ehcache缓存管理器
        manager.setCacheManager(ehCacheManager());
        manager.setRealm(authRealm);
        return manager;
    }


    /**
     * 定义shiroFilter过滤器并注入securityManager
     * @param manager
     * @return
     */
    @Bean("shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(@Qualifier("securityManager") SecurityManager manager) {
        ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
        //设置securityManager
        bean.setSecurityManager(manager);
        //设置登录页面
        //可以写路由也可以写jsp页面的访问路径
        bean.setLoginUrl(loginUrl);
        //设置登录成功跳转的页面
       // bean.setSuccessUrl("/pages/index.jsp");
        //设置未授权跳转的页面
        bean.setUnauthorizedUrl(unauthorizedUrl);


        //定义过滤器
        LinkedHashMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put(image, "anon");
        filterChainDefinitionMap.put(login, "anon");
        filterChainDefinitionMap.put(staticStr, "anon");
        //需要登录访问的资源 , 一般将/**放在最下边
        filterChainDefinitionMap.put(other, "authc");

        bean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return bean;
    }

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

    /**
     * 配置shiro跟spring的关联
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(@Qualifier("securityManager") SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }

    /**
     * lifecycleBeanPostProcessor是负责生命周期的 , 初始化和销毁的类
     * (可选)
     */
    @Bean("lifecycleBeanPostProcessor")
    public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }


    /**
     * shiro缓存管理器;
     * 需要添加到securityManager中
     * @return
     */
    @Bean
    public EhCacheManager ehCacheManager(){
        EhCacheManager cacheManager = new EhCacheManager();
        cacheManager.setCacheManagerConfigFile("classpath:ehcache-shiro.xml");
        return cacheManager;
    }

}

自定义Realm

自定义Realm包括对用户的认证、授权

package com.xhrtas.rtas.configuration.shrio;

import com.xhrtas.rtas.enums.ErrorCodeEnum;
import com.xhrtas.rtas.exception.BusinessException;
import com.xhrtas.rtas.repository.dao.UserDao;
import com.xhrtas.rtas.repository.domain.*;
import com.xhrtas.rtas.service.UserService;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

public class AuthRealm extends AuthorizingRealm {
    @Autowired
    private UserService userService;

    @Autowired
    private UserDao userDao;
    /**
     * 为用户授权
     * @param principals
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        System.out.println("授权========");
        //获取前端输入的用户信息，封装为User对象
        User userweb = (User) principals.getPrimaryPrincipal();
        //获取前端输入的用户电话号码
        String tel = userweb.getTelephone();
        //根据前端输入的用户名查询数据库中对应的记录
        User user = userDao.getByTelephone(tel);
        //如果数据库中有该用户名对应的记录，就进行授权操作
        if (user != null){
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            UserRole userRole = user.getUserRole();

            //为用户授予角色
            info.addRole(userRole.getRole().getName());
            //用户授予权限
            Collection<String> permissionCollection = new HashSet<String>();
            for(RolePermission  rolePermission:userRole.getRole().getRolePermissionList()){
                permissionCollection.add(rolePermission.getPermission().getName());
            }
            info.addStringPermissions(permissionCollection);
            return info;
        }else{
            return null;
        }
    }



    /**
     * 认证登录
     * @param token
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("认证========");
        //token携带了用户信息
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
        //获取前端输入的用户名
        String tel  = usernamePasswordToken.getUsername();
        //根据用户名查询数据库中对应的记录
        User user = userDao.getByTelephone(tel);
        if (user == null){
            throw new AuthenticationException();
        }

        //当前realm对象的name
        String realmName = getName();
       //封装用户信息，构建AuthenticationInfo对象并返回
        AuthenticationInfo authcInfo = new SimpleAuthenticationInfo(user, user.getPassword(),ByteSource.Util.bytes(user.getSalt()), realmName);
        return authcInfo;
    }


    /**
     * 重写方法,清除当前用户的的 授权缓存
     * @param principals
     */
    @Override
    public void clearCachedAuthorizationInfo(PrincipalCollection principals) {
        super.clearCachedAuthorizationInfo(principals);
    }

    /**
     * 重写方法，清除当前用户的 认证缓存
     * @param principals
     */
    @Override
    public void clearCachedAuthenticationInfo(PrincipalCollection principals) {
        super.clearCachedAuthenticationInfo(principals);
    }

    @Override
    public void clearCache(PrincipalCollection principals) {
        super.clearCache(principals);
    }
}

登陆

登陆操作，登陆成功后报错session

//初始化
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(telephone, password);
        User user =null;
        //登录，即身份校验，由通过Spring注入的UserRealm会自动校验输入的用户名和密码在数据库中是否有对应的值
        try {
            //4、登录，即身份验证
            subject.login(token);
            if(subject.isAuthenticated()){
                user = (User)subject.getPrincipal();
                request.getSession().setAttribute(SessionConstant.USER,user);
            }
        }catch (UnknownAccountException e) {
            throw new BusinessException(ErrorCodeEnum.NO_USER);
        } catch (IncorrectCredentialsException e) {
            throw new BusinessException(ErrorCodeEnum.PASSWORD_ERROR);
        } catch (AuthenticationException e) {
            //其他错误，比如锁定，如果想单独处理请单独catch处理
            throw new BusinessException(ErrorCodeEnum.NO_USER);
        }
        result.setUser(user);
        request.getSession().setAttribute("user", user);

使用shrio

使用shrio可以有两种
1. 认证用户角色
2. 认证用户权限

认证用户角色

@PostMapping(value = "/nais")
    @RequiresRoles(value = {"administrator","collector"},logical = Logical.OR)
    public ResultVo readNais(@RequestParam(value = "file") MultipartFile file, HttpSession session) throws IOException {
        //获取数据
        PageDto<AccidentVo> accidentPageDto = naisService.readNais(file);
        return ResultUtil.success(accidentPageDto);
    }

其中的logical = Logical.OR代表两角色有一个就行

认证用户权限

@RequestMapping(value = "data")
    @RequiresPermissions(value ={"total","nais"},logical = Logical.AND)
    public void getData(){
        
    }

其中的logical = Logical.AND代表两角色都有才就行

相关链接

springboot整合shrio
springboot整合shrio2
springboot整合带缓存的shrio

wenge1477
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Shiro-SpringBoot.整合
蔡定努
09-26 123
https://download.csdn.net/download/caidingnu/11808405
springboot(3)：整合shiro-redis
ostars
10-14 650
源码地址https://github.com/ostars/springboot-fast.git 分支：dev_redis springboot shiro整合redis做二级缓存，除了ShiroConfig.java 其余配置与shiro整合echahe做二级缓存一致 项目结构 ├── doc ...
【SpringBoot学习三】springboot2+hibernate5
随心所欲的博客
08-14 5428
springboot2集成hibernate5，先准备一个数据库及java驱动，我用的是mysql。 集成步骤如下 1.pom配置 需要的包如下，hibernate、spring事务、连接池、ORM、数据库驱动 <dependency> <groupId>org.hibernate</groupId> <artifactId>hibe...
SpringBoot整合shiro-spring-boot-starter
xiyafei122的博客
08-12 1211
shiro
SpringBoot-31-springboot整合shiro
时光
08-23 119
SpringBoot-31-springboot整合shiro
SpringBoot使用shiro-ehcache缓存
、思考致富的博客
05-09 4714
由于网上教程很多，对于shiro的概念和用法已经讲解非常详细，这里直接给出介绍shiro概念的博主连接Shiro笔记(一)----Shiro安全框架简介 以及写的不错的博客：springboot(十四)：springboot整合shiro-登录认证和权限管理 这里是本项目源码，已经上传github，感兴趣的小伙伴可以下载 : 去下载 话不多说，先上pom文件： <?xml version="...
Shiro实战系列--整合shiro-redis
热门推荐
IT利刃出鞘的博客
10-18 1万+
本文用实例介绍shiro通过引入shiro-redis来缓存权限。使用SpringBoot整合Shiro。
SpringBoot-34-shiro整合thymeleaf
时光
09-04 475
SpringBoot-34-shiro整合thymeleaf
shiro-cas------整合springboot客户端
weixin_39816740的博客
02-20 561
在这里我们创建了两个客户端。 整合cas(以shiro-cas-client-one为例) 总pom文件 <?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=...
springboot+devtools+shiro-redis整合出现ClassCastException异常
feinifi的博客
12-24 3240
上次在https://blog.csdn.net/feinifi/article/details/84990003这篇文章中，提到过springboot整合shiro时，使用redis做缓存管理，那么会用到shiro-redis这个依赖，那么问题来了，热部署+shiro-redis会导致：我们登录时存入在session中的用户信息，在我们再次取出来转为User时，报错：classcastexcep...
springboot-shiro-redis
02-04
标题“springboot-shiro-redis”表明我们正在讨论一个基于Spring Boot的应用程序，该应用程序集成了Apache Shiro安全框架，并利用Redis作为缓存层。这是一个常见的架构选择，因为Spring Boot简化了开发流程，Shiro...
springboot-07-shiro.zip
08-12
5. 集成SpringBoot：通过SpringBoot的自动配置，将Shiro与Spring容器进行整合。 三、Shiro核心组件解析 1. SecurityManager：Shiro的核心组件，负责管理所有安全相关的组件，如Subject、Realm、Session等。 2. ...
springboot-shiro权限管理系统.zip
07-05
整合SpringBoot和Shiro，需要在SpringBoot的配置文件（application.properties或application.yml）中设置Shiro的相关配置，如过滤器链定义、Realm的实现类等。部署时，SpringBoot的内嵌Tomcat服务器可以让系统以war...
springboot-vue-shiro-权限整合
01-06
springboot+vue+shiro 前后盾分离，权限整合，vue路由配置解析，有sql语句，shiro 权限验证。
大物实验下MOOC题目答案 .pdf
最新发布
08-18
文件概述： 大物实验下MOOC题目答案.pdf 是为物理学实验课程中的MOOC题目提供的答案汇编文件。该文件专门为物理学科的实验课程设计，旨在帮助学生更好地理解实验内容和提高解决问题的能力。文件内容涵盖了大量的实验题目及其详细答案，提供了一种有效的复习和学习工具。 文件内容： 实验题目：涵盖了物理实验课程中的各种MOOC题目，这些题目包括实验设计、数据分析、理论验证等方面，帮助学生深入理解实验内容。 详细解答：针对每个题目提供了详细的解答步骤和方法，包括实验操作流程、数据处理过程和理论分析。这些解答帮助学生理解实验的关键步骤和原理。 解题技巧：提供了一些解题技巧和常见错误的分析，帮助学生在实际实验和问题解答中避免常见陷阱，提高解题效率。 使用说明： 下载并打开该PDF文件后，建议学生首先浏览实验题目，然后仔细阅读对应的答案和解答步骤。通过对比自己的实验结果和答案，检查理解和解决方法的准确性。利用解答中的技巧和方法，进一步提高自己的实验操作和数据分析能力。 该文件旨在作为学习和复习的辅助工具，帮助学生有效地掌握物理实验课程的核心知识点，提升实验技能和问题解决能力。
2024申博白皮书（面试攻略、笔试攻略）
08-18
白皮书旨在帮助硕士生了解和规划申博之路。它首先分析了博士申请形势，包括招生人数增加、报考人数增多等趋势，并介绍了国内外申博的多种类型，例如直博、统考、审核制、同等学力申博等。接着，白皮书详细讲解了如何选择院校和套磁导师，以及申博文书的撰写技巧，包括个人简历、研究计划、个人陈述和推荐信。最后，白皮书还提供了复试的攻略，包括笔试和面试的准备方法，以及常见问题的回答思路。总而言之，这份白皮书为硕士生申博提供了全面的指导和参考。 一、博士申请形势分析 博士招生人数： 分析了近年来博士招生人数的增长趋势，以及不同高校的招生情况。 二、博士申请类型 三、选择导师和套磁 四、申博文书 五、复试 复试类型： 介绍了笔试和面试两种复试类型，以及各自的考查重点。 笔试攻略： 介绍了笔试的时间安排、答题次序、文字书写、答题量、重点突出、思维严谨、难题偏题应对等方面的技巧。 面试类型： 介绍了与导师单独面试和由院校委员组织的多人面试两种面试形式，以及面试委员会的组成人员。 面试攻略： 介绍了常规准备、informal 面试和正式面试的注意事项，以及常见的面试问题。 六、常见问题汇总 列举了十个常见的面试问题
Delphi 12 控件之ZipForge-695.zip
08-18
ZipForge_695.zip
基于语义分割，对GEOTIFF格式的光学卫星遥感图像进行多种地表类型的实时面积计算，并进行时序预测+python源代码+文档说明
08-18
<项目介绍> - 基于语义分割，对GEOTIFF格式的光学卫星遥感图像进行多种地表类型的实时面积计算，并进行时序预测 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
SpringBoot-Shiro整合实践：动态权限、Session共享与单点登录
此外，为了实现Session共享和单点登录，还引入了Shiro-redis插件3.1.0，并依赖于SpringBoot的Redis连接器。" 在SpringBoot项目中，Shiro作为安全框架，主要负责用户的认证（验证用户身份）、授权（确定用户是否有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值