• Home
• com.redis.om
• redis-om-spring
• 0.6.1
• source code
• MappingRedisOMConverter.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.redis.om.spring.convert.MappingRedisOMConverter Maven / Gradle / Ivy

package com.redis.om.spring.convert;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.CollectionFactory;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.ConverterNotFoundException;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.convert.support.GenericConversionService;
import org.springframework.data.convert.CustomConversions;
import org.springframework.data.mapping.AssociationHandler;
import org.springframework.data.mapping.InstanceCreatorMetadata;
import org.springframework.data.mapping.MappingException;
import org.springframework.data.mapping.PersistentPropertyAccessor;
import org.springframework.data.mapping.PersistentPropertyPath;
import org.springframework.data.mapping.PropertyHandler;
import org.springframework.data.mapping.model.EntityInstantiator;
import org.springframework.data.mapping.model.EntityInstantiators;
import org.springframework.data.mapping.model.PersistentEntityParameterValueProvider;
import org.springframework.data.mapping.model.PropertyValueProvider;
import org.springframework.data.redis.core.PartialUpdate;
import org.springframework.data.redis.core.PartialUpdate.PropertyUpdate;
import org.springframework.data.redis.core.PartialUpdate.UpdateCommand;
import org.springframework.data.redis.core.convert.Bucket;
import org.springframework.data.redis.core.convert.DefaultRedisTypeMapper;
import org.springframework.data.redis.core.convert.IndexResolver;
import org.springframework.data.redis.core.convert.RedisConverter;
import org.springframework.data.redis.core.convert.RedisCustomConversions;
import org.springframework.data.redis.core.convert.RedisData;
import org.springframework.data.redis.core.convert.RedisTypeMapper;
import org.springframework.data.redis.core.convert.ReferenceResolver;
import org.springframework.data.redis.core.mapping.RedisMappingContext;
import org.springframework.data.redis.core.mapping.RedisPersistentEntity;
import org.springframework.data.redis.core.mapping.RedisPersistentProperty;
import org.springframework.data.redis.util.ByteUtils;
import org.springframework.data.util.ClassTypeInformation;
import org.springframework.data.util.TypeInformation;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import org.springframework.util.comparator.NullSafeComparator;

import com.redis.om.spring.annotations.Indexed;
import com.redis.om.spring.annotations.TagIndexed;
import com.redis.om.spring.repository.query.QueryUtils;

public class MappingRedisOMConverter implements RedisConverter, InitializingBean {

  private static final String INVALID_TYPE_ASSIGNMENT = "Value of type %s cannot be assigned to property %s of type %s.";

  private final RedisMappingContext mappingContext;
  private final GenericConversionService conversionService;
  private final EntityInstantiators entityInstantiators;
  private final RedisTypeMapper typeMapper;
  private final Comparator listKeyComparator = new NullSafeComparator<>(NaturalOrderingKeyComparator.INSTANCE,
      true);

  private @Nullable ReferenceResolver referenceResolver;
  private CustomConversions customConversions;

  public MappingRedisOMConverter() {
    this(null);
  }

  /**
   * Creates new {@link MappingRedisOMConverter}.
   *
   * @param context can be {@literal null}.
   */
  public MappingRedisOMConverter(RedisMappingContext context) {
    this(context, null, null);
  }

  /**
   * Creates new {@link MappingRedisOMConverter} and defaults
   * {@link RedisMappingContext} when {@literal null}.
   *
   * @param mappingContext    can be {@literal null}.
   * @param referenceResolver can be not be {@literal null}.
   */
  public MappingRedisOMConverter(@Nullable RedisMappingContext mappingContext,
      @Nullable ReferenceResolver referenceResolver) {
    this(mappingContext, referenceResolver, null);
  }

  /**
   * Creates new {@link MappingRedisOMConverter} and defaults
   * {@link RedisMappingContext} when {@literal null}.
   *
   * @param mappingContext    can be {@literal null}.
   * @param referenceResolver can be {@literal null}.
   * @param typeMapper        can be {@literal null}.
   */
  public MappingRedisOMConverter(@Nullable RedisMappingContext mappingContext,
      @Nullable ReferenceResolver referenceResolver, @Nullable RedisTypeMapper typeMapper) {

    this.mappingContext = mappingContext != null ? mappingContext : new RedisMappingContext();

    this.entityInstantiators = new EntityInstantiators();
    this.conversionService = new DefaultConversionService();
    this.customConversions = new RedisOMCustomConversions();
    this.typeMapper = typeMapper != null ? typeMapper
        : new DefaultRedisTypeMapper(DefaultRedisTypeMapper.DEFAULT_TYPE_KEY, this.mappingContext);
    this.referenceResolver = referenceResolver;
    afterPropertiesSet();
  }

  /* (non-Javadoc)
   * 
   * @see org.springframework.data.convert.EntityReader#read(java.lang.Class,
   * java.lang.Object) */
  @Override
  @SuppressWarnings("unchecked")
  public  R read(Class type, RedisData source) {
    TypeInformation readType = typeMapper.readType(source.getBucket().getPath(), ClassTypeInformation.from(type));

    return readType.isCollectionLike()
        ? (R) readCollectionOrArray(type, "", ArrayList.class, Object.class, source.getBucket())
        : doReadInternal(type, "", type, source);
  }

  @Nullable
  private  R readInternal(Class entityClass, String path, Class type, RedisData source) {
    return source.getBucket().isEmpty() ? null : doReadInternal(entityClass, path, type, source);
  }

  @SuppressWarnings("unchecked")
  private  R doReadInternal(Class entityClass, String path, Class type, RedisData source) {

    TypeInformation readType = typeMapper.readType(source.getBucket().getPath(), ClassTypeInformation.from(type));

    if (customConversions.hasCustomReadTarget(Map.class, readType.getType())) {

      Map partial = new HashMap<>();

      if (!path.isEmpty()) {

        for (Entry entry : source.getBucket().extract(path + ".").entrySet()) {
          partial.put(entry.getKey().substring(path.length() + 1), entry.getValue());
        }

      } else {
        partial.putAll(source.getBucket().asMap());
      }
      R instance = (R) conversionService.convert(partial, readType.getType());

      RedisPersistentEntity entity = mappingContext.getPersistentEntity(readType);
      if (entity != null && entity.hasIdProperty()) {

        PersistentPropertyAccessor propertyAccessor = entity.getPropertyAccessor(instance);

        propertyAccessor.setProperty(entity.getRequiredIdProperty(), source.getId());
        instance = propertyAccessor.getBean();
      }
      return instance;
    }

    if (conversionService.canConvert(byte[].class, readType.getType())) {
      return (R) conversionService.convert(source.getBucket().get(StringUtils.hasText(path) ? path : "_raw"),
          readType.getType());
    }

    RedisPersistentEntity entity = mappingContext.getRequiredPersistentEntity(readType);
    EntityInstantiator instantiator = entityInstantiators.getInstantiatorFor(entity);

    Object instance = instantiator.createInstance((RedisPersistentEntity) entity,
        new PersistentEntityParameterValueProvider<>(entity,
            new ConverterAwareParameterValueProvider(entityClass, path, source, conversionService),
            this.conversionService));

    PersistentPropertyAccessor