devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot redis多租户切换统一切换key前缀

作者：你好赵伟 | 2024-04-09 02:22:58

赞

踩

springboot redis多租户

根据请求切换租户，修改redis前缀，不修改原来的代码，以最小改动实现，支持并发。

ThreadLocal 保存当前请求的数据以及租户相关信息，利用 Filter 拦截请求，判断配置当前请求的租户类型，保存设置到RequestContext中。

1.RequestContext 是当前线程文本类，存储当前线程中的一些变量以及租户信息，

TenantType是枚举类，定义租户信息，读者自行定义，这里不提供了。

public class RequestContext {

   private static final String TENANT_TYPE = "TENANT_TYPE";

   private Map<String, Object> values = new HashMap<String, Object>();
   
   private static final ThreadLocal<RequestContext> LOCAL = new ThreadLocal<RequestContext>() {
      @Override
      protected RequestContext initialValue() {
         return new RequestContext();
      }
   };

   public static RequestContext getContext() {
       return LOCAL.get();
   }
   
   public static void clearContext() {
       LOCAL.remove();
       LOCAL.set(new RequestContext());
   }
   
   public Object get(String key) {
        return values.get(key);
    }
   
   public void remove(String key) {
      values.remove(key);
   }
   
   public RequestContext set(String key, Object value) {
        if (value == null) {
            values.remove(key);
        } else {
            values.put(key, value);
        }
        return this;
    }

   /**
    * 设置数据源
    * @param value
    * @return
    */
   public RequestContext setDataSource(String value) {
      if (value == null) {
         values.remove(TENANT_TYPE);
      } else {
         values.put(TENANT_TYPE, value);
      }
      return this;
   }

   /**
    * 设置数据源
    * @param value
    * @return
    */
   public RequestContext setTenantType(String value) {
      if (value == null) {
         values.remove(TENANT_TYPE);
      } else {
         values.put(TENANT_TYPE, value);
      }
      return this;
   }

   /**
    * Get current DataSource
    *
    * @return data source name
    */
   public String getTenantType() {
      return (String) values.get(TENANT_TYPE);
   }

   /**
    * Get current DataSource
    *
    * @return data source name
    */
   public String getRedisPre() {
      if(StringUtils.isBlank(this.getTenantType())){
         throw new IllegalArgumentException("当前请求未找到租户类型");
      }
      return TenantType.getRedisPre(this.getTenantType());
   }

   /**
    * Get current DataSource
    *
    * @return data source name
    */
   public String getDataSource() {
      return (String) values.get(TENANT_TYPE);
   }

   /**
    * Clear current DataSource
    *
    * @return data source name
    */
   public void clearDataSource() {
      remove(TENANT_TYPE);
   }

}

 2.利用 Filter 过滤器在请求进入后，根据请求域名来判断租户（每个租户的域名请求是不同的），并且把租户保存到 RequestContext 中，供当前后续代码获取。

public class SwitchTenantFilter implements Filter {
   /** 日志 */
   private static Logger logger = LoggerFactory.getLogger(SwitchTenantFilter.class);

   @Override
   public void doFilter(ServletRequest req, ServletResponse resp,
         FilterChain filterChain) throws IOException, ServletException {
      HttpServletRequest request = (HttpServletRequest) req;
      HttpServletResponse response = (HttpServletResponse) resp;

      String host = request.getHeader("host");

      // 租户1访问
      if(host.contains("test1")){
         RequestContext.getContext().setDataSource("test1");
      }

      // 租户2访问
      if(host.contains("test2")){
         RequestContext.getContext().setDataSource("test2");
      }

      String dataSource = RequestContext.getContext().getDataSource();
      if(StringUtils.isBlank(dataSource)){
         logger.error("访问host：{}，切换数据源失败！！！", host);
         filterChain.doFilter(request, response);
         return;
      }
      logger.info("访问host：{}，切换数据源成功，数据源key：{}", host, RequestContext.getContext().getDataSource());
      filterChain.doFilter(request, response);
      // 清除 ThreadLocal 变量
   }
   
   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
      // TODO Auto-generated method stub
      
   }

   @Override
   public void destroy() {
      // TODO Auto-generated method stub
      
   }

}

3.在Configuration类中实例化这个Filter  Bean，配置拦截

//  ===SwitchTenantFilter  切换租户,在WebAccessLogFilter之前加载===
    @Bean
    public FilterRegistrationBean switchDataSourceFilterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        SwitchTenantFilter switchTenantFilter = new SwitchTenantFilter();
        registration.setFilter(switchTenantFilter);

        registration.addUrlPatterns("/*");
        registration.setName("switchDataSourceFilter");
        registration.setOrder(12);
        registration.setDispatcherTypes(DispatcherType.REQUEST);
        return registration;
    }
// ===SwitchTenantFilter===

--------------------------------------------------------------------------------------------------------------------

以下是简单的源码跟踪，不需要的可以跳过：

springboot 使用 RedisTemplate 操作redis

  1. redisTemplate.opsForValue().set(key, val); // 设置数据
  2. redisTemplate.opsForValue().get(key); // 获取数据
  3. redisTemplate.delete(key); //删除数据
  4. 等等....

 跟踪源码可以发现，RedisTemplate 在操作key和value时，会进行序列化。

AbstractOperations：

 这里扩展点就出来了，我们可以重写RedisTemplate  的 getKeySerializer 方法，来根据当前租户切换 keySerializer ，来达到修改前缀的目的。

-----------------------------------------------------------------------------------------------------------------------

以下是重写的RedisTemplate：

  1. public class DynamicRedisTemplate<K, V> extends RedisTemplate<K, V> {
  2.  
  3.     public static final String SEPARATE=":";
  4.  
  5.     private RedisSerializer<String> stringSerializer = RedisSerializer.string();
  6.  
  7.     @Override
  8.     public RedisSerializer getKeySerializer() {
  9.         RedisSerializer<?> redisSerializer = super.getKeySerializer();
  10.         if(StringUtils.isNotBlank(RequestContext.getContext().getRedisPre())){
  11.             String cachePrefix = RequestContext.getContext().getRedisPre() + DynamicRedisTemplate.SEPARATE;
  12.             redisSerializer = new KeyStringRedisSerializer(cachePrefix);
  13.         }
  14.         return redisSerializer;
  15.     }
  16.  
  17.     /*
  18.      * (non-Javadoc)
  19.      * @see org.springframework.data.redis.core.RedisOperations#delete(java.lang.Object)
  20.      */
  21.     @Override
  22.     public Boolean delete(K key) {
  23.  
  24.         byte[] rawKey = rawKey(key);
  25.  
  26.         Long result = execute(connection -> connection.del(rawKey), true);
  27.  
  28.         return result != null && result.intValue() == 1;
  29.     }
  30.  
  31.     /*
  32.      * (non-Javadoc)
  33.      * @see org.springframework.data.redis.core.RedisOperations#delete(java.util.Collection)
  34.      */
  35.     @Override
  36.     public Long delete(Collection<K> keys) {
  37.  
  38.         if (CollectionUtils.isEmpty(keys)) {
  39.             return 0L;
  40.         }
  41.  
  42.         byte[][] rawKeys = rawKeys(keys);
  43.  
  44.         return execute(connection -> connection.del(rawKeys), true);
  45.     }
  46.  
  47.     /*
  48.      * (non-Javadoc)
  49.      * @see org.springframework.data.redis.core.RedisOperations#unlink(java.lang.Object)
  50.      */
  51.     @Override
  52.     public Boolean unlink(K key) {
  53.  
  54.         byte[] rawKey = rawKey(key);
  55.  
  56.         Long result = execute(connection -> connection.unlink(rawKey), true);
  57.  
  58.         return result != null && result.intValue() == 1;
  59.     }
  60.  
  61.     /*
  62.      * (non-Javadoc)
  63.      * @see org.springframework.data.redis.core.RedisOperations#unlink(java.util.Collection)
  64.      */
  65.     @Override
  66.     public Long unlink(Collection<K> keys) {
  67.  
  68.         if (CollectionUtils.isEmpty(keys)) {
  69.             return 0L;
  70.         }
  71.  
  72.         byte[][] rawKeys = rawKeys(keys);
  73.  
  74.         return execute(connection -> connection.unlink(rawKeys), true);
  75.     }
  76.  
  77.     /*
  78.      * (non-Javadoc)
  79.      * @see org.springframework.data.redis.core.RedisOperations#countExistingKeys(java.util.Collection)
  80.      */
  81.     @Override
  82.     public Long countExistingKeys(Collection<K> keys) {
  83.  
  84.         Assert.notNull(keys, "Keys must not be null!");
  85.  
  86.         byte[][] rawKeys = rawKeys(keys);
  87.         return execute(connection -> connection.exists(rawKeys), true);
  88.     }
  89.  
  90.     /*
  91.      * (non-Javadoc)
  92.      * @see org.springframework.data.redis.core.RedisOperations#hasKey(java.lang.Object)
  93.      */
  94.     @Override
  95.     public Boolean hasKey(K key) {
  96.  
  97.         byte[] rawKey = rawKey(key);
  98.  
  99.         return execute(connection -> connection.exists(rawKey), true);
  100.     }
  101.  
  102.     /*
  103.      * (non-Javadoc)
  104.      * @see org.springframework.data.redis.core.RedisOperations#expire(java.lang.Object, long, java.util.concurrent.TimeUnit)
  105.      */
  106.     @Override
  107.     public Boolean expire(K key, final long timeout, final TimeUnit unit) {
  108.  
  109.         byte[] rawKey = rawKey(key);
  110.         long rawTimeout = TimeoutUtils.toMillis(timeout, unit);
  111.  
  112.         return execute(connection -> {
  113.             try {
  114.                 return connection.pExpire(rawKey, rawTimeout);
  115.             } catch (Exception e) {
  116.                 // Driver may not support pExpire or we may be running on Redis 2.4
  117.                 return connection.expire(rawKey, TimeoutUtils.toSeconds(timeout, unit));
  118.             }
  119.         }, true);
  120.     }
  121.  
  122.     /*
  123.      * (non-Javadoc)
  124.      * @see org.springframework.data.redis.core.RedisOperations#expireAt(java.lang.Object, java.util.Date)
  125.      */
  126.     @Override
  127.     public Boolean expireAt(K key, final Date date) {
  128.  
  129.         byte[] rawKey = rawKey(key);
  130.  
  131.         return execute(connection -> {
  132.             try {
  133.                 return connection.pExpireAt(rawKey, date.getTime());
  134.             } catch (Exception e) {
  135.                 return connection.expireAt(rawKey, date.getTime() / 1000);
  136.             }
  137.         }, true);
  138.     }
  139.  
  140.     /*
  141.      * (non-Javadoc)
  142.      * @see org.springframework.data.redis.core.RedisOperations#getExpire(java.lang.Object)
  143.      */
  144.     @Override
  145.     public Long getExpire(K key) {
  146.  
  147.         byte[] rawKey = rawKey(key);
  148.         return execute(connection -> connection.ttl(rawKey), true);
  149.     }
  150.  
  151.     /*
  152.      * (non-Javadoc)
  153.      * @see org.springframework.data.redis.core.RedisOperations#getExpire(java.lang.Object, java.util.concurrent.TimeUnit)
  154.      */
  155.     @Override
  156.     public Long getExpire(K key, final TimeUnit timeUnit) {
  157.  
  158.         byte[] rawKey = rawKey(key);
  159.         return execute(connection -> {
  160.             try {
  161.                 return connection.pTtl(rawKey, timeUnit);
  162.             } catch (Exception e) {
  163.                 // Driver may not support pTtl or we may be running on Redis 2.4
  164.                 return connection.ttl(rawKey, timeUnit);
  165.             }
  166.         }, true);
  167.     }
  168.  
  169.     /*
  170.      * (non-Javadoc)
  171.      * @see org.springframework.data.redis.core.RedisOperations#keys(java.lang.Object)
  172.      */
  173.     @Override
  174.     @SuppressWarnings("unchecked")
  175.     public Set<K> keys(K pattern) {
  176.  
  177.         byte[] rawKey = rawKey(pattern);
  178.         Set<byte[]> rawKeys = execute(connection -> connection.keys(rawKey), true);
  179.  
  180.         return getKeySerializer() != null ? SerializationUtils.deserialize(rawKeys, getKeySerializer()) : (Set<K>) rawKeys;
  181.     }
  182.  
  183.     /*
  184.      * (non-Javadoc)
  185.      * @see org.springframework.data.redis.core.RedisOperations#persist(java.lang.Object)
  186.      */
  187.     @Override
  188.     public Boolean persist(K key) {
  189.  
  190.         byte[] rawKey = rawKey(key);
  191.         return execute(connection -> connection.persist(rawKey), true);
  192.     }
  193.  
  194.     /*
  195.      * (non-Javadoc)
  196.      * @see org.springframework.data.redis.core.RedisOperations#move(java.lang.Object, int)
  197.      */
  198.     @Override
  199.     public Boolean move(K key, final int dbIndex) {
  200.  
  201.         byte[] rawKey = rawKey(key);
  202.         return execute(connection -> connection.move(rawKey, dbIndex), true);
  203.     }
  204.  
  205.     /*
  206.      * (non-Javadoc)
  207.      * @see org.springframework.data.redis.core.RedisOperations#randomKey()
  208.      */
  209.     @Override
  210.     public K randomKey() {
  211.  
  212.         byte[] rawKey = execute(RedisKeyCommands::randomKey, true);
  213.         return deserializeKey(rawKey);
  214.     }
  215.  
  216.     @SuppressWarnings("unchecked")
  217.     private K deserializeKey(byte[] value) {
  218.         return getKeySerializer() != null ? (K) getKeySerializer().deserialize(value) : (K) value;
  219.     }
  220.  
  221.     /*
  222.      * (non-Javadoc)
  223.      * @see org.springframework.data.redis.core.RedisOperations#rename(java.lang.Object, java.lang.Object)
  224.      */
  225.     @Override
  226.     public void rename(K oldKey, K newKey) {
  227.  
  228.         byte[] rawOldKey = rawKey(oldKey);
  229.         byte[] rawNewKey = rawKey(newKey);
  230.  
  231.         execute(connection -> {
  232.             connection.rename(rawOldKey, rawNewKey);
  233.             return null;
  234.         }, true);
  235.     }
  236.  
  237.     /*
  238.      * (non-Javadoc)
  239.      * @see org.springframework.data.redis.core.RedisOperations#renameIfAbsent(java.lang.Object, java.lang.Object)
  240.      */
  241.     @Override
  242.     public Boolean renameIfAbsent(K oldKey, K newKey) {
  243.  
  244.         byte[] rawOldKey = rawKey(oldKey);
  245.         byte[] rawNewKey = rawKey(newKey);
  246.         return execute(connection -> connection.renameNX(rawOldKey, rawNewKey), true);
  247.     }
  248.  
  249.     /*
  250.      * (non-Javadoc)
  251.      * @see org.springframework.data.redis.core.RedisOperations#type(java.lang.Object)
  252.      */
  253.     @Override
  254.     public DataType type(K key) {
  255.  
  256.         byte[] rawKey = rawKey(key);
  257.         return execute(connection -> connection.type(rawKey), true);
  258.     }
  259.  
  260.     /**
  261.      * Executes the Redis dump command and returns the results. Redis uses a non-standard serialization mechanism and
  262.      * includes checksum information, thus the raw bytes are returned as opposed to deserializing with valueSerializer.
  263.      * Use the return value of dump as the value argument to restore
  264.      *
  265.      * @param key The key to dump
  266.      * @return results The results of the dump operation
  267.      */
  268.     @Override
  269.     public byte[] dump(K key) {
  270.  
  271.         byte[] rawKey = rawKey(key);
  272.         return execute(connection -> connection.dump(rawKey), true);
  273.     }
  274.  
  275.     /**
  276.      * Executes the Redis restore command. The value passed in should be the exact serialized data returned from
  277.      * {@link #dump(Object)}, since Redis uses a non-standard serialization mechanism.
  278.      *
  279.      * @param key The key to restore
  280.      * @param value The value to restore, as returned by {@link #dump(Object)}
  281.      * @param timeToLive An expiration for the restored key, or 0 for no expiration
  282.      * @param unit The time unit for timeToLive
  283.      * @param replace use {@literal true} to replace a potentially existing value instead of erroring.
  284.      * @throws RedisSystemException if the key you are attempting to restore already exists and {@code replace} is set to
  285.      *           {@literal false}.
  286.      */
  287.     @Override
  288.     public void restore(K key, final byte[] value, long timeToLive, TimeUnit unit, boolean replace) {
  289.  
  290.         byte[] rawKey = rawKey(key);
  291.         long rawTimeout = TimeoutUtils.toMillis(timeToLive, unit);
  292.  
  293.         execute(connection -> {
  294.             connection.restore(rawKey, rawTimeout, value, replace);
  295.             return null;
  296.         }, true);
  297.     }
  298.  
  299.     /*
  300.      * (non-Javadoc)
  301.      * @see org.springframework.data.redis.core.RedisOperations#watch(java.lang.Object)
  302.      */
  303.     @Override
  304.     public void watch(K key) {
  305.  
  306.         byte[] rawKey = rawKey(key);
  307.  
  308.         execute(connection -> {
  309.             connection.watch(rawKey);
  310.             return null;
  311.         }, true);
  312.     }
  313.  
  314.     /*
  315.      * (non-Javadoc)
  316.      * @see org.springframework.data.redis.core.RedisOperations#watch(java.util.Collection)
  317.      */
  318.     @Override
  319.     public void watch(Collection<K> keys) {
  320.  
  321.         byte[][] rawKeys = rawKeys(keys);
  322.  
  323.         execute(connection -> {
  324.             connection.watch(rawKeys);
  325.             return null;
  326.         }, true);
  327.     }
  328.  
  329.     /*
  330.      * (non-Javadoc)
  331.      * @see org.springframework.data.redis.core.RedisOperations#sort(org.springframework.data.redis.core.query.SortQuery, org.springframework.data.redis.serializer.RedisSerializer)
  332.      */
  333.     @Override
  334.     public <T> List<T> sort(SortQuery<K> query, @Nullable RedisSerializer<T> resultSerializer) {
  335.  
  336.         byte[] rawKey = rawKey(query.getKey());
  337.         SortParameters params = QueryUtils.convertQuery(query, stringSerializer);
  338.  
  339.         List<byte[]> vals = execute(connection -> connection.sort(rawKey, params), true);
  340.  
  341.         return SerializationUtils.deserialize(vals, resultSerializer);
  342.     }
  343.  
  344.     /*
  345.      * (non-Javadoc)
  346.      * @see org.springframework.data.redis.core.RedisOperations#sort(org.springframework.data.redis.core.query.SortQuery, java.lang.Object)
  347.      */
  348.     @Override
  349.     public Long sort(SortQuery<K> query, K storeKey) {
  350.  
  351.         byte[] rawStoreKey = rawKey(storeKey);
  352.         byte[] rawKey = rawKey(query.getKey());
  353.         SortParameters params = QueryUtils.convertQuery(query, stringSerializer);
  354.  
  355.         return execute(connection -> connection.sort(rawKey, params, rawStoreKey), true);
  356.     }
  357.  
  358.     @SuppressWarnings("unchecked")
  359.     private byte[] rawKey(Object key) {
  360.         Assert.notNull(key, "non null key required");
  361.         if (getKeySerializer() == null && key instanceof byte[]) {
  362.             return (byte[]) key;
  363.         }
  364.         return getKeySerializer().serialize(key);
  365.     }
  366.  
  367.     private byte[][] rawKeys(Collection<K> keys) {
  368.         final byte[][] rawKeys = new byte[keys.size()][];
  369.  
  370.         int i = 0;
  371.         for (K key : keys) {
  372.             rawKeys[i++] = rawKey(key);
  373.         }
  374.  
  375.         return rawKeys;
  376.     }
  377. }

发现我们重写了 RedisTemplate里面的挺多方法没这事什么原因？

原因：这里RedisTemplate里面有个“坑”，不能只重写getKeySerializer方法。

因为调用 redisTemplate.delete 等RedisTemplate本身的方法时，获取keySerializer的方法 rawKey

是私有的，并且不是通过 getKeySerializer 方法获取的 keySerializer，而是直接使用RedisTemplate本身的变量，这就不得以把 RedisTemplate 一些操作方法都进行重写。

RedisTemplate：

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/389681
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号