Improved Redis Serialization

application/src/main/java/org/thingsboard/server/service/session/SessionRedisCache.java

@@ -23,6 +23,7 @@ import org.springframework.data.redis.serializer.SerializationException;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
+import org.thingsboard.server.cache.TbRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
@@ -33,14 +34,14 @@ import org.thingsboard.server.gen.transport.TransportProtos;
 public class SessionRedisCache extends RedisTbTransactionalCache<DeviceId, TransportProtos.DeviceSessionsCacheEntry> {
 
     public SessionRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.SESSIONS_CACHE, cacheSpecsMap, connectionFactory, configuration, new RedisSerializer<>() {
+        super(CacheConstants.SESSIONS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>() {
             @Override
             public byte[] serialize(TransportProtos.DeviceSessionsCacheEntry deviceSessionsCacheEntry) throws SerializationException {
                 return deviceSessionsCacheEntry.toByteArray();
             }
 
             @Override
-            public TransportProtos.DeviceSessionsCacheEntry deserialize(byte[] bytes) throws SerializationException {
+            public TransportProtos.DeviceSessionsCacheEntry deserialize(DeviceId key, byte[] bytes) throws SerializationException {
                 try {
                     return TransportProtos.DeviceSessionsCacheEntry.parseFrom(bytes);
                 } catch (InvalidProtocolBufferException e) {

application/src/main/java/org/thingsboard/server/service/sync/vc/VersionControlTaskRedisCache.java

@@ -15,19 +15,14 @@
  */
 package org.thingsboard.server.service.sync.vc;
 
-import com.google.protobuf.InvalidProtocolBufferException;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.data.redis.serializer.RedisSerializer;
-import org.springframework.data.redis.serializer.SerializationException;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
-import org.thingsboard.server.common.data.id.DeviceId;
-import org.thingsboard.server.gen.transport.TransportProtos;
 
 import java.util.UUID;
 
@@ -36,6 +31,6 @@ import java.util.UUID;
 public class VersionControlTaskRedisCache extends RedisTbTransactionalCache<UUID, VersionControlTaskCacheEntry> {
 
     public VersionControlTaskRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.VERSION_CONTROL_TASK_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.VERSION_CONTROL_TASK_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

application/src/main/java/org/thingsboard/server/service/sync/vc/autocommit/AutoCommitSettingsRedisCache.java

@@ -21,7 +21,7 @@ import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.sync.vc.AutoCommitSettings;
@@ -31,6 +31,6 @@ import org.thingsboard.server.common.data.sync.vc.AutoCommitSettings;
 public class AutoCommitSettingsRedisCache extends RedisTbTransactionalCache<TenantId, AutoCommitSettings> {
 
     public AutoCommitSettingsRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.AUTO_COMMIT_SETTINGS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.AUTO_COMMIT_SETTINGS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

application/src/main/java/org/thingsboard/server/service/sync/vc/repository/RepositorySettingsRedisCache.java

@@ -21,7 +21,7 @@ import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.sync.vc.RepositorySettings;
@@ -31,6 +31,6 @@ import org.thingsboard.server.common.data.sync.vc.RepositorySettings;
 public class RepositorySettingsRedisCache extends RedisTbTransactionalCache<TenantId, RepositorySettings> {
 
     public RepositorySettingsRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.REPOSITORY_SETTINGS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.REPOSITORY_SETTINGS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

common/cache/src/main/java/org/thingsboard/server/cache/RedisTbTransactionalCache.java

@@ -48,7 +48,7 @@ public abstract class RedisTbTransactionalCache<K extends Serializable, V extend
     private final String cacheName;
     private final JedisConnectionFactory connectionFactory;
     private final RedisSerializer<String> keySerializer = StringRedisSerializer.UTF_8;
-    private final RedisSerializer<V> valueSerializer;
+    private final TbRedisSerializer<K, V> valueSerializer;
     private final Expiration evictExpiration;
     private final Expiration cacheTtl;
 
@@ -56,7 +56,7 @@ public abstract class RedisTbTransactionalCache<K extends Serializable, V extend
                                      CacheSpecsMap cacheSpecsMap,
                                      RedisConnectionFactory connectionFactory,
                                      TBRedisCacheConfiguration configuration,
-                                     RedisSerializer<V> valueSerializer) {
+                                     TbRedisSerializer<K, V> valueSerializer) {
         this.cacheName = cacheName;
         this.connectionFactory = (JedisConnectionFactory) connectionFactory;
         this.valueSerializer = valueSerializer;
@@ -79,7 +79,7 @@ public abstract class RedisTbTransactionalCache<K extends Serializable, V extend
             } else if (Arrays.equals(rawValue, BINARY_NULL_VALUE)) {
                 return SimpleTbCacheValueWrapper.empty();
             } else {
-                V value = valueSerializer.deserialize(rawValue);
+                V value = valueSerializer.deserialize(key, rawValue);
                 return SimpleTbCacheValueWrapper.wrap(value);
             }
         }

common/cache/src/main/java/org/thingsboard/server/cache/TbFSTRedisSerializer.java

@@ -0,0 +1,32 @@
+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.cache;
+
+import org.springframework.data.redis.serializer.SerializationException;
+import org.thingsboard.server.common.data.FSTUtils;
+
+public class TbFSTRedisSerializer<K, V> implements TbRedisSerializer<K, V> {
+
+    @Override
+    public byte[] serialize(V value) throws SerializationException {
+        return FSTUtils.encode(value);
+    }
+
+    @Override
+    public V deserialize(K key, byte[] bytes) throws SerializationException {
+        return FSTUtils.decode(bytes);
+    }
+}

common/cache/src/main/java/org/thingsboard/server/cache/TbRedisSerializer.java

@@ -15,20 +15,15 @@
  */
 package org.thingsboard.server.cache;
 
-import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.data.redis.serializer.SerializationException;
+import org.springframework.lang.Nullable;
 
-public class TbRedisSerializer<T> implements RedisSerializer<T> {
+public interface TbRedisSerializer<K, T> {
 
-    private final RedisSerializer<Object> java = RedisSerializer.java();
+    @Nullable
+    byte[] serialize(@Nullable T t) throws SerializationException;
 
-    @Override
-    public byte[] serialize(T t) throws SerializationException {
-        return java.serialize(t);
-    }
+    @Nullable
+    T deserialize(K key, @Nullable byte[] bytes) throws SerializationException;
 
-    @Override
-    public T deserialize(byte[] bytes) throws SerializationException {
-        return (T) java.deserialize(bytes);
-    }
 }

common/cache/src/main/java/org/thingsboard/server/cache/device/DeviceRedisCache.java

@@ -21,7 +21,7 @@ import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.Device;
 
@@ -30,6 +30,6 @@ import org.thingsboard.server.common.data.Device;
 public class DeviceRedisCache extends RedisTbTransactionalCache<DeviceCacheKey, Device> {
 
     public DeviceRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.DEVICE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.DEVICE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

common/cluster-api/src/main/proto/queue.proto

@@ -85,6 +85,17 @@ message KeyValueProto {
   string json_v = 7;
 }
 
+message AttributeValueProto {
+  int64 lastUpdateTs = 1;
+  KeyValueType type = 2;
+  bool has_v = 3;
+  bool bool_v = 4;
+  int64 long_v = 5;
+  double double_v = 6;
+  string string_v = 7;
+  string json_v = 8;
+}
+
 message TsKvProto {
   int64 ts = 1;
   KeyValueProto kv = 2;

common/data/pom.xml

@@ -104,6 +104,10 @@
             <groupId>io.swagger</groupId>
             <artifactId>swagger-annotations</artifactId>
         </dependency>
+        <dependency>
+            <groupId>de.ruedigermoeller</groupId>
+            <artifactId>fst</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

common/data/src/main/java/org/thingsboard/server/common/data/FSTUtils.java

@@ -0,0 +1,35 @@
+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data;
+
+import lombok.extern.slf4j.Slf4j;
+import org.nustaq.serialization.FSTConfiguration;
+
+@Slf4j
+public class FSTUtils {
+
+    public static final FSTConfiguration CONFIG = FSTConfiguration.createDefaultConfiguration();
+
+    @SuppressWarnings("unchecked")
+    public static <T> T decode(byte[] byteArray) {
+        return byteArray != null && byteArray.length > 0 ? (T) CONFIG.asObject(byteArray) : null;
+    }
+
+    public static <T> byte[] encode(T msq) {
+        return CONFIG.asByteArray(msq);
+    }
+
+}

common/queue/pom.xml

@@ -120,10 +120,6 @@
             <groupId>com.google.protobuf</groupId>
             <artifactId>protobuf-java-util</artifactId>
         </dependency>
-        <dependency>
-            <groupId>de.ruedigermoeller</groupId>
-            <artifactId>fst</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.apache.curator</groupId>
             <artifactId>curator-recipes</artifactId>

common/queue/src/main/java/org/thingsboard/server/queue/util/ProtoWithFSTService.java

@@ -18,7 +18,7 @@ package org.thingsboard.server.queue.util;
 import lombok.extern.slf4j.Slf4j;
 import org.nustaq.serialization.FSTConfiguration;
 import org.springframework.stereotype.Service;
-import org.thingsboard.server.queue.util.DataDecodingEncodingService;
+import org.thingsboard.server.common.data.FSTUtils;
 
 import java.util.Optional;
 
@@ -26,23 +26,23 @@ import java.util.Optional;
 @Service
 public class ProtoWithFSTService implements DataDecodingEncodingService {
 
-    private final FSTConfiguration config = FSTConfiguration.createDefaultConfiguration();
+    public static final FSTConfiguration CONFIG = FSTConfiguration.createDefaultConfiguration();
 
     @Override
     public <T> Optional<T> decode(byte[] byteArray) {
         try {
-            @SuppressWarnings("unchecked")
-            T msg = byteArray != null && byteArray.length > 0 ? (T) config.asObject(byteArray) : null;
-            return Optional.ofNullable(msg);
+            return Optional.ofNullable(FSTUtils.decode(byteArray));
         } catch (IllegalArgumentException e) {
             log.error("Error during deserialization message, [{}]", e.getMessage());
             return Optional.empty();
         }
     }
 
+
     @Override
     public <T> byte[] encode(T msq) {
-        return config.asByteArray(msq);
+        return FSTUtils.encode(msq);
     }
 
+
 }

dao/src/main/java/org/thingsboard/server/dao/asset/AssetRedisCache.java

@@ -23,13 +23,13 @@ import org.thingsboard.server.cache.TBRedisCacheConfiguration;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("AssetCache")
 public class AssetRedisCache extends RedisTbTransactionalCache<AssetCacheKey, Asset> {
 
     public AssetRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.ASSET_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.ASSET_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

dao/src/main/java/org/thingsboard/server/dao/attributes/AttributeRedisCache.java

@@ -15,21 +15,99 @@
  */
 package org.thingsboard.server.dao.attributes;
 
+import com.google.protobuf.InvalidProtocolBufferException;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.serializer.SerializationException;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
+import org.thingsboard.server.cache.RedisTbTransactionalCache;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
+import org.thingsboard.server.cache.TbRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
-import org.thingsboard.server.cache.RedisTbTransactionalCache;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry;
+import org.thingsboard.server.common.data.kv.BooleanDataEntry;
+import org.thingsboard.server.common.data.kv.DoubleDataEntry;
+import org.thingsboard.server.common.data.kv.JsonDataEntry;
+import org.thingsboard.server.common.data.kv.KvEntry;
+import org.thingsboard.server.common.data.kv.LongDataEntry;
+import org.thingsboard.server.common.data.kv.StringDataEntry;
+import org.thingsboard.server.gen.transport.TransportProtos.AttributeValueProto;
+import org.thingsboard.server.gen.transport.TransportProtos.KeyValueType;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("AttributeCache")
 public class AttributeRedisCache extends RedisTbTransactionalCache<AttributeCacheKey, AttributeKvEntry> {
 
     public AttributeRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.ATTRIBUTES_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.ATTRIBUTES_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>() {
+            @Override
+            public byte[] serialize(AttributeKvEntry attributeKvEntry) throws SerializationException {
+                AttributeValueProto.Builder builder = AttributeValueProto.newBuilder()
+                        .setLastUpdateTs(attributeKvEntry.getLastUpdateTs());
+                switch (attributeKvEntry.getDataType()) {
+                    case BOOLEAN:
+                        attributeKvEntry.getBooleanValue().ifPresent(builder::setBoolV);
+                        builder.setHasV(attributeKvEntry.getBooleanValue().isPresent());
+                        builder.setType(KeyValueType.BOOLEAN_V);
+                        break;
+                    case STRING:
+                        attributeKvEntry.getStrValue().ifPresent(builder::setStringV);
+                        builder.setHasV(attributeKvEntry.getStrValue().isPresent());
+                        builder.setType(KeyValueType.STRING_V);
+                        break;
+                    case DOUBLE:
+                        attributeKvEntry.getDoubleValue().ifPresent(builder::setDoubleV);
+                        builder.setHasV(attributeKvEntry.getDoubleValue().isPresent());
+                        builder.setType(KeyValueType.DOUBLE_V);
+                        break;
+                    case LONG:
+                        attributeKvEntry.getLongValue().ifPresent(builder::setLongV);
+                        builder.setHasV(attributeKvEntry.getLongValue().isPresent());
+                        builder.setType(KeyValueType.LONG_V);
+                        break;
+                    case JSON:
+                        attributeKvEntry.getJsonValue().ifPresent(builder::setJsonV);
+                        builder.setHasV(attributeKvEntry.getJsonValue().isPresent());
+                        builder.setType(KeyValueType.JSON_V);
+                        break;
+
+                }
+                return builder.build().toByteArray();
+            }
+
+            @Override
+            public AttributeKvEntry deserialize(AttributeCacheKey key, byte[] bytes) throws SerializationException {
+                try {
+                    AttributeValueProto proto = AttributeValueProto.parseFrom(bytes);
+                    boolean hasValue = proto.getHasV();
+                    KvEntry entry;
+                    switch (proto.getType()) {
+                        case BOOLEAN_V:
+                            entry = new BooleanDataEntry(key.getKey(), hasValue ? proto.getBoolV() : null);
+                            break;
+                        case LONG_V:
+                            entry = new LongDataEntry(key.getKey(), hasValue ? proto.getLongV() : null);
+                            break;
+                        case DOUBLE_V:
+                            entry = new DoubleDataEntry(key.getKey(), hasValue ? proto.getDoubleV() : null);
+                            break;
+                        case STRING_V:
+                            entry = new StringDataEntry(key.getKey(), hasValue ? proto.getStringV() : null);
+                            break;
+                        case JSON_V:
+                            entry = new JsonDataEntry(key.getKey(), hasValue ? proto.getJsonV() : null);
+                            break;
+                        default:
+                            throw new InvalidProtocolBufferException("Unrecognized type: " + proto.getType() + " !");
+                    }
+                    return new BaseAttributeKvEntry(proto.getLastUpdateTs(), entry);
+                } catch (InvalidProtocolBufferException e) {
+                    throw new SerializationException(e.getMessage());
+                }
+            }
+        });
     }
+
 }

dao/src/main/java/org/thingsboard/server/dao/device/DeviceCredentialsRedisCache.java

@@ -20,16 +20,16 @@ import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
-import org.thingsboard.server.cache.TbRedisSerializer;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("DeviceCredentialsCache")
 public class DeviceCredentialsRedisCache extends RedisTbTransactionalCache<String, DeviceCredentials> {
 
     public DeviceCredentialsRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.DEVICE_CREDENTIALS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.DEVICE_CREDENTIALS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

dao/src/main/java/org/thingsboard/server/dao/device/DeviceProfileRedisCache.java

@@ -20,16 +20,16 @@ import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
-import org.thingsboard.server.cache.TbRedisSerializer;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("DeviceProfileCache")
 public class DeviceProfileRedisCache extends RedisTbTransactionalCache<DeviceProfileCacheKey, DeviceProfile> {
 
     public DeviceProfileRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.DEVICE_PROFILE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.DEVICE_PROFILE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

dao/src/main/java/org/thingsboard/server/dao/edge/EdgeRedisCache.java

@@ -23,13 +23,13 @@ import org.thingsboard.server.cache.TBRedisCacheConfiguration;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("EdgeCache")
 public class EdgeRedisCache extends RedisTbTransactionalCache<EdgeCacheKey, Edge> {
 
     public EdgeRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.EDGE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.EDGE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

dao/src/main/java/org/thingsboard/server/dao/entityview/EntityViewRedisCache.java

@@ -22,13 +22,13 @@ import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("EntityViewCache")
 public class EntityViewRedisCache extends RedisTbTransactionalCache<EntityViewCacheKey, EntityViewCacheValue> {
 
     public EntityViewRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.ENTITY_VIEW_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.ENTITY_VIEW_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

dao/src/main/java/org/thingsboard/server/dao/ota/OtaPackageRedisCache.java

@@ -20,16 +20,16 @@ import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.OtaPackageInfo;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
-import org.thingsboard.server.cache.TbRedisSerializer;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("OtaPackageCache")
 public class OtaPackageRedisCache extends RedisTbTransactionalCache<OtaPackageCacheKey, OtaPackageInfo> {
 
     public OtaPackageRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.OTA_PACKAGE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.OTA_PACKAGE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

dao/src/main/java/org/thingsboard/server/dao/relation/RelationRedisCache.java

@@ -20,15 +20,15 @@ import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
-import org.thingsboard.server.cache.TbRedisSerializer;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("RelationCache")
 public class RelationRedisCache extends RedisTbTransactionalCache<RelationCacheKey, RelationCacheValue> {
 
     public RelationRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.RELATIONS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.RELATIONS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

dao/src/main/java/org/thingsboard/server/dao/tenant/TenantExistsRedisCache.java

@@ -21,15 +21,14 @@ import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
-import org.thingsboard.server.common.data.Tenant;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("TenantExistsCache")
 public class TenantExistsRedisCache extends RedisTbTransactionalCache<TenantCacheKey, Boolean> {
 
     public TenantExistsRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.TENANTS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.TENANTS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

dao/src/main/java/org/thingsboard/server/dao/tenant/TenantProfileRedisCache.java

@@ -23,13 +23,13 @@ import org.thingsboard.server.cache.TBRedisCacheConfiguration;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.TenantProfile;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 
 @ConditionalOnProperty(prefix = "cache", value = "type", havingValue = "redis")
 @Service("TenantProfileCache")
 public class TenantProfileRedisCache extends RedisTbTransactionalCache<TenantProfileCacheKey, TenantProfile> {
 
     public TenantProfileRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.TENANT_PROFILE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.TENANT_PROFILE_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }

dao/src/main/java/org/thingsboard/server/dao/tenant/TenantRedisCache.java

@@ -21,7 +21,7 @@ import org.springframework.stereotype.Service;
 import org.thingsboard.server.cache.CacheSpecsMap;
 import org.thingsboard.server.cache.RedisTbTransactionalCache;
 import org.thingsboard.server.cache.TBRedisCacheConfiguration;
-import org.thingsboard.server.cache.TbRedisSerializer;
+import org.thingsboard.server.cache.TbFSTRedisSerializer;
 import org.thingsboard.server.common.data.CacheConstants;
 import org.thingsboard.server.common.data.Tenant;
 
@@ -30,6 +30,6 @@ import org.thingsboard.server.common.data.Tenant;
 public class TenantRedisCache extends RedisTbTransactionalCache<TenantCacheKey, Tenant> {
 
     public TenantRedisCache(TBRedisCacheConfiguration configuration, CacheSpecsMap cacheSpecsMap, RedisConnectionFactory connectionFactory) {
-        super(CacheConstants.TENANTS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbRedisSerializer<>());
+        super(CacheConstants.TENANTS_CACHE, cacheSpecsMap, connectionFactory, configuration, new TbFSTRedisSerializer<>());
     }
 }