SaToken系列--指定token存储的数据源

于 2024-06-23 22:59:14 发布
阅读量1k 收藏 17
点赞数 21
分类专栏： 踩坑笔记 文章标签： spring boot mybatis 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42972832/article/details/139888993
版权

一、背景

        由于特殊需求，需要在一个项目里面使用两个redis数据源，一个是本项目A的使用的，另一个数据源是用于satoken使用的。相当于需要使用其他项目B的登录校验，因此需要接入B的satoken，而B的satoken使用的token存储的数据源和本项目不是同一个。

 二、解决方案

一、satoken配置需要和B项目配置一致

# Sa-Token配置
sa-token:
  # token名称 (同时也是cookie名称)
  token-name: 
  # token有效期，单位s 默认30天, -1代表永不过期
  timeout: 
  # token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
  active-timeout: 
  # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
  is-concurrent: 
  # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
  is-share: 
  # 是否在登录后将 Token 写入到响应头
  isWriteHeader: tue
  # token风格
  token-style: 
  # 是否输出操作日志
  is-log: 

 二、satoken采用的数据源需要一致

当在springboot项目中加入下面依赖时，satoken将会自动使用redis作为数据源使用。

<dependency>
    <groupId>cn.dev33</groupId>
    <artifactId>sa-token-redis-jackson</artifactId>
</dependency>

如果项目配置文件中还配置了以下配置，satoken将会默认使用。

redis:
  database: 
  host: 
  port: 
  password: 
  timeout: 
  lettuce:
    pool:
      max-active: 
      max-wait: 
      max-idle: 
      min-idle: 
    shutdown-timeout:

注意：

一、所以想要在B项目登录拿到的token能够在A项目中使用，就需要给在A项目中的tsaoken使用和B项目一样的redis配置。如此在B项目中拿到token在A项目中使用，才能校验通过。

二、在A项目中配置两个redis数据源，且使用lettuce作为连接池，就需要手动配置两个数据源。一个用于A项目的业务操作，另外一个用于B项目的satoken使用。

 一、A项目的redis数据源配置

1、配置好RedisTemplate，以及lettuce链接池，当使用两个redis数据源的时候springboot底层对redis的自动装配会失效，需要手动处理。

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    // 这里会由于导入一个RedisTemplate而不再自动导入
    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

@Bean(name = "redisTemplate")
public RedisTemplate<String, Serializable> redisTemplate(@Qualifier("connectionFactory") RedisConnectionFactory connectionFactory) {
    RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    // 值采用JSON序列化
    GenericFastJsonRedisSerializer genericFastJsonRedisSerializer = new GenericFastJsonRedisSerializer();
    redisTemplate.setValueSerializer(genericFastJsonRedisSerializer);
    redisTemplate.setHashValueSerializer(genericFastJsonRedisSerializer);
    redisTemplate.setDefaultSerializer(genericFastJsonRedisSerializer);
    redisTemplate.setConnectionFactory(connectionFactory);
    return redisTemplate;
}
@Bean("connectionFactory") // 这里使用这个名字主要是SaTokenDaoRedisJackson底层需要
@Qualifier("connectionFactory")
public RedisConnectionFactory firstRedisConnectionFactory() {

    RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
    redisStandaloneConfiguration.setHostName(host);
    redisStandaloneConfiguration.setPort(port);
    redisStandaloneConfiguration.setDatabase(Integer.parseInt(database));
    redisStandaloneConfiguration.setPassword(password);

    GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
    poolConfig.setMaxIdle(maxIdle);
    poolConfig.setMinIdle(minIdle);
    poolConfig.setMaxTotal(maxActive);
    poolConfig.setMaxWaitMillis(Long.parseLong(maxWait));

    LettucePoolingClientConfiguration lettucePoolingClientConfiguration = LettucePoolingClientConfiguration
            .builder()
            .commandTimeout(Duration.ofMillis(Long.parseLong(timeout)))
            .poolConfig(poolConfig)
            .build();
    return new LettuceConnectionFactory(redisStandaloneConfiguration, lettucePoolingClientConfiguration);
}

二、B项目中的redis 数据源配置

@Bean("secondRedisConnectionFactory")
@Qualifier("secondRedisConnectionFactory")
public RedisConnectionFactory secondRedisConnectionFactory() {
    RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
    redisStandaloneConfiguration.setHostName(secondHost);
    redisStandaloneConfiguration.setPort(secondPort);
    redisStandaloneConfiguration.setDatabase(Integer.parseInt(secondDatabase));
    redisStandaloneConfiguration.setPassword(secondPassword);

    GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
    poolConfig.setMaxIdle(maxIdle);
    poolConfig.setMinIdle(minIdle);
    poolConfig.setMaxTotal(maxActive);
    poolConfig.setMaxWaitMillis(Long.parseLong(maxWait));

    LettucePoolingClientConfiguration lettucePoolingClientConfiguration = LettucePoolingClientConfiguration
            .builder()
            .commandTimeout(Duration.ofMillis(Long.parseLong(timeout)))
            .poolConfig(poolConfig)
            .build();
    return new LettuceConnectionFactory(redisStandaloneConfiguration, lettucePoolingClientConfiguration);
}


@Bean(name = "secondStringRedisTemplate")
@Qualifier("secondStringRedisTemplate")
public StringRedisTemplate secondStringRedisTemplate(@Qualifier("secondRedisConnectionFactory") RedisConnectionFactory lettuceConnectionFactory) {
    StringRedisTemplate stringTemplate = new StringRedisTemplate();
    stringTemplate.setConnectionFactory(lettuceConnectionFactory);
    stringTemplate.afterPropertiesSet();
    return stringTemplate;
}

@Bean(name = "secondRedisTemplate")
@Qualifier("secondRedisTemplate")
public RedisTemplate<String, Object> secondRedisTemplate(@Qualifier("secondRedisConnectionFactory") RedisConnectionFactory lettuceConnectionFactory) {
    StringRedisSerializer keySerializer = new StringRedisSerializer();
    GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(lettuceConnectionFactory);
    template.setKeySerializer(keySerializer);
    template.setHashKeySerializer(keySerializer);
    template.setValueSerializer(valueSerializer);
    template.setHashValueSerializer(valueSerializer);
    template.afterPropertiesSet();
    return template;
}

三、替换SaTokenDaoRedisJackson使用的redis配置

1、SaTokenDaoRedisJackson底层源码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package cn.dev33.satoken.dao;

import cn.dev33.satoken.strategy.SaStrategy;
import cn.dev33.satoken.util.SaFoxUtil;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import java.lang.reflect.Field;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

@Component
public class SaTokenDaoRedisJackson implements SaTokenDao {
    public static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
    public static final String DATE_PATTERN = "yyyy-MM-dd";
    public static final String TIME_PATTERN = "HH:mm:ss";
    public static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");
    public ObjectMapper objectMapper;
    public StringRedisTemplate stringRedisTemplate;
    public RedisTemplate<String, Object> objectRedisTemplate;
    public boolean isInit;

    public SaTokenDaoRedisJackson() {
    }

    @Autowired // 优先从容器中获取RedisConnectionFactory这个类型的bean，这个时候会有两个，然后这个注解会按照connectionFactory这个名字取获取就能获取到A项目的
    public void init(RedisConnectionFactory connectionFactory) {
        if (!this.isInit) {
            StringRedisSerializer keySerializer = new StringRedisSerializer();
            GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();

            try {
                Field field = GenericJackson2JsonRedisSerializer.class.getDeclaredField("mapper");
                field.setAccessible(true);
                this.objectMapper = (ObjectMapper)field.get(valueSerializer);
                this.objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
                JavaTimeModule timeModule = new JavaTimeModule();
                timeModule.addSerializer(new LocalDateTimeSerializer(DATE_TIME_FORMATTER));
                timeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DATE_TIME_FORMATTER));
                timeModule.addSerializer(new LocalDateSerializer(DATE_FORMATTER));
                timeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DATE_FORMATTER));
                timeModule.addSerializer(new LocalTimeSerializer(TIME_FORMATTER));
                timeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(TIME_FORMATTER));
                this.objectMapper.registerModule(timeModule);
                SaStrategy.instance.createSession = (sessionId) -> {
                    return new SaSessionForJacksonCustomized(sessionId);
                };
            } catch (Exception var6) {
                System.err.println(var6.getMessage());
            }

            StringRedisTemplate stringTemplate = new StringRedisTemplate();
            stringTemplate.setConnectionFactory(connectionFactory);
            stringTemplate.afterPropertiesSet();
            RedisTemplate<String, Object> template = new RedisTemplate();
            template.setConnectionFactory(connectionFactory);
            template.setKeySerializer(keySerializer);
            template.setHashKeySerializer(keySerializer);
            template.setValueSerializer(valueSerializer);
            template.setHashValueSerializer(valueSerializer);
            template.afterPropertiesSet();
            this.stringRedisTemplate = stringTemplate;
            this.objectRedisTemplate = template;
            this.isInit = true;
        }
    }

    public String get(String key) {
        return (String)this.stringRedisTemplate.opsForValue().get(key);
    }

    public void set(String key, String value, long timeout) {
        if (timeout != 0L && timeout > -2L) {
            if (timeout == -1L) {
                this.stringRedisTemplate.opsForValue().set(key, value);
            } else {
                this.stringRedisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
            }

        }
    }

    public void update(String key, String value) {
        long expire = this.getTimeout(key);
        if (expire != -2L) {
            this.set(key, value, expire);
        }
    }

    public void delete(String key) {
        this.stringRedisTemplate.delete(key);
    }

    public long getTimeout(String key) {
        return this.stringRedisTemplate.getExpire(key);
    }

    public void updateTimeout(String key, long timeout) {
        if (timeout == -1L) {
            long expire = this.getTimeout(key);
            if (expire != -1L) {
                this.set(key, this.get(key), timeout);
            }

        } else {
            this.stringRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
        }
    }

    public Object getObject(String key) {
        return this.objectRedisTemplate.opsForValue().get(key);
    }

    public void setObject(String key, Object object, long timeout) {
        if (timeout != 0L && timeout > -2L) {
            if (timeout == -1L) {
                this.objectRedisTemplate.opsForValue().set(key, object);
            } else {
                this.objectRedisTemplate.opsForValue().set(key, object, timeout, TimeUnit.SECONDS);
            }

        }
    }

    public void updateObject(String key, Object object) {
        long expire = this.getObjectTimeout(key);
        if (expire != -2L) {
            this.setObject(key, object, expire);
        }
    }

    public void deleteObject(String key) {
        this.objectRedisTemplate.delete(key);
    }

    public long getObjectTimeout(String key) {
        return this.objectRedisTemplate.getExpire(key);
    }

    public void updateObjectTimeout(String key, long timeout) {
        if (timeout == -1L) {
            long expire = this.getObjectTimeout(key);
            if (expire != -1L) {
                this.setObject(key, this.getObject(key), timeout);
            }

        } else {
            this.objectRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
        }
    }

    public List<String> searchData(String prefix, String keyword, int start, int size, boolean sortType) {
        Set<String> keys = this.stringRedisTemplate.keys(prefix + "*" + keyword + "*");
        List<String> list = new ArrayList(keys);
        return SaFoxUtil.searchList(list, start, size, sortType);
    }
}
 

 2、替换SaTokenDaoRedisJackson中的redis配置

也就是替换他的这两个成员变量，换成B的即可

    public StringRedisTemplate stringRedisTemplate;
    public RedisTemplate<String, Object> objectRedisTemplate;


@Configuration
public class SaTokenDaoRedisConfig {

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.database}")
    private String database;
    @Value("${spring.redis.second.host}")
    private String secondHost;
    @Value("${spring.redis.second.port}")
    private int secondPort;
    @Value("${spring.redis.second.password}")
    private String secondPassword;
    @Value("${spring.redis.second.database}")
    private String secondDatabase;
    @Value("${spring.redis.lettuce.pool.max-active}")
    private int maxActive;
    @Value("${spring.redis.lettuce.pool.max-wait}")
    private String maxWait;
    @Value("${spring.redis.lettuce.pool.max-idle}")
    private int maxIdle;
    @Value("${spring.redis.lettuce.pool.min-idle}")
    private int minIdle;
    @Value("${spring.redis.timeout}")
    private String  timeout;

    @Autowired
    @Qualifier("secondStringRedisTemplate")
    private StringRedisTemplate secondStringRedisTemplate;

    @Autowired
    @Qualifier("secondRedisTemplate")
    private RedisTemplate<String, Object> secondRedisTemplate;
    @Autowired
    private SaTokenDaoRedisJackson saTokenDaoRedisJackson;


    @PostConstruct // 项目启动初始化的时候，也就是bean以及创建完成，并赋值后在初始化的时候重新给这两个成员变量赋值
    public void init() {
        saTokenDaoRedisJackson.stringRedisTemplate = secondStringRedisTemplate;
        saTokenDaoRedisJackson.objectRedisTemplate = secondRedisTemplate;
    }

    @Bean("secondRedisConnectionFactory")
    @Qualifier("secondRedisConnectionFactory")
    public RedisConnectionFactory secondRedisConnectionFactory() {
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName(secondHost);
        redisStandaloneConfiguration.setPort(secondPort);
        redisStandaloneConfiguration.setDatabase(Integer.parseInt(secondDatabase));
        redisStandaloneConfiguration.setPassword(secondPassword);

        GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxWaitMillis(Long.parseLong(maxWait));

        LettucePoolingClientConfiguration lettucePoolingClientConfiguration = LettucePoolingClientConfiguration
                .builder()
                .commandTimeout(Duration.ofMillis(Long.parseLong(timeout)))
                .poolConfig(poolConfig)
                .build();
        return new LettuceConnectionFactory(redisStandaloneConfiguration, lettucePoolingClientConfiguration);
    }


    @Bean(name = "secondStringRedisTemplate")
    @Qualifier("secondStringRedisTemplate")
    public StringRedisTemplate secondStringRedisTemplate(@Qualifier("secondRedisConnectionFactory") RedisConnectionFactory lettuceConnectionFactory) {
        StringRedisTemplate stringTemplate = new StringRedisTemplate();
        stringTemplate.setConnectionFactory(lettuceConnectionFactory);
        stringTemplate.afterPropertiesSet();
        return stringTemplate;
    }

    @Bean(name = "secondRedisTemplate")
    @Qualifier("secondRedisTemplate")
    public RedisTemplate<String, Object> secondRedisTemplate(@Qualifier("secondRedisConnectionFactory") RedisConnectionFactory lettuceConnectionFactory) {
        StringRedisSerializer keySerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(lettuceConnectionFactory);
        template.setKeySerializer(keySerializer);
        template.setHashKeySerializer(keySerializer);
        template.setValueSerializer(valueSerializer);
        template.setHashValueSerializer(valueSerializer);
        template.afterPropertiesSet();
        return template;
    }

    @Bean("connectionFactory")
    @Qualifier("connectionFactory")
    public RedisConnectionFactory firstRedisConnectionFactory() {

        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        redisStandaloneConfiguration.setDatabase(Integer.parseInt(database));
        redisStandaloneConfiguration.setPassword(password);

        GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxWaitMillis(Long.parseLong(maxWait));

        LettucePoolingClientConfiguration lettucePoolingClientConfiguration = LettucePoolingClientConfiguration
                .builder()
                .commandTimeout(Duration.ofMillis(Long.parseLong(timeout)))
                .poolConfig(poolConfig)
                .build();
        return new LettuceConnectionFactory(redisStandaloneConfiguration, lettucePoolingClientConfiguration);
    }
}
 

以上设置完，就可以让A项目处理A项目的缓存数据，也可以让A项目通过B项目中的satoken的校验 

三、权限认证也需要重新配置，否则也无法通过，这是由于所有权限和菜单数据都放在B项目中导致的。

StpInterface

权限数据加载源接口
在使用权限校验 API 之前，你必须实现此接口，告诉框架哪些用户拥有哪些权限。 框架默认不对数据进行缓存，如果你的数据是从数据库中读取的，一般情况下你需要手动实现数据的缓存读写。

@Component
public class StpInterfaceImpl implements StpInterface {

    @Resource
    private SysMenuService sysMenuService;

    @Resource
    private SysUserRoleService sysUserRoleService;

    @Override
    public List<String> getPermissionList(Object loginId, String loginType) {
        if (!loginType.equals(StpUtil.TYPE)) {
            return null;
        }
        long userId = SaFoxUtil.getValueByType(loginId, long.class);
        return sysMenuService.permissionList(userId);
    }

    @Override
    public List<String> getRoleList(Object loginId, String loginType) {
        if (!loginType.equals(StpUtil.TYPE)) {
            return null;
        }
        long userId = SaFoxUtil.getValueByType(loginId, long.class);
        return sysUserRoleService.roleList(userId);
    }
}
 

一、@SaCheckPermission(AuthKeyConstant.REPORT_LIST)

 每个接口都会使用这样一个注解，并且标注上对应的权限标识。SaCheckPermission源码如下

package cn.dev33.satoken.annotation;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 权限认证：必须具有指定权限才能进入该方法 
 * <p> 可标注在函数、类上（效果等同于标注在此类的所有方法上） 
 * @author kong
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface SaCheckPermission {
 
	/**
	 * 需要校验的权限码
	 * @return 需要校验的权限码
	 */
	String [] value() default {};
 
	/**
	 * 验证模式：AND | OR，默认AND
	 * @return 验证模式
	 */
	SaMode mode() default SaMode.AND;
 
    /**
     * 多账号体系下所属的账号体系标识 
     * @return see note 
     */
	String type() default "";
 
	/**
	 * 在权限认证不通过时的次要选择，两者只要其一认证成功即可通过校验  
	 * 
	 * <p> 
	 * 	例1：@SaCheckPermission(value="user-add", orRole="admin")，
	 * 	代表本次请求只要具有 user-add权限 或 admin角色 其一即可通过校验 
	 * </p>
	 * 
	 * <p> 
	 * 	例2： orRole = {"admin", "manager", "staff"}，具有三个角色其一即可 <br> 
	 * 	例3： orRole = {"admin, manager, staff"}，必须三个角色同时具备 
	 * </p>
	 * 
	 * @return /
	 */
	String[] orRole() default {};
	
}

二、校验原理

每次请求对应接口时，只要有@SaCheckPermission这个注解，底层都会回调StpInterface实现类实现的方法，拿到这个用户的所有权限，然后与当前注解配置的权限码进行比较，如果这个用户有这个权限，比对就会通过，然后进入接口获取对应数据，否者会抛出对应异常。

注意：

也正是由于这个原因，获取权限的数据库需要配置为B项目的数据库，从B项目中获取用户的权限。

三、跨域问题解决方式

在和前段进行本地联调时出现跨域问题，导致拿不到请求头上面携带的token数据。

一、什么情况下会发生跨域 

简单理解，就是你在 A 域名下的页面，去调用 B 域名的接口，浏览器感觉你这次调用可能是不安全的请求行为，于是它需要用 cors 安全策略来确认一下这个请求是由用户真实的意愿发出的，而不是被 csrf 伪造请求攻击偷偷发送的。（这么说只是为了方便大家理解，不是特别严谨，实际上同域名下部分情形也会出现跨域问题）

请仔细理解上面这段话，因为它说明了两点：

  • 跨域不是后端接口对前端浏览器的限制，而是前端浏览器对用户的限制。
  • 跨域不是在保护后端接口免受攻击，而是浏览器在保护用户，避免用户发送自己不想发送的请求。

一般情况下，我们会碰到三种跨域场景：

1、本地页面调用测试服务器，只在项目开发阶段会有跨域问题。
2、使用 header 头提交 token，产生的跨域问题。
3、使用第三方 Cookie 提交 token，产生的跨域问题。

二、什么是OPTIONS请求?

浏览器在发送请求之前会先发送一个OPTIONS请求，来校验是否允许跨域访问，校验的结果存放在头信息的Access-Control-Allow-Origin，因此解决跨域也就是设置头部信息。当第一个请求通过了，才会真正的发送第二个请求，也即是请求接口获取数据。

三、解决方案

一、第一种方案

public class SaInterceptorImpl extends SaInterceptor {

    public SaInterceptorImpl() {
    }

    public SaInterceptorImpl(SaParamFunction<Object> auth) {
        super(auth);
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 如果这个请求是一个预检请求,或者它登录了则接口放行，然后会让浏览器进行第二次请求
        if ("OPTIONS".equals(request.getMethod())) {
            return true;
        }
        return super.preHandle(request, response, handler);
    }
}

    /**
     * 注册拦截器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册 Sa-Token 拦截器，校验规则为 StpUtil.checkLogin() 登录校验。
        registry.addInterceptor(new SaInterceptorImpl(handle -> StpUtil.checkLogin())).addPathPatterns("/**").excludePathPatterns(excludePathList);
    }

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowedMethods("PUT", "DELETE", "GET", "POST")
                .allowedHeaders("*")
                .exposedHeaders("access-control-allow-headers",
                        "access-control-allow-methods",
                        "access-control-allow-origin",
                        "access-control-max-age",
                        "X-Frame-Options")
                .allowCredentials(false).maxAge(3600);
    }

 第二个方案

在SaTokenConfig里面直接再加入一个即可

@Configuration
public class SaTokenConfig implements WebMvcConfigurer {

    /**
     * 白名单
     */
    private final List<String> excludePathList = Arrays.asList(
          
    );

    /**
     * 注册拦截器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册 Sa-Token 拦截器，校验规则为 StpUtil.checkLogin() 登录校验。
        registry.addInterceptor(new SaInterceptor(handle -> StpUtil.checkLogin())).addPathPatterns("/**").excludePathPatterns(excludePathList);
    }

}


 @Bean
    public SaServletFilter getSaServletFilter() {
        return new SaServletFilter()
                
                // 指定 [拦截路由] 与 [放行路由]
                .addInclude("/**").addExclude("/favicon.ico")
                
                // 认证函数: 每次请求执行 
                .setAuth(obj -> {
                    SaManager.getLog().debug("----- 请求path={}  提交token={}", SaHolder.getRequest().getRequestPath(), StpUtil.getTokenValue());
                    // ...
                })
                
                // 异常处理函数：每次认证函数发生异常时执行此函数 
                .setError(e -> {
                    return SaResult.error(e.getMessage());
                })
                
                // 前置函数：在每次认证函数之前执行
                .setBeforeAuth(obj -> {
                    SaHolder.getResponse()
 
                    // ---------- 设置跨域响应头 ----------
                    // 允许指定域访问跨域资源
                    .setHeader("Access-Control-Allow-Origin", "*")
                    // 允许所有请求方式
                    .setHeader("Access-Control-Allow-Methods", "*")
                    // 允许的header参数
                    .setHeader("Access-Control-Allow-Headers", "*")
                    // 有效时间
                    .setHeader("Access-Control-Max-Age", "3600")
                    ;
                    
                    // 如果是预检请求，则立即返回到前端 
                    SaRouter.match(SaHttpMethod.OPTIONS)
                        .free(r -> System.out.println("--------OPTIONS预检请求，不做处理"))
                        .back();
                })
                ;
    }
 

幼儿园里的山大王
关注
  • 21
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于SpringBoot的影像注册系统04 sa-token使用（源码解析 + 万字
m0_67614284的博客
05-03 1631
逻辑：查询username存不存在，再查询密码是否正确，只要没有抛异常就调用sa-token的login方法。 StpUtil.login(userReal.getId()); login方法传入我们user的id，比如： 把int类型的数值传进去了。 步骤 4 sa-token登录认证 ================= [核心思想](() 所谓登录认证，说白了就是限制某些API接口必须登录后才能访问（例：查询我的账号资料） 那么如何判断一个会话是否登录？框架会在登录成功后给你做个标记，每次登录认证时校
再见Spring Security！推荐一款功能强大的权限认证框架
m0_63213529的博客
10-25 468
在我们做SpringBoot项目的时候，认证授权是必不可少的功能！我们经常会选择Shiro、Spring Security这类权限认证框架来实现，但这些框架使用起来有点繁琐，而且功能也不够强大。最近发现一款功能强大的权限认证框架Sa-Token，它使用简单、API设计优雅，推荐给大家！ Sa-Token简介 Sa-Token是一款轻量级的Java权限认证框架，可以用来解决登录认证、权限认证、Session会话、单点登录、OAuth2.0、微服务网关鉴权等一系列权限相关问题。 框架集成简单、开箱即用.
【SaToken使用】SpringBoot整合SaToken（一）token自动续期+token定期刷新+注解鉴权
热门推荐
weixin_43165220的博客
09-28 1万+
SpringBoot整合SaToken，token自动续期+token定期刷新+注解鉴权
基于SpringBoot的影像注册系统04 sa-token使用（源码解析 + 万字）
最新发布
2401_84103616的博客
05-12 230
小编利用空余时间整理了一份《MySQL性能调优手册》，初衷也很简单，就是希望能够帮助到大家，减轻大家的负担和节省时间。关于这个，给大家看一份学习大纲（PDF）文件，每一个分支里面会有详细的介绍。这里都是以图片形式展示介绍，如要下载原文件以及更多的性能调优笔记（MySQL+Tomcat+JVM）！本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取。
Sa-Token 的简介和使用
qq_34654085的博客
08-19 3376
市场上，Shiro、SpringSecurity是目前鉴权主要的两个工具组件，在从最基本的配置到约定大于配置的发展道路上，Sa-token 应运而生。该组件目前在github上仅有1W的star，但是却有着很大的影响力。因为他的简约配置和优雅使用，得到了更多开发者的依赖。
再见Spring Security！推荐一款功能强大的权限认证框架，用起来够优雅！
HollisChuang's Blog
08-23 1584
‍‍在我们做SpringBoot项目的时候，认证授权是必不可少的功能！我们经常会选择Shiro、Spring Security这类权限认证框架来实现，但这些框架使用起来有点繁琐，而且功能也...
bpmn-js-token-simulation:用于令牌模拟的bpmn-js扩展
05-11
npm install bpmn-js-token-simulation 作为附加模块添加到 。 造型师 var BpmnModeler = require ( 'bpmn-js/lib/Modeler' ) ; var tokenSimulation = require ( 'bpmn-js-token-simulation' ) ; var modeler = ...
sa-token封装了一下
03-15
它可能是JWT（JSON Web Token）或者其他自定义格式，包含用户的标识和其他元数据，确保安全的用户交互。 【压缩包子文件的文件名称列表】： 1. mvnw.cmd：这是Spring Boot项目的命令行启动脚本，用于在Windows环境...
insomnia-plugin-aws-cognito-token:适用于AWS Cognito的Insomnia插件
05-27
失眠-插件-aws-认知令牌 适用于AWS Cognito的Insomnia插件，可让您自动获取JWT令牌并将令牌注入Authorization标头中。 注意：版本0.10.0更改了“标签”顺序，您可能必须重新排序“标签”值...添加插件的数据 请求标头
mapbox-gl 2.7.0 去token
01-12
1. **本地数据源**：如果只需要显示静态的地理数据，可以使用本地的GeoJSON或TopoJSON文件作为数据源，这样就不需要通过Mapbox服务器请求地图瓦片。 2. **自建地图服务**：开发者可以选择搭建自己的地图服务，如...
laravel5.5安装jwt-auth 生成token令牌的示例
10-16
今天小编就为大家分享一篇laravel5.5安装jwt-auth 生成token令牌的示例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
深入理解令牌认证机制（token）
10-16
主要介绍了深入理解令牌认证机制（token），文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Sa-Token基本到深入操作
cxl0209的博客
03-13 1641
1.Sa-Token 介绍 Sa-Token 是一个轻量级 Java 权限认证框架，主要解决：登录认证、权限认证、单点登录、OAuth2.0、分布式Session会话、微服务网关鉴权 等一系列权限相关问题。 Sa-Token 旨在以简单、优雅的方式完成系统的权限认证部分，以登录认证为例，你只需要： 下面展示一些 内联代码片。 // 会话登录，参数填登录人的账号id StpUtil.login(10001); 无需实现任何接口，无需创建任何配置文件，只需要这一句静态代码的调用，便可以完成会话登录认证。如果
sa-token快速上手
虎年限定七月月的博客
10-18 790
轻量级认证鉴权框架 sa-token快速入门，spring boot集成sa-token
【Sa-Token】Spring Boot项目中使用Sa-Token框架
apple_51673523的博客
03-02 1663
本篇介绍的是Sa-Token的使用
Sa-Token 实现分布式登录鉴权（轻量级，超简单）
z_ssyy的博客
08-27 1218
Sa-Token 是一个轻量级 Java 权限认证框架，主要解决：登录认证、权限认证、单点登录、OAuth2.0、分布式Session会话、微服务网关鉴权 等一系列权限相关问题。功能结构图@Data@Component // 保证此类被SpringBoot扫描，完成Sa-Token的自定义权限验证扩展/*** 返回一个账号所拥有的权限码集合*/@Override// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询权限//从redis中获取权限/**
springboot集成sa-token来实现登录鉴权（一）
书生灬今天不吃饭的博客
03-15 2625
sa-token是一个轻量级的登录鉴权框架，比之前的shiro和springsecurity都要轻量，一行代码就可以实现登录功能。sa-token官网。这里我们不再赘述。直接来看具体实现代码。
sa-token目前几个项目中用到最好用的鉴权框架
Gospel11的博客
05-29 1940
sa-token，权限，spring权限框架
Sa-token深入
cxl0209的博客
03-13 1270
1.Sa-Token-SSO 单点登录模块 什么是单点登录？解决什么问题？ 举个场景，假设我们的系统被切割为N个部分：商城、论坛、直播、社交…… 如果用户每访问一个模块都要登录一次，那么用户将会疯掉， 为了优化用户体验，我们急需一套机制将这N个系统的认证授权互通共享，让用户在一个系统登录之后，便可以畅通无阻的访问其它所有系统。 单点登录——就是为了解决这个问题而生！ 简而言之，单点登录可以做到： 在多个互相信任的系统中，用户只需登录一次，就可以访问所有系统。 架构选型 Sa-Token-SSO 由简入难划分
sa-token如何校验token
07-28
sa-token可以通过以下配置来校验token： 1. 配置token名称：在yml配置文件中，可以通过设置`sa-token.token-name`来指定token的名称，例如`sa-token.token-name: X-Token`\[1\]。 2. 配置token有效期：可以通过设置`sa-token.timeout`来指定token的有效期，单位为秒，默认为30天，可以设置为-1代表永不过期，例如`sa-token.timeout: 2592000`\[1\]。 3. 配置token临时有效期：可以通过设置`sa-token.activity-timeout`来指定token的临时有效期，即在指定时间内无操作就视为token过期，单位为秒，默认为-1，表示不设置临时有效期，例如`sa-token.activity-timeout: -1`\[1\]。 4. 配置是否允许同一账号并发登录：可以通过设置`sa-token.is-concurrent`来指定是否允许同一账号并发登录，为true时允许一起登录，为false时新登录会挤掉旧登录，例如`sa-token.is-concurrent: true`\[1\]。 5. 配置是否共用一个token：可以通过设置`sa-token.is-share`来指定在多人登录同一账号时，是否共用一个token，为true时所有登录共用一个token，为false时每次登录会新建一个token，例如`sa-token.is-share: true`\[1\]。 6. 配置是否输出操作日志：可以通过设置`sa-token.is-log`来指定是否输出操作日志，为true时输出操作日志，为false时不输出操作日志，例如`sa-token.is-log: false`\[1\]。 7. 配置是否使用cookie保存token：可以通过设置`sa-token.is-read-cookie`来指定是否使用cookie保存token，为true时使用cookie保存token，为false时不使用cookie保存token，例如`sa-token.is-read-cookie: false`\[1\]。 8. 配置是否使用head保存token：可以通过设置`sa-token.is-read-head`来指定是否使用head保存token，为true时使用head保存token，为false时不使用head保存token，例如`sa-token.is-read-head: true`\[1\]。 通过以上配置，sa-token可以根据配置的规则来校验token的有效性。 #### 引用[.reference_title] - *1* [最简单的权限验证实现——使用Sa-Token进行权限验证](https://blog.csdn.net/lp840312696/article/details/127072424)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [探索 Sa-Token (一) SpringBoot 集成 Sa-Token](https://blog.csdn.net/weixin_38982591/article/details/126764928)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值