shiro+jwt如何实现单点登录

使用 Shiro JWT 实现单点登录可以分为以下几步：

1. 在服务端配置 Shiro JWT 过滤器，使其能够识别和验证 JWT 令牌。

2. 在用户登录时，服务端生成 JWT 令牌并返回给客户端。

3. 客户端在发起请求时，将 JWT 令牌放在 HTTP 头部的认证信息中，发送给服务端。

4. 服务端通过 Shiro JWT 过滤器验证 JWT 令牌的有效性。如果令牌有效，则允许用户访问；否则，拒绝用户访问。

5. 在服务端和客户端之间的所有请求中，都将带有 JWT 令牌，从而实现单点登录。

相关问题

shiro+jwt如何实现单点登录,代码实例

### 回答1：
Shiro 支持使用 JSON Web Token (JWT) 实现单点登录 (SSO)。

实现步骤如下：

1. 在服务端生成 JWT 并返回给客户端。
2. 客户端保存 JWT 并在请求中加上 HTTP Header，如 "Authorization: Bearer JWT"。
3. 服务端收到请求后验证 JWT 的有效性。
4. 如果 JWT 有效，则允许访问请求的资源。

以下是一个使用 Shiro 实现 JWT 验证的示例代码：

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;

public class JwtRealm extends AuthorizingRealm {

    private String secretKey;

    public JwtRealm(String secretKey) {
        this.secretKey = secretKey;
    }

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        // 这里可以根据 JWT 中的自定义字段来进行权限控制
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        JwtToken jwtToken = (JwtToken) token;
        String jwt = jwtToken.getPrincipal().toString();
        Claims claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(jwt).getBody();
        // 验证 JWT 是否过期
        if (claims.getExpiration().before(new Date())) {
            throw new AuthenticationException("JWT 已过期");
        }
        // 这里可以使用 claims 中的用户信息来创建 SimpleAuthenticationInfo 对象
        return new SimpleAuthenticationInfo(jwt, jwt, "j  

### 回答2：
Shiro JWT是一种基于JSON Web Token（JWT）的认证方式，可以用于实现单点登录（Single Sign-On，SSO）。下面是一个简单的代码示例，展示如何使用Shiro JWT实现单点登录。

首先，需要添加Shiro和JWT的依赖包，可以使用Maven进行管理。在pom.xml文件中添加以下依赖项：

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

<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-api</artifactId>
<version>0.11.2</version>
</dependency>

<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-impl</artifactId>
<version>0.11.2</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId>
<version>0.11.2</version>
<scope>runtime</scope>
</dependency>

然后，需要创建一个JWT工具类，用于生成和解析JWT：

public class JWTUtil {
private static final String SECRET_KEY = "your-secret-key";
private static final long EXPIRATION_TIME = 86400000; // 24 hours

public static String createToken(String username) {
Date now = new Date();
Date expirationDate = new Date(now.getTime() + EXPIRATION_TIME);

return Jwts.builder()
.setSubject(username)
.setIssuedAt(now)
.setExpiration(expirationDate)
.signWith(SignatureAlgorithm.HS256, SECRET_KEY)
.compact();
}

public static String getUsernameFromToken(String token) {
Claims claims = Jwts.parser()
.setSigningKey(SECRET_KEY)
.parseClaimsJws(token)
.getBody();

return claims.getSubject();
}
}

接下来，在登录成功后生成JWT并返回给客户端：

public class LoginController {
@PostMapping("/login")
public String login(@RequestParam String username, @RequestParam String password) {
// 验证用户名和密码
if (authenticateUser(username, password)) {
// 生成JWT
String token = JWTUtil.createToken(username);
return token;
} else {
return "登录失败";
}
}
}

在其他需要单点登录的接口中，可以使用Shiro的注解来验证JWT的有效性：

public class UserController {
@RequiresAuthentication
@GetMapping("/user/{id}")
public String getUser(@PathVariable String id) {
// 处理业务逻辑
return "User " + id;
}
}

以上就是使用Shiro JWT实现单点登录的简单示例。在实际项目中，还需要结合数据库等存储方式来保存用户信息和JWT的校验过程，以及处理JWT过期等情况。  

### 回答3：
在Shiro中，实现JWT（JSON Web Token）的单点登录，需要以下步骤：

首先，确保已经集成了Shiro和JWT相关的依赖。
然后，定义一个Shiro的自定义Realm，用于验证用户身份和生成JWT。如下示例：

public class JWTRealm extends AuthorizingRealm {

@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
// 授权逻辑，可根据具体需求进行自定义实现
return null;
}

@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
JWTToken jwtToken = (JWTToken) token;
String jwt = jwtToken.getToken();

// 解析JWT并验证用户身份
String username = JWTUtils.getUsername(jwt);
String password = JWTUtils.getPassword(jwt);

// 根据用户名查询数据库或其他存储，获取用户信息
// 此处省略数据库查询逻辑
if (username == null || !password.equals("123456")) {
throw new IncorrectCredentialsException("用户身份验证失败");
}

// 用户身份验证通过，返回AuthenticationInfo对象
SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(username, jwt, getName());
return authenticationInfo;
}

@Override
public boolean supports(AuthenticationToken token) {
return token instanceof JWTToken;
}
}

接下来，配置Shiro的过滤链，让Shiro对请求进行JWT认证和授权的处理。如下示例：

public class ShiroConfig {

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

// 添加自定义的JWT过滤器
Map<String, Filter> filters = new HashMap<>();
filters.put("jwt", new JWTFilter());
shiroFilterFactoryBean.setFilters(filters);

// 配置过滤链
Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
filterChainDefinitionMap.put("/login", "anon");
filterChainDefinitionMap.put("/**", "jwt");
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

return shiroFilterFactoryBean;
}

@Bean
public DefaultWebSecurityManager securityManager(ShiroRealm shiroRealm) {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(shiroRealm);
return securityManager;
}

@Bean
public ShiroRealm shiroRealm() {
return new ShiroRealm();
}
}

最后，创建一个JWT过滤器，用于处理JWT的验证和登录。如下示例：

public class JWTFilter extends AuthenticatingFilter {

@Override
protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
String jwt = getTokenFromRequest(request);

if (StringUtils.isNotBlank(jwt) && JWTUtils.verifyToken(jwt)) {
return new JWTToken(jwt);
}

return null;
}

@Override
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
redirectToLogin(request, response);
return false;
}

@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
if (isLoginAttempt(request, response)) {
try {
executeLogin(request, response);
} catch (Exception e) {
e.printStackTrace();
}
}
return true;
}

private boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
String jwt = getTokenFromRequest(request);
return StringUtils.isNotBlank(jwt) && JWTUtils.verifyToken(jwt);
}

private String getTokenFromRequest(ServletRequest request) {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String jwt = httpServletRequest.getHeader("Authorization");
if (StringUtils.isNotBlank(jwt) && jwt.startsWith("Bearer ")) {
return jwt.replace("Bearer ", "");
}
return null;
}

private void redirectToLogin(ServletRequest request, ServletResponse response) {
HttpServletResponse httpServletResponse = (HttpServletResponse) response;
httpServletResponse.setStatus(HttpStatus.UNAUTHORIZED.value());
}
}

这样就实现了使用Shiro和JWT实现单点登录的功能。使用以上代码示例，可根据具体需求进行扩展和自定义。

Jwt redis shiro实现单点登录

单点登录是指用户只需要登录一次即可访问多个应用系统，而不需要针对每个应用系统单独登录。实现单点登录的方案很多，其中使用JWT、Redis和Shiro的组合可以实现一个轻量的、安全的单点登录方案。

具体实现步骤如下：

1. 首先，用户在登录系统时输入账号和密码提交登录请求。后端系统验证通过后，生成一个JWT Token，并将Token保存到Redis缓存中。

2. 把JWT Token返回给前端界面，前端将Token保存在浏览器的Cookie中。

3. 当用户访问第二个应用系统时，前端将Cookie中的Token发送到后端进行验证。后端系统从Redis缓存中获取Token，验证通过后返回结果，用户即可访问该应用系统。

4. 在验证过程中，使用Shiro进行权限控制，保障系统安全。

使用JWT、Redis和Shiro实现单点登录的好处是：

1. JWT Token在客户端和服务端之间传输时是加密的，保证了系统的安全性。

2. Redis缓存可以实现分布式缓存，提高系统性能。

3. Shiro封装了常见的安全操作，使用起来简单方便。

综上所述，使用JWT、Redis和Shiro实现单点登录是一种轻量、安全、高效的方案，可以大大提高用户体验和系统安全性。