org.springframework.data.mapping.context.MappingContext Java Examples

private DefaultArangoTypeMapper(final String typeKey, final ArangoTypeAliasAccessor accessor,
	final MappingContext<? extends PersistentEntity<?, ?>, ?> mappingContext,
	final List<? extends TypeInformationMapper> additionalMappers) {

	Assert.notNull(accessor, "Accessor must not be null!");
	Assert.notNull(additionalMappers, "AdditionalMappers must not be null!");

	final List<TypeInformationMapper> mappers = new ArrayList<>(additionalMappers.size() + 1);
	if (mappingContext != null) {
		mappers.add(new MappingContextTypeInformationMapper(mappingContext));
	}
	mappers.addAll(additionalMappers);

	this.mappers = Collections.unmodifiableList(mappers);
	this.accessor = accessor;
	this.typeCache = new ConcurrentHashMap<>(16, 0.75f, 4);
	this.typeKey = typeKey;
}
 

/**
 * Creates a new {@link MappingAuditingMetadata} instance from the given
 * {@link PersistentEntity}.
 */
public <P> MappingAuditingMetadata(
		MappingContext<?, ? extends PersistentProperty<?>> context,
		Class<?> type) {

	Assert.notNull(type, "Type must not be null!");

	this.createdByPaths = context.findPersistentPropertyPaths(type,
			withAnnotation(CreatedBy.class,
					org.springframework.data.mybatis.annotation.CreatedBy.class));
	this.createdDatePaths = context.findPersistentPropertyPaths(type,
			withAnnotation(CreatedDate.class,
					org.springframework.data.mybatis.annotation.CreatedDate.class));
	this.lastModifiedByPaths = context.findPersistentPropertyPaths(type,
			withAnnotation(LastModifiedBy.class,
					org.springframework.data.mybatis.annotation.LastModifiedBy.class));
	this.lastModifiedDatePaths = context.findPersistentPropertyPaths(type,
			withAnnotation(LastModifiedDate.class,
					org.springframework.data.mybatis.annotation.LastModifiedDate.class));

	this.isAuditable = Lazy.of( //
			() -> Arrays
					.asList(createdByPaths, createdDatePaths, lastModifiedByPaths,
							lastModifiedDatePaths) //
					.stream() //
					.anyMatch(it -> !it.isEmpty())//
	);
}
 

public MappingCosmosConverter(
    MappingContext<? extends CosmosPersistentEntity<?>, CosmosPersistentProperty> mappingContext,
    @Qualifier(Constants.OBJECTMAPPER_BEAN_NAME) ObjectMapper objectMapper) {
    this.mappingContext = mappingContext;
    this.conversionService = new GenericConversionService();
    this.objectMapper = objectMapper == null ? ObjectMapperFactory.getObjectMapper() :
        objectMapper;
}
 

/**
 * Creates a new {@link QueryMethod} from the given parameters. Looks up the correct
 * query to use for following invocations of the method given.
 *
 * @param method must not be {@literal null}.
 * @param metadata must not be {@literal null}.
 * @param factory must not be {@literal null}.
 * @param mappingContext the mapping context to use.
 */
public SpannerQueryMethod(Method method, RepositoryMetadata metadata,
		ProjectionFactory factory,
		MappingContext<? extends SpannerPersistentEntity<?>,
				SpannerPersistentProperty> mappingContext) {
	super(method, metadata, factory);

	Assert.notNull(mappingContext, "MappingContext must not be null!");

	this.method = method;
	this.mappingContext = mappingContext;
}
 

private DefaultVaultTypeMapper(@Nullable String typeKey, TypeAliasAccessor<Map<String, Object>> accessor,
		MappingContext<? extends PersistentEntity<?, ?>, ?> mappingContext,
		List<? extends TypeInformationMapper> mappers) {

	super(accessor, mappingContext, mappers);

	this.typeKey = typeKey;
}
 

public DefaultArangoConverter(
	final MappingContext<? extends ArangoPersistentEntity<?>, ArangoPersistentProperty> context,
	final CustomConversions conversions, final ResolverFactory resolverFactory, final ArangoTypeMapper typeMapper) {

	this.context = context;
	this.conversions = conversions;
	this.resolverFactory = resolverFactory;
	this.typeMapper = typeMapper;
	conversionService = new DefaultConversionService();
	conversions.registerConvertersIn(conversionService);
	instantiators = new EntityInstantiators();
}
 

@EventListener(ContextRefreshedEvent.class)
public void initIndicesAfterStartup() {

	MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext = this.mongoTemplate
			.getConverter().getMappingContext();

	// consider only entities that are annotated with @Document
	mappingContext.getPersistentEntities().stream().filter(it -> it.isAnnotationPresent(Document.class))
			.forEach(it -> {

				IndexOperations indexOps = this.mongoTemplate.indexOps(it.getType());
				IndexResolver.create(mappingContext).resolveIndexFor(it.getType()).forEach(indexOps::ensureIndex);
			});
}
 

public DerivedQueryCreator(
	final MappingContext<? extends ArangoPersistentEntity<?>, ArangoPersistentProperty> context,
	final Class<?> domainClass, final PartTree tree, final ArangoParameterAccessor accessor,
	final BindParameterBinding binder, final List<String> geoFields) {
	super(tree, accessor);
	this.context = context;
	collectionName = AqlUtils.buildCollectionName(context.getPersistentEntity(domainClass).getCollection());
	this.tree = tree;
	this.accessor = accessor;
	this.geoFields = geoFields;
	this.binding = binder;
	withCollections = new HashSet<>();
}
 

public MappingCrateConverter(MappingContext<? extends CratePersistentEntity<?>, CratePersistentProperty> mappingContext) {
	super(new DefaultConversionService());
	notNull(mappingContext, "Mapping context is required.");
	this.mappingContext = mappingContext;
	this.spELContext = new SpELContext(INSTANCE);
	this.typeMapper = new DefaultCrateTypeMapper();
}
 

public EntityColumnMapper(MappingContext<? extends CratePersistentEntity<?>, CratePersistentProperty> mappingContext) {
	this.mappingContext = mappingContext;
	this.primitiveTypeMapper = new PrimitiveColumnMapper();
	this.primitiveCollectionTypeMapper = new PrimitiveCollectionTypeColumnMapper();
	this.mapTypeMapper = new MapTypeColumnMapper();
	this.mapCollectionTypeMapper = new MapCollectionTypeColumnMapper();
}
 

/**
 * Create new {@link KeyValueTemplate} using the given {@link KeyValueAdapter} and {@link MappingContext}.
 *
 * @param adapter must not be {@literal null}.
 * @param mappingContext must not be {@literal null}.
 */
public KeyValueTemplate(KeyValueAdapter adapter,
		MappingContext<? extends KeyValuePersistentEntity<?, ?>, ? extends KeyValuePersistentProperty<?>> mappingContext) {

	Assert.notNull(adapter, "Adapter must not be null!");
	Assert.notNull(mappingContext, "MappingContext must not be null!");

	this.adapter = adapter;
	this.mappingContext = mappingContext;
	this.identifierGenerator = DefaultIdentifierGenerator.INSTANCE;
}
 

public MybatisMapperBuildProcessor(Configuration configuration,
		MappingContext<?, ?> mappingContext) {

	this.configuration = configuration;
	this.mappingContext = mappingContext;
}
 

@Override
public MappingContext<?, ?> getMappingContext() {
	return this.mappingContext;
}
 

public MappingContext<? extends CosmosPersistentEntity<?>, CosmosPersistentProperty> getMappingContext() {
    return mappingContext;
}
 

public XiaoEUKResultMapper(MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext) {
	super(new DefaultEntityMapper());
	this.mappingContext = mappingContext;
}
 

@Override
public void setMappingContext(MappingContext<?, ?> mappingContext) {
    super.setMappingContext(mappingContext);
}
 

public VaultQueryCreatorFactory(
		MappingContext<VaultPersistentEntity<?>, VaultPersistentProperty> mappingContext) {
	this.mappingContext = mappingContext;
}
 

@Override
public MappingContext<? extends VaultPersistentEntity<?>, VaultPersistentProperty> getMappingContext() {
	return this.mappingContext;
}
 

MappingContext<? extends VaultPersistentEntity<?>, VaultPersistentProperty> getMappingContext() {
	return this.vaultConverter.getMappingContext();
}
 

public MybatisQueryCreationListener(Configuration configuration,
		MappingContext<?, ?> mappingContext) {

	this.configuration = configuration;
	this.mappingContext = mappingContext;
}
 

@Override
public void setMappingContext(MappingContext<?, ?> mappingContext) {
	super.setMappingContext(mappingContext);
}
 

@Override
public void setMappingContext(MappingContext<?, ?> mappingContext) {
	super.setMappingContext(mappingContext);
	this.mappingContext = mappingContext;
}
 

@Override
public MappingContext<? extends CratePersistentEntity<?>, CratePersistentProperty> getMappingContext() {
	return mappingContext;
}
 

public CrateEntityInformationCreatorImpl(
           MappingContext<? extends CratePersistentEntity<?>, CratePersistentProperty> mappingContext) {
	Assert.notNull(mappingContext);
	this.mappingContext = mappingContext;
}
 

/**
 * Creates a new {@link CratePersistentEntityTableManager} for the given {@link CrateMappingContext}
 * 
 * @param mappingContext must not be {@literal null}.
 */
public CratePersistentEntityTableManager(MappingContext<? extends CratePersistentEntity<?>, CratePersistentProperty> mappingContext) {
	super();
	notNull(mappingContext);
	this.entityColumnMapper = new EntityColumnMapper(mappingContext);
}
 

public SolrQueryCreator(PartTree tree, SolrParameterAccessor parameters,
		MappingContext<?, SolrPersistentProperty> context) {
	super(tree, parameters);
	this.context = context;
}
 

public XiaoEUKResultMapper(
		MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext,
		EntityMapper entityMapper) {
	super(entityMapper);
	this.mappingContext = mappingContext;
}
 

public UKResultMapper(MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext) {
	super(new DefaultEntityMapper());
	this.mappingContext = mappingContext;
}
 

public UKResultMapper(
		MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext,
		EntityMapper entityMapper) {
	super(entityMapper);
	this.mappingContext = mappingContext;
}
 

public ResultMapperExt(MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext) {
	super(new DefaultEntityMapper());
	this.mappingContext = mappingContext;
}