Jwt redis shiro实现单点登录
时间: 2023-05-27 22:02:02 浏览: 88
单点登录是指用户只需要登录一次即可访问多个应用系统,而不需要针对每个应用系统单独登录。实现单点登录的方案很多,其中使用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实现单点登录是一种轻量、安全、高效的方案,可以大大提高用户体验和系统安全性。
相关问题
springboot shiro jwt redis
Spring Boot是一个基于Spring框架的快速应用开发工具,可以简化Spring应用的创建和配置。
Apache Shiro是一个强大且灵活的Java安全框架,可用于身份验证,授权,加密和会话管理。
JWT(JSON Web Token)是一种开放标准(RFC 7519),它定义了一种简洁的自包含方式,用于在各方之间安全地传输信息。
Redis是一个开源的内存数据库,支持存储键值对数据,常用于缓存和消息队列等。
springboot+jwt+shiro+redis例子
可以的,我可以为您提供一个基于Spring Boot、JWT、Shiro和Redis的例子。这个例子将演示如何使用这些技术实现用户认证和授权,并且将用户的状态存储在Redis中。
首先,您需要创建一个Spring Boot项目并添加所需的依赖。
在pom.xml文件中添加以下依赖:
```
<dependencies>
<!-- Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Shiro -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring-boot-web-starter</artifactId>
<version>1.7.1</version>
</dependency>
<!-- JWT -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<!-- Redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>
```
接下来,创建一个名为`JwtUtils`的JWT工具类,用于生成和验证JWT令牌。您可以参考以下代码:
```java
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.Date;
@Component
public class JwtUtils {
@Value("${jwt.secret}")
private String secret;
@Value("${jwt.expiration}")
private int expiration;
@PostConstruct
public void init() {
secret = Base64.getEncoder().encodeToString(secret.getBytes());
}
public String generateToken(String username) {
Date now = new Date();
Date expiryDate = new Date(now.getTime() + expiration * 1000);
return Jwts.builder()
.setSubject(username)
.setIssuedAt(now)
.setExpiration(expiryDate)
.signWith(SignatureAlgorithm.HS512, secret)
.compact();
}
public String getUsernameFromToken(String token) {
Claims claims = Jwts.parser()
.setSigningKey(secret)
.parseClaimsJws(token)
.getBody();
return claims.getSubject();
}
public boolean validateToken(String token) {
try {
Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
return true;
} catch (Exception e) {
return false;
}
}
}
```
然后,创建一个名为`RedisUtils`的Redis工具类,用于操作Redis。您可以参考以下代码:
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
@Component
public class RedisUtils {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
public void set(String key, Object value, long expiration) {
redisTemplate.opsForValue().set(key, value, expiration, TimeUnit.SECONDS);
}
public Object get(String key) {
return redisTemplate.opsForValue().get(key);
}
public void delete(String key) {
redisTemplate.delete(key);
}
public boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
}
```
接下来,创建一个名为`JwtRealm`的Shiro Realm,用于验证JWT令牌和授权。您可以参考以下代码:
```java
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
public class JwtRealm extends AuthorizingRealm {
@Autowired
private JwtUtils jwtUtils;
@Autowired
private RedisUtils redisUtils;
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof JwtToken;
}
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
// TODO: 实现授权逻辑
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
JwtToken jwtToken = (JwtToken) token;
String username = jwtUtils.getUsernameFromToken(jwtToken.getToken());
if (username == null || !jwtUtils.validateToken(jwtToken.getToken())) {
throw new AuthenticationException("无效的令牌");
}
// TODO: 查询用户信息并返回认证信息
return new SimpleAuthenticationInfo(username, jwtToken.getToken(), getName());
}
}
```
最后,创建一个名为`JwtToken`的Shiro Token,用于封装JWT令牌。您可以参考以下代码:
```java
import org.apache.shiro.authc.AuthenticationToken;
public class JwtToken implements AuthenticationToken {
private String token;
public JwtToken(String token) {
this.token = token;
}
@Override
public Object getPrincipal() {
return token;
}
@Override
public Object getCredentials() {
return token;
}
}
```
以上是一个基于Spring Boot、JWT、Shiro和Redis的例子。您可以根据您的需求进行修改和扩展。希望对您有帮助!