From 04ed0643469314d7da199cea3827022f8f85b4f2 Mon Sep 17 00:00:00 2001 From: jackygurui Date: Sun, 5 Jun 2016 23:49:53 +0100 Subject: [PATCH] RedissonAttachedLiveObjectService enhancement & author update RedissonAttachedLiveObjectService now supports objects with different codecs. updated author tag on files created by me to match my github profile --- .travis.yml | 3 + src/main/java/org/redisson/Redisson.java | 14 +++- .../RedissonAttachedLiveObjectService.java | 22 +++--- .../java/org/redisson/RedissonClient.java | 13 +++- .../java/org/redisson/RedissonObject.java | 5 ++ .../java/org/redisson/RedissonReference.java | 48 ++++++++----- src/main/java/org/redisson/core/RObject.java | 8 +++ .../redisson/liveobject/CodecProvider.java | 23 ++++++ .../liveobject/DefaultCodecProvider.java | 59 +++++++++++++++ .../RAttachedLiveObjectService.java | 2 +- .../RDetachedLiveObjectService.java | 2 +- .../liveobject/RLiveObjectService.java | 2 +- .../liveobject/annotation/REntity.java | 7 +- .../redisson/liveobject/annotation/RId.java | 2 +- .../liveobject/core/AccessorInterceptor.java | 72 +++++++++++-------- .../liveobject/misc/Introspectior.java | 2 +- .../resolver/FieldValueAsIdGenerator.java | 2 +- .../liveobject/resolver/Resolver.java | 2 +- src/test/java/org/redisson/RedisRunner.java | 4 ++ src/test/java/org/redisson/RedisVersion.java | 2 +- ...RedissonAttachedLiveObjectServiceTest.java | 13 ++-- .../redisson/RedissonRuntimeEnvironment.java | 10 ++- 22 files changed, 234 insertions(+), 83 deletions(-) create mode 100644 src/main/java/org/redisson/liveobject/CodecProvider.java create mode 100644 src/main/java/org/redisson/liveobject/DefaultCodecProvider.java diff --git a/.travis.yml b/.travis.yml index 07c9d704b..60579e9a6 100644 --- a/.travis.yml +++ b/.travis.yml @@ -26,6 +26,7 @@ env: - REDIS_VERSION=3.2.0 REDISSON_TEST=org.redisson.RedissonAtomicDoubleTest - REDIS_VERSION=3.2.0 REDISSON_TEST=org.redisson.RedissonAtomicLongReactiveTest - REDIS_VERSION=3.2.0 REDISSON_TEST=org.redisson.RedissonAtomicLongTest + - REDIS_VERSION=3.2.0 REDISSON_TEST=org.redisson.RedissonAttachedLiveObjectServiceTest - REDIS_VERSION=3.2.0 REDISSON_TEST=org.redisson.RedissonBatchTest - REDIS_VERSION=3.2.0 REDISSON_TEST=org.redisson.RedissonBitSetReactiveTest - REDIS_VERSION=3.2.0 REDISSON_TEST=org.redisson.RedissonBitSetTest @@ -88,6 +89,7 @@ env: - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonAtomicDoubleTest - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonAtomicLongReactiveTest - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonAtomicLongTest + - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonAttachedLiveObjectServiceTest - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonBatchTest - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonBitSetReactiveTest - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonBitSetTest @@ -149,6 +151,7 @@ env: - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonAtomicDoubleTest - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonAtomicLongReactiveTest - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonAtomicLongTest + - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonAttachedLiveObjectServiceTest - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonBatchTest - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonBitSetReactiveTest - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonBitSetTest diff --git a/src/main/java/org/redisson/Redisson.java b/src/main/java/org/redisson/Redisson.java index 9963e5e83..28cef1a67 100755 --- a/src/main/java/org/redisson/Redisson.java +++ b/src/main/java/org/redisson/Redisson.java @@ -73,6 +73,9 @@ import org.redisson.core.RSetMultimap; import org.redisson.core.RSetMultimapCache; import org.redisson.core.RSortedSet; import org.redisson.core.RTopic; +import org.redisson.liveobject.CodecProvider; +import org.redisson.liveobject.DefaultCodecProvider; +import org.redisson.liveobject.RAttachedLiveObjectService; import io.netty.util.concurrent.Future; import io.netty.util.internal.PlatformDependent; @@ -95,7 +98,7 @@ public class Redisson implements RedissonClient { = PlatformDependent.newConcurrentHashMap(); private final Map liveObjectProxyCache = PlatformDependent.newConcurrentHashMap(); - + private final CodecProvider liveObjectDefaultCodecProvider = new DefaultCodecProvider(); private final Config config; private final UUID id = UUID.randomUUID(); @@ -540,8 +543,13 @@ public class Redisson implements RedissonClient { } @Override - public RedissonAttachedLiveObjectService getAttachedLiveObjectService() { - return new RedissonAttachedLiveObjectService(this, commandExecutor, liveObjectClassCache, liveObjectProxyCache); + public RAttachedLiveObjectService getAttachedLiveObjectService() { + return new RedissonAttachedLiveObjectService(this, liveObjectClassCache, liveObjectProxyCache, liveObjectDefaultCodecProvider); + } + + @Override + public RAttachedLiveObjectService getAttachedLiveObjectService(CodecProvider ProviderCodec) { + return new RedissonAttachedLiveObjectService(this, liveObjectClassCache, liveObjectProxyCache, new DefaultCodecProvider()); } @Override diff --git a/src/main/java/org/redisson/RedissonAttachedLiveObjectService.java b/src/main/java/org/redisson/RedissonAttachedLiveObjectService.java index 04475fb65..9703e210e 100644 --- a/src/main/java/org/redisson/RedissonAttachedLiveObjectService.java +++ b/src/main/java/org/redisson/RedissonAttachedLiveObjectService.java @@ -1,6 +1,5 @@ package org.redisson; -import io.netty.util.internal.PlatformDependent; import java.util.Map; import net.bytebuddy.ByteBuddy; import net.bytebuddy.description.field.FieldDescription; @@ -8,8 +7,8 @@ import net.bytebuddy.description.field.FieldList; import net.bytebuddy.dynamic.loading.ClassLoadingStrategy; import net.bytebuddy.implementation.MethodDelegation; import net.bytebuddy.matcher.ElementMatchers; -import org.redisson.command.CommandAsyncExecutor; import org.redisson.core.RObject; +import org.redisson.liveobject.CodecProvider; import org.redisson.liveobject.RAttachedLiveObjectService; import org.redisson.liveobject.annotation.REntity; import org.redisson.liveobject.annotation.RId; @@ -20,17 +19,17 @@ public class RedissonAttachedLiveObjectService implements RAttachedLiveObjectSer private final Map classCache; private final Map proxyCache; - private final RedissonClient redisson; - private final CommandAsyncExecutor commandExecutor; - public RedissonAttachedLiveObjectService(RedissonClient redisson, CommandAsyncExecutor commandExecutor, Map classCache, Map proxyCache) { + private final CodecProvider codecProvider; + + public RedissonAttachedLiveObjectService(RedissonClient redisson, Map classCache, Map proxyCache, CodecProvider codecProvider) { this.redisson = redisson; - this.commandExecutor = commandExecutor; this.classCache = classCache; this.proxyCache = proxyCache; + this.codecProvider = codecProvider; } - + //TODO: Support ID Generator @Override public T get(Class entityClass, K id, long ttl) { @@ -83,7 +82,7 @@ public class RedissonAttachedLiveObjectService implements RAttachedLiveObjectSer .and(ElementMatchers.isGetter() .or(ElementMatchers.isSetter())) .and(ElementMatchers.isPublic())) - .intercept(MethodDelegation.to(new AccessorInterceptor(redisson, commandExecutor, entityClass, idFieldName))) + .intercept(MethodDelegation.to(new AccessorInterceptor(redisson, codecProvider, entityClass, idFieldName))) .make().load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER) .getLoaded()); @@ -104,4 +103,11 @@ public class RedissonAttachedLiveObjectService implements RAttachedLiveObjectSer } } + /** + * @return the codecProvider + */ + public CodecProvider getCodecProvider() { + return codecProvider; + } + } diff --git a/src/main/java/org/redisson/RedissonClient.java b/src/main/java/org/redisson/RedissonClient.java index 3b02a8243..3443a99b7 100755 --- a/src/main/java/org/redisson/RedissonClient.java +++ b/src/main/java/org/redisson/RedissonClient.java @@ -59,6 +59,8 @@ import org.redisson.core.RSetMultimap; import org.redisson.core.RSetMultimapCache; import org.redisson.core.RSortedSet; import org.redisson.core.RTopic; +import org.redisson.liveobject.CodecProvider; +import org.redisson.liveobject.RAttachedLiveObjectService; /** * Main Redisson interface for access @@ -645,7 +647,16 @@ public interface RedissonClient { * * @return */ - RedissonAttachedLiveObjectService getAttachedLiveObjectService(); + RAttachedLiveObjectService getAttachedLiveObjectService(); + + /** + * Returns RedissonAttachedLiveObjectService which can be used to + * retrieve live REntity(s) + * + * @param codecProvider the CodecProvider to be used to create the service + * @return + */ + RAttachedLiveObjectService getAttachedLiveObjectService(CodecProvider codecProvider); /** * Shuts down Redisson instance NOT Redis server diff --git a/src/main/java/org/redisson/RedissonObject.java b/src/main/java/org/redisson/RedissonObject.java index 6cc3d6000..c614fae5d 100644 --- a/src/main/java/org/redisson/RedissonObject.java +++ b/src/main/java/org/redisson/RedissonObject.java @@ -128,4 +128,9 @@ abstract class RedissonObject implements RObject { return commandExecutor.readAsync(getName(), codec, RedisCommands.EXISTS, getName()); } + @Override + public Codec getCodec() { + return codec; + } + } diff --git a/src/main/java/org/redisson/RedissonReference.java b/src/main/java/org/redisson/RedissonReference.java index c32c6e230..1d7f3dce5 100644 --- a/src/main/java/org/redisson/RedissonReference.java +++ b/src/main/java/org/redisson/RedissonReference.java @@ -5,23 +5,24 @@ import org.redisson.core.RObject; /** * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) */ public class RedissonReference { + private String type; - private Object keyName; + private String keyName; private String codec; public RedissonReference() { } - public RedissonReference(Class type, Object keyName) { + public RedissonReference(Class type, String keyName) { this.type = type.getCanonicalName(); this.keyName = keyName; this.codec = null; } - public RedissonReference(Class type, Object keyName, Codec codec) { + public RedissonReference(Class type, String keyName, Codec codec) { this.type = type.getCanonicalName(); this.keyName = keyName; this.codec = codec.getClass().getCanonicalName(); @@ -34,12 +35,15 @@ public class RedissonReference { /** * @return the type */ - public Class getType() { - try { - return (Class) Class.forName(type); - } catch (ClassNotFoundException ex) { - return null; - } + public Class getType() throws Exception { + return (Class) Class.forName(type); + } + + /** + * @return type name in string + */ + public String getTypeName() { + return type; } /** @@ -52,32 +56,38 @@ public class RedissonReference { /** * @return the keyName */ - public Object getKeyName() { + public String getKeyName() { return keyName; } /** * @param keyName the keyName to set */ - public void setKeyName(Object keyName) { + public void setKeyName(String keyName) { this.keyName = keyName; } /** * @return the codec */ - public Codec getCodec() throws Exception { - return codec == null + public Class getCodecType() throws Exception { + return (Class) (codec == null ? null - : (Codec) Class.forName(codec).newInstance(); + : Class.forName(codec)); + } + + /** + * @return Codec name in string + */ + public String getCodecName() { + return codec; } /** * @param codec the codec to set */ - public void setCodec(Codec codec) { - this.codec = codec.getClass().getCanonicalName(); + public void setCodecType(Class codec) { + this.codec = codec.getCanonicalName(); } - - + } diff --git a/src/main/java/org/redisson/core/RObject.java b/src/main/java/org/redisson/core/RObject.java index 3a0c09ac6..fd1d972e1 100644 --- a/src/main/java/org/redisson/core/RObject.java +++ b/src/main/java/org/redisson/core/RObject.java @@ -15,6 +15,8 @@ */ package org.redisson.core; +import org.redisson.client.codec.Codec; + /** * Base interface for all Redisson objects * @@ -76,4 +78,10 @@ public interface RObject extends RObjectAsync { */ boolean isExists(); + /** + * Returns the underlying Codec used by this RObject + * + * @return + */ + Codec getCodec(); } diff --git a/src/main/java/org/redisson/liveobject/CodecProvider.java b/src/main/java/org/redisson/liveobject/CodecProvider.java new file mode 100644 index 000000000..6428e1cf6 --- /dev/null +++ b/src/main/java/org/redisson/liveobject/CodecProvider.java @@ -0,0 +1,23 @@ +package org.redisson.liveobject; + +import org.redisson.client.codec.Codec; +import org.redisson.core.RObject; + +/** + * + * @author Rui Gu (https://github.com/jackygurui) + */ +public interface CodecProvider { + + Codec getCodec(Class codecClass); + + Codec getCodec(Class codecClass, Class rObjectClass, String name); + + Codec getCodec(Class codecClass, RObject rObject, String name); + + void registerCodec(Class codecClass, Codec codec); + + void registerCodec(Class codecClass, Class rObjectClass, String name, Codec codec); + + void registerCodec(Class codecClass, RObject rObject, String name, Codec codec); +} diff --git a/src/main/java/org/redisson/liveobject/DefaultCodecProvider.java b/src/main/java/org/redisson/liveobject/DefaultCodecProvider.java new file mode 100644 index 000000000..030fa81e0 --- /dev/null +++ b/src/main/java/org/redisson/liveobject/DefaultCodecProvider.java @@ -0,0 +1,59 @@ +package org.redisson.liveobject; + +import io.netty.util.internal.PlatformDependent; +import java.util.concurrent.ConcurrentMap; +import org.redisson.client.codec.Codec; +import org.redisson.core.RObject; + +/** + * + * @author Rui Gu (https://github.com/jackygurui) + */ +public class DefaultCodecProvider implements CodecProvider { + + public static final ConcurrentMap, Codec> codecCache = PlatformDependent.newConcurrentHashMap(); + + @Override + public Codec getCodec(Class codecClass) { + if (!codecCache.containsKey(codecClass)) { + try { + codecCache.putIfAbsent(codecClass, codecClass.newInstance()); + } catch (Exception ex) { + throw new RuntimeException(ex); + } + } + return codecCache.get(codecClass); + } + + @Override + public Codec getCodec(Class codecClass, Class rObjectClass, String name) { + if (rObjectClass.isInterface()) { + throw new IllegalArgumentException("Cannot lookup an interface class of RObject " + rObjectClass.getCanonicalName() + ". Concrete class only."); + } + return getCodec(codecClass); + } + + @Override + public Codec getCodec(Class codecClass, RObject rObject, String name) { + return getCodec(codecClass, rObject.getClass(), name); + } + + @Override + public void registerCodec(Class cls, Codec codec) { + codecCache.putIfAbsent(cls, codec); + } + + @Override + public void registerCodec(Class codecClass, Class rObjectClass, String name, Codec codec) { + if (rObjectClass.isInterface()) { + throw new IllegalArgumentException("Cannot register an interface class of RObject " + rObjectClass.getCanonicalName() + ". Concrete class only."); + } + registerCodec(codecClass, codec); + } + + @Override + public void registerCodec(Class codecClass, RObject rObject, String name, Codec codec) { + registerCodec(codecClass, rObject.getClass(), name, codec); + } + +} diff --git a/src/main/java/org/redisson/liveobject/RAttachedLiveObjectService.java b/src/main/java/org/redisson/liveobject/RAttachedLiveObjectService.java index 5f39befe8..f6ed7cc26 100644 --- a/src/main/java/org/redisson/liveobject/RAttachedLiveObjectService.java +++ b/src/main/java/org/redisson/liveobject/RAttachedLiveObjectService.java @@ -2,7 +2,7 @@ package org.redisson.liveobject; /** * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) * */ public interface RAttachedLiveObjectService extends RLiveObjectService { diff --git a/src/main/java/org/redisson/liveobject/RDetachedLiveObjectService.java b/src/main/java/org/redisson/liveobject/RDetachedLiveObjectService.java index b33206ce5..c79d6f38b 100644 --- a/src/main/java/org/redisson/liveobject/RDetachedLiveObjectService.java +++ b/src/main/java/org/redisson/liveobject/RDetachedLiveObjectService.java @@ -4,7 +4,7 @@ import io.netty.util.concurrent.Future; /** * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) * * @param Entity type * @param Key type diff --git a/src/main/java/org/redisson/liveobject/RLiveObjectService.java b/src/main/java/org/redisson/liveobject/RLiveObjectService.java index 65c5b8c26..4751f5c33 100644 --- a/src/main/java/org/redisson/liveobject/RLiveObjectService.java +++ b/src/main/java/org/redisson/liveobject/RLiveObjectService.java @@ -9,7 +9,7 @@ package org.redisson.liveobject; * In DETACHED Mode, entity's field values are kept local and only pushed to * Redis when update is called. * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) * */ public interface RLiveObjectService { diff --git a/src/main/java/org/redisson/liveobject/annotation/REntity.java b/src/main/java/org/redisson/liveobject/annotation/REntity.java index 957ced00b..eb7642301 100644 --- a/src/main/java/org/redisson/liveobject/annotation/REntity.java +++ b/src/main/java/org/redisson/liveobject/annotation/REntity.java @@ -4,10 +4,12 @@ import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; +import org.redisson.client.codec.Codec; +import org.redisson.codec.JsonJacksonCodec; /** * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) */ @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) @@ -15,7 +17,8 @@ public @interface REntity { Class namingScheme() default DefaultNamingScheme.class; - + Class codec() default JsonJacksonCodec.class; + public interface NamingScheme { public String getName(Class cls, String idFieldName, Object id); diff --git a/src/main/java/org/redisson/liveobject/annotation/RId.java b/src/main/java/org/redisson/liveobject/annotation/RId.java index 0dfbf6aef..967ad2c8c 100644 --- a/src/main/java/org/redisson/liveobject/annotation/RId.java +++ b/src/main/java/org/redisson/liveobject/annotation/RId.java @@ -8,7 +8,7 @@ import org.redisson.liveobject.resolver.FieldValueAsIdGenerator; /** * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) */ @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.FIELD}) diff --git a/src/main/java/org/redisson/liveobject/core/AccessorInterceptor.java b/src/main/java/org/redisson/liveobject/core/AccessorInterceptor.java index 106185f53..8906394c0 100644 --- a/src/main/java/org/redisson/liveobject/core/AccessorInterceptor.java +++ b/src/main/java/org/redisson/liveobject/core/AccessorInterceptor.java @@ -7,38 +7,41 @@ import net.bytebuddy.implementation.bind.annotation.Origin; import net.bytebuddy.implementation.bind.annotation.RuntimeType; import net.bytebuddy.implementation.bind.annotation.SuperCall; import net.bytebuddy.implementation.bind.annotation.This; -import org.redisson.RedissonAttachedLiveObjectService; import org.redisson.RedissonClient; +import org.redisson.RedissonMap; import org.redisson.RedissonReference; import org.redisson.client.RedisException; import org.redisson.client.codec.Codec; -import org.redisson.command.CommandAsyncExecutor; import org.redisson.core.RMap; import org.redisson.core.RObject; +import org.redisson.liveobject.CodecProvider; import org.redisson.liveobject.annotation.REntity; import org.redisson.liveobject.annotation.RId; import org.redisson.liveobject.misc.Introspectior; /** + * This class is going to be instantiated and becomes a static field of the proxied + * target class. That is one instance of this class per proxied class. * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) */ public class AccessorInterceptor { private final RedissonClient redisson; - private final CommandAsyncExecutor commandExecutor; + private final CodecProvider codecProvider; private final Class originalClass; private final String idFieldName; private final REntity.NamingScheme namingScheme; - private RMap liveMap; - - public AccessorInterceptor(RedissonClient redisson, CommandAsyncExecutor commandExecutor, Class entityClass, String idFieldName) throws Exception { + private final Class codecClass; + + public AccessorInterceptor(RedissonClient redisson, CodecProvider codecProvider, Class entityClass, String idFieldName) throws Exception { this.redisson = redisson; - this.commandExecutor = commandExecutor; + this.codecProvider = codecProvider; this.originalClass = entityClass; this.idFieldName = idFieldName; - this.namingScheme = ((REntity) entityClass.getAnnotation(REntity.class)) - .namingScheme().newInstance(); + REntity anno = ((REntity) entityClass.getAnnotation(REntity.class)); + this.namingScheme = anno.namingScheme().newInstance(); + this.codecClass = anno.codec(); } @RuntimeType @@ -47,10 +50,10 @@ public class AccessorInterceptor { if (isGetter(method, idFieldName)) { return superMethod.call(); } - initLiveMapIfRequired(getId(me)); + String id = getMapKey(getId(me)); + RMap liveMap = redisson.getMap(id, codecProvider.getCodec(codecClass, RedissonMap.class, id)); if (isSetter(method, idFieldName)) { //TODO: distributed locking maybe required. - superMethod.call(); try { liveMap.rename(getMapKey(args[0])); } catch (RedisException e) { @@ -58,44 +61,34 @@ public class AccessorInterceptor { throw e; } } - liveMap = null; + superMethod.call(); return null; } String fieldName = getFieldName(method); if (isGetter(method, fieldName)) { Object result = liveMap.get(fieldName); if (method.getReturnType().isAnnotationPresent(REntity.class)) { - return redisson.getAttachedLiveObjectService() + return redisson.getAttachedLiveObjectService(codecProvider) .get((Class) method.getReturnType(), result); } else if (result instanceof RedissonReference) { - RedissonReference r = ((RedissonReference) result); - //TODO: use reflection on redisson object - return r.getType() - .getConstructor(Codec.class, CommandAsyncExecutor.class, String.class) - .newInstance(r.isDefaultCodec() - ? commandExecutor.getConnectionManager().getCodec() - : r.getCodec(), commandExecutor, r.getKeyName()); + return createRedissonObject((RedissonReference) result, method.getReturnType()); } return result; } if (isSetter(method, fieldName)) { if (method.getParameterTypes()[0].isAnnotationPresent(REntity.class)) { - return liveMap.fastPut(fieldName, getREntityId(args[0])); + return liveMap.put(fieldName, getREntityId(args[0])); } else if (args[0] instanceof RObject) { RObject ar = (RObject) args[0]; - return liveMap.fastPut(fieldName, new RedissonReference((Class) args[0].getClass(), ar.getName())); + Codec codec = ar.getCodec(); + codecProvider.registerCodec(codec.getClass(), ar, fieldName, codec); + return liveMap.put(fieldName, new RedissonReference(ar.getClass(), ar.getName(), codec)); } - return liveMap.fastPut(fieldName, args[0]); + return liveMap.put(fieldName, args[0]); } return superMethod.call(); } - private void initLiveMapIfRequired(Object id) { - if (liveMap == null) { - liveMap = redisson.getMap(getMapKey(id)); - } - } - private String getFieldName(Method method) { return method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4); } @@ -134,4 +127,23 @@ public class AccessorInterceptor { return getFieldValue(o, idName); } + private RObject createRedissonObject(RedissonReference rr, Class expected) throws Exception { + if (rr.getType() != null) { + for (Method method : RedissonClient.class.getDeclaredMethods()) { + if (method.getName().startsWith("get") + && method.getReturnType().isAssignableFrom(rr.getType()) + && method.getReturnType().isAssignableFrom(expected)) { + if (rr.isDefaultCodec() && method.getParameterCount() == 1) { + return (RObject) method.invoke(redisson, rr.getKeyName()); + } else if (!rr.isDefaultCodec() + && method.getParameterCount() == 2 + && String.class.equals(method.getParameterTypes()[0]) + && Codec.class.equals(method.getParameterTypes()[1])) { + return (RObject) method.invoke(redisson, rr.getKeyName(), codecProvider.getCodec(rr.getCodecType())); + } + } + } + } + throw new ClassNotFoundException("No RObject is found to match class type of " + rr.getTypeName() + " with codec type of " + rr.getCodecName()); + } } diff --git a/src/main/java/org/redisson/liveobject/misc/Introspectior.java b/src/main/java/org/redisson/liveobject/misc/Introspectior.java index 9356a699f..66404d942 100644 --- a/src/main/java/org/redisson/liveobject/misc/Introspectior.java +++ b/src/main/java/org/redisson/liveobject/misc/Introspectior.java @@ -11,7 +11,7 @@ import net.bytebuddy.matcher.ElementMatchers; /** * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) */ public class Introspectior { diff --git a/src/main/java/org/redisson/liveobject/resolver/FieldValueAsIdGenerator.java b/src/main/java/org/redisson/liveobject/resolver/FieldValueAsIdGenerator.java index cda164c13..206e7abc5 100644 --- a/src/main/java/org/redisson/liveobject/resolver/FieldValueAsIdGenerator.java +++ b/src/main/java/org/redisson/liveobject/resolver/FieldValueAsIdGenerator.java @@ -4,7 +4,7 @@ import org.redisson.liveobject.annotation.RId; /** * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) */ public class FieldValueAsIdGenerator implements Resolver{ diff --git a/src/main/java/org/redisson/liveobject/resolver/Resolver.java b/src/main/java/org/redisson/liveobject/resolver/Resolver.java index 69b5941e8..0cd7cf72e 100644 --- a/src/main/java/org/redisson/liveobject/resolver/Resolver.java +++ b/src/main/java/org/redisson/liveobject/resolver/Resolver.java @@ -4,7 +4,7 @@ import java.lang.annotation.Annotation; /** * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) * @param Field instance * @param Annotation to resolve */ diff --git a/src/test/java/org/redisson/RedisRunner.java b/src/test/java/org/redisson/RedisRunner.java index 5eda29ff5..d12d1ba97 100644 --- a/src/test/java/org/redisson/RedisRunner.java +++ b/src/test/java/org/redisson/RedisRunner.java @@ -19,6 +19,10 @@ import org.redisson.client.RedisConnection; import org.redisson.client.protocol.RedisStrictCommand; import org.redisson.client.protocol.convertor.VoidReplayConvertor; +/** + * + * @author Rui Gu (https://github.com/jackygurui) + */ public class RedisRunner { public enum REDIS_OPTIONS { diff --git a/src/test/java/org/redisson/RedisVersion.java b/src/test/java/org/redisson/RedisVersion.java index 03829d82d..1b4db4746 100644 --- a/src/test/java/org/redisson/RedisVersion.java +++ b/src/test/java/org/redisson/RedisVersion.java @@ -5,7 +5,7 @@ import java.util.regex.Pattern; /** * - * @author Jack + * @author Rui Gu (https://github.com/jackygurui) */ public class RedisVersion implements Comparable{ diff --git a/src/test/java/org/redisson/RedissonAttachedLiveObjectServiceTest.java b/src/test/java/org/redisson/RedissonAttachedLiveObjectServiceTest.java index 7be8c255d..2b580ef90 100644 --- a/src/test/java/org/redisson/RedissonAttachedLiveObjectServiceTest.java +++ b/src/test/java/org/redisson/RedissonAttachedLiveObjectServiceTest.java @@ -4,12 +4,13 @@ import java.io.Serializable; import static org.junit.Assert.*; import org.junit.Test; import org.redisson.core.RMap; +import org.redisson.liveobject.RAttachedLiveObjectService; import org.redisson.liveobject.annotation.REntity; import org.redisson.liveobject.annotation.RId; /** * - * @author ruigu + * @author Rui Gu (https://github.com/jackygurui) */ public class RedissonAttachedLiveObjectServiceTest extends BaseTest { @@ -189,8 +190,8 @@ public class RedissonAttachedLiveObjectServiceTest extends BaseTest { } @Test - public void test() { - RedissonAttachedLiveObjectService s = redisson.getAttachedLiveObjectService(); + public void testBasics() { + RAttachedLiveObjectService s = redisson.getAttachedLiveObjectService(); TestREntity t = s.get(TestREntity.class, "1"); assertEquals("1", t.getName()); assertTrue(!redisson.getMap(REntity.DefaultNamingScheme.INSTANCE.getName(TestREntity.class, "name", "1")).isExists()); @@ -206,7 +207,7 @@ public class RedissonAttachedLiveObjectServiceTest extends BaseTest { @Test public void testLiveObjectWithRObject() { - RedissonAttachedLiveObjectService s = redisson.getAttachedLiveObjectService(); + RAttachedLiveObjectService s = redisson.getAttachedLiveObjectService(); TestREntityWithRMap t = s.get(TestREntityWithRMap.class, "2"); RMap map = redisson.getMap("testMap"); t.setValue(map); @@ -222,7 +223,7 @@ public class RedissonAttachedLiveObjectServiceTest extends BaseTest { @Test public void testLiveObjectWithNestedLiveObjectAsId() { - RedissonAttachedLiveObjectService s = redisson.getAttachedLiveObjectService(); + RAttachedLiveObjectService s = redisson.getAttachedLiveObjectService(); TestREntity t1 = s.get(TestREntity.class, "1"); try { s.get(TestREntityIdNested.class, t1); @@ -233,7 +234,7 @@ public class RedissonAttachedLiveObjectServiceTest extends BaseTest { @Test public void testLiveObjectWithNestedLiveObjectAsValue() throws Exception { - RedissonAttachedLiveObjectService s = redisson.getAttachedLiveObjectService(); + RAttachedLiveObjectService s = redisson.getAttachedLiveObjectService(); TestREntityWithRMap t1 = s.get(TestREntityWithRMap.class, "111"); TestREntityValueNested t2 = s.get(TestREntityValueNested.class, "122"); RMap map = redisson.getMap("32123"); diff --git a/src/test/java/org/redisson/RedissonRuntimeEnvironment.java b/src/test/java/org/redisson/RedissonRuntimeEnvironment.java index a214f975c..578c98a25 100644 --- a/src/test/java/org/redisson/RedissonRuntimeEnvironment.java +++ b/src/test/java/org/redisson/RedissonRuntimeEnvironment.java @@ -1,13 +1,11 @@ package org.redisson; -import java.lang.management.ManagementFactory; -import java.lang.management.RuntimeMXBean; import java.util.Locale; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicLong; -import java.util.logging.Level; -import java.util.logging.Logger; +/** + * + * @author Rui Gu (https://github.com/jackygurui) + */ public class RedissonRuntimeEnvironment { public static final boolean isTravis = "true".equalsIgnoreCase(System.getProperty("travisEnv"));