Java RawJsonDocument类代码示例

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public RegisteredService save(final RegisteredService service) {
    logger.debug("Saving service {}", service);

    if (service.getId() == AbstractRegisteredService.INITIAL_IDENTIFIER_VALUE) {
        ((AbstractRegisteredService) service).setId(service.hashCode());
    }

    final StringWriter stringWriter = new StringWriter();
    registeredServiceJsonSerializer.toJson(stringWriter, service);

    couchbase.bucket().upsert(
            RawJsonDocument.create(
                    String.valueOf(service.getId()),
                    0, stringWriter.toString()));
    return service;
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public List<RegisteredService> load() {
    try {
        logger.debug("Loading services");

        final Bucket bucket = couchbase.bucket();
        final ViewResult allKeys = bucket.query(ViewQuery.from(UTIL_DOCUMENT, ALL_SERVICES_VIEW.name()));
        final List<RegisteredService> services = new LinkedList<>();
        for (final ViewRow row : allKeys) {

            final RawJsonDocument document = row.document(RawJsonDocument.class);
            if (document != null) {
                final String json = document.content();
                logger.debug("Found service: {}", json);

                final StringReader stringReader = new StringReader(json);
                services.add(registeredServiceJsonSerializer.fromJson(stringReader));
            }
        }
        return services;
    } catch (final RuntimeException e) {
        logger.error(e.getMessage(), e);
        return new LinkedList<>();
    }
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public RegisteredService save(final RegisteredService service) {
    LOGGER.debug("Saving service [{}]", service);

    if (service.getId() == AbstractRegisteredService.INITIAL_IDENTIFIER_VALUE) {
        ((AbstractRegisteredService) service).setId(service.hashCode());
    }

    final StringWriter stringWriter = new StringWriter();
    this.registeredServiceJsonSerializer.to(stringWriter, service);

    this.couchbase.bucket().upsert(
            RawJsonDocument.create(
                    String.valueOf(service.getId()),
                    0, stringWriter.toString()));
    return service;
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public List<RegisteredService> load() {
    try {
        LOGGER.debug("Loading services");
        final ViewResult allKeys = executeViewQueryForAllServices();
        final List<RegisteredService> services = new LinkedList<>();
        for (final ViewRow row : allKeys) {

            final RawJsonDocument document = row.document(RawJsonDocument.class);
            if (document != null) {
                final String json = document.content();
                LOGGER.debug("Found service: [{}]", json);

                final StringReader stringReader = new StringReader(json);
                final RegisteredService service = this.registeredServiceJsonSerializer.from(stringReader);
                services.add(service);
                publishEvent(new CasRegisteredServiceLoadedEvent(this, service));
            }
        }
        return services;
    } catch (final RuntimeException e) {
        LOGGER.error(e.getMessage(), e);
        return new LinkedList<>();
    }
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
public void save(List<Event> events) {
	
	for(Event e: events) {
		String es = null;
		try {
			es = mapper.writeValueAsString(e);
		} catch (JsonProcessingException ex) {
			ex.printStackTrace();
		}
		
		RawJsonDocument jsonDoc = RawJsonDocument.create(e.getEventId(), es);
		db.getBucket().insert(jsonDoc);
		
	}
	
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public E checkAndSave(String id, E entity) {
    logger.trace("Check and save entity '{}' with id '{}'", entity, id);
    try {
        String content = getJsonMapper().writeValueAsString(entity);
        RawJsonDocument insertedDocument;
        insertedDocument = runAsync(bucket -> {
            if (entity.getCas() != null) {
                return bucket.replace(RawJsonDocument.create(id, content, entity.getCas()));
            }
            return bucket.insert(RawJsonDocument.create(id, content));
        });
        entity.setCas(insertedDocument.cas());
        return entity;
    } catch (JsonProcessingException e) {
        throw new CouchmoveException("Unable to save document with id " + id, e);
    }
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
/**
 * Test that a single Json document can be written successfully
 * @throws IOException
 * @throws DataConversionException
 * @throws ExecutionException
 * @throws InterruptedException
 */
@Test(groups={"timeout"})
public void testJsonDocumentWrite()
    throws IOException, DataConversionException, ExecutionException, InterruptedException {
  CouchbaseWriter writer = new CouchbaseWriter(_couchbaseEnvironment, ConfigFactory.empty());
  try {

    String key = "hello";
    String testContent = "hello world";
    HashMap<String, String> contentMap = new HashMap<>();
    contentMap.put("value", testContent);
    Gson gson = new Gson();
    String jsonString = gson.toJson(contentMap);
    RawJsonDocument jsonDocument = RawJsonDocument.create(key, jsonString);
    writer.write(jsonDocument, null).get();
    RawJsonDocument returnDoc = writer.getBucket().get(key, RawJsonDocument.class);

    Map<String, String> returnedMap = gson.fromJson(returnDoc.content(), Map.class);
    Assert.assertEquals(testContent, returnedMap.get("value"));
  } finally {
    writer.close();
  }
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public RegisteredService findServiceById(final long id) {
    try {
        logger.debug("Lookup for service {}", id);
        final RawJsonDocument document = couchbase.bucket().get(String.valueOf(id), RawJsonDocument.class);
        if (document != null) {
            final String json = document.content();
            final StringReader stringReader = new StringReader(json);
            return registeredServiceJsonSerializer.fromJson(stringReader);
        }
    } catch (final Exception e) {
        logger.error(e.getMessage(), e);
    }
    return null;
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public RegisteredService findServiceById(final long id) {
    try {
        LOGGER.debug("Lookup for service [{}]", id);
        final RawJsonDocument document = this.couchbase.bucket().get(String.valueOf(id), RawJsonDocument.class);
        if (document != null) {
            final String json = document.content();
            final StringReader stringReader = new StringReader(json);
            return this.registeredServiceJsonSerializer.from(stringReader);
        }
    } catch (final Exception e) {
        LOGGER.error(e.getMessage(), e);
    }
    return null;
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
public void save(Cart cart) {
	String json = null;
	try {
		json = mapper.writeValueAsString(cart);
	} catch (JsonProcessingException ex) {
		ex.printStackTrace();
	}

	RawJsonDocument jsonDoc = RawJsonDocument.create(cart.getId(), json);
	db.getBucket().upsert(jsonDoc);
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public E save(String id, E entity) {
    logger.trace("Save entity '{}' with id '{}'", entity, id);
    try {
        String json = getJsonMapper().writeValueAsString(entity);
        RawJsonDocument insertedDocument = runAsync(bucket -> bucket.upsert(RawJsonDocument.create(id, json)));
        entity.setCas(insertedDocument.cas());
        return entity;
    } catch (JsonProcessingException e) {
        throw new CouchmoveException("Unable to save document with id " + id, e);
    }
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public E findOne(String id) {
    logger.trace("Find entity with id '{}'", id);
    RawJsonDocument document = runAsync(bucket -> bucket.get(id, RawJsonDocument.class));
    if (document == null) {
        return null;
    }
    try {
        E entity = getJsonMapper().readValue(document.content(), entityClass);
        entity.setCas(document.cas());
        return entity;
    } catch (IOException e) {
        throw new CouchmoveException("Unable to read document with id " + id, e);
    }
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public Observable<T> findAll(final Iterable<String> ids) {
  return Observable.from(ids)
    .flatMap(id -> bucket.get(id, RawJsonDocument.class))
    .map(deserializer)
    .timeout(timeout, unit);
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public Observable<T> queryView(final ViewQuery query) {
  return Observable.just(query)
    .flatMap(bucket::query)
    .flatMap(AsyncViewResult::rows)
    .flatMap(row -> row.document(RawJsonDocument.class))
    .map(deserializer)
    .timeout(timeout, unit);
}
 

import com.couchbase.client.java.document.RawJsonDocument; //导入依赖的package包/类
@Override
public Observable<String> delete(final T entity) {
  return Observable.just(entity)
      .map(serializer)
      .flatMap(bucket::remove)
      .map(RawJsonDocument::id)
      .timeout(timeout, unit);
}