com.google.cloud.datastore.DatastoreReaderWriter Java Examples

public DatastoreTemplate(Supplier<? extends DatastoreReaderWriter> datastore,
		DatastoreEntityConverter datastoreEntityConverter,
		DatastoreMappingContext datastoreMappingContext,
		ObjectToKeyFactory objectToKeyFactory) {
	Assert.notNull(datastore, "A non-null Datastore service object is required.");
	Assert.notNull(datastoreEntityConverter,
			"A non-null DatastoreEntityConverter is required.");
	Assert.notNull(datastoreMappingContext,
			"A non-null DatastoreMappingContext is required.");
	Assert.notNull(objectToKeyFactory,
			"A non-null Object to Key factory is required.");
	this.datastore = datastore;
	this.datastoreEntityConverter = datastoreEntityConverter;
	this.datastoreMappingContext = datastoreMappingContext;
	this.objectToKeyFactory = objectToKeyFactory;
}
 

private <T> T computeReferencedField(BaseEntity entity, ReadContext context,
		DatastorePersistentProperty referenceProperty, String fieldName, Class<T> type) {
	T referenced;
	if (referenceProperty.isLazyLoaded()) {
		DatastoreReaderWriter originalTx = getDatastoreReadWriter();
		referenced = LazyUtil.wrapSimpleLazyProxy(() -> {
			if (getDatastoreReadWriter() != originalTx) {
				throw new DatastoreDataException("Lazy load should be invoked within the same transaction");
			}
			return (T) findReferenced(entity, referenceProperty, context);
		}, type, entity.getValue(fieldName));
	}
	else {
		referenced = (T) findReferenced(entity, referenceProperty, context);
	}
	return referenced;
}
 

@Test
public void performTransactionTest() {

	DatastoreReaderWriter transactionContext = mock(DatastoreReaderWriter.class);

	when(this.datastore.runInTransaction(any())).thenAnswer((invocation) -> {
		TransactionCallable<String> callable = invocation.getArgument(0);
		return callable.run(transactionContext);
	});

	List<Entity> e1 = Collections
			.singletonList(this.e1);
	when(transactionContext.fetch(ArgumentMatchers.<Key[]>any())).thenReturn(e1);

	String finalResult = this.datastoreTemplate
			.performTransaction((datastoreOperations) -> {
				datastoreOperations.save(this.ob2);
				datastoreOperations.findById("ignored", TestEntity.class);
				return "all done";
			});

	assertThat(finalResult).isEqualTo("all done");
	verify(transactionContext, times(1)).put(ArgumentMatchers.<FullEntity[]>any());
	verify(transactionContext, times(2)).fetch((Key[]) any());
}
 

/** Example of running in a transaction. */
// [TARGET runInTransaction(TransactionCallable)]
// [VARIABLE "my_callable_result"]
public String runInTransaction(final String callableResult) {
  // [START runInTransaction]
  TransactionCallable<String> callable =
      new TransactionCallable<String>() {
        public String run(DatastoreReaderWriter readerWriter) {
          // use readerWriter to run in transaction
          return callableResult;
        }
      };
  String result = datastore.runInTransaction(callable);
  // [END runInTransaction]
  return result;
}
 

@Override
public <A> A performTransaction(Function<DatastoreOperations, A> operations) {
	if (!(getDatastoreReadWriter() instanceof Datastore)) {
		throw new DatastoreDataException(
				"This DatastoreReadWriter cannot be used to run transactions. A full Datastore service"
						+ " object is required to run functions as transactions. Ensure that this method "
						+ "was not called in an ongoing transaction.");
	}
	return ((Datastore) getDatastoreReadWriter())
			.runInTransaction(
			(DatastoreReaderWriter readerWriter) -> operations.apply(new DatastoreTemplate(() -> readerWriter,
					DatastoreTemplate.this.datastoreEntityConverter,
					DatastoreTemplate.this.datastoreMappingContext,
					DatastoreTemplate.this.objectToKeyFactory)));
}
 

private DatastoreReaderWriter getDatastoreReadWriter() {
	if (TransactionSynchronizationManager.isActualTransactionActive()) {
		DatastoreTransactionManager.Tx tx = (DatastoreTransactionManager.Tx) TransactionSynchronizationManager
				.getResource(this.datastore.get());
		if (tx != null && tx.getTransaction() != null) {
			return tx.getTransaction();
		}
	}
	return this.datastore.get();
}
 

@Bean
@ConditionalOnMissingBean
public DatastoreTemplate datastoreTemplate(Supplier<? extends DatastoreReaderWriter> datastore,
		DatastoreMappingContext datastoreMappingContext,
		DatastoreEntityConverter datastoreEntityConverter, ObjectToKeyFactory objectToKeyFactory) {
	return new DatastoreTemplate(datastore, datastoreEntityConverter, datastoreMappingContext, objectToKeyFactory);
}
 

static InstrumentedDatastoreReaderWriter of(Stats stats, DatastoreReaderWriter readerWriter) {
  Objects.requireNonNull(stats, "stats");
  Objects.requireNonNull(readerWriter, "readerWriter");
  return new InstrumentedDatastoreReaderWriter() {
    @Override
    public DatastoreReaderWriter readerWriter() {
      return readerWriter;
    }

    @Override
    public Stats stats() {
      return stats;
    }
  };
}
 

/**
 * Create a new {@link CheckedDatastoreReaderWriter} wrapping a {@link DatastoreReaderWriter}.
 */
CheckedDatastoreReaderWriter(DatastoreReaderWriter rw) {
  this.rw = Objects.requireNonNull(rw);
}
 

@Override
default DatastoreReaderWriter readerWriter() {
  return transaction();
}
 

@Override
public DatastoreReaderWriter readerWriter() {
  return delegate;
}
 

private void testReaderWriter(DatastoreReaderWriter instrumented, DatastoreReaderWriter delegate) {
  testReader(instrumented, delegate);
  testWriter(instrumented, delegate);
}
 

DatastoreReaderWriter readerWriter();