() {
diff --git a/redisson/src/main/java/org/redisson/api/LocalCachedMapOptions.java b/redisson/src/main/java/org/redisson/api/LocalCachedMapOptions.java
index 89a600aa5..523cc5ff5 100644
--- a/redisson/src/main/java/org/redisson/api/LocalCachedMapOptions.java
+++ b/redisson/src/main/java/org/redisson/api/LocalCachedMapOptions.java
@@ -25,7 +25,7 @@ import java.util.concurrent.TimeUnit;
*/
public class LocalCachedMapOptions {
- public enum EvictionPolicy {NONE, LRU, LFU};
+ public enum EvictionPolicy {NONE, LRU, LFU, SOFT};
private boolean invalidateEntryOnChange;
private EvictionPolicy evictionPolicy;
@@ -115,6 +115,7 @@ public class LocalCachedMapOptions {
* @param evictionPolicy
* LRU - uses cache with LRU (least recently used) eviction policy.
*
LFU - uses cache with LFU (least frequently used) eviction policy.
+ *
SOFT - uses cache with soft references. The garbage collector will evict items from the cache when the JVM is running out of memory.
*
NONE - doesn't use eviction policy, but timeToLive and maxIdleTime params are still working.
* @return LocalCachedMapOptions instance
*/
diff --git a/redisson/src/main/java/org/redisson/api/RedissonClient.java b/redisson/src/main/java/org/redisson/api/RedissonClient.java
index 2845c5035..b38746061 100755
--- a/redisson/src/main/java/org/redisson/api/RedissonClient.java
+++ b/redisson/src/main/java/org/redisson/api/RedissonClient.java
@@ -742,12 +742,28 @@ public interface RedissonClient {
* Returns ScheduledExecutorService by name
* using provided codec for task, response and request serialization
*
+ * Please use getExecutorService(String name, Codec codec) method instead.
+ *
+ * @deprecated - use {@link #getExecutorService(String, Codec)} instead.
+ *
* @param name - name of object
* @param codec - codec for task, response and request
* @return ScheduledExecutorService object
*/
+ @Deprecated
RScheduledExecutorService getExecutorService(Codec codec, String name);
+ /**
+ * Returns ScheduledExecutorService by name
+ * using provided codec for task, response and request serialization
+ *
+ * @param name - name of object
+ * @param codec - codec for task, response and request
+ * @return ScheduledExecutorService object
+ * @since 2.8.2
+ */
+ RScheduledExecutorService getExecutorService(String name, Codec codec);
+
/**
* Returns object for remote operations prefixed with the default name (redisson_remote_service)
*
diff --git a/redisson/src/main/java/org/redisson/misc/AbstractCacheMap.java b/redisson/src/main/java/org/redisson/cache/AbstractCacheMap.java
similarity index 81%
rename from redisson/src/main/java/org/redisson/misc/AbstractCacheMap.java
rename to redisson/src/main/java/org/redisson/cache/AbstractCacheMap.java
index 75fecc81c..1741c6d25 100644
--- a/redisson/src/main/java/org/redisson/misc/AbstractCacheMap.java
+++ b/redisson/src/main/java/org/redisson/cache/AbstractCacheMap.java
@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.redisson.misc;
+package org.redisson.cache;
import java.util.AbstractCollection;
import java.util.AbstractMap.SimpleEntry;
@@ -37,56 +37,8 @@ import io.netty.util.internal.PlatformDependent;
*/
public abstract class AbstractCacheMap implements Cache {
- public static class CachedValue {
-
- private final Object key;
- private final Object value;
-
- long ttl;
- long maxIdleTime;
-
- long creationTime;
- long lastAccess;
-
- public CachedValue(Object key, Object value, long ttl, long maxIdleTime) {
- this.value = value;
- this.ttl = ttl;
- this.key = key;
- this.maxIdleTime = maxIdleTime;
- creationTime = System.currentTimeMillis();
- lastAccess = creationTime;
- }
-
- public boolean isExpired() {
- boolean result = false;
- long currentTime = System.currentTimeMillis();
- if (ttl != 0 && creationTime + ttl < currentTime) {
- result = true;
- }
- if (maxIdleTime != 0 && lastAccess + maxIdleTime < currentTime) {
- result = true;
- }
- return result;
- }
-
- public Object getKey() {
- return key;
- }
-
- public Object getValue() {
- lastAccess = System.currentTimeMillis();
- return value;
- }
-
- @Override
- public String toString() {
- return "CachedValue [key=" + key + ", value=" + value + "]";
- }
-
- }
-
final int size;
- final ConcurrentMap map = PlatformDependent.newConcurrentHashMap();
+ final ConcurrentMap> map = PlatformDependent.newConcurrentHashMap();
private final long timeToLiveInMillis;
private final long maxIdleInMillis;
@@ -100,11 +52,11 @@ public abstract class AbstractCacheMap implements Cache {
this.timeToLiveInMillis = timeToLiveInMillis;
}
- protected void onValueRead(CachedValue value) {
+ protected void onValueRead(CachedValue value) {
}
- protected void onValueRemove(CachedValue value) {
+ protected void onValueRemove(CachedValue value) {
}
@@ -137,7 +89,7 @@ public abstract class AbstractCacheMap implements Cache {
throw new NullPointerException();
}
- CachedValue entry = map.get(key);
+ CachedValue entry = map.get(key);
if (entry == null) {
return false;
}
@@ -161,8 +113,8 @@ public abstract class AbstractCacheMap implements Cache {
throw new NullPointerException();
}
- for (Map.Entry entry : map.entrySet()) {
- CachedValue cachedValue = entry.getValue();
+ for (Map.Entry> entry : map.entrySet()) {
+ CachedValue cachedValue = entry.getValue();
if (cachedValue.getValue().equals(value)) {
if (cachedValue.isExpired()) {
if (map.remove(cachedValue.getKey(), cachedValue)) {
@@ -187,7 +139,7 @@ public abstract class AbstractCacheMap implements Cache {
throw new NullPointerException();
}
- CachedValue entry = map.get(key);
+ CachedValue entry = map.get(key);
if (entry == null) {
return null;
}
@@ -201,8 +153,7 @@ public abstract class AbstractCacheMap implements Cache {
return readValue(entry);
}
- @SuppressWarnings("unchecked")
- protected V readValue(CachedValue entry) {
+ protected V readValue(CachedValue entry) {
onValueRead(entry);
return (V) entry.getValue();
}
@@ -216,17 +167,16 @@ public abstract class AbstractCacheMap implements Cache {
return put(key, value, timeToLiveInMillis, TimeUnit.MILLISECONDS, maxIdleInMillis, TimeUnit.MILLISECONDS);
}
- @SuppressWarnings("unchecked")
@Override
public V put(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit) {
- CachedValue entry = create(key, value, ttlUnit.toMillis(ttl), maxIdleUnit.toMillis(maxIdleTime));
+ CachedValue entry = create(key, value, ttlUnit.toMillis(ttl), maxIdleUnit.toMillis(maxIdleTime));
if (isFull(key)) {
if (!removeExpiredEntries()) {
onMapFull();
}
}
onValueCreate(entry);
- CachedValue prevCachedValue = map.put(key, entry);
+ CachedValue prevCachedValue = map.put(key, entry);
if (prevCachedValue != null) {
onValueRemove(prevCachedValue);
if (!prevCachedValue.isExpired()) {
@@ -236,17 +186,17 @@ public abstract class AbstractCacheMap implements Cache {
return null;
}
- protected CachedValue create(K key, V value, long ttl, long maxIdleTime) {
- return new CachedValue(key, value, ttl, maxIdleTime);
+ protected CachedValue create(K key, V value, long ttl, long maxIdleTime) {
+ return new StdCachedValue(key, value, ttl, maxIdleTime);
}
- protected void onValueCreate(CachedValue entry) {
+ protected void onValueCreate(CachedValue entry) {
}
- private boolean removeExpiredEntries() {
+ protected boolean removeExpiredEntries() {
boolean removed = false;
// TODO optimize
- for (CachedValue value : map.values()) {
+ for (CachedValue value : map.values()) {
if (value.isExpired()) {
if (map.remove(value.getKey(), value)) {
onValueRemove(value);
@@ -280,10 +230,9 @@ public abstract class AbstractCacheMap implements Cache {
* (non-Javadoc)
* @see java.util.Map#remove(java.lang.Object)
*/
- @SuppressWarnings("unchecked")
@Override
public V remove(Object key) {
- CachedValue entry = map.remove(key);
+ CachedValue entry = map.remove(key);
if (entry != null) {
onValueRemove(entry);
if (!entry.isExpired()) {
@@ -346,9 +295,9 @@ public abstract class AbstractCacheMap implements Cache {
abstract class MapIterator implements Iterator {
- final Iterator> keyIterator = map.entrySet().iterator();
+ final Iterator>> keyIterator = map.entrySet().iterator();
- Map.Entry mapEntry;
+ Map.Entry> mapEntry;
@Override
public boolean hasNext() {
@@ -357,7 +306,7 @@ public abstract class AbstractCacheMap implements Cache {
}
mapEntry = null;
while (keyIterator.hasNext()) {
- Map.Entry entry = keyIterator.next();
+ Map.Entry> entry = keyIterator.next();
if (entry.getValue().isExpired()) {
continue;
}
diff --git a/redisson/src/main/java/org/redisson/misc/Cache.java b/redisson/src/main/java/org/redisson/cache/Cache.java
similarity index 96%
rename from redisson/src/main/java/org/redisson/misc/Cache.java
rename to redisson/src/main/java/org/redisson/cache/Cache.java
index 2856da98b..87dcdd863 100644
--- a/redisson/src/main/java/org/redisson/misc/Cache.java
+++ b/redisson/src/main/java/org/redisson/cache/Cache.java
@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.redisson.misc;
+package org.redisson.cache;
import java.util.Map;
import java.util.concurrent.TimeUnit;
diff --git a/redisson/src/main/java/org/redisson/cache/CachedValue.java b/redisson/src/main/java/org/redisson/cache/CachedValue.java
new file mode 100644
index 000000000..069dbc331
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/cache/CachedValue.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.cache;
+
+/**
+ * Created by jribble on 2/20/17.
+ */
+public interface CachedValue {
+ boolean isExpired();
+
+ K getKey();
+
+ V getValue();
+}
diff --git a/redisson/src/main/java/org/redisson/cache/CachedValueReference.java b/redisson/src/main/java/org/redisson/cache/CachedValueReference.java
new file mode 100644
index 000000000..c6e0c4bfb
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/cache/CachedValueReference.java
@@ -0,0 +1,34 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.cache;
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+
+public class CachedValueReference extends SoftReference {
+
+ private final CachedValue owner;
+
+ public CachedValueReference(CachedValue owner, V referent, ReferenceQueue q) {
+ super(referent, q);
+ this.owner = owner;
+ }
+
+ public CachedValue getOwner() {
+ return owner;
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/misc/LFUCacheMap.java b/redisson/src/main/java/org/redisson/cache/LFUCacheMap.java
similarity index 97%
rename from redisson/src/main/java/org/redisson/misc/LFUCacheMap.java
rename to redisson/src/main/java/org/redisson/cache/LFUCacheMap.java
index 720b46088..c06b21e94 100644
--- a/redisson/src/main/java/org/redisson/misc/LFUCacheMap.java
+++ b/redisson/src/main/java/org/redisson/cache/LFUCacheMap.java
@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.redisson.misc;
+package org.redisson.cache;
import java.util.Map;
import java.util.concurrent.ConcurrentNavigableMap;
@@ -57,7 +57,7 @@ public class LFUCacheMap extends AbstractCacheMap {
}
- public static class LFUCachedValue extends CachedValue {
+ public static class LFUCachedValue extends StdCachedValue {
Long id;
long accessCount;
diff --git a/redisson/src/main/java/org/redisson/misc/LRUCacheMap.java b/redisson/src/main/java/org/redisson/cache/LRUCacheMap.java
similarity index 98%
rename from redisson/src/main/java/org/redisson/misc/LRUCacheMap.java
rename to redisson/src/main/java/org/redisson/cache/LRUCacheMap.java
index 8ba4368c1..d90ebf471 100644
--- a/redisson/src/main/java/org/redisson/misc/LRUCacheMap.java
+++ b/redisson/src/main/java/org/redisson/cache/LRUCacheMap.java
@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.redisson.misc;
+package org.redisson.cache;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
diff --git a/redisson/src/main/java/org/redisson/misc/NoneCacheMap.java b/redisson/src/main/java/org/redisson/cache/NoneCacheMap.java
similarity index 97%
rename from redisson/src/main/java/org/redisson/misc/NoneCacheMap.java
rename to redisson/src/main/java/org/redisson/cache/NoneCacheMap.java
index 9b71681f0..db6354222 100644
--- a/redisson/src/main/java/org/redisson/misc/NoneCacheMap.java
+++ b/redisson/src/main/java/org/redisson/cache/NoneCacheMap.java
@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.redisson.misc;
+package org.redisson.cache;
/**
*
diff --git a/redisson/src/main/java/org/redisson/cache/SoftCacheMap.java b/redisson/src/main/java/org/redisson/cache/SoftCacheMap.java
new file mode 100644
index 000000000..d861fb37c
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/cache/SoftCacheMap.java
@@ -0,0 +1,55 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.cache;
+
+import java.lang.ref.ReferenceQueue;
+
+/**
+ *
+ * @author Nikita Koksharov
+ *
+ * @param key
+ * @param value
+ */
+public class SoftCacheMap extends AbstractCacheMap {
+
+ private final ReferenceQueue queue = new ReferenceQueue();
+
+ public SoftCacheMap(long timeToLiveInMillis, long maxIdleInMillis) {
+ super(0, timeToLiveInMillis, maxIdleInMillis);
+ }
+
+ protected CachedValue create(K key, V value, long ttl, long maxIdleTime) {
+ return new SoftCachedValue(key, value, ttl, maxIdleTime, queue);
+ }
+
+ @Override
+ protected boolean removeExpiredEntries() {
+ while (true) {
+ CachedValueReference value = (CachedValueReference) queue.poll();
+ if (value == null) {
+ break;
+ }
+ map.remove(value.getOwner().getKey(), value.getOwner());
+ }
+ return super.removeExpiredEntries();
+ }
+
+ @Override
+ protected void onMapFull() {
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/cache/SoftCachedValue.java b/redisson/src/main/java/org/redisson/cache/SoftCachedValue.java
new file mode 100644
index 000000000..efdedc100
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/cache/SoftCachedValue.java
@@ -0,0 +1,39 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.cache;
+
+import java.lang.ref.ReferenceQueue;
+
+/**
+ * Created by jribble on 2/20/17.
+ */
+
+public class SoftCachedValue extends StdCachedValue implements CachedValue {
+
+ private final CachedValueReference ref;
+
+ public SoftCachedValue(K key, V value, long ttl, long maxIdleTime, ReferenceQueue queue) {
+ super(key, null, ttl, maxIdleTime);
+ this.ref = new CachedValueReference(this, value, queue);
+ }
+
+ @Override
+ public V getValue() {
+ super.getValue();
+ return ref.get();
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/cache/StdCachedValue.java b/redisson/src/main/java/org/redisson/cache/StdCachedValue.java
new file mode 100644
index 000000000..8d41abdf6
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/cache/StdCachedValue.java
@@ -0,0 +1,71 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.cache;
+
+/**
+ * Created by jribble on 2/20/17.
+ */
+
+public class StdCachedValue implements CachedValue {
+
+ protected final K key;
+ protected final V value;
+
+ long ttl;
+ long maxIdleTime;
+
+ long creationTime;
+ long lastAccess;
+
+ public StdCachedValue(K key, V value, long ttl, long maxIdleTime) {
+ this.value = value;
+ this.ttl = ttl;
+ this.key = key;
+ this.maxIdleTime = maxIdleTime;
+ creationTime = System.currentTimeMillis();
+ lastAccess = creationTime;
+ }
+
+ @Override
+ public boolean isExpired() {
+ boolean result = false;
+ long currentTime = System.currentTimeMillis();
+ if (ttl != 0 && creationTime + ttl < currentTime) {
+ result = true;
+ }
+ if (maxIdleTime != 0 && lastAccess + maxIdleTime < currentTime) {
+ result = true;
+ }
+ return result;
+ }
+
+ @Override
+ public K getKey() {
+ return key;
+ }
+
+ @Override
+ public V getValue() {
+ lastAccess = System.currentTimeMillis();
+ return value;
+ }
+
+ @Override
+ public String toString() {
+ return "CachedValue [key=" + key + ", value=" + value + "]";
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/client/RedisConnection.java b/redisson/src/main/java/org/redisson/client/RedisConnection.java
index 23c64625c..003324b2f 100644
--- a/redisson/src/main/java/org/redisson/client/RedisConnection.java
+++ b/redisson/src/main/java/org/redisson/client/RedisConnection.java
@@ -38,6 +38,11 @@ import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.FutureListener;
import io.netty.util.concurrent.ScheduledFuture;
+/**
+ *
+ * @author Nikita Koksharov
+ *
+ */
public class RedisConnection implements RedisCommands {
private static final AttributeKey CONNECTION = AttributeKey.valueOf("connection");
diff --git a/redisson/src/main/java/org/redisson/client/RedisPubSubConnection.java b/redisson/src/main/java/org/redisson/client/RedisPubSubConnection.java
index 7103d1af0..ea8566ed2 100644
--- a/redisson/src/main/java/org/redisson/client/RedisPubSubConnection.java
+++ b/redisson/src/main/java/org/redisson/client/RedisPubSubConnection.java
@@ -40,6 +40,11 @@ import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.FutureListener;
import io.netty.util.internal.PlatformDependent;
+/**
+ *
+ * @author Nikita Koksharov
+ *
+ */
public class RedisPubSubConnection extends RedisConnection {
final Queue> listeners = new ConcurrentLinkedQueue>();
diff --git a/redisson/src/main/java/org/redisson/client/handler/CommandDecoder.java b/redisson/src/main/java/org/redisson/client/handler/CommandDecoder.java
index b5024789f..b2411e589 100644
--- a/redisson/src/main/java/org/redisson/client/handler/CommandDecoder.java
+++ b/redisson/src/main/java/org/redisson/client/handler/CommandDecoder.java
@@ -184,7 +184,7 @@ public class CommandDecoder extends ReplayingDecoder {
CommandsData commandBatch) {
int i = state().getBatchIndex();
- RedisException error = null;
+ Throwable error = null;
while (in.writerIndex() > in.readerIndex()) {
CommandData cmd = null;
try {
@@ -192,12 +192,12 @@ public class CommandDecoder extends ReplayingDecoder {
state().setBatchIndex(i);
cmd = (CommandData) commandBatch.getCommands().get(i);
decode(in, cmd, null, ctx.channel());
- i++;
- } catch (IOException e) {
+ } catch (Exception e) {
cmd.tryFailure(e);
}
+ i++;
if (!cmd.isSuccess()) {
- error = (RedisException) cmd.cause();
+ error = cmd.cause();
}
}
diff --git a/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java b/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java
index 8ba7e5996..8eaf72bef 100644
--- a/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java
+++ b/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java
@@ -278,7 +278,7 @@ public interface RedisCommands {
RedisCommand SET = new RedisCommand("SET", new VoidReplayConvertor(), 2);
RedisCommand SETPXNX = new RedisCommand("SET", new BooleanNotNullReplayConvertor(), 2);
RedisCommand SETNX = new RedisCommand("SETNX", new BooleanReplayConvertor(), 2);
- RedisCommand SETEX = new RedisCommand("SETEX", new VoidReplayConvertor(), 3);
+ RedisCommand PSETEX = new RedisCommand("PSETEX", new VoidReplayConvertor(), 3);
RedisStrictCommand EXISTS_LONG = new RedisStrictCommand("EXISTS");
RedisStrictCommand EXISTS = new RedisStrictCommand("EXISTS", new BooleanReplayConvertor());
diff --git a/redisson/src/main/java/org/redisson/cluster/ClusterConnectionManager.java b/redisson/src/main/java/org/redisson/cluster/ClusterConnectionManager.java
index e6c5f7b8b..4c4ee586d 100644
--- a/redisson/src/main/java/org/redisson/cluster/ClusterConnectionManager.java
+++ b/redisson/src/main/java/org/redisson/cluster/ClusterConnectionManager.java
@@ -671,7 +671,7 @@ public class ClusterConnectionManager extends MasterSlaveConnectionManager {
private Collection parsePartitions(List nodes) {
Map partitions = new HashMap();
for (ClusterNodeInfo clusterNodeInfo : nodes) {
- if (clusterNodeInfo.containsFlag(Flag.NOADDR)) {
+ if (clusterNodeInfo.containsFlag(Flag.NOADDR) || clusterNodeInfo.containsFlag(Flag.HANDSHAKE)) {
// skip it
continue;
}
diff --git a/redisson/src/main/java/org/redisson/codec/AvroJacksonCodec.java b/redisson/src/main/java/org/redisson/codec/AvroJacksonCodec.java
index 4994bbd64..cfe4fd526 100644
--- a/redisson/src/main/java/org/redisson/codec/AvroJacksonCodec.java
+++ b/redisson/src/main/java/org/redisson/codec/AvroJacksonCodec.java
@@ -15,8 +15,16 @@
*/
package org.redisson.codec;
+import java.io.IOException;
+import java.io.InputStream;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.avro.AvroFactory;
+import com.fasterxml.jackson.dataformat.avro.AvroMapper;
+import com.fasterxml.jackson.dataformat.avro.AvroSchema;
/**
* Avro binary codec
@@ -26,12 +34,42 @@ import com.fasterxml.jackson.dataformat.avro.AvroFactory;
*/
public class AvroJacksonCodec extends JsonJacksonCodec {
- public AvroJacksonCodec() {
- super(new ObjectMapper(new AvroFactory()));
+ public static class AvroExtendedMapper extends AvroMapper {
+
+ private static final long serialVersionUID = -560070554221164163L;
+
+ private final AvroSchema schema;
+ private final Class type;
+
+ public AvroExtendedMapper(Class type, AvroSchema schema) {
+ super();
+ this.type = type;
+ this.schema = schema;
+ }
+
+ @Override
+ public byte[] writeValueAsBytes(Object value) throws JsonProcessingException {
+ return writerFor(type).with(schema).writeValueAsBytes(value);
+ }
+
+ @Override
+ public T readValue(InputStream src, Class valueType)
+ throws IOException, JsonParseException, JsonMappingException {
+ return readerFor(type).with(schema).readValue(src);
+ }
+
+ }
+
+ public AvroJacksonCodec(Class type, AvroSchema schema) {
+ super(new AvroExtendedMapper(type, schema));
}
public AvroJacksonCodec(ClassLoader classLoader) {
super(createObjectMapper(classLoader, new ObjectMapper(new AvroFactory())));
}
+ @Override
+ protected void initTypeInclusion(ObjectMapper mapObjectMapper) {
+ }
+
}
diff --git a/redisson/src/main/java/org/redisson/codec/JsonJacksonCodec.java b/redisson/src/main/java/org/redisson/codec/JsonJacksonCodec.java
index 98976b9f0..f31482fa7 100755
--- a/redisson/src/main/java/org/redisson/codec/JsonJacksonCodec.java
+++ b/redisson/src/main/java/org/redisson/codec/JsonJacksonCodec.java
@@ -93,7 +93,10 @@ public class JsonJacksonCodec implements Codec {
public JsonJacksonCodec(ObjectMapper mapObjectMapper) {
this.mapObjectMapper = mapObjectMapper;
init(mapObjectMapper);
- // type info inclusion
+ initTypeInclusion(mapObjectMapper);
+ }
+
+ protected void initTypeInclusion(ObjectMapper mapObjectMapper) {
TypeResolverBuilder mapTyper = new DefaultTypeResolverBuilder(DefaultTyping.NON_FINAL) {
public boolean useForType(JavaType t) {
switch (_appliesFor) {
diff --git a/redisson/src/main/java/org/redisson/config/BaseMasterSlaveServersConfig.java b/redisson/src/main/java/org/redisson/config/BaseMasterSlaveServersConfig.java
index 9965501c8..bdc5d7312 100644
--- a/redisson/src/main/java/org/redisson/config/BaseMasterSlaveServersConfig.java
+++ b/redisson/src/main/java/org/redisson/config/BaseMasterSlaveServersConfig.java
@@ -31,16 +31,6 @@ public class BaseMasterSlaveServersConfigeach slave node
- */
- private int slaveSubscriptionConnectionMinimumIdleSize = 1;
-
- /**
- * Redis 'slave' node maximum subscription (pub/sub) connection pool size for each slave node
- */
- private int slaveSubscriptionConnectionPoolSize = 50;
-
/**
* Redis 'slave' node minimum idle connection amount for each slave node
*/
@@ -62,6 +52,18 @@ public class BaseMasterSlaveServersConfigeach slave node
+ */
+ private int subscriptionConnectionMinimumIdleSize = 1;
+
+ /**
+ * Redis 'slave' node maximum subscription (pub/sub) connection pool size for each slave node
+ */
+ private int subscriptionConnectionPoolSize = 50;
public BaseMasterSlaveServersConfig() {
}
@@ -71,11 +73,12 @@ public class BaseMasterSlaveServersConfigeach slave node
*
* Default is 50
*
- * @see #setSlaveSubscriptionConnectionMinimumIdleSize(int)
+ * @see #setSubscriptionConnectionMinimumIdleSize(int)
*
- * @param slaveSubscriptionConnectionPoolSize - pool size
+ * @param subscriptionConnectionPoolSize - pool size
* @return config
*/
- public T setSlaveSubscriptionConnectionPoolSize(int slaveSubscriptionConnectionPoolSize) {
- this.slaveSubscriptionConnectionPoolSize = slaveSubscriptionConnectionPoolSize;
+ public T setSubscriptionConnectionPoolSize(int subscriptionConnectionPoolSize) {
+ this.subscriptionConnectionPoolSize = subscriptionConnectionPoolSize;
return (T)this;
}
- public int getSlaveSubscriptionConnectionPoolSize() {
- return slaveSubscriptionConnectionPoolSize;
+ public int getSubscriptionConnectionPoolSize() {
+ return subscriptionConnectionPoolSize;
}
+
/**
* Redis 'slave' node minimum idle connection amount for each slave node
*
@@ -188,24 +207,40 @@ public class BaseMasterSlaveServersConfigeach slave node.
*
* Default is 1
*
- * @see #setSlaveSubscriptionConnectionPoolSize(int)
+ * @see #setSubscriptionConnectionPoolSize(int)
*
- * @param slaveSubscriptionConnectionMinimumIdleSize - pool size
+ * @param subscriptionConnectionMinimumIdleSize - pool size
* @return config
*/
- public T setSlaveSubscriptionConnectionMinimumIdleSize(int slaveSubscriptionConnectionMinimumIdleSize) {
- this.slaveSubscriptionConnectionMinimumIdleSize = slaveSubscriptionConnectionMinimumIdleSize;
+ public T setSubscriptionConnectionMinimumIdleSize(int subscriptionConnectionMinimumIdleSize) {
+ this.subscriptionConnectionMinimumIdleSize = subscriptionConnectionMinimumIdleSize;
return (T) this;
}
- public int getSlaveSubscriptionConnectionMinimumIdleSize() {
- return slaveSubscriptionConnectionMinimumIdleSize;
+ public int getSubscriptionConnectionMinimumIdleSize() {
+ return subscriptionConnectionMinimumIdleSize;
}
+
/**
* Set node type used for read operation.
*
@@ -222,4 +257,21 @@ public class BaseMasterSlaveServersConfig
+ * Default is SLAVE
+ *
+ * @param subscriptionMode param
+ * @return config
+ */
+ public T setSubscriptionMode(SubscriptionMode subscriptionMode) {
+ this.subscriptionMode = subscriptionMode;
+ return (T) this;
+ }
+ public SubscriptionMode getSubscriptionMode() {
+ return subscriptionMode;
+ }
+
+
}
diff --git a/redisson/src/main/java/org/redisson/config/Config.java b/redisson/src/main/java/org/redisson/config/Config.java
index 233778dc0..e5c74e387 100644
--- a/redisson/src/main/java/org/redisson/config/Config.java
+++ b/redisson/src/main/java/org/redisson/config/Config.java
@@ -556,12 +556,24 @@ public class Config {
* Read config object stored in JSON format from File
*
* @param file object
+ * @param classLoader class loader
* @return config
* @throws IOException error
*/
- public static Config fromJSON(File file) throws IOException {
+ public static Config fromJSON(File file, ClassLoader classLoader) throws IOException {
ConfigSupport support = new ConfigSupport();
- return support.fromJSON(file, Config.class);
+ return support.fromJSON(file, Config.class, classLoader);
+ }
+
+ /**
+ * Read config object stored in JSON format from File
+ *
+ * @param file object
+ * @return config
+ * @throws IOException error
+ */
+ public static Config fromJSON(File file) throws IOException {
+ return fromJSON(file, null);
}
/**
@@ -631,8 +643,12 @@ public class Config {
* @throws IOException error
*/
public static Config fromYAML(File file) throws IOException {
+ return fromYAML(file, null);
+ }
+
+ public static Config fromYAML(File file, ClassLoader classLoader) throws IOException {
ConfigSupport support = new ConfigSupport();
- return support.fromYAML(file, Config.class);
+ return support.fromYAML(file, Config.class, classLoader);
}
/**
diff --git a/redisson/src/main/java/org/redisson/config/ConfigSupport.java b/redisson/src/main/java/org/redisson/config/ConfigSupport.java
index 8d08feb1d..7c55bb5e4 100644
--- a/redisson/src/main/java/org/redisson/config/ConfigSupport.java
+++ b/redisson/src/main/java/org/redisson/config/ConfigSupport.java
@@ -26,13 +26,16 @@ import java.util.List;
import org.redisson.api.RedissonNodeInitializer;
import org.redisson.client.codec.Codec;
import org.redisson.cluster.ClusterConnectionManager;
+import org.redisson.codec.CodecProvider;
import org.redisson.connection.ConnectionManager;
import org.redisson.connection.ElasticacheConnectionManager;
-import org.redisson.connection.ReplicatedConnectionManager;
import org.redisson.connection.MasterSlaveConnectionManager;
+import org.redisson.connection.ReplicatedConnectionManager;
import org.redisson.connection.SentinelConnectionManager;
import org.redisson.connection.SingleConnectionManager;
import org.redisson.connection.balancer.LoadBalancer;
+import org.redisson.liveobject.provider.ResolverProvider;
+import org.redisson.misc.URLBuilder;
import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.annotation.JsonIgnore;
@@ -45,10 +48,8 @@ import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
+import com.fasterxml.jackson.databind.type.TypeFactory;
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
-import org.redisson.codec.CodecProvider;
-import org.redisson.liveobject.provider.ResolverProvider;
-import org.redisson.misc.URLBuilder;
/**
*
@@ -118,8 +119,8 @@ public class ConfigSupport {
}
- private final ObjectMapper jsonMapper = createMapper(null);
- private final ObjectMapper yamlMapper = createMapper(new YAMLFactory());
+ private ObjectMapper jsonMapper = createMapper(null, null);
+ private ObjectMapper yamlMapper = createMapper(new YAMLFactory(), null);
public T fromJSON(String content, Class configType) throws IOException {
URLBuilder.replaceURLFactory();
@@ -131,8 +132,13 @@ public class ConfigSupport {
}
public T fromJSON(File file, Class configType) throws IOException {
+ return fromJSON(file, configType, null);
+ }
+
+ public T fromJSON(File file, Class configType, ClassLoader classLoader) throws IOException {
URLBuilder.replaceURLFactory();
try {
+ jsonMapper = createMapper(null, classLoader);
return jsonMapper.readValue(file, configType);
} finally {
URLBuilder.restoreURLFactory();
@@ -192,6 +198,17 @@ public class ConfigSupport {
URLBuilder.restoreURLFactory();
}
}
+
+ public T fromYAML(File file, Class configType, ClassLoader classLoader) throws IOException {
+ URLBuilder.replaceURLFactory();
+ try {
+ yamlMapper = createMapper(new YAMLFactory(), classLoader);
+ return yamlMapper.readValue(file, configType);
+ } finally {
+ URLBuilder.restoreURLFactory();
+ }
+ }
+
public T fromYAML(URL url, Class configType) throws IOException {
URLBuilder.replaceURLFactory();
@@ -266,12 +283,12 @@ public class ConfigSupport {
if (config.getMasterConnectionPoolSize() < config.getMasterConnectionMinimumIdleSize()) {
throw new IllegalArgumentException("masterConnectionPoolSize can't be lower than masterConnectionMinimumIdleSize");
}
- if (config.getSlaveSubscriptionConnectionPoolSize() < config.getSlaveSubscriptionConnectionMinimumIdleSize()) {
+ if (config.getSubscriptionConnectionPoolSize() < config.getSubscriptionConnectionMinimumIdleSize()) {
throw new IllegalArgumentException("slaveSubscriptionConnectionMinimumIdleSize can't be lower than slaveSubscriptionConnectionPoolSize");
}
}
- private ObjectMapper createMapper(JsonFactory mapping) {
+ private ObjectMapper createMapper(JsonFactory mapping, ClassLoader classLoader) {
ObjectMapper mapper = new ObjectMapper(mapping);
mapper.addMixIn(MasterSlaveServersConfig.class, MasterSlaveServersConfigMixIn.class);
mapper.addMixIn(SingleServerConfig.class, SingleSeverConfigMixIn.class);
@@ -285,6 +302,13 @@ public class ConfigSupport {
.addFilter("classFilter", SimpleBeanPropertyFilter.filterOutAllExcept());
mapper.setFilterProvider(filterProvider);
mapper.setSerializationInclusion(Include.NON_NULL);
+
+ if (classLoader != null) {
+ TypeFactory tf = TypeFactory.defaultInstance()
+ .withClassLoader(classLoader);
+ mapper.setTypeFactory(tf);
+ }
+
return mapper;
}
diff --git a/redisson/src/main/java/org/redisson/config/ReadMode.java b/redisson/src/main/java/org/redisson/config/ReadMode.java
index 51cfe3421..320c7dc82 100644
--- a/redisson/src/main/java/org/redisson/config/ReadMode.java
+++ b/redisson/src/main/java/org/redisson/config/ReadMode.java
@@ -15,6 +15,11 @@
*/
package org.redisson.config;
+/**
+ *
+ * @author Nikita Koksharov
+ *
+ */
public enum ReadMode {
/**
diff --git a/redisson/src/main/java/org/redisson/config/SubscriptionMode.java b/redisson/src/main/java/org/redisson/config/SubscriptionMode.java
new file mode 100644
index 000000000..ec1f0495c
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/config/SubscriptionMode.java
@@ -0,0 +1,35 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.config;
+
+/**
+ *
+ * @author Nikita Koksharov
+ *
+ */
+public enum SubscriptionMode {
+
+ /**
+ * Subscribe to slave nodes
+ */
+ SLAVE,
+
+ /**
+ * Subscribe to master node
+ */
+ MASTER
+
+}
diff --git a/redisson/src/main/java/org/redisson/connection/CountListener.java b/redisson/src/main/java/org/redisson/connection/CountListener.java
new file mode 100644
index 000000000..ec449beb3
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/connection/CountListener.java
@@ -0,0 +1,64 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.connection;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.redisson.api.RFuture;
+import org.redisson.misc.RPromise;
+import org.redisson.misc.RedissonPromise;
+
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.FutureListener;
+
+/**
+ *
+ * @author Nikita Koksharov
+ *
+ */
+public class CountListener implements FutureListener {
+
+ private final RPromise res;
+
+ private final AtomicInteger counter;
+
+ public static RPromise create(RFuture... futures) {
+ RPromise result = new RedissonPromise();
+ FutureListener listener = new CountListener(result, futures.length);
+ for (RFuture future : futures) {
+ future.addListener(listener);
+ }
+ return result;
+ }
+
+ public CountListener(RPromise res, int amount) {
+ super();
+ this.res = res;
+ this.counter = new AtomicInteger(amount);
+ }
+
+ @Override
+ public void operationComplete(Future future) throws Exception {
+ if (!future.isSuccess()) {
+ res.tryFailure(future.cause());
+ return;
+ }
+ if (counter.decrementAndGet() == 0) {
+ res.trySuccess(null);
+ }
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/connection/MasterSlaveConnectionManager.java b/redisson/src/main/java/org/redisson/connection/MasterSlaveConnectionManager.java
index 1069f2885..de0392b13 100644
--- a/redisson/src/main/java/org/redisson/connection/MasterSlaveConnectionManager.java
+++ b/redisson/src/main/java/org/redisson/connection/MasterSlaveConnectionManager.java
@@ -320,7 +320,7 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
c.setClientName(cfg.getClientName());
c.setMasterConnectionPoolSize(cfg.getMasterConnectionPoolSize());
c.setSlaveConnectionPoolSize(cfg.getSlaveConnectionPoolSize());
- c.setSlaveSubscriptionConnectionPoolSize(cfg.getSlaveSubscriptionConnectionPoolSize());
+ c.setSubscriptionConnectionPoolSize(cfg.getSubscriptionConnectionPoolSize());
c.setSubscriptionsPerConnection(cfg.getSubscriptionsPerConnection());
c.setConnectTimeout(cfg.getConnectTimeout());
c.setIdleConnectionTimeout(cfg.getIdleConnectionTimeout());
@@ -329,8 +329,9 @@ public class MasterSlaveConnectionManager implements ConnectionManager {
c.setReconnectionTimeout(cfg.getReconnectionTimeout());
c.setMasterConnectionMinimumIdleSize(cfg.getMasterConnectionMinimumIdleSize());
c.setSlaveConnectionMinimumIdleSize(cfg.getSlaveConnectionMinimumIdleSize());
- c.setSlaveSubscriptionConnectionMinimumIdleSize(cfg.getSlaveSubscriptionConnectionMinimumIdleSize());
+ c.setSubscriptionConnectionMinimumIdleSize(cfg.getSubscriptionConnectionMinimumIdleSize());
c.setReadMode(cfg.getReadMode());
+ c.setSubscriptionMode(cfg.getSubscriptionMode());
return c;
}
diff --git a/redisson/src/main/java/org/redisson/connection/MasterSlaveEntry.java b/redisson/src/main/java/org/redisson/connection/MasterSlaveEntry.java
index e8d940300..2fab36ea6 100644
--- a/redisson/src/main/java/org/redisson/connection/MasterSlaveEntry.java
+++ b/redisson/src/main/java/org/redisson/connection/MasterSlaveEntry.java
@@ -37,9 +37,11 @@ import org.redisson.client.protocol.RedisCommands;
import org.redisson.cluster.ClusterSlotRange;
import org.redisson.config.MasterSlaveServersConfig;
import org.redisson.config.ReadMode;
+import org.redisson.config.SubscriptionMode;
import org.redisson.connection.ClientConnectionsEntry.FreezeReason;
import org.redisson.connection.balancer.LoadBalancerManager;
import org.redisson.connection.pool.MasterConnectionPool;
+import org.redisson.connection.pool.MasterPubSubConnectionPool;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -65,6 +67,8 @@ public class MasterSlaveEntry {
final MasterConnectionPool writeConnectionHolder;
final Set slots = new HashSet();
+
+ final MasterPubSubConnectionPool pubSubConnectionHolder;
final AtomicBoolean active = new AtomicBoolean(true);
@@ -79,6 +83,7 @@ public class MasterSlaveEntry {
slaveBalancer = new LoadBalancerManager(config, connectionManager, this);
writeConnectionHolder = new MasterConnectionPool(config, connectionManager, this);
+ pubSubConnectionHolder = new MasterPubSubConnectionPool(config, connectionManager, this);
}
public List> initSlaveBalancer(Collection disconnectedNodes) {
@@ -98,8 +103,20 @@ public class MasterSlaveEntry {
public RFuture setupMasterEntry(String host, int port) {
RedisClient client = connectionManager.createClient(NodeType.MASTER, host, port);
- masterEntry = new ClientConnectionsEntry(client, config.getMasterConnectionMinimumIdleSize(), config.getMasterConnectionPoolSize(),
- 0, 0, connectionManager, NodeType.MASTER);
+ masterEntry = new ClientConnectionsEntry(
+ client,
+ config.getMasterConnectionMinimumIdleSize(),
+ config.getMasterConnectionPoolSize(),
+ config.getSubscriptionConnectionMinimumIdleSize(),
+ config.getSubscriptionConnectionPoolSize(),
+ connectionManager,
+ NodeType.MASTER);
+
+ if (config.getSubscriptionMode() == SubscriptionMode.MASTER) {
+ RFuture f = writeConnectionHolder.add(masterEntry);
+ RFuture s = pubSubConnectionHolder.add(masterEntry);
+ return CountListener.create(s, f);
+ }
return writeConnectionHolder.add(masterEntry);
}
@@ -307,8 +324,8 @@ public class MasterSlaveEntry {
ClientConnectionsEntry entry = new ClientConnectionsEntry(client,
this.config.getSlaveConnectionMinimumIdleSize(),
this.config.getSlaveConnectionPoolSize(),
- this.config.getSlaveSubscriptionConnectionMinimumIdleSize(),
- this.config.getSlaveSubscriptionConnectionPoolSize(), connectionManager, mode);
+ this.config.getSubscriptionConnectionMinimumIdleSize(),
+ this.config.getSubscriptionConnectionPoolSize(), connectionManager, mode);
if (freezed) {
synchronized (entry) {
entry.setFreezed(freezed);
@@ -352,6 +369,7 @@ public class MasterSlaveEntry {
@Override
public void operationComplete(Future future) throws Exception {
writeConnectionHolder.remove(oldMaster);
+ pubSubConnectionHolder.remove(oldMaster);
slaveDown(oldMaster, FreezeReason.MANAGER);
// more than one slave available, so master can be removed from slaves
@@ -406,10 +424,18 @@ public class MasterSlaveEntry {
}
RFuture nextPubSubConnection() {
+ if (config.getSubscriptionMode() == SubscriptionMode.MASTER) {
+ return pubSubConnectionHolder.get();
+ }
+
return slaveBalancer.nextPubSubConnection();
}
public void returnPubSubConnection(PubSubConnectionEntry entry) {
+ if (config.getSubscriptionMode() == SubscriptionMode.MASTER) {
+ pubSubConnectionHolder.returnConnection(masterEntry, entry.getConnection());
+ return;
+ }
slaveBalancer.returnPubSubConnection(entry.getConnection());
}
diff --git a/redisson/src/main/java/org/redisson/connection/SingleConnectionManager.java b/redisson/src/main/java/org/redisson/connection/SingleConnectionManager.java
index 8cb088bf3..b965b54b4 100644
--- a/redisson/src/main/java/org/redisson/connection/SingleConnectionManager.java
+++ b/redisson/src/main/java/org/redisson/connection/SingleConnectionManager.java
@@ -25,6 +25,7 @@ import org.redisson.config.Config;
import org.redisson.config.MasterSlaveServersConfig;
import org.redisson.config.ReadMode;
import org.redisson.config.SingleServerConfig;
+import org.redisson.config.SubscriptionMode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -71,15 +72,16 @@ public class SingleConnectionManager extends MasterSlaveConnectionManager {
newconfig.setMasterAddress(addr);
newconfig.setMasterConnectionPoolSize(cfg.getConnectionPoolSize());
newconfig.setSubscriptionsPerConnection(cfg.getSubscriptionsPerConnection());
- newconfig.setSlaveSubscriptionConnectionPoolSize(cfg.getSubscriptionConnectionPoolSize());
+ newconfig.setSubscriptionConnectionPoolSize(cfg.getSubscriptionConnectionPoolSize());
newconfig.setConnectTimeout(cfg.getConnectTimeout());
newconfig.setIdleConnectionTimeout(cfg.getIdleConnectionTimeout());
newconfig.setFailedAttempts(cfg.getFailedAttempts());
newconfig.setReconnectionTimeout(cfg.getReconnectionTimeout());
newconfig.setMasterConnectionMinimumIdleSize(cfg.getConnectionMinimumIdleSize());
- newconfig.setSlaveSubscriptionConnectionMinimumIdleSize(cfg.getSubscriptionConnectionMinimumIdleSize());
+ newconfig.setSubscriptionConnectionMinimumIdleSize(cfg.getSubscriptionConnectionMinimumIdleSize());
newconfig.setReadMode(ReadMode.MASTER);
+ newconfig.setSubscriptionMode(SubscriptionMode.MASTER);
return newconfig;
}
diff --git a/redisson/src/main/java/org/redisson/connection/SingleEntry.java b/redisson/src/main/java/org/redisson/connection/SingleEntry.java
index c5b0c7a5a..5fffe82f6 100644
--- a/redisson/src/main/java/org/redisson/connection/SingleEntry.java
+++ b/redisson/src/main/java/org/redisson/connection/SingleEntry.java
@@ -17,69 +17,22 @@ package org.redisson.connection;
import java.net.InetSocketAddress;
import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
-import org.redisson.api.NodeType;
import org.redisson.api.RFuture;
-import org.redisson.client.RedisClient;
import org.redisson.client.RedisConnection;
-import org.redisson.client.RedisPubSubConnection;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.cluster.ClusterSlotRange;
import org.redisson.config.MasterSlaveServersConfig;
-import org.redisson.connection.pool.PubSubConnectionPool;
-import org.redisson.connection.pool.SinglePubSubConnectionPool;
-import org.redisson.misc.RPromise;
-
-import io.netty.util.concurrent.Future;
-import io.netty.util.concurrent.FutureListener;
+/**
+ *
+ * @author Nikita Koksharov
+ *
+ */
public class SingleEntry extends MasterSlaveEntry {
- final PubSubConnectionPool pubSubConnectionHolder;
-
public SingleEntry(Set slotRanges, ConnectionManager connectionManager, MasterSlaveServersConfig config) {
super(slotRanges, connectionManager, config);
- pubSubConnectionHolder = new SinglePubSubConnectionPool(config, connectionManager, this);
- }
-
- @Override
- public RFuture setupMasterEntry(String host, int port) {
- RedisClient masterClient = connectionManager.createClient(NodeType.MASTER, host, port);
- masterEntry = new ClientConnectionsEntry(masterClient,
- config.getMasterConnectionMinimumIdleSize(),
- config.getMasterConnectionPoolSize(),
- config.getSlaveConnectionMinimumIdleSize(),
- config.getSlaveSubscriptionConnectionPoolSize(), connectionManager, NodeType.MASTER);
- final RPromise res = connectionManager.newPromise();
- RFuture f = writeConnectionHolder.add(masterEntry);
- RFuture s = pubSubConnectionHolder.add(masterEntry);
- FutureListener listener = new FutureListener() {
- AtomicInteger counter = new AtomicInteger(2);
- @Override
- public void operationComplete(Future future) throws Exception {
- if (!future.isSuccess()) {
- res.tryFailure(future.cause());
- return;
- }
- if (counter.decrementAndGet() == 0) {
- res.trySuccess(null);
- }
- }
- };
- f.addListener(listener);
- s.addListener(listener);
- return res;
- }
-
- @Override
- RFuture nextPubSubConnection() {
- return pubSubConnectionHolder.get();
- }
-
- @Override
- public void returnPubSubConnection(PubSubConnectionEntry entry) {
- pubSubConnectionHolder.returnConnection(masterEntry, entry.getConnection());
}
@Override
diff --git a/redisson/src/main/java/org/redisson/connection/pool/SinglePubSubConnectionPool.java b/redisson/src/main/java/org/redisson/connection/pool/MasterPubSubConnectionPool.java
similarity index 83%
rename from redisson/src/main/java/org/redisson/connection/pool/SinglePubSubConnectionPool.java
rename to redisson/src/main/java/org/redisson/connection/pool/MasterPubSubConnectionPool.java
index 08741a488..00cbac51d 100644
--- a/redisson/src/main/java/org/redisson/connection/pool/SinglePubSubConnectionPool.java
+++ b/redisson/src/main/java/org/redisson/connection/pool/MasterPubSubConnectionPool.java
@@ -26,15 +26,20 @@ import org.redisson.connection.MasterSlaveEntry;
* @author Nikita Koksharov
*
*/
-public class SinglePubSubConnectionPool extends PubSubConnectionPool {
+public class MasterPubSubConnectionPool extends PubSubConnectionPool {
- public SinglePubSubConnectionPool(MasterSlaveServersConfig config, ConnectionManager connectionManager,
+ public MasterPubSubConnectionPool(MasterSlaveServersConfig config, ConnectionManager connectionManager,
MasterSlaveEntry masterSlaveEntry) {
super(config, connectionManager, masterSlaveEntry);
}
+ @Override
protected ClientConnectionsEntry getEntry() {
return entries.get(0);
}
+ public void remove(ClientConnectionsEntry entry) {
+ entries.remove(entry);
+ }
+
}
diff --git a/redisson/src/main/java/org/redisson/connection/pool/PubSubConnectionPool.java b/redisson/src/main/java/org/redisson/connection/pool/PubSubConnectionPool.java
index 859623a9b..7051d55a6 100644
--- a/redisson/src/main/java/org/redisson/connection/pool/PubSubConnectionPool.java
+++ b/redisson/src/main/java/org/redisson/connection/pool/PubSubConnectionPool.java
@@ -47,7 +47,7 @@ public class PubSubConnectionPool extends ConnectionPool
@Override
protected int getMinimumIdleSize(ClientConnectionsEntry entry) {
- return config.getSlaveSubscriptionConnectionMinimumIdleSize();
+ return config.getSubscriptionConnectionMinimumIdleSize();
}
@Override
diff --git a/redisson/src/main/java/org/redisson/misc/URLBuilder.java b/redisson/src/main/java/org/redisson/misc/URLBuilder.java
index f27c189db..4a7e0291b 100644
--- a/redisson/src/main/java/org/redisson/misc/URLBuilder.java
+++ b/redisson/src/main/java/org/redisson/misc/URLBuilder.java
@@ -33,7 +33,36 @@ public class URLBuilder {
private static URLStreamHandlerFactory currentFactory;
- public static void restoreURLFactory() {
+ private final static URLStreamHandlerFactory newFactory = new URLStreamHandlerFactory() {
+ @Override
+ public URLStreamHandler createURLStreamHandler(String protocol) {
+ if ("redis".equals(protocol)) {
+ return new URLStreamHandler() {
+ @Override
+ protected URLConnection openConnection(URL u) throws IOException {
+ throw new UnsupportedOperationException();
+ };
+
+ @Override
+ protected boolean equals(URL u1, URL u2) {
+ return u1.toString().equals(u2.toString());
+ }
+
+ @Override
+ protected int hashCode(URL u) {
+ return u.toString().hashCode();
+ }
+ };
+ }
+
+ if (currentFactory != null) {
+ return currentFactory.createURLStreamHandler(protocol);
+ }
+ return null;
+ }
+ };
+
+ public static synchronized void restoreURLFactory() {
try {
Field field = URL.class.getDeclaredField("factory");
field.setAccessible(true);
@@ -43,43 +72,20 @@ public class URLBuilder {
}
}
- public static void replaceURLFactory() {
+ public static synchronized void replaceURLFactory() {
try {
Field field = URL.class.getDeclaredField("factory");
field.setAccessible(true);
currentFactory = (URLStreamHandlerFactory) field.get(null);
- if (currentFactory != null) {
+ if (currentFactory != null && currentFactory != newFactory) {
field.set(null, null);
}
- URL.setURLStreamHandlerFactory(new URLStreamHandlerFactory() {
- @Override
- public URLStreamHandler createURLStreamHandler(String protocol) {
- if ("redis".equals(protocol)) {
- return new URLStreamHandler() {
- @Override
- protected URLConnection openConnection(URL u) throws IOException {
- throw new UnsupportedOperationException();
- };
-
- @Override
- protected boolean equals(URL u1, URL u2) {
- return u1.toString().equals(u2.toString());
- }
-
- @Override
- protected int hashCode(URL u) {
- return u.toString().hashCode();
- }
- };
- }
-
- if (currentFactory != null) {
- return currentFactory.createURLStreamHandler(protocol);
- }
- return null;
- }
- });
+ if (currentFactory != newFactory) {
+ URL.setURLStreamHandlerFactory(newFactory);
+ } else {
+ currentFactory = null;
+ }
} catch (Exception e) {
throw new IllegalStateException(e);
}
diff --git a/redisson/src/main/java/org/redisson/pubsub/PublishSubscribe.java b/redisson/src/main/java/org/redisson/pubsub/PublishSubscribe.java
index d15bec4c0..eb9a0fce1 100644
--- a/redisson/src/main/java/org/redisson/pubsub/PublishSubscribe.java
+++ b/redisson/src/main/java/org/redisson/pubsub/PublishSubscribe.java
@@ -34,7 +34,6 @@ import io.netty.util.internal.PlatformDependent;
*
* @author Nikita Koksharov
*
- * @param
*/
abstract class PublishSubscribe> {
diff --git a/redisson/src/main/java/org/redisson/reactive/RedissonBucketReactive.java b/redisson/src/main/java/org/redisson/reactive/RedissonBucketReactive.java
index 50536c832..0df97e17e 100644
--- a/redisson/src/main/java/org/redisson/reactive/RedissonBucketReactive.java
+++ b/redisson/src/main/java/org/redisson/reactive/RedissonBucketReactive.java
@@ -45,7 +45,7 @@ public class RedissonBucketReactive extends RedissonExpirableReactive impleme
@Override
public Publisher set(V value, long timeToLive, TimeUnit timeUnit) {
- return commandExecutor.writeReactive(getName(), codec, RedisCommands.SETEX, getName(), timeUnit.toSeconds(timeToLive), value);
+ return commandExecutor.writeReactive(getName(), codec, RedisCommands.PSETEX, getName(), timeUnit.toMillis(timeToLive), value);
}
}
diff --git a/redisson/src/main/java/org/redisson/spring/misc/BeanMethodInvoker.java b/redisson/src/main/java/org/redisson/spring/misc/BeanMethodInvoker.java
new file mode 100644
index 000000000..fe6d8c7e0
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/misc/BeanMethodInvoker.java
@@ -0,0 +1,44 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.misc;
+
+import java.lang.reflect.InvocationTargetException;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.support.ArgumentConvertingMethodInvoker;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class BeanMethodInvoker extends ArgumentConvertingMethodInvoker
+ implements InitializingBean {
+
+ @Override
+ public void afterPropertiesSet() throws Exception {
+ prepare();
+ try {
+ invoke();
+ } catch (InvocationTargetException ex) {
+ if (ex.getTargetException() instanceof Exception) {
+ throw (Exception) ex.getTargetException();
+ }
+ if (ex.getTargetException() instanceof Error) {
+ throw (Error) ex.getTargetException();
+ }
+ throw ex;
+ }
+ }
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/AbstractRedissonNamespaceDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/AbstractRedissonNamespaceDefinitionParser.java
new file mode 100644
index 000000000..313333612
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/AbstractRedissonNamespaceDefinitionParser.java
@@ -0,0 +1,84 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.util.Assert;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public abstract class AbstractRedissonNamespaceDefinitionParser
+ extends AbstractSingleBeanDefinitionParser {
+
+ protected final RedissonNamespaceParserSupport helper;
+ private final RedissonNamespaceDecorator decorator;
+ private final String parentRefAttribute;
+
+ protected AbstractRedissonNamespaceDefinitionParser(RedissonNamespaceParserSupport helper, String parentRefAttribute) {
+ this.helper = helper;
+ this.parentRefAttribute = parentRefAttribute;
+ this.decorator = new RedissonNamespaceDefaultDecorator();
+ }
+
+ public AbstractRedissonNamespaceDefinitionParser(RedissonNamespaceParserSupport helper, String parentRefAttribute, RedissonNamespaceDecorator decorator) {
+ this.helper = helper;
+ this.parentRefAttribute = parentRefAttribute;
+ this.decorator = decorator;
+ }
+
+ @Override
+ protected final void doParse(Element element, BeanDefinitionBuilder builder) {
+ }
+
+ @Override
+ protected final void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
+ Assert.state(helper.isRedissonNS(element),
+ "Illegal state. "
+ + this.getClass().getName()
+ + " can only parse "
+ + RedissonNamespaceParserSupport.REDISSON_NAMESPACE
+ + " namespace elements");
+ Assert.state(element.hasAttribute(parentRefAttribute),
+ "Illegal state. property \"" + parentRefAttribute
+ + "\" is required in the \""
+ + helper.getName(element)
+ + "\" element.");
+
+ helper.populateIdAttribute(element, builder, parserContext);
+ AbstractBeanDefinition bd = builder.getRawBeanDefinition();
+ parseNested(element, parserContext, builder, bd);
+ decorator.decorate(element, parserContext, builder, helper);
+ parserContext.getDelegate().parseQualifierElements(element, bd);
+ if (parserContext.isNested()) {
+ helper.registerBeanDefinition(builder, element, parserContext);
+ }
+ }
+
+ protected abstract void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd);
+
+ @Override
+ protected final boolean shouldGenerateIdAsFallback() {
+ return true;
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/DelayedQueueDecorator.java b/redisson/src/main/java/org/redisson/spring/support/DelayedQueueDecorator.java
new file mode 100644
index 000000000..452d4ab5e
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/DelayedQueueDecorator.java
@@ -0,0 +1,44 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.redisson.api.RQueue;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.util.Assert;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class DelayedQueueDecorator implements RedissonNamespaceDecorator {
+
+ private static final String DESTINATION_QUEUE_REF = "destination-queue-ref";
+
+ @Override
+ public void decorate(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper) {
+ Assert.state(element.hasAttribute(DESTINATION_QUEUE_REF),
+ "Illegal state. property \"" + DESTINATION_QUEUE_REF
+ + "\" is required in the \""
+ + helper.getName(element)
+ + "\" element.");
+ helper.addConstructorArgs(new RuntimeBeanReference(
+ helper.getAttribute(element, DESTINATION_QUEUE_REF)),
+ RQueue.class, builder);
+ }
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/LocalCachedMapOptionsDecorator.java b/redisson/src/main/java/org/redisson/spring/support/LocalCachedMapOptionsDecorator.java
new file mode 100644
index 000000000..16d5c4635
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/LocalCachedMapOptionsDecorator.java
@@ -0,0 +1,95 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.redisson.api.LocalCachedMapOptions;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.parsing.BeanComponentDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.core.Conventions;
+import org.springframework.util.Assert;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class LocalCachedMapOptionsDecorator implements RedissonNamespaceDecorator {
+
+ @Override
+ public void decorate(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper) {
+ NodeList list = element.getElementsByTagNameNS(
+ RedissonNamespaceParserSupport.REDISSON_NAMESPACE,
+ RedissonNamespaceParserSupport.LOCAL_CACHED_MAP_OPTIONS_ELEMENT);
+ Element options = null;
+ String id;
+ if (list.getLength() == 1) {
+ options = (Element) list.item(0);
+ id = invokeOptions(options, parserContext, helper);
+ for (int i = 0; i < options.getAttributes().getLength(); i++) {
+ Attr item = (Attr) options.getAttributes().item(i);
+ if (helper.isEligibleAttribute(item)
+ && !RedissonNamespaceParserSupport.TIME_TO_LIVE_UNIT_ATTRIBUTE
+ .equals(item.getLocalName())
+ && !RedissonNamespaceParserSupport.MAX_IDLE_UNIT_ATTRIBUTE
+ .equals(item.getLocalName())) {
+ helper.invoker(id,
+ helper.getName(item),
+ new Object[]{item.getValue()},
+ parserContext);
+ }
+ }
+ invokeTimeUnitOptions(options, id, parserContext, helper,
+ RedissonNamespaceParserSupport.TIME_TO_LIVE_ATTRIBUTE,
+ RedissonNamespaceParserSupport.TIME_TO_LIVE_UNIT_ATTRIBUTE);
+
+ invokeTimeUnitOptions(options, id, parserContext, helper,
+ RedissonNamespaceParserSupport.MAX_IDLE_ATTRIBUTE,
+ RedissonNamespaceParserSupport.MAX_IDLE_UNIT_ATTRIBUTE);
+ } else {
+ id = invokeOptions(options, parserContext, helper);
+ }
+ helper.addConstructorArgs(new RuntimeBeanReference(id),
+ LocalCachedMapOptions.class, builder);
+ }
+
+ private String invokeOptions(Element element, ParserContext parserContext, RedissonNamespaceParserSupport helper) {
+ BeanComponentDefinition defaultOption
+ = helper.factoryInvoker(element, LocalCachedMapOptions.class,
+ "defaults", null, parserContext);
+ return defaultOption.getName();
+ }
+
+ private void invokeTimeUnitOptions(Element element, String id, ParserContext parserContext, RedissonNamespaceParserSupport helper, String timeAttrubute, String timeUnitAttribute) {
+ if (helper.hasAttribute(element, timeUnitAttribute)) {
+ Assert.state(
+ helper.hasAttribute(element, timeAttrubute),
+ "Missing \"" + timeAttrubute + "\" attribute in \""
+ + RedissonNamespaceParserSupport.LOCAL_CACHED_MAP_OPTIONS_ELEMENT
+ + "\" element.");
+ helper.invoker(id,
+ Conventions.attributeNameToPropertyName(timeAttrubute),
+ new Object[]{
+ Integer.parseInt(
+ helper.getAttribute(element, timeAttrubute)),
+ helper.getAttribute(element, timeUnitAttribute)},
+ parserContext);
+ }
+ }
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/ReadWriteLockDecorator.java b/redisson/src/main/java/org/redisson/spring/support/ReadWriteLockDecorator.java
new file mode 100644
index 000000000..6f36c8c59
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/ReadWriteLockDecorator.java
@@ -0,0 +1,48 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class ReadWriteLockDecorator implements RedissonNamespaceDecorator {
+
+
+ @Override
+ public void decorate(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper) {
+ parseNested(element, RedissonNamespaceParserSupport.READ_LOCK_ELEMENT, parserContext, builder, helper);
+ parseNested(element, RedissonNamespaceParserSupport.WRITE_LOCK_ELEMENT, parserContext, builder, helper);
+ }
+
+ private void parseNested(Element element, String eltType, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper) {
+ NodeList list = element.getElementsByTagNameNS(
+ RedissonNamespaceParserSupport.REDISSON_NAMESPACE, eltType);
+ if (list.getLength() == 1) {
+ Element elt = (Element) list.item(0);
+ helper.setAttribute(elt, RedissonNamespaceParserSupport.READ_WRITE_LOCK_REF_ATTRIBUTE,
+ helper.getAttribute(element,
+ RedissonNamespaceParserSupport.ID_ATTRIBUTE));
+ parserContext.getDelegate()
+ .parseCustomElement(elt, builder.getRawBeanDefinition());
+ }
+ }
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedisDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/RedisDefinitionParser.java
new file mode 100644
index 000000000..6c02eee29
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedisDefinitionParser.java
@@ -0,0 +1,78 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.redisson.client.RedisClient;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public final class RedisDefinitionParser
+ extends AbstractSimpleBeanDefinitionParser {
+
+ private static final String HOST_ATTRIBUTE = "host";
+ private static final String PORT_ATTRIBUTE = "port";
+ private static final String CONNECTION_TIMEOUT_ATTRIBUTE = "connectionTimeout";
+ private static final String COMMAND_TIMEOUT_ATTRIBUTE = "commandTimeout";
+
+ private final RedissonNamespaceParserSupport helper;
+
+ public RedisDefinitionParser(RedissonNamespaceParserSupport helper) {
+ this.helper = helper;
+ }
+
+ @Override
+ protected Class getBeanClass(Element element) {
+ return RedisClient.class;
+ }
+
+ @Override
+ protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
+ builder.getRawBeanDefinition().setBeanClass(RedisClient.class);
+ helper.addConstructorArgs(element,
+ HOST_ATTRIBUTE, String.class, builder);
+ helper.addConstructorArgs(element,
+ PORT_ATTRIBUTE, int.class, builder);
+ helper.addConstructorArgs(element,
+ CONNECTION_TIMEOUT_ATTRIBUTE, int.class, builder);
+ helper.addConstructorArgs(element,
+ COMMAND_TIMEOUT_ATTRIBUTE, int.class, builder);
+ builder.setDestroyMethodName("shutdown");
+ parserContext.getDelegate().parseQualifierElements(element,
+ builder.getRawBeanDefinition());
+ }
+
+ @Override
+ protected boolean shouldGenerateIdAsFallback() {
+ return true;
+ }
+
+ @Override
+ protected boolean isEligibleAttribute(String attributeName) {
+ return helper.isEligibleAttribute(attributeName);
+ }
+
+ @Override
+ protected boolean isEligibleAttribute(Attr attribute, ParserContext parserContext) {
+ return helper.isEligibleAttribute(attribute);
+ }
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/RedissonDefinitionParser.java
new file mode 100644
index 000000000..7beef7354
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonDefinitionParser.java
@@ -0,0 +1,210 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import java.util.List;
+import org.redisson.Redisson;
+import org.redisson.config.Config;
+import org.redisson.misc.URLBuilder;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.parsing.BeanComponentDefinition;
+import org.springframework.beans.factory.parsing.CompositeComponentDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.BeanDefinitionParser;
+import org.springframework.beans.factory.xml.BeanDefinitionParserDelegate;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.core.Conventions;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+import org.springframework.util.xml.DomUtils;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public final class RedissonDefinitionParser
+ implements BeanDefinitionParser {
+
+ public static final String ID_ATTRIBUTE = "id";
+ public static final String NAME_ATTRIBUTE = "name";
+ private static final String REF_SUFFIX = "-ref";
+ private static final String REDISSON_REF = "redisson-ref";
+
+ static enum ConfigType {
+ singleServer,
+ sentinelServers,
+ replicatedServers,
+ masterSlaveServers,
+ clusterServers;
+
+ public static boolean contains(String type) {
+ try {
+ valueOf(type);
+ return true;
+ } catch (IllegalArgumentException e) {
+ return false;
+ }
+ }
+ }
+
+ static enum AddressType {
+ slaveAddress,
+ sentinelAddress,
+ nodeAddress;
+
+ public static boolean contains(String type) {
+ try {
+ valueOf(type);
+ return true;
+ } catch (IllegalArgumentException e) {
+ return false;
+ }
+ }
+ }
+
+ private final RedissonNamespaceParserSupport helper;
+
+ RedissonDefinitionParser(RedissonNamespaceParserSupport helper) {
+ this.helper = helper;
+ }
+
+ private void parseChildElements(Element element, String parentId, String redissonRef, BeanDefinitionBuilder redissonDef, ParserContext parserContext) {
+ if (element.hasChildNodes()) {
+ CompositeComponentDefinition compositeDef
+ = new CompositeComponentDefinition(parentId,
+ parserContext.extractSource(element));
+ parserContext.pushContainingComponent(compositeDef);
+ List childElts = DomUtils.getChildElements(element);
+ for (Element elt : childElts) {
+ if(BeanDefinitionParserDelegate
+ .QUALIFIER_ELEMENT.equals(elt.getLocalName())) {
+ continue;//parsed elsewhere
+ }
+ String localName = parserContext.getDelegate().getLocalName(elt);
+ localName = Conventions.attributeNameToPropertyName(localName);
+ if (ConfigType.contains(localName)) {
+ parseConfigTypes(elt, localName, redissonDef, parserContext);
+ } else if (AddressType.contains(localName)) {
+ parseAddressTypes(elt, localName, redissonDef, parserContext);
+ } else if (helper.isRedissonNS(elt)) {
+ elt.setAttribute(REDISSON_REF, redissonRef);
+ parserContext.getDelegate().parseCustomElement(elt);
+ }
+ }
+ parserContext.popContainingComponent();
+ }
+ }
+
+ private void parseConfigTypes(Element element, String configType, BeanDefinitionBuilder redissonDef, ParserContext parserContext) {
+ BeanDefinitionBuilder builder
+ = helper.createBeanDefinitionBuilder(element,
+ parserContext, null);
+ //Use factory method on the Config bean
+ AbstractBeanDefinition bd = builder.getRawBeanDefinition();
+ bd.setFactoryMethodName("use" + StringUtils.capitalize(configType));
+ bd.setFactoryBeanName(parserContext.getContainingComponent().getName());
+ String id = parserContext.getReaderContext().generateBeanName(bd);
+ helper.registerBeanDefinition(builder, id,
+ helper.parseAliase(element), parserContext);
+ parseAttributes(element, parserContext, builder);
+ redissonDef.addDependsOn(id);
+ parseChildElements(element, id, null, redissonDef, parserContext);
+ parserContext.getDelegate().parseQualifierElements(element, bd);
+ }
+
+ private void parseAddressTypes(Element element, String addressType, BeanDefinitionBuilder redissonDef, ParserContext parserContext) {
+ BeanComponentDefinition invoker = helper.invoker(element,
+ parserContext.getContainingComponent().getName(),
+ "add" + StringUtils.capitalize(addressType),
+ new String[]{element.getAttribute("value")},
+ parserContext);
+ String id = invoker.getName();
+ redissonDef.addDependsOn(id);
+ }
+
+ private void parseAttributes(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
+ NamedNodeMap attributes = element.getAttributes();
+ for (int x = 0; x < attributes.getLength(); x++) {
+ Attr attribute = (Attr) attributes.item(x);
+ if (helper.isEligibleAttribute(attribute)) {
+ String propertyName
+ = attribute.getLocalName().endsWith(REF_SUFFIX)
+ ? attribute.getLocalName()
+ .substring(0, attribute.getLocalName()
+ .length() - REF_SUFFIX.length())
+ : attribute.getLocalName();
+ propertyName = Conventions
+ .attributeNameToPropertyName(propertyName);
+ Assert.state(StringUtils.hasText(propertyName),
+ "Illegal property name returned from"
+ + " 'extractPropertyName(String)': cannot be"
+ + " null or empty.");
+ if (attribute.getLocalName().endsWith(REF_SUFFIX)) {
+ builder.addPropertyReference(propertyName,
+ attribute.getValue());
+ } else {
+ Object value = attribute.getValue();
+ String localName = helper.getName(element);
+ if ("masterAddress".equals(propertyName)
+ && ConfigType.masterSlaveServers.name()
+ .equals(localName)) {
+ try {
+ value = URLBuilder.create((String) value);
+ } catch (Exception e) {
+ //value may be a placeholder
+ value = "redis://" + value;
+ }
+ }
+ builder.addPropertyValue(propertyName, value);
+ }
+ }
+ }
+ }
+
+ @Override
+ public BeanDefinition parse(Element element, ParserContext parserContext) {
+ //Sort out the Config Class
+ BeanDefinitionBuilder configBuilder
+ = helper.createBeanDefinitionBuilder(element, parserContext,
+ Config.class);
+ String configId = helper.getId(null, configBuilder, parserContext);
+ parseAttributes(element, parserContext, configBuilder);
+ helper.registerBeanDefinition(configBuilder, configId,
+ null, parserContext);
+
+ //Do the main Redisson bean
+ BeanDefinitionBuilder builder
+ = helper.createBeanDefinitionBuilder(element, parserContext,
+ Redisson.class);
+ builder.setFactoryMethod("create");
+ builder.setDestroyMethodName("shutdown");
+ builder.addConstructorArgReference(configId);
+ parserContext.getDelegate().parseQualifierElements(element,
+ builder.getRawBeanDefinition());
+ String id = helper.getId(element, builder, parserContext);
+ parseAttributes(element, parserContext, configBuilder);
+ //Sort out all the nested elements
+ parseChildElements(element, configId, id, builder, parserContext);
+
+ helper.registerBeanDefinition(builder, id,
+ helper.parseAliase(element), parserContext);
+ return builder.getBeanDefinition();
+ }
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonGenericObjectDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/RedissonGenericObjectDefinitionParser.java
new file mode 100644
index 000000000..681e26a3d
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonGenericObjectDefinitionParser.java
@@ -0,0 +1,90 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.redisson.api.RDestroyable;
+import org.redisson.client.codec.Codec;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.core.Conventions;
+import org.springframework.util.StringUtils;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonGenericObjectDefinitionParser
+ extends AbstractRedissonNamespaceDefinitionParser {
+
+ private final static String KEY_ATTRIBUTE = "key";
+ private final static String TOPIC_ATTRIBUTE = "topic";
+ private final static String PATTERN_ATTRIBUTE = "pattern";
+ private final static String SERVICE_ATTRIBUTE = "service";
+ private final static String CODEC_REF_ATTRIBUTE = "codec-ref";
+ private final static String FAIL_LOCK = "fairLock";
+
+ RedissonGenericObjectDefinitionParser(RedissonNamespaceParserSupport helper) {
+ super(helper, RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE);
+ }
+
+ RedissonGenericObjectDefinitionParser(RedissonNamespaceParserSupport helper, RedissonNamespaceDecorator decorator) {
+ super(helper,
+ RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE,
+ decorator);
+ }
+
+ @Override
+ protected void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd) {
+ bd.setFactoryBeanName(element.getAttribute(
+ RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE));
+ String typeName
+ = Conventions.attributeNameToPropertyName(element.getLocalName());
+ bd.setFactoryMethodName("get" + StringUtils.capitalize(typeName));
+
+ helper.addConstructorArgs(element, KEY_ATTRIBUTE,
+ String.class, builder);
+ helper.addConstructorArgs(element, TOPIC_ATTRIBUTE,
+ String.class, builder);
+ helper.addConstructorArgs(element, PATTERN_ATTRIBUTE,
+ String.class, builder);
+ helper.addConstructorArgs(element, SERVICE_ATTRIBUTE,
+ String.class, builder);
+ helper.addConstructorArgs(element, CODEC_REF_ATTRIBUTE,
+ Codec.class, builder);
+ if (RDestroyable.class.isAssignableFrom(getBeanClass(element))) {
+ ((AbstractBeanDefinition) bd).setDestroyMethodName("destroy");
+ }
+ }
+
+ @Override
+ protected Class getBeanClass(Element element) {
+ String elementName
+ = Conventions.attributeNameToPropertyName(
+ element.getLocalName());
+ try {
+ return Class.forName(RedissonNamespaceParserSupport.API_CLASS_PATH_PREFIX
+ + (StringUtils.capitalize(FAIL_LOCK.equals(elementName)
+ ? "lock"
+ : elementName)));
+ } catch (ClassNotFoundException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonLiveObjectDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/RedissonLiveObjectDefinitionParser.java
new file mode 100644
index 000000000..38ec7f644
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonLiveObjectDefinitionParser.java
@@ -0,0 +1,87 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.MethodInvokingFactoryBean;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.ManagedList;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.w3c.dom.Element;
+import reactor.core.support.Assert;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonLiveObjectDefinitionParser
+ extends AbstractRedissonNamespaceDefinitionParser {
+
+ public RedissonLiveObjectDefinitionParser(RedissonNamespaceParserSupport helper) {
+ super(helper, RedissonNamespaceParserSupport.LIVE_OBJECT_SERVICE_REF_ATTRIBUTE);
+ }
+
+ @Override
+ protected void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd) {
+ Class apiClass;
+ try {
+ apiClass = Class.forName(helper.getAttribute(element,
+ RedissonNamespaceParserSupport.CLASS_ATTRIBUTE));
+ } catch (ClassNotFoundException ex) {
+ throw new IllegalArgumentException(
+ "The class [" + helper.getAttribute(element,
+ RedissonNamespaceParserSupport.CLASS_ATTRIBUTE)
+ + "] specified in \"api-class\" attribute has not "
+ + "found. Please check the class path.", ex);
+ }
+ Assert.state(helper.hasAttribute(element,
+ RedissonNamespaceParserSupport.OBJECT_ID_ATTRIBUTE)
+ || helper.hasAttribute(element,
+ RedissonNamespaceParserSupport.OBJECT_ID_REF_ATTRIBUTE),
+ "One of \""
+ + RedissonNamespaceParserSupport.OBJECT_ID_ATTRIBUTE
+ + "\" or \""
+ + RedissonNamespaceParserSupport.OBJECT_ID_REF_ATTRIBUTE
+ + "\" attribute is required in the \""
+ + RedissonNamespaceParserSupport.LIVE_OBJECT_ELEMENT
+ + "\" element.");
+ builder.addPropertyValue("targetObject", new RuntimeBeanReference(
+ helper.getAttribute(element,
+ RedissonNamespaceParserSupport.LIVE_OBJECT_SERVICE_REF_ATTRIBUTE)));
+ builder.addPropertyValue("targetMethod", "get");
+ ManagedList args = new ManagedList();
+ args.add(apiClass);
+ if (helper.hasAttribute(element,
+ RedissonNamespaceParserSupport.OBJECT_ID_ATTRIBUTE)) {
+ args.add(helper.getAttribute(element,
+ RedissonNamespaceParserSupport.OBJECT_ID_ATTRIBUTE));
+ }
+ if (helper.hasAttribute(element,
+ RedissonNamespaceParserSupport.OBJECT_ID_REF_ATTRIBUTE)) {
+ args.add(new RuntimeBeanReference(
+ helper.getAttribute(element,
+ RedissonNamespaceParserSupport.OBJECT_ID_REF_ATTRIBUTE)));
+ }
+ builder.addPropertyValue("arguments", args);
+ }
+
+ @Override
+ protected Class getBeanClass(Element element) {
+ return MethodInvokingFactoryBean.class;
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonLiveObjectRegistrationDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/RedissonLiveObjectRegistrationDefinitionParser.java
new file mode 100644
index 000000000..4090cc0ec
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonLiveObjectRegistrationDefinitionParser.java
@@ -0,0 +1,62 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.redisson.spring.misc.BeanMethodInvoker;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonLiveObjectRegistrationDefinitionParser
+ extends AbstractRedissonNamespaceDefinitionParser {
+
+ public RedissonLiveObjectRegistrationDefinitionParser(RedissonNamespaceParserSupport helper) {
+ super(helper,
+ RedissonNamespaceParserSupport.LIVE_OBJECT_SERVICE_REF_ATTRIBUTE);
+ }
+
+ @Override
+ protected void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd) {
+ Class apiClass;
+ try {
+ apiClass = Class.forName(helper.getAttribute(element,
+ RedissonNamespaceParserSupport.CLASS_ATTRIBUTE));
+ } catch (ClassNotFoundException ex) {
+ throw new IllegalArgumentException(
+ "The class [" + helper.getAttribute(element,
+ RedissonNamespaceParserSupport.CLASS_ATTRIBUTE)
+ + "] specified in \"api-class\" attribute has not "
+ + "found. Please check the class path.", ex);
+ }
+ builder.addPropertyValue("targetObject", new RuntimeBeanReference(
+ helper.getAttribute(element,
+ RedissonNamespaceParserSupport.LIVE_OBJECT_SERVICE_REF_ATTRIBUTE)));
+ builder.addPropertyValue("targetMethod", "registerClass");
+ builder.addPropertyValue("arguments", new Object[] {apiClass});
+ }
+
+ @Override
+ protected Class getBeanClass(Element element) {
+ return BeanMethodInvoker.class;
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonMultiLockDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/RedissonMultiLockDefinitionParser.java
new file mode 100644
index 000000000..0cad4c335
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonMultiLockDefinitionParser.java
@@ -0,0 +1,102 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import java.util.List;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.ConstructorArgumentValues;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.ManagedList;
+import org.springframework.beans.factory.xml.BeanDefinitionParserDelegate;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.core.Conventions;
+import org.springframework.util.StringUtils;
+import org.springframework.util.xml.DomUtils;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonMultiLockDefinitionParser
+ extends AbstractRedissonNamespaceDefinitionParser {
+
+ public RedissonMultiLockDefinitionParser(RedissonNamespaceParserSupport helper) {
+ super(helper,
+ RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE);
+ }
+
+ @Override
+ protected void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd) {
+ bd.setDependsOn(element.getAttribute(
+ RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE));
+ List childElements = DomUtils.getChildElements(element);
+ for (Element elt : childElements) {
+ String localName = elt.getLocalName();
+ if (BeanDefinitionParserDelegate
+ .QUALIFIER_ELEMENT.equals(localName)) {
+ continue;//parsed elsewhere
+ }
+ String id;
+ if (BeanDefinitionParserDelegate.REF_ELEMENT.equals(localName)){
+ id = elt.getAttribute(
+ BeanDefinitionParserDelegate.BEAN_REF_ATTRIBUTE);
+ } else {
+ if (!elt.hasAttribute(
+ RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE)) {
+ helper.setAttribute(elt,
+ RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE,
+ element.getAttribute(
+ RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE));
+ }
+ helper.populateIdAttribute(elt, builder, parserContext);
+ parserContext.getDelegate().parseCustomElement(elt, bd);
+ id = elt.getAttribute(
+ RedissonNamespaceParserSupport.ID_ATTRIBUTE);
+ }
+ ConstructorArgumentValues args
+ = builder.getRawBeanDefinition()
+ .getConstructorArgumentValues();
+ if (args.getArgumentCount() > 0) {
+ ConstructorArgumentValues.ValueHolder value
+ = args.getIndexedArgumentValues().get(0);
+ ManagedList list;
+ if (value.getValue() instanceof ManagedList) {
+ list = (ManagedList) value.getValue();
+ } else {
+ list = new ManagedList();
+ list.add(value.getValue());
+ value.setValue(list);
+ value.setType(ManagedList.class.getName());
+ }
+ list.add(new RuntimeBeanReference(id));
+ } else {
+ builder.addConstructorArgReference(id);
+ }
+ }
+ }
+
+ @Override
+ protected String getBeanClassName(Element element) {
+ String elementName
+ = Conventions.attributeNameToPropertyName(
+ element.getLocalName());
+ return RedissonNamespaceParserSupport.IMPL_CLASS_PATH_PREFIX
+ + StringUtils.capitalize(elementName);
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceDecorator.java b/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceDecorator.java
new file mode 100644
index 000000000..b04c29824
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceDecorator.java
@@ -0,0 +1,29 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public interface RedissonNamespaceDecorator {
+
+ void decorate(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper);
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceDefaultDecorator.java b/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceDefaultDecorator.java
new file mode 100644
index 000000000..7aa9bf96c
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceDefaultDecorator.java
@@ -0,0 +1,33 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonNamespaceDefaultDecorator implements RedissonNamespaceDecorator {
+
+ @Override
+ public void decorate(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper) {
+ //default is no decoration;
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceHandlerSupport.java b/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceHandlerSupport.java
new file mode 100644
index 000000000..cf14811a0
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceHandlerSupport.java
@@ -0,0 +1,144 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonNamespaceHandlerSupport extends NamespaceHandlerSupport {
+
+ @Override
+ public void init() {
+ RedissonNamespaceParserSupport helper
+ = new RedissonNamespaceParserSupport();
+
+ RedissonGenericObjectDefinitionParser defaultParser
+ = new RedissonGenericObjectDefinitionParser(helper);
+
+ RedissonReadAndWriteLockDefinitionParser readAndWriteLockParser
+ = new RedissonReadAndWriteLockDefinitionParser(helper);
+
+ RedissonMultiLockDefinitionParser nestedParser
+ = new RedissonMultiLockDefinitionParser(helper);
+
+ RedissonNestedElementAwareDecorator readWriteLockDecorator
+ = new RedissonNestedElementAwareDecorator(
+ new String[]{
+ RedissonNamespaceParserSupport.READ_LOCK_ELEMENT,
+ RedissonNamespaceParserSupport.WRITE_LOCK_ELEMENT
+ },
+ RedissonNamespaceParserSupport.READ_WRITE_LOCK_REF_ATTRIBUTE);
+
+ RedissonGenericObjectDefinitionParser readWriteLockParser
+ = new RedissonGenericObjectDefinitionParser(helper,
+ readWriteLockDecorator);
+
+ RedissonNestedElementAwareDecorator remoteServiceDecorator
+ = new RedissonNestedElementAwareDecorator(
+ new String[]{
+ RedissonNamespaceParserSupport.RPC_SERVER_ELEMENT,
+ RedissonNamespaceParserSupport.RPC_CLIENT_ELEMENT
+ },
+ RedissonNamespaceParserSupport.REMOTE_SERVICE_REF_ATTRIBUTE);
+
+ RedissonGenericObjectDefinitionParser remoteServiceParser
+ = new RedissonGenericObjectDefinitionParser(helper,
+ remoteServiceDecorator);
+
+ RedissonNestedElementAwareDecorator liveObjectServiceDecorator
+ = new RedissonNestedElementAwareDecorator(
+ new String[]{
+ RedissonNamespaceParserSupport.LIVE_OBJECT_ELEMENT,
+ RedissonNamespaceParserSupport.LIVE_OBJECT_REGISTRATION_ELEMENT
+ },
+ RedissonNamespaceParserSupport.LIVE_OBJECT_SERVICE_REF_ATTRIBUTE);
+
+ RedissonGenericObjectDefinitionParser liveObjectServiceParser
+ = new RedissonGenericObjectDefinitionParser(helper,
+ liveObjectServiceDecorator);
+
+ //root beans
+ registerBeanDefinitionParser("client",
+ new RedissonDefinitionParser(helper));
+ registerBeanDefinitionParser("redis", new RedisDefinitionParser(helper));
+ //object parsers
+ registerBeanDefinitionParser("binary-stream", defaultParser);
+ registerBeanDefinitionParser("geo", defaultParser);
+ registerBeanDefinitionParser("set-cache", defaultParser);
+ registerBeanDefinitionParser("map-cache", defaultParser);
+ registerBeanDefinitionParser("bucket", defaultParser);
+ registerBeanDefinitionParser("buckets", defaultParser);
+ registerBeanDefinitionParser("hyper-log-log", defaultParser);
+ registerBeanDefinitionParser("list", defaultParser);
+ registerBeanDefinitionParser("list-multimap", defaultParser);
+ registerBeanDefinitionParser("list-multimap-cache", defaultParser);
+ registerBeanDefinitionParser("local-cached-map",
+ new RedissonGenericObjectDefinitionParser(helper,
+ new LocalCachedMapOptionsDecorator()));
+ registerBeanDefinitionParser("map", defaultParser);
+ registerBeanDefinitionParser("set-multimap", defaultParser);
+ registerBeanDefinitionParser("set-multimap-cache", defaultParser);
+ registerBeanDefinitionParser("semaphore", defaultParser);
+ registerBeanDefinitionParser("permit-expirable-semaphore", defaultParser);
+ registerBeanDefinitionParser("lock", defaultParser);
+ registerBeanDefinitionParser("fair-lock", defaultParser);
+ registerBeanDefinitionParser("read-write-lock",readWriteLockParser);
+ registerBeanDefinitionParser("read-lock", readAndWriteLockParser);
+ registerBeanDefinitionParser("write-lock", readAndWriteLockParser);
+ registerBeanDefinitionParser("multi-lock", nestedParser);
+ registerBeanDefinitionParser("red-lock", nestedParser);
+ registerBeanDefinitionParser("set", defaultParser);
+ registerBeanDefinitionParser("sorted-set", defaultParser);
+ registerBeanDefinitionParser("scored-sorted-set", defaultParser);
+ registerBeanDefinitionParser("lex-sorted-set", defaultParser);
+ registerBeanDefinitionParser("topic", defaultParser);
+ registerBeanDefinitionParser("pattern-topic", defaultParser);
+ registerBeanDefinitionParser("blocking-fair-queue", defaultParser);
+ registerBeanDefinitionParser("queue", defaultParser);
+ registerBeanDefinitionParser("delayed-queue",
+ new RedissonGenericObjectDefinitionParser(helper,
+ new DelayedQueueDecorator()));
+ registerBeanDefinitionParser("priority-queue", defaultParser);
+ registerBeanDefinitionParser("priority-deque", defaultParser);
+ registerBeanDefinitionParser("blocking-queue", defaultParser);
+ registerBeanDefinitionParser("bounded-blocking-queue", defaultParser);
+ registerBeanDefinitionParser("deque", defaultParser);
+ registerBeanDefinitionParser("blocking-deque", defaultParser);
+ registerBeanDefinitionParser("atomic-long", defaultParser);
+ registerBeanDefinitionParser("atomic-double", defaultParser);
+ registerBeanDefinitionParser("count-down-latch", defaultParser);
+ registerBeanDefinitionParser("bit-set", defaultParser);
+ registerBeanDefinitionParser("bloom-filter", defaultParser);
+ registerBeanDefinitionParser("script", defaultParser);
+ registerBeanDefinitionParser("executor-service", defaultParser);//nested unfinished
+ registerBeanDefinitionParser("remote-service", remoteServiceParser);
+ registerBeanDefinitionParser("rpc-server",
+ new RedissonRPCServerDefinitionParser(helper));
+ registerBeanDefinitionParser("rpc-client",
+ new RedissonRPCClientDefinitionParser(helper,
+ new RemoteInvocationOptionDecorator()));
+ registerBeanDefinitionParser("keys", defaultParser);
+ registerBeanDefinitionParser("live-object-service", liveObjectServiceParser);
+ registerBeanDefinitionParser("live-object",
+ new RedissonLiveObjectDefinitionParser(helper));
+ registerBeanDefinitionParser("live-object-registration",
+ new RedissonLiveObjectRegistrationDefinitionParser(helper));
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceParserSupport.java b/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceParserSupport.java
new file mode 100644
index 000000000..d7b2804aa
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonNamespaceParserSupport.java
@@ -0,0 +1,300 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.redisson.spring.misc.BeanMethodInvoker;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.BeanDefinitionHolder;
+import org.springframework.beans.factory.config.ConstructorArgumentValues;
+import org.springframework.beans.factory.config.MethodInvokingFactoryBean;
+import org.springframework.beans.factory.parsing.BeanComponentDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.core.Conventions;
+import org.springframework.util.StringUtils;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonNamespaceParserSupport {
+
+ public final static String REDISSON_NAMESPACE
+ = "http://redisson.org/schema/redisson";
+
+ static final String API_CLASS_PATH_PREFIX = "org.redisson.api.R";
+ static final String IMPL_CLASS_PATH_PREFIX = "org.redisson.Redisson";
+
+ static final String ID_ATTRIBUTE = "id";
+ static final String NAME_ATTRIBUTE = "name";
+ static final String REDISSON_REF_ATTRIBUTE = "redisson-ref";
+ static final String READ_WRITE_LOCK_REF_ATTRIBUTE = "read-write-lock-ref";
+ static final String EXECUTOR_REF_ATTRIBUTE = "executor-ref";
+ static final String REMOTE_SERVICE_REF_ATTRIBUTE = "remote-service-ref";
+ static final String LIVE_OBJECT_SERVICE_REF_ATTRIBUTE
+ = "live-object-service-ref";
+ static final String OBJECT_ID_REF_ATTRIBUTE = "object-id-ref";
+
+ static final String MAX_IDLE_ATTRIBUTE = "max-idle";
+ static final String TIME_TO_LIVE_ATTRIBUTE = "time-to-live";
+ static final String MAX_IDLE_UNIT_ATTRIBUTE = "max-idle-unit";
+ static final String TIME_TO_LIVE_UNIT_ATTRIBUTE = "time-to-live-unit";
+ static final String CONCURRENT_WORKERS_ATTRIBUTE = "concurrent-workers";
+ static final String WITHIN_ATTRIBUTE = "within";
+ static final String TIME_UNIT_ATTRIBUTE = "time-unit";
+ static final String API_CLASS_ATTRIBUTE = "api-class";
+ static final String CLASS_ATTRIBUTE = "class";
+ static final String OBJECT_ID_ATTRIBUTE = "object-id";
+
+ static final String READ_LOCK_ELEMENT = "read-lock";
+ static final String WRITE_LOCK_ELEMENT = "write-lock";
+ static final String RPC_SERVER_ELEMENT = "rpc-server";
+ static final String RPC_CLIENT_ELEMENT = "rpc-client";
+ static final String REMOTE_INVOCATION_OPTIONS_ELEMENT
+ = "remote-invocation-options";
+ static final String REMOTE_NO_ACK_ELEMENT = "remote-no-ack";
+ static final String REMOTE_ACK_ELEMENT = "remote-ack";
+ static final String REMOTE_NO_RESULT_ELEMENT = "remote-no-result";
+ static final String REMOTE_RESULT_ELEMENT = "remote-result";
+ static final String LOCAL_CACHED_MAP_OPTIONS_ELEMENT
+ = "local-cached-map-options";
+ static final String LIVE_OBJECT_ELEMENT
+ = "live-object";
+ static final String LIVE_OBJECT_REGISTRATION_ELEMENT
+ = "live-object-registration";
+
+ public String[] parseAliase(Element element) {
+ if (element == null) {
+ return null;
+ }
+ String[] aliases = null;
+ String name = element.getAttribute(NAME_ATTRIBUTE);
+ if (StringUtils.hasLength(name)) {
+ aliases = StringUtils.trimArrayElements(
+ StringUtils.commaDelimitedListToStringArray(name));
+ }
+ return aliases;
+ }
+
+ public BeanDefinitionBuilder createBeanDefinitionBuilder(Element element, ParserContext parserContext, Class cls) {
+ BeanDefinitionBuilder builder
+ = BeanDefinitionBuilder.genericBeanDefinition();
+ builder.getRawBeanDefinition().setBeanClass(cls);
+ builder.getRawBeanDefinition()
+ .setSource(parserContext.extractSource(element));
+ if (parserContext.isNested()) {
+ builder.setScope(parserContext.getContainingBeanDefinition()
+ .getScope());
+ }
+ if (parserContext.isDefaultLazyInit()) {
+ builder.setLazyInit(true);
+ }
+ return builder;
+ }
+
+ public BeanComponentDefinition registerBeanDefinition(BeanDefinitionBuilder builder, String id, String[] aliases, ParserContext parserContext) {
+ BeanDefinitionHolder holder
+ = new BeanDefinitionHolder(builder.getBeanDefinition(), id,
+ aliases);
+ BeanDefinitionReaderUtils
+ .registerBeanDefinition(holder, parserContext.getRegistry());
+ BeanComponentDefinition componentDefinition
+ = new BeanComponentDefinition(holder);
+ parserContext.registerComponent(componentDefinition);
+ return componentDefinition;
+ }
+
+ public BeanComponentDefinition registerBeanDefinition(BeanDefinitionBuilder builder, Element element, ParserContext parserContext) {
+ BeanDefinitionHolder holder
+ = new BeanDefinitionHolder(builder.getBeanDefinition(),
+ getId(element, builder, parserContext),
+ parseAliase(element));
+ BeanDefinitionReaderUtils
+ .registerBeanDefinition(holder, parserContext.getRegistry());
+ BeanComponentDefinition componentDefinition
+ = new BeanComponentDefinition(holder);
+ parserContext.registerComponent(componentDefinition);
+ return componentDefinition;
+ }
+
+ public void addConstructorArgs(Element element, String attribute, Class type, BeanDefinition bd) {
+ if (element.hasAttribute(attribute)) {
+ addConstructorArgs(element.getAttribute(attribute), type, bd);
+ }
+ }
+
+ public void addConstructorArgs(Object value, Class type, BeanDefinition bd) {
+ ConstructorArgumentValues.ValueHolder vHolder
+ = new ConstructorArgumentValues.ValueHolder(value, type.getName());
+ ConstructorArgumentValues args
+ = bd.getConstructorArgumentValues();
+ args.addIndexedArgumentValue(args.getArgumentCount(), vHolder);
+ }
+
+ public void addConstructorArgs(Element element, String attribute, Class type, BeanDefinitionBuilder builder) {
+ addConstructorArgs(element, attribute, type, builder.getRawBeanDefinition());
+ }
+
+ public void addConstructorArgs(Object value, Class type, BeanDefinitionBuilder builder) {
+ addConstructorArgs(value, type, builder.getRawBeanDefinition());
+ }
+
+ public String getName(Node node) {
+ return Conventions.attributeNameToPropertyName(node.getLocalName());
+ }
+
+ public String getId(Element element, BeanDefinitionBuilder builder, ParserContext parserContext) {
+ String id = element != null
+ ? element.getAttribute(ID_ATTRIBUTE)
+ : null;
+ if (!StringUtils.hasText(id)) {
+ id = generateId(builder, parserContext);
+ }
+ return id;
+ }
+
+ public String generateId(BeanDefinitionBuilder builder, ParserContext parserContext) {
+ return parserContext.getReaderContext()
+ .generateBeanName(builder.getRawBeanDefinition());
+ }
+
+ public void populateIdAttribute(Element element, BeanDefinitionBuilder builder, ParserContext parserContext) {
+ if (element == null) {
+ return;
+ }
+ if (!StringUtils.hasText(element.getAttribute(ID_ATTRIBUTE))) {
+ element.setAttribute(ID_ATTRIBUTE,
+ generateId(builder, parserContext));
+ }
+ }
+
+ public BeanComponentDefinition factoryInvoker(Element element, String bean, String method, Object[] args, ParserContext parserContext) {
+ BeanDefinitionBuilder builder
+ = preInvoke(element, bean, method, args, parserContext, true);
+ builder.addPropertyReference("targetObject", bean);
+ return doInvoke(element, builder, parserContext);
+ }
+
+ public BeanComponentDefinition factoryInvoker(Element element, Object obj, String method, Object[] args, ParserContext parserContext) {
+ BeanDefinitionBuilder builder
+ = preInvoke(element, obj, method, args, parserContext, true);
+ builder.addPropertyValue("targetObject", obj);
+ return doInvoke(element, builder, parserContext);
+ }
+
+
+ public BeanComponentDefinition factoryInvoker(String bean, String method, Object[] args, ParserContext parserContext) {
+ return factoryInvoker(null, bean, method, args, parserContext);
+ }
+
+ public BeanComponentDefinition factoryInvoker(Object obj, String method, Object[] args, ParserContext parserContext) {
+ return factoryInvoker(null, obj, method, args, parserContext);
+ }
+
+
+ public BeanComponentDefinition invoker(Element element, String bean, String method, Object[] args, ParserContext parserContext) {
+ BeanDefinitionBuilder builder
+ = preInvoke(element, bean, method, args, parserContext, false);
+ builder.addPropertyReference("targetObject", bean);
+ return doInvoke(element, builder, parserContext);
+ }
+
+ public BeanComponentDefinition invoker(Element element, Object obj, String method, Object[] args, ParserContext parserContext) {
+ BeanDefinitionBuilder builder
+ = preInvoke(element, obj, method, args, parserContext, false);
+ builder.addPropertyValue("targetObject", obj);
+ return doInvoke(element, builder, parserContext);
+ }
+
+
+ public BeanComponentDefinition invoker(String bean, String method, Object[] args, ParserContext parserContext) {
+ return invoker(null, bean, method, args, parserContext);
+ }
+
+ public BeanComponentDefinition invoker(Object obj, String method, Object[] args, ParserContext parserContext) {
+ return invoker(null, obj, method, args, parserContext);
+ }
+
+ private BeanDefinitionBuilder preInvoke(Element element, Object obj, String method, Object[] args, ParserContext parserContext, boolean factory) {
+ BeanDefinitionBuilder builder
+ = createBeanDefinitionBuilder(element, parserContext,
+ factory
+ ? MethodInvokingFactoryBean.class
+ : BeanMethodInvoker.class);
+ if (obj instanceof Class) {
+ builder.addPropertyValue("staticMethod",
+ ((Class) obj).getName() + "." + method);
+ } else {
+ builder.addPropertyValue("targetMethod", method);
+ }
+ builder.addPropertyValue("arguments", args);
+ if (element != null) {
+ parserContext.getDelegate().parseQualifierElements(element,
+ builder.getRawBeanDefinition());
+ }
+ return builder;
+ }
+
+ private BeanComponentDefinition doInvoke(Element element, BeanDefinitionBuilder builder, ParserContext parserContext) {
+ String id = getId(element, builder, parserContext);
+ return registerBeanDefinition(builder, id,
+ parseAliase(element), parserContext);
+ }
+
+ public boolean isEligibleAttribute(String attributeName) {
+ return !attributeName.equals("xmlns")
+ && !attributeName.startsWith("xmlns:")
+ && !ID_ATTRIBUTE.equals(attributeName)
+ && !NAME_ATTRIBUTE.equals(attributeName);
+ }
+
+ public boolean isEligibleAttribute(Attr attribute) {
+ return isEligibleAttribute(attribute.getName());
+ }
+
+ public boolean isRedissonNS(Node node) {
+ return node != null
+ && REDISSON_NAMESPACE.equals(node.getNamespaceURI());
+ }
+
+ public String getAttribute(Element element, String attribute) {
+ return element.getAttribute(attribute);
+ }
+
+ public void setAttribute(Element element, String attribute, String value) {
+ element.setAttribute(attribute, value);
+ }
+
+ public boolean hasAttribute(Element element, String attribute) {
+ return element.hasAttribute(attribute);
+ }
+
+ public boolean hasElement(Element element, String tagName) {
+ return element.getElementsByTagNameNS(
+ RedissonNamespaceParserSupport.REDISSON_NAMESPACE, tagName)
+ .getLength() > 0;
+ }
+
+ public Element getSingleElement(Element element, String tagName) {
+ return (Element) element.getElementsByTagNameNS(
+ RedissonNamespaceParserSupport.REDISSON_NAMESPACE, tagName)
+ .item(0);
+ }
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonNestedElementAwareDecorator.java b/redisson/src/main/java/org/redisson/spring/support/RedissonNestedElementAwareDecorator.java
new file mode 100644
index 000000000..7ff45b562
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonNestedElementAwareDecorator.java
@@ -0,0 +1,62 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.util.StringUtils;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonNestedElementAwareDecorator implements RedissonNamespaceDecorator {
+
+ private final String[] nestedElements;
+ private final String referenceAttribute;
+
+ public RedissonNestedElementAwareDecorator(String[] nestedElements, String referenceAttribute) {
+ this.nestedElements = nestedElements;
+ this.referenceAttribute = referenceAttribute;
+ }
+
+ @Override
+ public void decorate(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper) {
+ for (String nestedElement : nestedElements) {
+ parseNested(element, nestedElement, parserContext, builder, helper);
+ }
+ }
+
+ private void parseNested(Element element, String eltType, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper) {
+ NodeList list = element.getElementsByTagNameNS(
+ RedissonNamespaceParserSupport.REDISSON_NAMESPACE, eltType);
+ if (list.getLength() == 1) {
+ Element elt = (Element) list.item(0);
+ if (StringUtils.hasText(referenceAttribute)) {
+ helper.setAttribute(elt, referenceAttribute,
+ helper.getAttribute(element,
+ RedissonNamespaceParserSupport.ID_ATTRIBUTE));
+ helper.setAttribute(elt, RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE,
+ helper.getAttribute(element,
+ RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE));
+ }
+ parserContext.getDelegate()
+ .parseCustomElement(elt, builder.getRawBeanDefinition());
+ }
+ }
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonRPCClientDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/RedissonRPCClientDefinitionParser.java
new file mode 100644
index 000000000..35d3258a7
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonRPCClientDefinitionParser.java
@@ -0,0 +1,65 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.MethodInvokingFactoryBean;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonRPCClientDefinitionParser
+ extends AbstractRedissonNamespaceDefinitionParser {
+
+ public RedissonRPCClientDefinitionParser(RedissonNamespaceParserSupport helper, RedissonNamespaceDecorator decorator) {
+ super(helper,
+ RedissonNamespaceParserSupport.REMOTE_SERVICE_REF_ATTRIBUTE,
+ decorator);
+ }
+
+ @Override
+ protected void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd) {
+ Class apiClass;
+ try {
+ apiClass = Class.forName(helper.getAttribute(element,
+ RedissonNamespaceParserSupport.API_CLASS_ATTRIBUTE));
+ } catch (ClassNotFoundException ex) {
+ throw new IllegalArgumentException(
+ "The class [" + helper.getAttribute(element,
+ RedissonNamespaceParserSupport.API_CLASS_ATTRIBUTE)
+ + "] specified in \""
+ + RedissonNamespaceParserSupport.API_CLASS_ATTRIBUTE
+ + "\" attribute has not "
+ + "found. Please check the class path.", ex);
+ }
+ builder.addPropertyValue("targetObject", new RuntimeBeanReference(
+ helper.getAttribute(element,
+ RedissonNamespaceParserSupport.REMOTE_SERVICE_REF_ATTRIBUTE)));
+ builder.addPropertyValue("targetMethod", "get");
+ builder.addPropertyValue("arguments", new Object[] {apiClass});
+ }
+
+ @Override
+ protected Class getBeanClass(Element element) {
+ return MethodInvokingFactoryBean.class;
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonRPCServerDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/RedissonRPCServerDefinitionParser.java
new file mode 100644
index 000000000..d4e6586b8
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonRPCServerDefinitionParser.java
@@ -0,0 +1,96 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.redisson.spring.misc.BeanMethodInvoker;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.ManagedList;
+import org.springframework.beans.factory.xml.BeanDefinitionParserDelegate;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.util.StringUtils;
+import org.w3c.dom.Element;
+import reactor.core.support.Assert;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonRPCServerDefinitionParser
+ extends AbstractRedissonNamespaceDefinitionParser {
+
+ public RedissonRPCServerDefinitionParser(RedissonNamespaceParserSupport helper) {
+ super(helper, RedissonNamespaceParserSupport.REMOTE_SERVICE_REF_ATTRIBUTE);
+ }
+
+ @Override
+ protected void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd) {
+ Class apiClass;
+ try {
+ apiClass = Class.forName(helper.getAttribute(element,
+ RedissonNamespaceParserSupport.API_CLASS_ATTRIBUTE));
+ } catch (ClassNotFoundException ex) {
+ throw new IllegalArgumentException(
+ "The class [" + helper.getAttribute(element,
+ RedissonNamespaceParserSupport.API_CLASS_ATTRIBUTE)
+ + "] specified in \""
+ + RedissonNamespaceParserSupport.API_CLASS_ATTRIBUTE
+ + "\" attribute has not "
+ + "found. Please check the class path.", ex);
+ }
+ builder.addPropertyValue("targetObject", new RuntimeBeanReference(
+ helper.getAttribute(element,
+ RedissonNamespaceParserSupport.REMOTE_SERVICE_REF_ATTRIBUTE)));
+ builder.addPropertyValue("targetMethod", "register");
+ ManagedList args = new ManagedList();
+ args.add(apiClass);
+ args.add(new RuntimeBeanReference(
+ helper.getAttribute(element,
+ BeanDefinitionParserDelegate.BEAN_REF_ATTRIBUTE)));
+ String workers = null;
+ if (helper.hasAttribute(element,
+ RedissonNamespaceParserSupport.CONCURRENT_WORKERS_ATTRIBUTE)) {
+ workers = helper.getAttribute(element,
+ RedissonNamespaceParserSupport.CONCURRENT_WORKERS_ATTRIBUTE);
+ }
+ if (StringUtils.hasText(workers)) {
+ args.add(Integer.parseInt(workers));
+ }
+ if (helper.hasAttribute(element,
+ RedissonNamespaceParserSupport.EXECUTOR_REF_ATTRIBUTE)) {
+ Assert.state(helper.hasAttribute(element,
+ RedissonNamespaceParserSupport.CONCURRENT_WORKERS_ATTRIBUTE),
+ "The \""
+ + RedissonNamespaceParserSupport.CONCURRENT_WORKERS_ATTRIBUTE
+ + "\" attribute in \""
+ + RedissonNamespaceParserSupport.RPC_SERVER_ELEMENT
+ + "\" element is required when \""
+ + RedissonNamespaceParserSupport.EXECUTOR_REF_ATTRIBUTE
+ + "\" attribute is specified.");
+ args.add(new RuntimeBeanReference(
+ helper.getAttribute(element,
+ RedissonNamespaceParserSupport.EXECUTOR_REF_ATTRIBUTE)));
+ }
+ builder.addPropertyValue("arguments", args);
+ }
+
+ @Override
+ protected Class getBeanClass(Element element) {
+ return BeanMethodInvoker.class;
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RedissonReadAndWriteLockDefinitionParser.java b/redisson/src/main/java/org/redisson/spring/support/RedissonReadAndWriteLockDefinitionParser.java
new file mode 100644
index 000000000..248af5430
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RedissonReadAndWriteLockDefinitionParser.java
@@ -0,0 +1,55 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.core.Conventions;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RedissonReadAndWriteLockDefinitionParser
+ extends AbstractRedissonNamespaceDefinitionParser {
+
+ public RedissonReadAndWriteLockDefinitionParser(RedissonNamespaceParserSupport helper) {
+ super(helper,
+ RedissonNamespaceParserSupport.READ_WRITE_LOCK_REF_ATTRIBUTE);
+ }
+
+ @Override
+ protected void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd) {
+ bd.setFactoryBeanName(element.getAttribute(
+ RedissonNamespaceParserSupport.READ_WRITE_LOCK_REF_ATTRIBUTE));
+ String typeName
+ = Conventions.attributeNameToPropertyName(element.getLocalName());
+ bd.setFactoryMethodName(typeName);
+ }
+
+ @Override
+ protected Class getBeanClass(Element element) {
+ try {
+ return Class.forName(RedissonNamespaceParserSupport.API_CLASS_PATH_PREFIX
+ + "Lock");
+ } catch (ClassNotFoundException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+}
diff --git a/redisson/src/main/java/org/redisson/spring/support/RemoteInvocationOptionDecorator.java b/redisson/src/main/java/org/redisson/spring/support/RemoteInvocationOptionDecorator.java
new file mode 100644
index 000000000..a622f8e6f
--- /dev/null
+++ b/redisson/src/main/java/org/redisson/spring/support/RemoteInvocationOptionDecorator.java
@@ -0,0 +1,116 @@
+/**
+ * Copyright 2016 Nikita Koksharov
+ *
+ * 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.redisson.spring.support;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import org.redisson.api.RemoteInvocationOptions;
+import org.springframework.beans.MutablePropertyValues;
+import org.springframework.beans.PropertyValue;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.parsing.BeanComponentDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.ManagedList;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.w3c.dom.Element;
+import reactor.core.support.Assert;
+
+/**
+ *
+ * @author Rui Gu (https://github.com/jackygurui)
+ */
+public class RemoteInvocationOptionDecorator implements RedissonNamespaceDecorator {
+
+ @Override
+ public void decorate(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper) {
+ if (helper.hasElement(element,
+ RedissonNamespaceParserSupport.REMOTE_INVOCATION_OPTIONS_ELEMENT)) {
+ Element options = helper.getSingleElement(element,
+ RedissonNamespaceParserSupport.REMOTE_INVOCATION_OPTIONS_ELEMENT);
+ String optionBeanId = invokeOptions(options, parserContext, helper);
+ if (helper.hasElement(element,
+ RedissonNamespaceParserSupport.REMOTE_NO_ACK_ELEMENT)) {
+ helper.invoker(optionBeanId, "noAck", null, parserContext);
+ }
+ if (helper.hasElement(element,
+ RedissonNamespaceParserSupport.REMOTE_ACK_ELEMENT)) {
+ Element remoteAck = helper.getSingleElement(element,
+ RedissonNamespaceParserSupport.REMOTE_ACK_ELEMENT);
+ Assert.state(helper.hasAttribute(remoteAck,
+ RedissonNamespaceParserSupport.WITHIN_ATTRIBUTE),
+ "Missing \""
+ + RedissonNamespaceParserSupport.WITHIN_ATTRIBUTE
+ + "\" attribute in \""
+ + RedissonNamespaceParserSupport.REMOTE_ACK_ELEMENT
+ + "\" element.");
+ ArrayList args = new ArrayList(2);
+ args.add(helper.getAttribute(remoteAck,
+ RedissonNamespaceParserSupport.WITHIN_ATTRIBUTE));
+ if (helper.hasAttribute(remoteAck,
+ RedissonNamespaceParserSupport.TIME_UNIT_ATTRIBUTE)) {
+ args.add(helper.getAttribute(remoteAck,
+ RedissonNamespaceParserSupport.TIME_UNIT_ATTRIBUTE));
+ }
+ helper.invoker(optionBeanId, "expectAckWithin", args.toArray(),
+ parserContext);
+ }
+ if (helper.hasElement(element,
+ RedissonNamespaceParserSupport.REMOTE_NO_RESULT_ELEMENT)) {
+ helper.invoker(optionBeanId, "noResult", null, parserContext);
+ }
+ if (helper.hasElement(element,
+ RedissonNamespaceParserSupport.REMOTE_RESULT_ELEMENT)) {
+ Element remoteResult = helper.getSingleElement(element,
+ RedissonNamespaceParserSupport.REMOTE_RESULT_ELEMENT);
+ Assert.state(helper.hasAttribute(remoteResult,
+ RedissonNamespaceParserSupport.WITHIN_ATTRIBUTE),
+ "Missing \""
+ + RedissonNamespaceParserSupport.WITHIN_ATTRIBUTE
+ + "\" attribute in \""
+ + RedissonNamespaceParserSupport.REMOTE_RESULT_ELEMENT
+ + "\" element.");
+ ArrayList args = new ArrayList(2);
+ args.add(helper.getAttribute(remoteResult,
+ RedissonNamespaceParserSupport.WITHIN_ATTRIBUTE));
+ if (helper.hasAttribute(remoteResult,
+ RedissonNamespaceParserSupport.TIME_UNIT_ATTRIBUTE)) {
+ args.add(helper.getAttribute(remoteResult,
+ RedissonNamespaceParserSupport.TIME_UNIT_ATTRIBUTE));
+ }
+ helper.invoker(optionBeanId, "expectResultWithin", args.toArray(),
+ parserContext);
+ }
+ MutablePropertyValues properties = builder.getRawBeanDefinition()
+ .getPropertyValues();
+ PropertyValue propertyValue
+ = properties.getPropertyValue("arguments");
+ ManagedList