org.springframework.data.repository.core.EntityInformation Java Examples

/** {@inheritDoc} */
@Override public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {
    return new AbstractEntityInformation<T, ID>(domainClass) {
        /** {@inheritDoc} */
        @Override public ID getId(T entity) {
            return null;
        }

        /** {@inheritDoc} */
        @Override public Class<ID> getIdType() {
            return null;
        }
    };
}
 

@SuppressWarnings("unchecked")
private <T, S> EntityInformation<T, S> getEntityInformationFor(Class<T> type) {

	PersistentEntity<T, ?> requiredPersistentEntity = (PersistentEntity<T, ?>) context
			.getRequiredPersistentEntity(type);

	return new PersistentEntityInformation<>(requiredPersistentEntity);
}
 

@Test // DATACMNS-525
public void saveNewWithNumericId() {

	EntityInformation<WithNumericId, ?> ei = getEntityInformationFor(WithNumericId.class);
	SimpleKeyValueRepository<WithNumericId, ?> temp = new SimpleKeyValueRepository<>(ei, opsMock);

	WithNumericId withNumericId = new WithNumericId();
	temp.save(withNumericId);

	verify(opsMock, times(1)).insert(eq(withNumericId));
}
 

@Before
public void setUp() {

	this.context = new KeyValueMappingContext<>();

	EntityInformation<Foo, String> ei = getEntityInformationFor(Foo.class);
	repo = new SimpleKeyValueRepository<>(ei, opsMock);
}
 

@Override
@SuppressWarnings("unchecked")
public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {

	PersistentEntity<T, ?> entity = (PersistentEntity<T, ?>) context.getRequiredPersistentEntity(domainClass);

	return new PersistentEntityInformation<>(entity);
}
 

/**
 * Creates a new {@link QuerydslKeyValueRepository} for the given {@link EntityInformation},
 * {@link KeyValueOperations} and {@link EntityPathResolver}.
 *
 * @param entityInformation must not be {@literal null}.
 * @param operations must not be {@literal null}.
 * @param resolver must not be {@literal null}.
 */
public QuerydslKeyValueRepository(EntityInformation<T, ID> entityInformation, KeyValueOperations operations,
		EntityPathResolver resolver) {

	super(entityInformation, operations);

	Assert.notNull(resolver, "EntityPathResolver must not be null!");

	EntityPath<T> path = resolver.createPath(entityInformation.getJavaType());
	this.builder = new PathBuilder<>(path.getType(), path.getMetadata());
}
 

/**
 * Creates a new {@link SimpleKeyValueRepository} for the given {@link EntityInformation} and
 * {@link KeyValueOperations}.
 *
 * @param metadata must not be {@literal null}.
 * @param operations must not be {@literal null}.
 */
public SimpleKeyValueRepository(EntityInformation<T, ID> metadata, KeyValueOperations operations) {

	Assert.notNull(metadata, "EntityInformation must not be null!");
	Assert.notNull(operations, "KeyValueOperations must not be null!");

	this.entityInformation = metadata;
	this.operations = operations;
}
 

@Override
public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {
    PersistentEntity<T, ?> entity = (PersistentEntity<T, ?>) keyValueOperations.getMappingContext()
                                                                               .getPersistentEntity(domainClass);
    Assert.notNull(entity, "Entity must not be 'null'.");
    return new HazelcastEntityInformation<>(entity);
}
 

@SuppressWarnings({ "unchecked", "rawtypes" })
private <S extends T> EntityInformation<Object, S> getEntityInformation(S entity) {

	Class<?> userClass = ClassUtils.getUserClass(entity.getClass());

	if (entity instanceof AbstractPersistable<?>) {
		return new JpaPersistableEntityInformation(userClass, entityManager.getMetamodel());
	}

	return new JpaMetamodelEntityInformation(userClass, entityManager.getMetamodel());
}
 

/**
 * @param entity
 */
private <S extends T> void doSave(S entity) {

	EntityInformation<Object, S> entityInformation = getEntityInformation(entity);

	if (entityInformation.isNew(entity)) {
		entityManager.persist(entity);
	} else {
		entityManager.merge(entity);
	}
}
 

/** {@inheritDoc} */
@Override public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {
    return new AbstractEntityInformation<T, ID>(domainClass) {
        /** {@inheritDoc} */
        @Override public ID getId(T entity) {
            return null;
        }

        /** {@inheritDoc} */
        @Override public Class<ID> getIdType() {
            return null;
        }
    };
}
 

@Transactional
@Override
public <T> T save(Class<T> clazz, T entity) {
    EntityInformation<T, ?> entityInformation = getEntityInformation(clazz);
    if (entityInformation.isNew(entity)) {
        entityManager.persist(entity);
        return entity;
    } else {
        return entityManager.merge(entity);
    }
}
 

/** {@inheritDoc} */
@Override public <T, ID extends Serializable> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {
    return new AbstractEntityInformation<T, ID>(domainClass) {
        @Override public ID getId(T entity) {
            return null;
        }

        @Override public Class<ID> getIdType() {
            return null;
        }
    };
}
 

@Override
@SuppressWarnings("unchecked")
public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {

	VaultPersistentEntity<T> entity = (VaultPersistentEntity<T>) this.operations.getMappingContext()
			.getPersistentEntity(domainClass);

	return new MappingVaultEntityInformation<>(entity);
}
 

@Test
public void getEntityInformationTest() {
	EntityInformation<TestEntity, Key> entityInformation = this.spannerRepositoryFactory
			.getEntityInformation(TestEntity.class);
	assertThat(entityInformation.getJavaType()).isEqualTo(TestEntity.class);
	assertThat(entityInformation.getIdType()).isEqualTo(Key.class);

	TestEntity t = new TestEntity();
	t.id = "a";
	t.id2 = 3L;
	assertThat(entityInformation.getId(t))
			.isEqualTo(Key.newBuilder().append(t.id).append(t.id2).build());
}
 

@Override
@SuppressWarnings("unchecked")
public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {
	SpannerPersistentEntity<T> entity = (SpannerPersistentEntity<T>) this.spannerMappingContext
			.getPersistentEntity(domainClass);

	if (entity == null) {
		throw new MappingException(String.format(
				"Could not lookup mapping metadata for domain class %s!",
				domainClass.getName()));
	}

	return (EntityInformation<T, ID>) new SpannerPersistentEntityInformation<>(
			entity);
}
 

@Test
public void getEntityInformationTest() {
	EntityInformation<TestEntity, String> entityInformation = this.datastoreRepositoryFactory
			.getEntityInformation(TestEntity.class);
	assertThat(entityInformation.getJavaType()).isEqualTo(TestEntity.class);
	assertThat(entityInformation.getIdType()).isEqualTo(String.class);

	TestEntity t = new TestEntity();
	t.id = "a";
	assertThat(entityInformation.getId(t)).isEqualTo("a");
}
 

@Override
protected Object getTargetRepository(RepositoryInformation information) {
    final EntityInformation<?, Serializable> entityInformation =
        getEntityInformation(information.getDomainType());
    return getTargetRepositoryViaReflection(information, entityInformation,
        this.applicationContext);
}
 

@Override
@SuppressWarnings("unchecked")
public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {
	DatastorePersistentEntity entity = this.datastoreMappingContext
			.getPersistentEntity(domainClass);

	if (entity == null) {
		throw new MappingException(
				"Could not lookup mapping metadata for domain class: "
						+ domainClass.getName());
	}

	return new DatastorePersistentEntityInformation<>(entity);
}
 

@Override
protected Object getTargetRepository(RepositoryInformation information) {
    final EntityInformation<?, Serializable> entityInformation = getEntityInformation(information.getDomainType());
    return getTargetRepositoryViaReflection(information, entityInformation, this.applicationContext);
}
 

public EntityInformation getEntityInformation(Class<?> entityClass, EntityManager em) {
    return JpaEntityInformationSupport.getEntityInformation(entityClass, em);
}
 

@Override
public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainType) {
    return new CosmosEntityInformation<>(domainType);
}
 

@Override
public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainType) {
    return new CosmosEntityInformation<>(domainType);
}
 

@Override
protected Object getTargetRepository(RepositoryInformation repositoryInformation) {

	EntityInformation<?, ?> entityInformation = getEntityInformation(repositoryInformation.getDomainType());
	return super.getTargetRepositoryViaReflection(repositoryInformation, entityInformation, keyValueOperations);
}
 

@Test
public void useMappingCosmosDBEntityInfoIfMappingContextSet() {
    final CosmosRepositoryFactory factory = new CosmosRepositoryFactory(dbTemplate, applicationContext);
    final EntityInformation<Person, String> entityInfo = factory.getEntityInformation(Person.class);
    assertTrue(entityInfo instanceof CosmosEntityInformation);
}
 

@SuppressWarnings({"unchecked", "rawtypes"})
protected Object getTargetRepository(RepositoryInformation repositoryInformation) {
    EntityInformation<?, Serializable> entityInformation = getEntityInformation(repositoryInformation.getDomainType());
    return new MyTitleRepositoryImpl(entityInformation, this.keyValueOperations);
}
 

public MyTitleRepositoryImpl(EntityInformation<T, ID> metadata, KeyValueOperations keyValueOperations) {
    super(metadata, keyValueOperations);
}
 

public SimpleHazelcastRepository(EntityInformation<T, ID> metadata, KeyValueOperations operations) {
    super(metadata, operations);
}
 

@Override
public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> aClass) {
	return (EntityInformation<T, ID>) new FirestorePersistentEntityInformation<T>(
			(FirestorePersistentEntity<T>) this.firestoreMappingContext.getPersistentEntity(aClass));
}
 

@SuppressWarnings("unchecked")
@Override
public <T, ID> EntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {
    return new EbeanEntityInformation(this.ebeanServer, domainClass);
}