shiro整合springboot+jwt

最新推荐文章于 2024-07-24 10:31:44 发布
最新推荐文章于 2024-07-24 10:31:44 发布
阅读量927 收藏 1
点赞数
分类专栏： java 文章标签： java shiro spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38320702/article/details/106438637
版权

同类博客：SpringSecurity整合springboot+jwt

目录

目录结构

依赖

 配置文件

代码介绍

SecurityProperties

AuthController

ShiroConfiguration

JwtAuthFilter

 DbShiroRealm

JwtShiroRealm

JwtToken

JwtTokenProvider

用于权限测试的接口类

 操作

github地址

 

目录结构

红框中是核心配置文件

依赖

<?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 https://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.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.siyang</groupId>
    <artifactId>shiro-springboot-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>shiro-springboot-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--Spring boot end-->
        <!--  shiro-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-web-starter</artifactId>
            <version>1.4.1</version>
        </dependency>
        <!--Mysql依赖包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- druid数据源驱动 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!--lombok插件-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.54</version>
        </dependency>
        <!--工具包 加密相关-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.0.6</version>
        </dependency>
        <!--jwt-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.10.6</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.10.6</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.10.6</version>
        </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-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

 配置文件

spring:
  datasource:
    druid:
      url: jdbc:mysql://localhost:3306/securitydemo?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver
  jpa:
    show-sql: true
    hibernate:
      naming:
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

#jwt
jwt:
  header: Authorization
  # 令牌前缀
  token-start-with: Bearer
  # 必须使用最少88位的Base64对该令牌进行编码
  base64-secret: ZmQ0ZGI5NjQ0MDQwY2I4MjMxY2Y3ZmI3MjdhN2ZmMjNhODViOTg1ZGE0NTBjMGM4NDA5NzYxMjdjOWMwYWRmZTBlZjlhNGY3ZTg4Y2U3YTE1ODVkZDU5Y2Y3OGYwZWE1NzUzNWQ2YjFjZDc0NGMxZWU2MmQ3MjY1NzJmNTE0MzI=
  # 令牌过期时间 此处单位/毫秒 ，默认4小时，可在此网站生成 https://www.convertworld.com/zh-hans/time/milliseconds.html
  token-validity-in-seconds: 14400000
  # 在线用户key
  online-key: online-token
  # 验证码
  code-key: code-key

代码介绍

SecurityProperties

 

jwt配置文件参数映射

/**
 * @author siyang
 * @create 2020-01-12 14:45
 */
@Data
@Configuration
@ConfigurationProperties(prefix = "jwt")//从yml配置文件中获取配置的属性
public class SecurityProperties {

    /** Request Headers ： Authorization */
    private String header;

    /** 令牌前缀，最后留个空格 Bearer */
    private String tokenStartWith;

    /** 必须使用最少88位的Base64对该令牌进行编码 */
    private String base64Secret;

    /** 令牌过期时间 此处单位/毫秒 */
    private Long tokenValidityInSeconds;

    /** 在线用户 key，根据 key 查询 redis 中在线用户的数据 */
    private String onlineKey;

    /** 验证码 key */
    private String codeKey;

    public String getTokenStartWith() {
        return tokenStartWith + " ";
    }

}

AuthController

登录认证接口

/**
 * @author siyang
 * @create 2020-05-29 11:26
 */
@RestController
@RequestMapping("/auth")
public class AuthController {
    @Autowired
    private SecurityProperties properties;
    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @PostMapping("/login")
    public ResponseEntity<Object> login(User user){
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(user.getUsername(), user.getPassword());
        // 登录验证
        subject.login(usernamePasswordToken);

        // 生成token
        String token = jwtTokenProvider.createToken(user.getUsername());
        // 将token放入redis，没写

        Map<String,Object> authInfo = new HashMap<String,Object>(1){{
            put("token", properties.getTokenStartWith() + token);
        }};

        return ResponseEntity.ok(authInfo);
    }

}

ShiroConfiguration

shiro配置类，配置数据源，拦截路径，权限注解开启

@Configuration
public class ShiroConfiguration {

    /**
     * 设置过滤器
     * @param securityManager
     * @return
     */
    @Bean("shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager, JwtTokenProvider jwtTokenProvider){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //配置安全管理
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        Map<String, Filter> filters = shiroFilterFactoryBean.getFilters();
        filters.put("authcToken", new JwtAuthFilter(jwtTokenProvider));
//        filters.put("anyRole", createRolesFilter());
        shiroFilterFactoryBean.setFilters(filters);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(shiroFilterChainDefinition().getFilterChainMap());

        return shiroFilterFactoryBean;

    }

    /**
     * 配置拦截路径及相应过滤器
     * @return
     */
    @Bean
    protected ShiroFilterChainDefinition shiroFilterChainDefinition() {

        DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();

        chainDefinition.addPathDefinition("/*.html", "anon");
        chainDefinition.addPathDefinition("/**/*.html", "anon");
        chainDefinition.addPathDefinition("/**/*.css", "anon");
        chainDefinition.addPathDefinition("/**/*.js", "anon");
        chainDefinition.addPathDefinition("/webSocket/**", "anon");
        chainDefinition.addPathDefinition("/swagger-ui.html", "anon");
        chainDefinition.addPathDefinition("/swagger-resources/**", "anon");
        chainDefinition.addPathDefinition("/webjars/**", "anon");
        chainDefinition.addPathDefinition("/*/api-docs", "anon");
        chainDefinition.addPathDefinition("/avatar/**", "anon");
        chainDefinition.addPathDefinition("/file/**", "anon");
        chainDefinition.addPathDefinition("/druid/**", "anon");
        chainDefinition.addPathDefinition("/avatar/**", "anon");
        //控制器路径
        chainDefinition.addPathDefinition("/", "anon");
        chainDefinition.addPathDefinition("/auth/login", "anon");
        chainDefinition.addPathDefinition("/auth/code", "anon");
        chainDefinition.addPathDefinition("/auth/logout", "authcToken[permissive]");

        chainDefinition.addPathDefinition("/**", "authcToken");  //对所有进行验证token
        return chainDefinition;
    }

    /**
     * 禁用session, 不保存用户登录状态。保证每次请求都重新认证。
     * 需要注意的是，如果用户代码里调用Subject.getSession()还是可以用session，如果要完全禁用，要配合下面的noSessionCreation的Filter来实现
     */
    @Bean
    protected SessionStorageEvaluator sessionStorageEvaluator(){
        DefaultWebSessionStorageEvaluator sessionStorageEvaluator = new DefaultWebSessionStorageEvaluator();
        sessionStorageEvaluator.setSessionStorageEnabled(false);
        return sessionStorageEvaluator;
    }

    /**
     * 注册shiro的Filter，拦截请求
     */
    @Bean
    public FilterRegistrationBean<Filter> filterRegistrationBean(SecurityManager securityManager, JwtTokenProvider jwtTokenProvider) throws Exception{
        FilterRegistrationBean<Filter> filterRegistration = new FilterRegistrationBean<Filter>();
        filterRegistration.setFilter((Filter)shiroFilter(securityManager, jwtTokenProvider).getObject());
        filterRegistration.addInitParameter("targetFilterLifecycle", "true");
        filterRegistration.setAsyncSupported(true);
        filterRegistration.setEnabled(true);
        filterRegistration.setDispatcherTypes(DispatcherType.REQUEST);

        return filterRegistration;
    }
    /**
     * 初始化Authenticator 身份认证
     */
    @Bean
    public Authenticator authenticator() {
        ModularRealmAuthenticator authenticator = new ModularRealmAuthenticator();
        //设置两个Realm，一个用于用户登录验证和访问权限获取；一个用于jwt token的认证
        authenticator.setRealms(Arrays.asList(dbShiroRealm(),jwtShiroRealm()));
        //设置多个realm认证策略，一个成功即跳过其它的
        authenticator.setAuthenticationStrategy(new FirstSuccessfulStrategy());
        return authenticator;
    }
    /**
     * 初始化authorizer 认证器 权限认证
     * @return
     */
    @Bean
    public Authorizer authorizer() {
        ModularRealmAuthorizer authorizer = new ModularRealmAuthorizer();//这里的
        authorizer.setRealms(Arrays.asList(jwtShiroRealm()));
        return authorizer;
    }

    /**
     * DbRealm,默认的密码校验算法为BCrypt
     * @return
     */
    @Bean("dbRealm")
    public Realm dbShiroRealm() {
        DbShiroRealm myShiroRealm = new DbShiroRealm();
        //将Realm的默认密码校验设置为BCrypt算法
        myShiroRealm.setCredentialsMatcher(new CredentialsMatcher() {
            @Override
            public boolean doCredentialsMatch(AuthenticationToken authenticationToken, AuthenticationInfo authenticationInfo) {
                String password = new String(((UsernamePasswordToken) authenticationToken).getPassword());
                String hashed = (String) authenticationInfo.getCredentials();
                return BCrypt.checkpw(password,hashed);
            }
        });
        return myShiroRealm;
    }
    /**
     * jwtToken->Realm
     * 校验前后token是否相同，其实可以直接返回true。
     * 因为前面过滤器已经验证过token的完整性和正确性
     * @return
     */
    @Bean("jwtRealm")
    public Realm jwtShiroRealm() {
        JwtShiroRealm myShiroRealm = new JwtShiroRealm();
        myShiroRealm.setCredentialsMatcher(new CredentialsMatcher() {
            @Override
            public boolean doCredentialsMatch(AuthenticationToken authenticationToken, AuthenticationInfo authenticationInfo) {
                JwtToken jwtToken1 = (JwtToken) authenticationToken;
                JwtToken jwtToken2 = (JwtToken)authenticationInfo.getCredentials();
                String token1 = jwtToken1.getToken();
                String token2 = jwtToken2.getToken();

                return token1.equals(token2);
            }
        });
        return myShiroRealm;
    }
    /**
     * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
     * 配置以下两个bean(DefaultAdvisorAutoProxyCreator(可选)和AuthorizationAttributeSourceAdvisor)即可实现此功能
     * @return
     */
    @Bean
    @DependsOn({"lifecycleBeanPostProcessor"})
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator creator  = new DefaultAdvisorAutoProxyCreator();
        creator.setProxyTargetClass(true);
        return creator;
    }
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }
}

 

JwtAuthFilter

shiro过滤器

 

 

/**
 * @author siyang
 * @create 2020-01-12 20:40
 * jwt过滤器
 * 不能写@bean之类的直接，不能交给spring管理
 */
@Slf4j
public class JwtAuthFilter extends BasicHttpAuthenticationFilter {

    private JwtTokenProvider jwtTokenProvider;


    public JwtAuthFilter(JwtTokenProvider jwtTokenProvider) {
        this.jwtTokenProvider = jwtTokenProvider;
    }


    /**
     *父类会在请求进入拦截器后调用该方法，返回true则继续，返回false则会调用onAccessDenied()。这里在不通过时，还调用了isPermissive()方法，我们后面解释。
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {

        boolean allowed = false;
        try {
            //内部的方法会执行createToken
            allowed = executeLogin(request, response);
        } catch(IllegalStateException e){ //not found any token
            log.error("Not found any token");
        }catch (Exception e) {
            log.error("Error occurs when login", e);
        }
        return allowed || super.isPermissive(mappedValue);
    }

    /**
     *  这里重写了父类的方法，使用我们自己定义的Token类，提交给shiro。这个方法返回null的话会直接抛出异常，进入isAccessAllowed（）的异常处理逻辑。
     * @param request
     * @param response
     * @return
     */
    @Override
    protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
        //从request头中取出token
        String token = jwtTokenProvider.getToken((HttpServletRequest) request);
        //如果token不为空 并且token验证合格
        if(token!=null){
            // 返回的JWTtoken 会被JwtShiroRealm 进行解析
            return new JwtToken(token);
        }

        return null;
    }


    /**
     * 如果这个Filter在之前isAccessAllowed（）方法中返回false,则会进入这个方法。我们这里直接返回错误的response
     * @param servletRequest
     * @param servletResponse
     * @return
     * @throws Exception
     */
    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {

        HttpServletResponse res = (HttpServletResponse)servletResponse;
        res.setHeader("Access-Control-Allow-Origin", "*");
        res.setStatus(HttpServletResponse.SC_OK);
        res.setCharacterEncoding("UTF-8");
        PrintWriter writer = res.getWriter();
        Map<String, Object> map= new HashMap<>();
        map.put("status", 401);
        LocalDateTime now = LocalDateTime.now();
        now.format(DateTimeFormatter.ISO_DATE_TIME);

        map.put("timestamp", now.toString());
        map.put("message", "身份认证失败");
        writer.write(JSON.toJSONString(map));
        writer.close();
        return false;
    }
}

 

 DbShiroRealm

登录验证数据源

/**
 * @author siyang
 * @create 2020-01-12 20:15
 * 只需要登录验证，所以只需要继承AuthenticatingRealm
 */
public class DbShiroRealm extends AuthenticatingRealm {

    @Autowired
    private UserService userService;

    /**
     * 限定这个Realm只支持UsernamePasswordToken
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof UsernamePasswordToken;
    }

    /**
     * 验证
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken usernamePasswordToken =(UsernamePasswordToken) authenticationToken;
        String username = usernamePasswordToken.getUsername();
        User user = userService.getUserByUsername(username);
        if(user == null) {
            // 账号不存在
            throw new AuthenticationException();
        }
        return new SimpleAuthenticationInfo(user,user.getPassword(),"dbRealm");
    }
}

JwtShiroRealm

jwt认证、授权数据源

/**
 * @author siyang
 * @create 2020-01-14 18:13
 * 需要jwt验证和授权，所以需要继承AuthorizingRealm
 */
public class JwtShiroRealm extends AuthorizingRealm {
    @Autowired
    private UserService userService;
    @Autowired
    private JwtTokenProvider jwtTokenProvider;


    /**
     * 限定这个Realm只支持我们自定义的JWT Token
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }



    /**
     * 授权
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        JwtToken primaryPrincipal = (JwtToken)principalCollection.getPrimaryPrincipal();
        String token = primaryPrincipal.getToken();
        String username = jwtTokenProvider.parseToken(token);
        User user = userService.getUserByUsername(username);
        Set<Role> roles = user.getRoles();
        Set<String> roleSet = new HashSet<>();
        Set<String> permissionSet = new HashSet<>();
        for (Role role : roles) {
            roleSet.add(role.getName());
            // 将角色下所有权限都存入permissions
            Set<Permission> p = role.getPermissions();
            for (Permission permission : p) {
                permissionSet.add(permission.getPermissionValue());
            }
        }

        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.setRoles(roleSet);
        simpleAuthorizationInfo.setStringPermissions(permissionSet);
        return simpleAuthorizationInfo;

    }

    /**
     * token登录，每次请求都要判断路径
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        JwtToken token = (JwtToken) authenticationToken;
        // 如果解析jwt有问题会跳出
        String username = jwtTokenProvider.parseToken(token.getToken());
        User user = userService.getUserByUsername(username);
        if(user == null) {
            // 账号不存在
            throw new AuthenticationException();
        }
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(token,token,"jwtRealm");
        return simpleAuthenticationInfo;
    }
}

JwtToken

为UsernamePasswordToken的兄弟类，用于区分使用哪个数据源，这个是使用jwtToken，在数据源中support中指定

/**
 * @author siyang
 * @create 2020-01-14 17:48
 * 封装的JwtToken对象
 */
public class JwtToken implements HostAuthenticationToken {
    private String token;
    private String host;
    public JwtToken(String token) {
        this(token, null);
    }
    public JwtToken(String token, String host) {
        this.token = token;
        this.host = host;
    }
    public String getToken(){
        return this.token;
    }
    public String getHost() {
        return host;
    }
    @Override
    public Object getPrincipal() {
        return token;
    }
    @Override
    public Object getCredentials() {
        return token;
    }
    @Override
    public String toString(){
        return token + ':' + host;
    }
}

JwtTokenProvider

jwt提供工具类

/**
 * @author siyang
 * @create 2020-01-12 20:50
 * JWT-TOKEN 提供类
 */
@Slf4j
@Component
public class JwtTokenProvider implements InitializingBean {

    @Autowired
    private SecurityProperties properties;
    private static final String AUTHORITIES_KEY ="auth";
    private Key key;
    /**
     * 实例化对前会调用此方法,需要Spring的环境
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        byte[] decode = Decoders.BASE64.decode(properties.getBase64Secret());
        this.key= Keys.hmacShaKeyFor(decode);
    }

    /**
     * 创建token
     * @return
     */
    public String createToken(String username){

        long now = new Date().getTime();
        Date date = new Date(now + properties.getTokenValidityInSeconds());
        return Jwts.builder().setSubject(username).setExpiration(date).signWith(key, SignatureAlgorithm.HS512).compact();

    }

    /**
     * 验证token
     * @return
     */
    public boolean vaildateToken (String token){

        try {
            Jwts.parser().setSigningKey(key).parseClaimsJws(token);
            return true;
        } catch (io.jsonwebtoken.security.SecurityException | MalformedJwtException e) {
            log.info("Invalid JWT signature.");
            e.printStackTrace();
        } catch (ExpiredJwtException e) {
            log.info("Expired JWT token.");
            e.printStackTrace();
        } catch (UnsupportedJwtException e) {
            log.info("Unsupported JWT token.");
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            log.info("JWT token compact of handler are invalid.");
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 根据token 解析出username
     * @param token
     * @return
     */
    public String parseToken(String token){
        Claims body = Jwts.parser().setSigningKey(key).parseClaimsJws(token).getBody();
        String username = body.getSubject();
        return username;

    }
    /**
     * 从request中获取token
     * @param request
     * @return
     */
    public String getToken(HttpServletRequest request){
        String header = request.getHeader(properties.getHeader());
        if(header != null && header.startsWith(properties.getTokenStartWith())){
            header=header.substring(properties.getTokenStartWith().length());
        }
        return header;
    }

}

 

用于权限测试的接口类

/**
 * @author siyang
 * @create 2020-05-29 12:00
 */
@RestController
@RequestMapping("/")
public class UserController {
    @Autowired
    UserService userService;

    @RequiresPermissions("read")
    @GetMapping("getAll")
    public ResponseEntity getAllUsers(){
        List<User> all = userService.findAll();
        Map<String, Object> map = new HashMap<>();
        map.put("list",all);
        return ResponseEntity.ok(map);
    }
}

 

 操作

使用resource/下的sql文件创建数据，然后使用postman测试接口，使用/auth/login登录 （sql文件存在2个用户siyang/lisi,密码123456）

然后登录成功会返回token信息，将它放入header中，header名为Authorization 。然后用get方式访问/getAll 接口获得用户信息，通过切换2个用户产生的token 值，可以看到权限的管理功能。

github地址

https://github.com/ebb94f53au/shiro-springboot-demo

 

 

 

 

 

司杨
关注
专栏目录
教你 Shiro + SpringBoot 整合 JWT
Howie_Y的博客
05-06 8211
本篇文章将教大家在 shiro + springBoot 的基础上整合 JWT （JSON Web Token） 如果对 shiro 如何整合 springBoot 还不了解的可以先去看我的上一篇文章 《教你 Shiro 整合 SpringBoot，避开各种坑》 附上源码：https://github.com/HowieYuan/shiro JWT JSON Web...
SpringBoot集成Shiro\JWT
qq_36541573的博客
04-14 243
1.大体思路总结 shiro：权限验证 （1）需要自定义realm,realm中处理用户角色权限相关的东西. （2）shiroConfig.java，shiro配置i相关 （3）loginController,登录处理 （4）拦截器，集成jwt后，对token进行校验 JWT:生成token的工具 （1）工具类：生成token，验证token等各种方法 （2）JWTToken.java,一个存to...
SpringBoot和SpringSecurity整合一下JWT
qq_1641486826的博客
12-03 862
上一篇写了SpringBoot整合SpringSecurity实现了登录认证和授权，但是SpringSecurity是把用户信息存储在session中的。对服务器有一定的压力，所以目前JWT这种服务无状态的校验方式比较流行 我接着上篇的代码改进，将JWT融合进去 首先导入JWT的maven坐标，我使用的是jjwt <properties> <java.version>1.8</java.version> <jjwt.versio
shiro视频2018 shiro+springboot+mybatis
05-04
shiro视频2018 shiro+springboot+mybatis 1 Authentication 认证 用户登录 2 Authorization 授权 用户具有那些权限 3 cryptography 安全加密 4 session management 会话加密 5 web integration web 系统集成 6 interations 集成其它应用，spring 缓存框架
基于JWT 和 Shiro 做接口权限认证
最新发布
ewii12567的博客
07-24 1150
自定义的权限认证和身份认证逻辑。方法是权限认证。方法是身份认证时就是交给这个自定义类处理。@Service@Autowired// /**// * 大坑！，必须重写此方法，不然Shiro会报错// */// }// /**// * 只有当需要检测用户权限的时候才会调用此方法，例如checkRole,checkPermission之类的// */@Override/*** 默认使用此方法进行用户名正确与否验证，错误抛出异常即可。
spring boot整合shiro(附带简单demo)
热门推荐
诗简默的博客
06-08 1万+
shiro是目前主流的java安全框架，主要用来更便捷的认证，授权，加密，会话管理。废话不多说，下面是一个简单的案例，Soring boot整合shiro；首先搭建一个spring boot框架，具体步骤请参考点击打开链接；然后配置shiro依赖（顺便整合mybatis）               &lt;dependency&gt; &lt;groupId&gt;org.springfra...
Spring Boot 整合 Shiro 快速入门
fishpro的博客
03-16 1595
Spring Boot 整合 Shiro 快速入门1 Spring Boot 快速集成 Shiro 示例1.1 新建 Spring Boot Maven 示例工程项目1.2 依赖引入 Pom.xml1.3 配置 application.yml1.4 自定义 Realm 领域 UserRealm 实现自定义认证与授权1.6 shiro 实现登录认证1.6.1 登录 html 页面1.6.2 登录逻辑...
spring boot + shiro
Suneey专栏
04-15 467
文章目录Spring Boot+Shiro1 简介2 环境搭建2.1 开发环境2.2 创建项目2.3 项目文件结构2.4 pom.xml2.5 application.yml3 数据库3.1 数据库设计3.2 数据库字段4 类4.1 po4.2 mapper4.3 config4.4 realm4.5 service4.6 controller5 页面6 测试运行6.1 普通用户登录6...
Springboot整合Shiro
凡是过往，皆为序章
03-26 1403
不了解shiro的同学可以先学习下这篇博客《30分钟学会如何使用Shiro》 项目结构截图： 项目在结构上没有任何特殊之处，基本就是MVC的传统结构重点需要关注的是3个Entity类、2个Controller类和1个Config类。 首先，提供pom的完整文档结构： <project xmlns="http://maven.apache.org/POM/4.0.0" ...
springboot + jwt + websocket + 拦截
09-02
将这四个技术整合在一起，我们可以构建一个安全且具有实时交互功能的Web应用。具体步骤可能包括： 1. **用户认证**：使用JWT进行用户身份验证。用户登录时，服务器生成一个包含用户信息的JWT并返回给客户端。客户端...
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制
10-17
在这个项目中，SpringBoot作为基础框架，整合了Shiro、JWT、数据库和Redis等组件，提供了RESTful API的入口和处理逻辑。 **MySQL数据库** MySQL是广泛使用的开源关系型数据库，用于存储用户信息、权限规则等数据。...
springboot+Shiro 实现动态授权
09-05
Spring springboot，Mybatis、Shiro 实现动态授权, 避免了在使用Shiro时 在系统控制层 加入权限判断进行鉴权处理！
shrio-with-jwt-spring-boot-starter:spring-boot环境下基于JWT Token的无状态shiro权限验证框架
05-14
如需了解本框架的设计细节，请阅读：这篇文章 简介 用户权限管理是每个信息系统最基本的需求，对基于 Java 的项目来说，最常用的权限管理框架就是大名鼎鼎的 Apache Shiro。Apache Shiro 功能非常强大，使用广泛，几乎成为了权限管理的代名词。但对于普通项目来说，Shiro 的设计理念因为追求灵活性，一些概念如 Realm，Subject 的抽象级别都比较高，显得比较复杂。如果没有对框架细节进行深入了解的话，很难理解其中的准确含义。要将其应用于实际项目，还需要针对项目的实际情况做大量的配置和改造，时间成本较高。 而且 Shiro 兴起的时代主流应用还是传统的基于 Session 的 Web 网站，并没有过多的考虑目前流行的微服务等应用形式的权限管理需求。导致其并没有提供一套无状态微服务的开箱即用的整合方案。需要在项目层面对 Shiro 进行二次封装和改进，开发难度较大。 s
Spring boot整合shiro+jwt实现前后端分离
08-25
主要为大家详细介绍了Spring boot整合shiro+jwt实现前后端分离，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
springboot+mybatis+layui+shiro 权限注解-后台的完整的项目整合
04-23
非常适合刚学习springboot的初学者用了学习springboot+mybatis+layui+shiro 权限注解-后台的完整的项目整合 后台的账号密码 admin-111111
SpringBoot+shiro+redis+jwt .zip
01-03
本项目通过`SpringBoot`整合`Shiro`和`Redis`，利用`JWT`来实现用户鉴权，旨在提供一种简洁、高效的解决方案。 首先，`SpringBoot`简化了传统`Spring`项目的配置和依赖管理，通过自动配置特性，开发者可以快速构建...
基于SpringBoot+Spring+SpringMvc+Mybatis+Shiro+Redis 开发单点登录管理系统源码
06-19
基于 SpringBoot + Spring + SpringMvc + Mybatis + Shiro+ Redis 开发单点登录管理系统 基于 SpringBoot + Spring + SpringMvc + Mybatis + Shiro+ Redis 开发单点登录管理系统 基于 SpringBoot + Spring + ...
Shiro实战+springboot集成
醉鱼的博客
12-03 364
本文未排版点击链接阅读原文 注：本文只做流程分享，重点解读，源码已上传github，源码获取方式（左下角阅读原文） Springboot+Shiro 版本介绍 Springboot: 2.0.5.RELEASE Java: JDK1.8 Shiro: 1.4.1 MySQL：8.0 本文简介 该例子中使用Springboot集成Shiro的方式展示Shiro 授权，主要涉及技术点，tkmapper...
springboot+shiro
weixin_42465093的博客
10-26 571
springboot+shiro的学习Shiro简介shiro的核心架构shiro认证普通的认证过程自定义Realm认证MD5+随机盐方式认证自定义加密Realm认证shiro授权授权方式授权实现自定义Realm授权web项目中使用shiro（springboot）认证大概过程MD5+随机盐进行注册MD5+随机盐进行认证授权过程基于角色的授权基于权限的授权 Shiro简介 Shiro是一个功能强大且易于使用的Java安全框架，它执行身份验证、授权、加密和会话管理。使用Shiro易于理解的API，您可以快速轻
springboot+shiro+jwt+mybatisplus框架
06-09
这个框架整合可以分为以下几个步骤： 1. 集成 Spring Boot：在 pom.xml 文件中添加 Spring ...这样，简单的 Spring Boot + Shiro + JWT + MyBatis Plus 整合就完成了。你可以根据具体的需求，对代码进行修改和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值