Java JsonDocument类代码示例

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Override
public void appendEvents(Bucket bucket, List<? extends EventMessage<?>> events, Serializer serializer) {
    List<JsonObject> jsonObjects = createEventDocuments(events, serializer).collect(Collectors.toList());
    jsonObjects.forEach((e) -> {
        String docId = EVENT_PREFIX + e.getString("aggregateIdentifier");
        if (!bucket.exists(docId)) {
            JsonArray eventArray = JsonArray.empty()
                    .add(e);
            JsonObject data = JsonObject.empty()
                    .put("events", eventArray);
            JsonDocument doc = JsonDocument.create(docId, data);
            bucket.insert(doc);
        } else {
            bucket.mutateIn(docId)
                    .arrayAppend("events", e, false)
                    .execute();
        }

    });
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Override
public List<? extends DomainEventData<?>> findDomainEvents(Bucket bucket, String aggregateIdentifier, long firstSequenceNumber, int batchSize) {
    String docId = EVENT_PREFIX + aggregateIdentifier;
    JsonDocument doc = bucket.get(docId);
    List<EventEntry> eventEntries = new ArrayList<>();
    if (doc != null) {
        DocumentFragment<Lookup> fragment = bucket.lookupIn(docId)
                .get("events")
                .execute();
        JsonArray events = fragment.content("events", JsonArray.class);
        events.forEach((event) -> {
            eventEntries.add(new EventEntry((JsonObject) event));
        });
    }
    return eventEntries;
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
public void loadJson(Bucket bucket, String artistId) 
{
	SpotifyLoaderService loaderService = new SpotifyLoaderServiceImpl();
	
	String jsonU2Artist = loaderService.getArtist(artistId);
	
	JsonObject json = JsonObject.fromJson(jsonU2Artist);
	JsonDocument docs = JsonDocument.create("artist", json);
	bucket.upsert(docs);
	
	String jsonU2Albums = loaderService.getAlbums(artistId);
	
	json = JsonObject.fromJson(jsonU2Albums);
	docs = JsonDocument.create("albums", json);
	bucket.upsert(docs);
	
	String jsonU2RelatedArtists = loaderService.getRelatedArtists(artistId);
	
	json = JsonObject.fromJson(jsonU2RelatedArtists);
	docs = JsonDocument.create("relArtists", json);
	bucket.upsert(docs);
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
/**
 * The id in the specified <code>jsonDocument</code> will be set to the returned object if and only if the id is not null or empty and the content in <code>jsonDocument</code> doesn't contain any "id" property, and it's acceptable to the <code>targetClass</code>.
 * 
 * @param targetClass an entity class with getter/setter method or <code>Map.class</code>
 * @param jsonDocument
 * @return
 */
public static <T> T toEntity(final Class<T> targetClass, final JsonDocument jsonDocument) {
    final T result = toEntity(targetClass, jsonDocument.content());
    final String id = jsonDocument.id();

    if (N.notNullOrEmpty(id) && result != null) {
        if (Map.class.isAssignableFrom(targetClass)) {
            ((Map<String, Object>) result).put(_ID, id);
        } else {
            final Method idSetMethod = getObjectIdSetMethod(targetClass);

            if (idSetMethod != null) {
                ClassUtil.setPropValue(result, idSetMethod, id);
            }
        }
    }

    return result;
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
/**
 * Returns an instance of the specified target class with the property values from the specified JSON String.
 * 
 * @param targetClass <code>JsonArray.class</code>, <code>JsonObject.class</code> or <code>JsonDocument.class</code>
 * @param json
 * @return
 */
public static <T> T fromJSON(final Class<T> targetClass, final String json) {
    if (targetClass.equals(JsonObject.class)) {
        return (T) JsonObject.from(N.fromJSON(Map.class, json));
    } else if (targetClass.equals(JsonArray.class)) {
        return (T) JsonArray.from(N.fromJSON(List.class, json));
    } else if (targetClass.equals(JsonDocument.class)) {
        final JsonObject jsonObject = JsonObject.from(N.fromJSON(Map.class, json));
        final String id = N.stringOf(jsonObject.get(_ID));

        jsonObject.removeKey(_ID);

        return (T) JsonDocument.create(id, jsonObject);
    } else {
        throw new IllegalArgumentException("Unsupported type: " + ClassUtil.getCanonicalClassName(targetClass));
    }
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
static JsonDocument toJsonDocument(final Object obj, final JsonObject jsonObject) {
    final Class<?> cls = obj.getClass();
    final Method idSetMethod = getObjectIdSetMethod(obj.getClass());
    final String idPropertyName = N.isEntity(cls) ? (idSetMethod == null ? null : ClassUtil.getPropNameByMethod(idSetMethod)) : _ID;

    String id = null;

    if (idPropertyName != null && jsonObject.containsKey(idPropertyName)) {
        id = N.stringOf(jsonObject.get(idPropertyName));

        jsonObject.removeKey(idPropertyName);
    }

    if (N.isNullOrEmpty(id)) {
        throw new IllegalArgumentException("No id property included the specified object: " + N.toString(jsonObject));
    }

    return JsonDocument.create(id, jsonObject);
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Test
    public void basicJSONtest() {

        JsonObject user = JsonObject.empty()
                .put("firstname", "Walter")
                .put("lastname", "White")
                .put("job", "chemistry teacher")
                .put("age", 50);
        
        assertEquals( "{\"firstname\":\"Walter\",\"job\":\"chemistry teacher\",\"age\":50,\"lastname\":\"White\"}", user.toString());
        
        JsonDocument doc = JsonDocument.create("walter", user);
        
        assertEquals("JsonDocument{id='walter', cas=0, expiry=0, content={\"firstname\":\"Walter\",\"job\":\"chemistry teacher\",\"age\":50,\"lastname\":\"White\"}, mutationToken=null}\n" +
"", doc.toString());

    }
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Test
public void createDocument() throws Exception {
  new MockUnit(Bucket.class, Session.class)
      .expect(session("sid", 2, 3, 4, "foo", "bar"))
      .expect(unit -> {
        Bucket bucket = unit.get(Bucket.class);
        JsonDocument doc = JsonDocument.create("session::sid", 60, JsonObject.create()
            .put("foo", "bar")
            .put("_createdAt", 2L)
            .put("_accessedAt", 3L)
            .put("_savedAt", 4L));
        expect(bucket.upsert(doc)).andReturn(doc);
      })
      .run(unit -> {
        new CouchbaseSessionStore(unit.get(Bucket.class), "1m")
            .create(unit.get(Session.class));
      });
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Test
public void saveDocument() throws Exception {
  new MockUnit(Bucket.class, Session.class)
      .expect(session("sid", 2, 3, 4, "foo", "bar"))
      .expect(unit -> {
        Bucket bucket = unit.get(Bucket.class);
        JsonDocument doc = JsonDocument.create("session::sid", 60, JsonObject.create()
            .put("foo", "bar")
            .put("_createdAt", 2L)
            .put("_accessedAt", 3L)
            .put("_savedAt", 4L));
        expect(bucket.upsert(doc)).andReturn(doc);
      })
      .run(unit -> {
        new CouchbaseSessionStore(unit.get(Bucket.class), "1m")
            .save(unit.get(Session.class));
      });
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Test
public void createDocumentWithSeconds() throws Exception {
  new MockUnit(Bucket.class, Session.class)
      .expect(session("sid", 2, 3, 4, "foo", "bar"))
      .expect(unit -> {
        Bucket bucket = unit.get(Bucket.class);
        JsonDocument doc = JsonDocument.create("session::sid", 45, JsonObject.create()
            .put("foo", "bar")
            .put("_createdAt", 2L)
            .put("_accessedAt", 3L)
            .put("_savedAt", 4L));
        expect(bucket.upsert(doc)).andReturn(doc);
      })
      .run(unit -> {
        new CouchbaseSessionStore(unit.get(Bucket.class), "45")
            .create(unit.get(Session.class));
      });
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Test
public void createDocumentNoTimeout() throws Exception {
  new MockUnit(Bucket.class, Session.class)
      .expect(session("sid", 2, 3, 4, "foo", "bar"))
      .expect(unit -> {
        Bucket bucket = unit.get(Bucket.class);
        JsonDocument doc = JsonDocument.create("session::sid", 0, JsonObject.create()
            .put("foo", "bar")
            .put("_createdAt", 2L)
            .put("_accessedAt", 3L)
            .put("_savedAt", 4L));
        expect(bucket.upsert(doc)).andReturn(doc);
      })
      .run(unit -> {
        new CouchbaseSessionStore(unit.get(Bucket.class), -1)
            .create(unit.get(Session.class));
      });
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Override
public void handle(RoutingContext rc) {
  Long albumId = PathUtil.parseLongParam(rc.pathParam("albumId"));
  if (albumId == null) {
    rc.next();
    return;
  }

  User user = rc.user();
  if (user == null) {
    rc.response().setStatusCode(HTTP_UNAUTHORIZED).end();
    return;
  }

  String comment = rc.getBodyAsString();
  if (comment == null || comment.isEmpty()) {
    rc.response().setStatusCode(HTTP_BAD_REQUEST).end();
    return;
  }

  long timestamp = System.currentTimeMillis();

  JsonObject content = new JsonObject()
    .put("albumId", albumId)
    .put("username", user.principal().getValue("username"))
    .put("timestamp", timestamp)
    .put("comment", comment);

  JsonDocument document = JsonDocument.create("comment::" + timestamp, com.couchbase.client.java.document.json.JsonObject.from(content.getMap()));
  Vertx vertx = rc.vertx();
  Observable<JsonDocument> documentObservable = albumCommentsBucket.upsert(document);
  RxJavaInterop.toV2Single(documentObservable.toSingle())
    .observeOn(RxHelper.scheduler(vertx.getOrCreateContext()))
    .doOnSuccess(doc -> vertx.setTimer(1000, v -> {
      String address = "album." + albumId + ".comments.new";
      vertx.eventBus().<JsonObject>publish(address, content);
    }))
    .subscribe(doc -> rc.response().end(), rc::fail);
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
public static boolean checkIfDocumentExists(String coilID, Bucket proteusBucket) {
	JsonDocument checkExists = proteusBucket.get(coilID);
	if (checkExists == null)
		return false;
	else
		return true;
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Test
public void testRepository() throws Exception {
	Developer developer = new Developer();
       DeveloperInfo developerInfo = new DeveloperInfo();
	developer.setId("alovelace");
       developerInfo.setFirstName("Ada");
       developerInfo.setLastName("Lovelace");
	developerInfo.setUsername("alovelace");
       developer.setDeveloperInfo(developerInfo);
	developerRepository.save(developer);

	JsonDocument doc = bucket.get("alovelace");
	Assert.assertNotNull(doc);
}
 

import com.couchbase.client.java.document.JsonDocument; //导入依赖的package包/类
@Override
public Tt upsert(Tt tt) {
    JsonObject content = JsonObject.fromJson(gson.toJson(tt));
    content.put(DOCTYPE_KEY, DOCTYPE_TT);
    Document<?> document = JsonDocument.create(tt.getId().toString(), content);
    bucket.upsert(document);
    return tt;
}