springboot+shiro+jwt获取当前登录用户

在Spring Boot中使用Shiro和JWT获取当前登录用户，可以按照以下步骤进行：

1. 配置Shiro和JWT：在Spring Boot的配置文件中配置Shiro和JWT，包括配置Shiro的Realm、SessionManager和SecurityManager，以及配置JWT的密钥、过期时间等参数。

2. 创建ShiroRealm：继承Shiro的AuthorizingRealm类，重写doGetAuthenticationInfo和doGetAuthorizationInfo方法，用于验证用户身份和获取用户权限信息。

3. 创建JWT工具类：实现生成JWT、解析JWT和验证JWT的方法。

4. 创建登录接口：在登录接口中，验证用户的身份和密码是否正确，并生成JWT返回给客户端。

5. 创建获取当前登录用户接口：在需要获取当前登录用户的接口中，从请求头或请求参数中获取JWT，并解析JWT获取用户信息。

6. 配置Shiro的过滤链：在Spring Boot的配置类中配置Shiro的过滤链，将需要验证用户身份的接口配置为需要登录认证。

7. 编写前端代码：在前端页面中，发送登录请求获取JWT，并在需要获取当前登录用户的地方带上JWT发送请求。

总结：通过配置Shiro和JWT，重写ShiroRealm，创建JWT工具类，并在登录和获取用户接口中进行相关操作，可以实现在Spring Boot中使用Shiro和JWT获取当前登录用户的功能。

相关问题

springboot shiro token

Spring Boot和Shiro是两个独立的开源项目，可以结合使用来实现身份认证和授权功能。在Spring Boot中集成Shiro，可以使用Shiro提供的Token来进行用户身份认证。

在使用Shiro进行身份认证时，可以使用不同类型的Token，比如UsernamePasswordToken、JWTToken等。这些Token都实现了Shiro的AuthenticationToken接口，用于传递用户的身份信息。

下面是一个使用Shiro Token进行身份认证的简单示例：

1. 首先，需要在Spring Boot的依赖管理中添加Shiro和相应的Token库的依赖，比如shiro-spring、shiro-jwt等。

2. 创建一个自定义的Token类，继承Shiro的AuthenticationToken接口，并实现其中的方法。该Token类可以封装用户的身份信息，比如用户名和密码等。

3. 在Shiro的配置类中，配置认证器（Authenticator）和Realm等相关信息。认证器负责验证用户的身份信息，并将其与数据库或其他存储中的用户信息进行比对。

4. 在需要进行身份认证的地方，可以通过SecurityUtils获取当前Subject对象，并调用其login方法进行身份认证。在login方法中，将自定义的Token对象传入即可。

5. 根据需要，可以使用Shiro的注解来进行授权操作，比如@RequiresPermissions、@RequiresRoles等。

这只是一个简单的示例，具体的使用方式还需要根据具体的需求和场景来进行调整。你可以参考Shiro的官方文档和Spring Boot的相关文档，深入了解和学习如何使用Spring Boot和Shiro来实现身份认证和授权功能。

springboot shiro前后端分离 多用户

Spring Boot和Shiro与前后端分离的结合可以使用RESTful API来实现。多用户可以通过Shiro的Realm来实现用户的认证和授权。下面是一个简单的示例：

1. 配置Shiro

在Spring Boot中，可以使用Shiro的Java Config方式配置Shiro。

@Configuration
public class ShiroConfig {

    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        shiroFilterFactoryBean.setLoginUrl("/login");
        shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized");

        Map<String, Filter> filters = new LinkedHashMap<>();
        filters.put("jwt", new JwtFilter());
        shiroFilterFactoryBean.setFilters(filters);

        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/api/login", "anon");
        filterChainDefinitionMap.put("/api/logout", "logout");
        filterChainDefinitionMap.put("/**", "jwt");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

        return shiroFilterFactoryBean;
    }

    @Bean
    public SecurityManager securityManager(Realm realm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);
        return securityManager;
    }

    @Bean
    public Realm realm() {
        return new MyRealm();
    }

}

在上面的代码中，我们配置了Shiro的过滤器，并且设置了登录URL和未授权URL。我们还配置了一个JwtFilter来验证JWT Token。最后，我们将所有URL都设置为需要通过JwtFilter才能访问。

2. 自定义Realm

public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String username = (String) principals.getPrimaryPrincipal();
        User user = userService.findByUsername(username);
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        authorizationInfo.setRoles(user.getRoles());
        authorizationInfo.setStringPermissions(user.getPermissions());
        return authorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String username = (String) token.getPrincipal();
        User user = userService.findByUsername(username);
        if (user == null) {
            throw new UnknownAccountException();
        }
        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName());
        return authenticationInfo;
    }

}

在上面的代码中，我们自定义了一个Realm，用于用户的认证和授权。在认证时，我们根据用户名查询数据库，如果查询到了对应的用户，则返回一个SimpleAuthenticationInfo对象；否则抛出UnknownAccountException异常。在授权时，我们根据用户名查询数据库，然后将用户的角色和权限设置到SimpleAuthorizationInfo对象中。

3. 编写JWT Filter

public class JwtFilter extends AuthenticatingFilter {

    @Autowired
    private UserService userService;

    @Autowired
    private JwtUtils jwtUtils;

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Authorization");
        if (StringUtils.isEmpty(token)) {
            throw new UnauthorizedException();
        }
        try {
            Claims claims = jwtUtils.getClaimsFromToken(token);
            String username = claims.getSubject();
            User user = userService.findByUsername(username);
            if (user == null) {
                throw new UnauthorizedException();
            }
            JwtToken jwtToken = new JwtToken(token);
            getSubject(request, response).login(jwtToken);
            return true;
        } catch (Exception e) {
            throw new UnauthorizedException();
        }
    }

    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        return false;
    }

}

在上面的代码中，我们编写了一个JwtFilter，用于验证JWT Token。在过滤器中，我们从Header中获取Token，并解析出其中的用户名。然后根据用户名查询数据库，如果查询到了对应的用户，则创建一个JwtToken对象，调用Subject的login方法进行登录。

4. 编写Controller

@RestController
@RequestMapping("/api")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/login")
    public Result login(@RequestBody User user) {
        User dbUser = userService.findByUsername(user.getUsername());
        if (dbUser == null || !dbUser.getPassword().equals(user.getPassword())) {
            return Result.fail("用户名或密码错误");
        }
        String token = JwtUtils.generateToken(dbUser.getUsername());
        return Result.success(token);
    }

    @GetMapping("/user")
    public Result getUser() {
        String username = (String) SecurityUtils.getSubject().getPrincipal();
        User user = userService.findByUsername(username);
        return Result.success(user);
    }

    @RequiresPermissions("user:add")
    @PostMapping("/user")
    public Result addUser(@RequestBody User user) {
        userService.addUser(user);
        return Result.success();
    }

}

在上面的代码中，我们编写了一个UserController，用于处理用户相关的请求。在登录接口中，我们根据用户名和密码查询数据库，如果查询到了对应的用户，则使用JwtUtils生成一个Token并返回。在getUser接口中，我们获取当前登录的用户名，然后根据用户名查询数据库并返回用户信息。在addUser接口中，我们使用@RequiresPermissions注解来限制只有拥有user:add权限的用户才能访问该接口。

5. 测试

使用Postman等工具来测试接口，可以通过登录接口获取Token，并在后续请求中将Token加入到Header中进行访问。

以上就是Spring Boot和Shiro与前后端分离结合实现多用户认证和授权的示例。