org.springframework.data.redis.serializer.RedisSerializationContext Maven / Gradle / Ivy
/*
* Copyright 2017-2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.redis.serializer;
import java.nio.ByteBuffer;
import org.springframework.util.Assert;
/**
* Serialization context for reactive use.
*
* This context provides {@link SerializationPair}s for key, value, hash-key (field), hash-value and {@link String}
* serialization and deserialization.
*
* @author Mark Paluch
* @author Christoph Strobl
* @since 2.0
* @see RedisElementWriter
* @see RedisElementReader
*/
public interface RedisSerializationContext {
/**
* Creates a new {@link RedisSerializationContextBuilder}.
*
* @param expected key type.
* @param expected value type.
* @return a new {@link RedisSerializationContextBuilder}.
*/
@SuppressWarnings("unchecked")
static RedisSerializationContextBuilder newSerializationContext() {
return new DefaultRedisSerializationContext.DefaultRedisSerializationContextBuilder();
}
/**
* Creates a new {@link RedisSerializationContextBuilder} using a given default {@link RedisSerializer}.
*
* @param defaultSerializer must not be {@literal null}.
* @param expected key type.
* @param expected value type.
* @return a new {@link RedisSerializationContextBuilder}.
*/
static RedisSerializationContextBuilder newSerializationContext(RedisSerializer defaultSerializer) {
Assert.notNull(defaultSerializer, "DefaultSerializer must not be null!");
return newSerializationContext(SerializationPair.fromSerializer(defaultSerializer));
}
/**
* Creates a new {@link RedisSerializationContextBuilder} using a given default {@link SerializationPair}.
*
* @param serializationPair must not be {@literal null}.
* @param expected key type.
* @param expected value type.
* @return a new {@link RedisSerializationContextBuilder}.
*/
@SuppressWarnings("unchecked")
static RedisSerializationContextBuilder newSerializationContext(SerializationPair serializationPair) {
Assert.notNull(serializationPair, "SerializationPair must not be null!");
return new DefaultRedisSerializationContext.DefaultRedisSerializationContextBuilder() //
.key(serializationPair).value(serializationPair) //
.hashKey(serializationPair).hashValue(serializationPair);
}
/**
* Creates a new {@link RedisSerializationContext} using a {@link SerializationPair#raw()} serialization pair.
*
* @return
*/
static RedisSerializationContext raw() {
return just(SerializationPair.raw());
}
/**
* Creates a new {@link RedisSerializationContext} using a {@link JdkSerializationRedisSerializer}.
*
* @return new instance of {@link RedisSerializationContext}.
* @since 2.1
*/
static RedisSerializationContext java() {
return fromSerializer(RedisSerializer.java());
}
/**
* Creates a new {@link RedisSerializationContext} using a {@link JdkSerializationRedisSerializer} with given
* {@link ClassLoader}.
*
* @param classLoader the {@link ClassLoader} to use for deserialization. Can be {@literal null}.
* @return new instance of {@link RedisSerializationContext}.
* @since 2.1
*/
static RedisSerializationContext java(ClassLoader classLoader) {
return fromSerializer(RedisSerializer.java(classLoader));
}
/**
* Creates a new {@link RedisSerializationContext} using a {@link StringRedisSerializer}.
*
* @return
*/
static RedisSerializationContext string() {
return fromSerializer(RedisSerializer.string());
}
/**
* Creates a new {@link RedisSerializationContext} using the given {@link RedisSerializer}.
*
* @param serializer must not be {@literal null}.
* @param
* @return
*/
static RedisSerializationContext fromSerializer(RedisSerializer serializer) {
return just(SerializationPair.fromSerializer(serializer));
}
/**
* Creates a new {@link RedisSerializationContext} using the given {@link SerializationPair}.
*
* @param serializationPair
* @param
* @return
*/
static RedisSerializationContext just(SerializationPair serializationPair) {
return RedisSerializationContext. newSerializationContext(serializationPair).build();
}
/**
* @return {@link SerializationPair} for key-typed serialization and deserialization.
*/
SerializationPair getKeySerializationPair();
/**
* @return {@link SerializationPair} for value-typed serialization and deserialization.
*/
SerializationPair getValueSerializationPair();
/**
* @return {@link SerializationPair} for hash-key-typed serialization and deserialization.
*/
SerializationPair getHashKeySerializationPair();
/**
* @return {@link SerializationPair} for hash-value-typed serialization and deserialization.
*/
SerializationPair getHashValueSerializationPair();
/**
* @return {@link SerializationPair} for {@link String}-typed serialization and deserialization.
*/
SerializationPair getStringSerializationPair();
/**
* Typed serialization tuple.
*
* @author Mark Paluch
* @author Christoph Strobl
*/
interface SerializationPair {
/**
* Creates a {@link SerializationPair} adapter given {@link RedisSerializer}.
*
* @param serializer must not be {@literal null}.
* @return a {@link SerializationPair} adapter for {@link RedisSerializer}.
*/
static SerializationPair fromSerializer(RedisSerializer serializer) {
Assert.notNull(serializer, "RedisSerializer must not be null!");
return new RedisSerializerToSerializationPairAdapter<>(serializer);
}
/**
* Creates a {@link SerializationPair} adapter given {@link RedisElementReader} and {@link RedisElementWriter}.
*
* @param reader must not be {@literal null}.
* @param writer must not be {@literal null}.
* @return a {@link SerializationPair} encapsulating {@link RedisElementReader} and {@link RedisElementWriter}.
*/
static SerializationPair just(RedisElementReader reader,
RedisElementWriter writer) {
Assert.notNull(reader, "RedisElementReader must not be null!");
Assert.notNull(writer, "RedisElementWriter must not be null!");
return new DefaultSerializationPair<>(reader, writer);
}
/**
* Creates a pass through {@link SerializationPair} to pass-thru {@link ByteBuffer} objects.
*
* @return a pass through {@link SerializationPair}.
*/
static SerializationPair raw() {
return RedisSerializerToSerializationPairAdapter.raw();
}
/**
* @return the {@link RedisElementReader}.
*/
RedisElementReader getReader();
/**
* Deserialize a {@link ByteBuffer} into the according type.
*
* @param buffer must not be {@literal null}.
* @return the deserialized value.
*/
default T read(ByteBuffer buffer) {
return getReader().read(buffer);
}
/**
* @return the {@link RedisElementWriter}.
*/
RedisElementWriter getWriter();
/**
* Serialize a {@code element} to its {@link ByteBuffer} representation.
*
* @param element
* @return the {@link ByteBuffer} representing {@code element} in its binary form.
*/
default ByteBuffer write(T element) {
return getWriter().write(element);
}
}
/**
* Builder for {@link RedisSerializationContext}.
*
* @author Mark Paluch
* @author Christoph Strobl
*/
interface RedisSerializationContextBuilder {
/**
* Set the key {@link SerializationPair}.
*
* @param pair must not be {@literal null}.
* @return {@literal this} builder.
*/
RedisSerializationContextBuilder key(SerializationPair pair);
/**
* Set the key {@link RedisElementReader} and {@link RedisElementWriter}.
*
* @param reader must not be {@literal null}.
* @param writer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder key(RedisElementReader reader, RedisElementWriter writer) {
key(SerializationPair.just(reader, writer));
return this;
}
/**
* Set the key {@link SerializationPair} given a {@link RedisSerializer}.
*
* @param serializer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder key(RedisSerializer serializer) {
key(SerializationPair.fromSerializer(serializer));
return this;
}
/**
* Set the value {@link SerializationPair}.
*
* @param pair must not be {@literal null}.
* @return {@literal this} builder.
*/
RedisSerializationContextBuilder value(SerializationPair pair);
/**
* Set the value {@link RedisElementReader} and {@link RedisElementWriter}.
*
* @param reader must not be {@literal null}.
* @param writer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder value(RedisElementReader reader, RedisElementWriter writer) {
value(SerializationPair.just(reader, writer));
return this;
}
/**
* Set the value {@link SerializationPair} given a {@link RedisSerializer}.
*
* @param serializer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder value(RedisSerializer serializer) {
value(SerializationPair.fromSerializer(serializer));
return this;
}
/**
* Set the hash key {@link SerializationPair}.
*
* @param pair must not be {@literal null}.
* @return {@literal this} builder.
*/
RedisSerializationContextBuilder hashKey(SerializationPair pair);
/**
* Set the hash key {@link RedisElementReader} and {@link RedisElementWriter}.
*
* @param reader must not be {@literal null}.
* @param writer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder hashKey(RedisElementReader reader,
RedisElementWriter writer) {
hashKey(SerializationPair.just(reader, writer));
return this;
}
/**
* Set the hash key {@link SerializationPair} given a {@link RedisSerializer}.
*
* @param serializer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder hashKey(RedisSerializer serializer) {
hashKey(SerializationPair.fromSerializer(serializer));
return this;
}
/**
* Set the hash value {@link SerializationPair}.
*
* @param pair must not be {@literal null}.
* @return {@literal this} builder.
*/
RedisSerializationContextBuilder hashValue(SerializationPair pair);
/**
* Set the hash value {@link RedisElementReader} and {@link RedisElementWriter}.
*
* @param reader must not be {@literal null}.
* @param writer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder hashValue(RedisElementReader reader,
RedisElementWriter writer) {
hashValue(SerializationPair.just(reader, writer));
return this;
}
/**
* Set the hash value {@link SerializationPair} given a {@link RedisSerializer}.
*
* @param serializer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder hashValue(RedisSerializer serializer) {
hashValue(SerializationPair.fromSerializer(serializer));
return this;
}
/**
* Set the string {@link SerializationPair}.
*
* @param pair must not be {@literal null}.
* @return {@literal this} builder.
*/
RedisSerializationContextBuilder string(SerializationPair pair);
/**
* Set the string {@link RedisElementReader} and {@link RedisElementWriter}.
*
* @param reader must not be {@literal null}.
* @param writer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder string(RedisElementReader reader,
RedisElementWriter writer) {
string(SerializationPair.just(reader, writer));
return this;
}
/**
* Set the string {@link SerializationPair} given a {@link RedisSerializer}.
*
* @param serializer must not be {@literal null}.
* @return {@literal this} builder.
*/
default RedisSerializationContextBuilder string(RedisSerializer serializer) {
string(SerializationPair.fromSerializer(serializer));
return this;
}
/**
* Builds a {@link RedisSerializationContext}.
*
* @return the {@link RedisSerializationContext}.
*/
RedisSerializationContext build();
}
}