refactoring

redisson/src/main/java/org/redisson/Redisson.java

@@ -74,7 +74,6 @@ import org.redisson.api.RTopic;
 import org.redisson.api.RedissonClient;
 import org.redisson.api.RedissonReactiveClient;
 import org.redisson.client.codec.Codec;
-import org.redisson.codec.ReferenceCodecProvider;
 import org.redisson.command.CommandExecutor;
 import org.redisson.config.Config;
 import org.redisson.config.ConfigSupport;
@@ -105,7 +104,6 @@ public class Redisson implements RedissonClient {
     protected final ConnectionManager connectionManager;
     
     protected final ConcurrentMap<Class<?>, Class<?>> liveObjectClassCache = PlatformDependent.newConcurrentHashMap();
-    protected final ReferenceCodecProvider codecProvider;
     protected final Config config;
     protected final SemaphorePubSub semaphorePubSub = new SemaphorePubSub();
 
@@ -118,7 +116,6 @@ public class Redisson implements RedissonClient {
         
         connectionManager = ConfigSupport.createConnectionManager(configCopy);
         evictionScheduler = new EvictionScheduler(connectionManager.getCommandExecutor());
-        codecProvider = configCopy.getReferenceCodecProvider();
     }
     
     public EvictionScheduler getEvictionScheduler() {
@@ -585,7 +582,7 @@ public class Redisson implements RedissonClient {
 
     @Override
     public RLiveObjectService getLiveObjectService() {
-        return new RedissonLiveObjectService(this, liveObjectClassCache, codecProvider);
+        return new RedissonLiveObjectService(this, liveObjectClassCache);
     }
     
     @Override
@@ -604,11 +601,6 @@ public class Redisson implements RedissonClient {
         return config;
     }
 
-    @Override
-    public ReferenceCodecProvider getCodecProvider() {
-        return codecProvider;
-    }
-    
     @Override
     public NodesGroup<Node> getNodesGroup() {
         return new RedisNodes<Node>(connectionManager);

redisson/src/main/java/org/redisson/RedissonLiveObjectService.java

@@ -54,7 +54,6 @@ import org.redisson.api.annotation.RCascade;
 import org.redisson.api.annotation.REntity;
 import org.redisson.api.annotation.RFieldAccessor;
 import org.redisson.api.annotation.RId;
-import org.redisson.codec.ReferenceCodecProvider;
 import org.redisson.liveobject.LiveObjectTemplate;
 import org.redisson.liveobject.core.AccessorInterceptor;
 import org.redisson.liveobject.core.FieldAccessorInterceptor;
@@ -85,14 +84,12 @@ public class RedissonLiveObjectService implements RLiveObjectService {
     private static final ConcurrentMap<Class<? extends Resolver>, Resolver<?, ?, ?>> providerCache = PlatformDependent.newConcurrentHashMap();
     private final ConcurrentMap<Class<?>, Class<?>> classCache;
     private final RedissonClient redisson;
-    private final ReferenceCodecProvider codecProvider;
     private final RedissonObjectBuilder objectBuilder;
 
-    public RedissonLiveObjectService(RedissonClient redisson, ConcurrentMap<Class<?>, Class<?>> classCache, ReferenceCodecProvider codecProvider) {
+    public RedissonLiveObjectService(RedissonClient redisson, ConcurrentMap<Class<?>, Class<?>> classCache) {
         this.redisson = redisson;
         this.classCache = classCache;
-        this.codecProvider = codecProvider;
-        this.objectBuilder = new RedissonObjectBuilder(redisson, codecProvider);
+        this.objectBuilder = new RedissonObjectBuilder(redisson);
     }
 
     //TODO: Add ttl renewal functionality
@@ -642,7 +639,7 @@ public class RedissonLiveObjectService implements RLiveObjectService {
                         .withBinders(FieldProxy.Binder
                                 .install(LiveObjectInterceptor.Getter.class,
                                         LiveObjectInterceptor.Setter.class))
-                        .to(new LiveObjectInterceptor(redisson, codecProvider, entityClass,
+                        .to(new LiveObjectInterceptor(redisson, entityClass,
                                 getRIdFieldName(entityClass))))
 //                .intercept(MethodDelegation.to(
 //                                new LiveObjectInterceptor(redisson, codecProvider, entityClass,

redisson/src/main/java/org/redisson/api/RedissonClient.java

@@ -18,7 +18,6 @@ package org.redisson.api;
 import java.util.concurrent.TimeUnit;
 
 import org.redisson.client.codec.Codec;
-import org.redisson.codec.ReferenceCodecProvider;
 import org.redisson.config.Config;
 
 /**
@@ -956,13 +955,6 @@ public interface RedissonClient {
      */
     Config getConfig();
 
-    /**
-     * Returns the CodecProvider instance
-     * 
-     * @return CodecProvider object
-     */
-    public ReferenceCodecProvider getCodecProvider();
-    
     /**
      * Get Redis nodes group for server operations
      *

redisson/src/main/java/org/redisson/liveobject/core/AccessorInterceptor.java

@@ -29,7 +29,6 @@ import org.redisson.api.annotation.REntity;
 import org.redisson.api.annotation.REntity.TransformationMode;
 import org.redisson.api.annotation.RId;
 import org.redisson.client.codec.Codec;
-import org.redisson.codec.ReferenceCodecProvider;
 import org.redisson.liveobject.misc.ClassUtils;
 import org.redisson.liveobject.misc.Introspectior;
 import org.redisson.liveobject.resolver.NamingScheme;
@@ -52,12 +51,10 @@ import net.bytebuddy.implementation.bind.annotation.This;
 public class AccessorInterceptor {
 
     private final RedissonClient redisson;
-    private final ReferenceCodecProvider codecProvider;
     private final RedissonObjectBuilder objectBuilder;
 
     public AccessorInterceptor(RedissonClient redisson, RedissonObjectBuilder objectBuilder) {
         this.redisson = redisson;
-        this.codecProvider = redisson.getCodecProvider();
         this.objectBuilder = objectBuilder;
     }
 
@@ -104,7 +101,7 @@ public class AccessorInterceptor {
                 REntity anno = ClassUtils.getAnnotation(rEntity, REntity.class);
                 NamingScheme ns = anno.namingScheme()
                         .getDeclaredConstructor(Codec.class)
-                        .newInstance(codecProvider.getCodec(anno, (Class) rEntity));
+                        .newInstance(redisson.getConfig().getReferenceCodecProvider().getCodec(anno, (Class) rEntity));
                 liveMap.fastPut(fieldName, new RedissonReference(rEntity,
                         ns.getName(rEntity, fieldType, getREntityIdFieldName(liveObject),
                                 liveObject.getLiveObjectId())));

redisson/src/main/java/org/redisson/liveobject/core/LiveObjectInterceptor.java

@@ -57,9 +57,9 @@ public class LiveObjectInterceptor {
     private final NamingScheme namingScheme;
     private final Class<? extends Codec> codecClass;
 
-    public LiveObjectInterceptor(RedissonClient redisson, ReferenceCodecProvider codecProvider, Class<?> entityClass, String idFieldName) {
+    public LiveObjectInterceptor(RedissonClient redisson, Class<?> entityClass, String idFieldName) {
         this.redisson = redisson;
-        this.codecProvider = codecProvider;
+        this.codecProvider = redisson.getConfig().getReferenceCodecProvider();
         this.originalClass = entityClass;
         this.idFieldName = idFieldName;
         REntity anno = (REntity) ClassUtils.getAnnotation(entityClass, REntity.class);

redisson/src/main/java/org/redisson/liveobject/core/RedissonObjectBuilder.java

@@ -76,10 +76,10 @@ public class RedissonObjectBuilder {
     private final RedissonClient redisson;
     private final ReferenceCodecProvider codecProvider;
     
-    public RedissonObjectBuilder(RedissonClient redisson, ReferenceCodecProvider codecProvider) {
+    public RedissonObjectBuilder(RedissonClient redisson) {
         super();
         this.redisson = redisson;
-        this.codecProvider = codecProvider;
+        this.codecProvider = redisson.getConfig().getReferenceCodecProvider();
     }
 
     public void store(RObject ar, String fieldName, RMap<String, Object> liveMap) {