Example usage for org.springframework.data.mapping AssociationHandler AssociationHandler

List of usage examples for org.springframework.data.mapping AssociationHandler AssociationHandler

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.data.mapping.*
  5. AssociationHandler
  6. AssociationHandler

Introduction

In this page you can find the example usage for org.springframework.data.mapping AssociationHandler AssociationHandler.

Prototype

AssociationHandler

Source Link

Usage

From source file:org.oasis.datacore.sdk.data.spring.DatacoreMappingMongoConverter.java

protected void writeInternal(Object obj, final DBObject dbo, MongoPersistentEntity<?> entity) {

    if (obj == null) {
        return;/*from  w ww  .j a  v  a 2s . com*/
    }

    if (null == entity) {
        throw new MappingException("No mapping metadata found for entity of type " + obj.getClass().getName());
    }

    final BeanWrapper<MongoPersistentEntity<Object>, Object> wrapper = BeanWrapper.create(obj,
            conversionService);
    final MongoPersistentProperty idProperty = entity.getIdProperty();

    if (!dbo.containsField("_id") && null != idProperty) {

        boolean fieldAccessOnly = idProperty.usePropertyAccess() ? false : useFieldAccessOnly;

        try {
            Object id = wrapper.getProperty(idProperty, Object.class, fieldAccessOnly);
            dbo.put("_id", idMapper.convertId(id));
        } catch (ConversionException ignored) {
        }
    }

    // Write the properties
    entity.doWithProperties(new PropertyHandler<MongoPersistentProperty>() {
        public void doWithPersistentProperty(MongoPersistentProperty prop) {

            if (prop.equals(idProperty)) {
                return;
            }

            boolean fieldAccessOnly = prop.usePropertyAccess() ? false : useFieldAccessOnly;

            Object propertyObj = wrapper.getProperty(prop, prop.getType(), fieldAccessOnly);

            //if (null != propertyObj) { // [Ozwillo] HACK to allow unset / set to null at save
            if (/*[Ozwillo] HACK*/null != propertyObj
                    && /*[Ozwillo] END*/!conversions.isSimpleType(propertyObj.getClass())) {
                writePropertyInternal(propertyObj, dbo, prop);
            } else {
                writeSimpleInternal(propertyObj, dbo, prop.getFieldName());
            }
            //} // [Ozwillo] HACK
        }
    });

    entity.doWithAssociations(new AssociationHandler<MongoPersistentProperty>() {
        public void doWithAssociation(Association<MongoPersistentProperty> association) {
            MongoPersistentProperty inverseProp = association.getInverse();
            Class<?> type = inverseProp.getType();
            Object propertyObj = wrapper.getProperty(inverseProp, type, useFieldAccessOnly);
            //if (null != propertyObj) { // [Ozwillo] HACK to allow unset / set to null at save
            writePropertyInternal(propertyObj, dbo, inverseProp);
            //} // [Ozwillo] HACK
        }
    });

    // [Ozwillo] HACK to persist Datacore model fields at root level NOT FOR NOW
    /*if ("DCEntity".equals(entity.getName())) {
       DCEntity dcEntity = (DCEntity) object;
       DCModel dcModel = dcModelService.getModel(dcEntity.getType());
       for (DCField dcField : dcModel.getAllFields()) {
            
       }
    }*/
}

From source file:org.develspot.data.orientdb.convert.MappingOrientConverter.java

@SuppressWarnings("unchecked")
private <S extends Object> S read(final OrientPersistentEntity<S> entity, final OrientElement dbObject,
        boolean lazy) {
    OrientMappingInstance mappingInstance = MappingInstanceHolder.getMappingInstance();

    //check if entity is already loaded
    if (mappingInstance.instanceLoaded(dbObject.getId())) {
        return (S) mappingInstance.get(dbObject.getId());
    }/*  www. j ava  2s . c  o m*/

    EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity);
    final DefaultOrientPropertyValueProvider objectResolver = new DefaultOrientPropertyValueProvider(dbObject,
            this, spELContext, lazy);

    PersistentEntityParameterValueProvider<OrientPersistentProperty> parameterProvider = new PersistentEntityParameterValueProvider<OrientPersistentProperty>(
            entity, objectResolver, null);

    S instance = instantiator.createInstance(entity, parameterProvider);
    final BeanWrapper<OrientPersistentEntity<S>, S> wrapper = BeanWrapper.create(instance, conversionService);

    final S result = wrapper.getBean();
    mappingInstance.addInstance(dbObject.getId(), result);

    // Set properties not already set in the constructor
    entity.doWithProperties(new PropertyHandler<OrientPersistentProperty>() {
        public void doWithPersistentProperty(OrientPersistentProperty prop) {
            if (!prop.isIdProperty() && (dbObject.getProperty(prop.getField().getName()) == null
                    || entity.isConstructorArgument(prop))) {
                return;
            }
            Object obj = objectResolver.getPropertyValue(prop);
            wrapper.setProperty(prop, obj, fieldAccessOnly);
        }
    });

    entity.doWithAssociations(new AssociationHandler<OrientPersistentProperty>() {
        public void doWithAssociation(Association<OrientPersistentProperty> association) {
            OrientPersistentProperty inverse = association.getInverse();
            Object resolved = objectResolver.getPropertyValue(inverse);
            wrapper.setProperty(inverse, resolved);

        }
    });
    return result;
}

From source file:io.twipple.springframework.data.clusterpoint.convert.DefaultClusterpointEntityConverter.java

/**
 * Read an incoming {@link ClusterpointDocument} into the target entity.
 *
 * @param entity the target entity.// w w w.j a va  2  s .  com
 * @param source the document to convert.
 * @param parent an optional parent object.
 * @param <R>    the entity type.
 * @return the converted entity.
 */
@NotNull
@SuppressWarnings("unchecked")
protected <R> R read(@NotNull final ClusterpointPersistentEntity<R> entity,
        @NotNull final ClusterpointDocument source, Object parent) {
    Assert.notNull(entity);
    Assert.notNull(source);

    final DefaultSpELExpressionEvaluator evaluator = new DefaultSpELExpressionEvaluator(source, spELContext);
    ParameterValueProvider<ClusterpointPersistentProperty> parameterValueProvider = getParameterValueProvider(
            entity, source, evaluator, parent);
    final PersistentPropertyAccessor propertyAccessor = getPersistentPropertyAccessor(entity,
            parameterValueProvider);
    final PropertyValueProvider<ClusterpointPersistentProperty> propertyValueProvider = getPropertyValueProvider(
            source, propertyAccessor);

    entity.doWithProperties(new PropertyHandler<ClusterpointPersistentProperty>() {
        @Override
        public void doWithPersistentProperty(@NotNull ClusterpointPersistentProperty property) {

            Assert.notNull(property);

            if (!source.doesPropertyExist(property) || entity.isConstructorArgument(property)) {
                return;
            }

            Object obj = propertyValueProvider.getPropertyValue(property);
            setPropertyInternal(propertyAccessor, property, obj);
        }
    });

    entity.doWithAssociations(new AssociationHandler<ClusterpointPersistentProperty>() {
        @Override
        public void doWithAssociation(@NotNull Association<ClusterpointPersistentProperty> association) {

            Assert.notNull(association);

            ClusterpointPersistentProperty inverseProperty = association.getInverse();
            Object obj = propertyValueProvider.getPropertyValue(inverseProperty);
            setPropertyInternal(propertyAccessor, inverseProperty, obj);
        }
    });

    return (R) propertyAccessor.getBean();
}

From source file:org.springframework.data.document.mongodb.convert.MappingMongoConverter.java

private <S extends Object> S read(final MongoPersistentEntity<S> entity, final DBObject dbo) {

    final StandardEvaluationContext spelCtx = new StandardEvaluationContext();
    if (null != applicationContext) {
        spelCtx.setBeanResolver(new BeanFactoryResolver(applicationContext));
    }/*from w  ww . j  a  va 2s.com*/
    if (!(dbo instanceof BasicDBList)) {
        String[] keySet = dbo.keySet().toArray(new String[] {});
        for (String key : keySet) {
            spelCtx.setVariable(key, dbo.get(key));
        }
    }

    final List<String> ctorParamNames = new ArrayList<String>();
    final MongoPersistentProperty idProperty = entity.getIdProperty();
    final S instance = constructInstance(entity, new PreferredConstructor.ParameterValueProvider() {
        @SuppressWarnings("unchecked")
        public <T> T getParameterValue(PreferredConstructor.Parameter<T> parameter) {
            String name = parameter.getName();
            TypeInformation<T> type = parameter.getType();
            Class<T> rawType = parameter.getRawType();
            String key = idProperty == null ? name
                    : idProperty.getName().equals(name) ? idProperty.getKey() : name;
            Object obj = dbo.get(key);

            ctorParamNames.add(name);
            if (obj instanceof DBRef) {
                return read(type, ((DBRef) obj).fetch());
            } else if (obj instanceof BasicDBList) {
                BasicDBList objAsDbList = (BasicDBList) obj;
                List<?> l = unwrapList(objAsDbList, type);
                return conversionService.convert(l, rawType);
            } else if (obj instanceof DBObject) {
                return read(type, ((DBObject) obj));
            } else if (null != obj && obj.getClass().isAssignableFrom(rawType)) {
                return (T) obj;
            } else if (null != obj) {
                return conversionService.convert(obj, rawType);
            }

            return null;
        }
    }, spelCtx);

    // Set properties not already set in the constructor
    entity.doWithProperties(new PropertyHandler<MongoPersistentProperty>() {
        public void doWithPersistentProperty(MongoPersistentProperty prop) {

            boolean isConstructorProperty = ctorParamNames.contains(prop.getName());
            boolean hasValueForProperty = dbo.containsField(prop.getKey());

            if (!hasValueForProperty || isConstructorProperty) {
                return;
            }

            Object obj = getValueInternal(prop, dbo, spelCtx, prop.getSpelExpression());
            try {
                setProperty(instance, prop, obj, useFieldAccessOnly);
            } catch (IllegalAccessException e) {
                throw new MappingException(e.getMessage(), e);
            } catch (InvocationTargetException e) {
                throw new MappingException(e.getMessage(), e);
            }
        }
    });

    // Handle associations
    entity.doWithAssociations(new AssociationHandler<MongoPersistentProperty>() {
        public void doWithAssociation(Association<MongoPersistentProperty> association) {
            MongoPersistentProperty inverseProp = association.getInverse();
            Object obj = getValueInternal(inverseProp, dbo, spelCtx, inverseProp.getSpelExpression());
            try {
                setProperty(instance, inverseProp, obj);
            } catch (IllegalAccessException e) {
                throw new MappingException(e.getMessage(), e);
            } catch (InvocationTargetException e) {
                throw new MappingException(e.getMessage(), e);
            }
        }
    });

    return instance;
}

From source file:org.springframework.data.document.mongodb.convert.MappingMongoConverter.java

protected void writeInternal(final Object obj, final DBObject dbo, MongoPersistentEntity<?> entity) {

    if (obj == null) {
        return;/*from  w  w  w  .  j a  va 2  s.c  om*/
    }

    if (null == entity) {
        throw new MappingException("No mapping metadata found for entity of type " + obj.getClass().getName());
    }

    // Write the ID
    final MongoPersistentProperty idProperty = entity.getIdProperty();
    if (!dbo.containsField("_id") && null != idProperty) {
        Object idObj;
        try {
            idObj = getProperty(obj, idProperty, Object.class, useFieldAccessOnly);
        } catch (IllegalAccessException e) {
            throw new MappingException(e.getMessage(), e);
        } catch (InvocationTargetException e) {
            throw new MappingException(e.getMessage(), e);
        }

        if (null != idObj) {
            dbo.put("_id", idObj);
        } else {
            if (!VALID_ID_TYPES.contains(idProperty.getType())) {
                throw new MappingException("Invalid data type " + idProperty.getType().getName()
                        + " for Id property. Should be one of " + VALID_ID_TYPES);
            }
        }
    }

    // Write the properties
    entity.doWithProperties(new PropertyHandler<MongoPersistentProperty>() {
        public void doWithPersistentProperty(MongoPersistentProperty prop) {
            String name = prop.getName();
            Class<?> type = prop.getType();
            Object propertyObj;
            try {
                propertyObj = getProperty(obj, prop, type, useFieldAccessOnly);
            } catch (IllegalAccessException e) {
                throw new MappingException(e.getMessage(), e);
            } catch (InvocationTargetException e) {
                throw new MappingException(e.getMessage(), e);
            }
            if (null != propertyObj) {
                if (!isSimpleType(propertyObj.getClass())) {
                    writePropertyInternal(prop, propertyObj, dbo);
                } else {
                    dbo.put(name, propertyObj);
                }
            }
        }
    });

    entity.doWithAssociations(new AssociationHandler<MongoPersistentProperty>() {
        public void doWithAssociation(Association<MongoPersistentProperty> association) {
            MongoPersistentProperty inverseProp = association.getInverse();
            Class<?> type = inverseProp.getType();
            Object propertyObj;
            try {
                propertyObj = getProperty(obj, inverseProp, type, useFieldAccessOnly);
            } catch (IllegalAccessException e) {
                throw new MappingException(e.getMessage(), e);
            } catch (InvocationTargetException e) {
                throw new MappingException(e.getMessage(), e);
            }
            if (null != propertyObj) {
                writePropertyInternal(inverseProp, propertyObj, dbo);
            }
        }
    });
}

From source file:org.springframework.data.mongodb.core.convert.MappingMongoConverter.java

private <S extends Object> S read(final MongoPersistentEntity<S> entity, final DBObject dbo) {

    final StandardEvaluationContext spelCtx = new StandardEvaluationContext(dbo);
    spelCtx.addPropertyAccessor(DBObjectPropertyAccessor.INSTANCE);

    if (applicationContext != null) {
        spelCtx.setBeanResolver(new BeanFactoryResolver(applicationContext));
    }/*from w w  w  .j av  a 2  s.  c  o m*/

    final MappedConstructor constructor = new MappedConstructor(entity, mappingContext);

    SpELAwareParameterValueProvider delegate = new SpELAwareParameterValueProvider(spelExpressionParser,
            spelCtx);
    ParameterValueProvider provider = new DelegatingParameterValueProvider(constructor, dbo, delegate);

    final BeanWrapper<MongoPersistentEntity<S>, S> wrapper = BeanWrapper.create(entity, provider,
            conversionService);

    // Set properties not already set in the constructor
    entity.doWithProperties(new PropertyHandler<MongoPersistentProperty>() {
        public void doWithPersistentProperty(MongoPersistentProperty prop) {

            boolean isConstructorProperty = constructor.isConstructorParameter(prop);
            boolean hasValueForProperty = dbo.containsField(prop.getFieldName());

            if (!hasValueForProperty || isConstructorProperty) {
                return;
            }

            Object obj = getValueInternal(prop, dbo, spelCtx, prop.getSpelExpression());
            wrapper.setProperty(prop, obj, useFieldAccessOnly);
        }
    });

    // Handle associations
    entity.doWithAssociations(new AssociationHandler<MongoPersistentProperty>() {
        public void doWithAssociation(Association<MongoPersistentProperty> association) {
            MongoPersistentProperty inverseProp = association.getInverse();
            Object obj = getValueInternal(inverseProp, dbo, spelCtx, inverseProp.getSpelExpression());
            try {
                wrapper.setProperty(inverseProp, obj);
            } catch (IllegalAccessException e) {
                throw new MappingException(e.getMessage(), e);
            } catch (InvocationTargetException e) {
                throw new MappingException(e.getMessage(), e);
            }
        }
    });

    return wrapper.getBean();
}

From source file:org.springframework.data.mongodb.core.convert.MappingMongoConverter.java

protected void writeInternal(Object obj, final DBObject dbo, MongoPersistentEntity<?> entity) {

    if (obj == null) {
        return;/*from ww  w.j av  a  2s . com*/
    }

    if (null == entity) {
        throw new MappingException("No mapping metadata found for entity of type " + obj.getClass().getName());
    }

    final BeanWrapper<MongoPersistentEntity<Object>, Object> wrapper = BeanWrapper.create(obj,
            conversionService);

    // Write the ID
    final MongoPersistentProperty idProperty = entity.getIdProperty();
    if (!dbo.containsField("_id") && null != idProperty) {

        try {
            Object id = wrapper.getProperty(idProperty, Object.class, useFieldAccessOnly);
            dbo.put("_id", idMapper.convertId(id));
        } catch (ConversionException ignored) {
        }
    }

    // Write the properties
    entity.doWithProperties(new PropertyHandler<MongoPersistentProperty>() {
        public void doWithPersistentProperty(MongoPersistentProperty prop) {

            if (prop.equals(idProperty)) {
                return;
            }

            Object propertyObj = wrapper.getProperty(prop, prop.getType(), useFieldAccessOnly);

            if (null != propertyObj) {
                if (!conversions.isSimpleType(propertyObj.getClass())) {
                    writePropertyInternal(propertyObj, dbo, prop);
                } else {
                    writeSimpleInternal(propertyObj, dbo, prop.getFieldName());
                }
            }
        }
    });

    entity.doWithAssociations(new AssociationHandler<MongoPersistentProperty>() {
        public void doWithAssociation(Association<MongoPersistentProperty> association) {
            MongoPersistentProperty inverseProp = association.getInverse();
            Class<?> type = inverseProp.getType();
            Object propertyObj = wrapper.getProperty(inverseProp, type, useFieldAccessOnly);
            if (null != propertyObj) {
                writePropertyInternal(propertyObj, dbo, inverseProp);
            }
        }
    });
}

From source file:org.springframework.data.neo4j.fieldaccess.DelegatingFieldAccessorFactory.java

@SuppressWarnings("unchecked")
public <T> FieldAccessorFactoryProviders<T> accessorFactoriesFor(final Neo4jPersistentEntity<?> type) {
    synchronized (this) {
        final TypeInformation<?> typeInformation = type.getTypeInformation();
        final FieldAccessorFactoryProviders<T> fieldAccessorFactoryProviders = accessorFactoryProviderCache
                .get(typeInformation);/*from  ww  w  .  j  a v  a2s .c  o  m*/
        if (fieldAccessorFactoryProviders != null)
            return fieldAccessorFactoryProviders;
        final FieldAccessorFactoryProviders<T> newFieldAccessorFactories = new FieldAccessorFactoryProviders<T>(
                typeInformation, template);
        type.doWithProperties(new PropertyHandler<Neo4jPersistentProperty>() {
            @Override
            public void doWithPersistentProperty(Neo4jPersistentProperty property) {
                final FieldAccessorFactory factory = factoryForField(property);
                final List<FieldAccessorListenerFactory> listenerFactories = getFieldAccessListenerFactories(
                        property);
                newFieldAccessorFactories.add(property, factory, listenerFactories);
            }
        });
        type.doWithAssociations(new AssociationHandler<Neo4jPersistentProperty>() {
            @Override
            public void doWithAssociation(Association<Neo4jPersistentProperty> association) {
                final Neo4jPersistentProperty property = association.getInverse();
                final FieldAccessorFactory factory = factoryForField(property);
                final List<FieldAccessorListenerFactory> listenerFactories = getFieldAccessListenerFactories(
                        property);
                newFieldAccessorFactories.add(property, factory, listenerFactories);
            }
        });
        accessorFactoryProviderCache.put(typeInformation, newFieldAccessorFactories);
        return newFieldAccessorFactories;
    }
}