Java NamespaceManager类代码示例

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    throws java.io.IOException {

  // Update the count for the current namespace.
  updateCount("request");

  // Update the count for the "-global-" namespace.
  String namespace = NamespaceManager.get();
  try {
    // "-global-" is namespace reserved by the application.
    NamespaceManager.set("-global-");
    updateCount("request");
  } finally {
    NamespaceManager.set(namespace);
  }
  resp.setContentType("text/plain");
  resp.getWriter().println("Counts are now updated.");
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Override
protected void doGet(HttpServletRequest req,
                     HttpServletResponse resp)
    throws IOException {

  // Increment the count for the current namespace asynchronously.
  QueueFactory.getDefaultQueue().add(
      TaskOptions.Builder.withUrl("/_ah/update_count")
          .param("countName", "SomeRequest"));
  // Increment the global count and set the
  // namespace locally.  The namespace is
  // transferred to the invoked request and
  // executed asynchronously.
  String namespace = NamespaceManager.get();
  try {
    NamespaceManager.set("-global-");
    QueueFactory.getDefaultQueue().add(
        TaskOptions.Builder.withUrl("/_ah/update_count")
            .param("countName", "SomeRequest"));
  } finally {
    NamespaceManager.set(namespace);
  }
  resp.setContentType("text/plain");
  resp.getWriter().println("Counts are being updated.");
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {

  // Increment the count for the current namespace asynchronously.
  QueueFactory.getDefaultQueue()
      .add(TaskOptions.Builder.withUrl("/_ah/update_count").param("countName", "SomeRequest"));
  // Increment the global count and set the
  // namespace locally.  The namespace is
  // transferred to the invoked request and
  // executed asynchronously.
  String namespace = NamespaceManager.get();
  try {
    NamespaceManager.set("-global-");
    QueueFactory.getDefaultQueue()
        .add(TaskOptions.Builder.withUrl("/_ah/update_count").param("countName", "SomeRequest"));
  } finally {
    NamespaceManager.set(namespace);
  }
  resp.setContentType("text/plain");
  resp.getWriter().println("Counts are being updated.");
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
private void populate(DatastoreService ds, String namespace) {
  NamespaceManager.set(namespace);
  Entity e = new Entity("Fun");
  e.setProperty("me", "yes");
  e.setProperty("you", 23);
  e.setUnindexedProperty("haha", 0);
  ds.put(e);
  Entity s = new Entity("Strange");
  ArrayList nowhereList = new ArrayList<Integer>();
  nowhereList.add(1);
  nowhereList.add(2);
  nowhereList.add(3);
  s.setProperty("nowhere", nowhereList);
  ds.put(s);
  Entity s2 = new Entity("Stranger");
  s2.setProperty("missing", new ArrayList<Integer>());
  ds.put(s2);
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Override
public Map<String, SessionData> getAllSessions() {
  final String originalNamespace = NamespaceManager.get();
  NamespaceManager.set("");
  try {
    DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
    PreparedQuery pq = ds.prepare(new Query(SESSION_ENTITY_TYPE));
    Map<String, SessionData> sessions = new HashMap<>();
    for (Entity entity : pq.asIterable()) {
      sessions.put(entity.getKey().getName(), createSessionFromEntity(entity));
    }
    return sessions;
  } finally {
    NamespaceManager.set(originalNamespace);
  }
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
/**
 * Creates a {@link com.google.appengine.api.datastore.Key} from the specified kindName and CloudEntity id. If
 * the kindName has _private suffix, the key will be created under a namespace
 * for the specified {@link com.google.appengine.api.users.User}.
 *
 * @param kindName
 *          Name of kind
 * @param id
 *          CloudEntity id
 * @param user
 *          {@link com.google.appengine.api.users.User} of the requestor
 * @return {@link com.google.appengine.api.datastore.Key}
 */
public Key createKeyWithNamespace(String kindName, String id, User user) {

  // save the original namespace
  String origNamespace = NamespaceManager.get();

  // set namespace based on the kind suffix
  if (kindName.startsWith(SecurityChecker.KIND_PREFIX_PRIVATE)) {
    String userId = getUserId(user);
    NamespaceManager.set(userId);
  } else {
    NamespaceManager.set(SecurityChecker.NAMESPACE_DEFAULT);
  }

  // create a key
  Key k = KeyFactory.createKey(kindName, id);

  // restore the original namespace
  NamespaceManager.set(origNamespace);
  return k;
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
/**
 * Creates {@link com.google.appengine.api.datastore.Query} from the specified kindName. If the kindName has
 * _private suffix, the key will be created under a namespace for the
 * specified {@link com.google.appengine.api.users.User}.
 *
 * @param kindName
 *          Name of kind
 * @param user
 *          {@link com.google.appengine.api.users.User} of the requestor
 * @return {@link com.google.appengine.api.datastore.Query}
 */
public Query createKindQueryWithNamespace(String kindName, User user) {

  // save the original namespace
  String origNamespace = NamespaceManager.get();

  // set namespace based on the kind suffix
  if (kindName.startsWith(KIND_PREFIX_PRIVATE)) {
    String userId = getUserId(user);
    NamespaceManager.set(userId);
  } else {
    NamespaceManager.set(NAMESPACE_DEFAULT);
  }

  // create a key
  Query q = new Query(kindName);

  // restore the original namespace
  NamespaceManager.set(origNamespace);
  return q;
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
/**
 * Creates a {@link Key} from the specified kindName and CloudEntity id. If
 * the kindName has _private suffix, the key will be created under a namespace
 * for the specified {@link User}.
 *
 * @param kindName
 *          Name of kind
 * @param id
 *          CloudEntity id
 * @param user
 *          {@link User} of the requestor
 * @return {@link Key}
 */
public Key createKeyWithNamespace(String kindName, String id, User user) {

  // save the original namespace
  String origNamespace = NamespaceManager.get();

  // set namespace based on the kind suffix
  if (kindName.startsWith(SecurityChecker.KIND_PREFIX_PRIVATE)) {
    String userId = getUserId(user);
    NamespaceManager.set(userId);
  } else {
    NamespaceManager.set(SecurityChecker.NAMESPACE_DEFAULT);
  }

  // create a key
  Key k = KeyFactory.createKey(kindName, id);

  // restore the original namespace
  NamespaceManager.set(origNamespace);
  return k;
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
/**
 * Creates {@link Query} from the specified kindName. If the kindName has
 * _private suffix, the key will be created under a namespace for the
 * specified {@link User}.
 *
 * @param kindName
 *          Name of kind
 * @param user
 *          {@link User} of the requestor
 * @return {@link Query}
 */
public Query createKindQueryWithNamespace(String kindName, User user) {

  // save the original namespace
  String origNamespace = NamespaceManager.get();

  // set namespace based on the kind suffix
  if (kindName.startsWith(KIND_PREFIX_PRIVATE)) {
    String userId = getUserId(user);
    NamespaceManager.set(userId);
  } else {
    NamespaceManager.set(NAMESPACE_DEFAULT);
  }

  // create a key
  Query q = new Query(kindName);

  // restore the original namespace
  NamespaceManager.set(origNamespace);
  return q;
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Test
public void testUserNameSpace() {
    String testMethodTag = "testUserNameSpace";
    NamespaceManager.set("junittest");

    TaskOptions taskOptions = TaskOptions.Builder
        .withMethod(TaskOptions.Method.POST)
        .param(TEST_RUN_ID, testRunId)
        .param(TEST_METHOD_TAG, testMethodTag)
        .url("/queuetask/addentity");
    // task name explicitly not specified.

    QueueFactory.getQueue(E2E_TESTING).add(taskOptions);
    Entity entity = dsUtil.waitForTaskThenFetchEntity(waitInterval, retryMax, testMethodTag);
    Map<String, String> expectedParams = dsUtil.createParamMap(testMethodTag);
    dsUtil.assertTaskParamsMatchEntityProperties(expectedParams, entity);
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Test
public void testDeferredUserNS() {
    String testMethodTag = "testDeferredUserNS";
    String specifiedNameSpace = "the_testDeferredUserNS";
    Map<String, String> paramMap = dsUtil.createParamMap(testMethodTag);

    NamespaceManager.set(specifiedNameSpace);

    TaskOptions taskOptions = TaskOptions.Builder.withPayload(new ExecDeferred(dsUtil, paramMap));

    // no task name specified.
    QueueFactory.getQueue(E2E_TESTING_DEFERRED).add(taskOptions);
    Entity entity = dsUtil.waitForTaskThenFetchEntity(waitInterval, retryMax, testMethodTag);

    Map<String, String> expectedMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
    expectedMap.putAll(paramMap);
    expectedMap.put("X-AppEngine-Current-Namespace", specifiedNameSpace);

    dsUtil.assertTaskParamsMatchEntityProperties(expectedMap, entity);
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Test
public void testQueryListWithNamespaceChange() throws Exception {
    Key parentKey = createQueryNamespaceTestParent("testQueryListWithNamespaceChange");
    Entity bob = createEntity("QLWNC", parentKey)
        .withProperty("name", "Bob")
        .withProperty("lastName", "Smith")
        .store();

    try {
        Query query = new Query("QLWNC");
        List<Entity> list = service.prepare(query).asList(withDefaults());

        final String previousNS = NamespaceManager.get();
        NamespaceManager.set("QwertyNS");
        try {
            assertEquals(1, list.size());
        } finally {
            NamespaceManager.set(previousNS);
        }
    } finally {
        service.delete(bob.getKey(), parentKey);
    }
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Test
public void testQueriesOnlyReturnResultsInCurrentNamespace() {
    deleteNsKinds("one", "foo");
    deleteNsKinds("two", "foo");
    sync();

    NamespaceManager.set("one");
    Entity fooOne = new Entity("foo");
    service.put(fooOne);

    NamespaceManager.set("two");
    Entity fooTwo = new Entity("foo");
    service.put(fooTwo);
    sync();

    List<Entity> listTwo = service.prepare(new Query("foo").setAncestor(fooTwo.getKey())).asList(withDefaults());
    assertEquals(Collections.singletonList(fooTwo), listTwo);

    NamespaceManager.set("one");
    List<Entity> listOne = service.prepare(new Query("foo").setAncestor(fooOne.getKey())).asList(withDefaults());
    assertEquals(Collections.singletonList(fooOne), listOne);

    service.delete(fooOne.getKey());
    service.delete(fooTwo.getKey());
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void testQueriesByAncestorInOtherNamespaceThrowsIllegalArgumentException() {
    deleteNsKinds("one", "foo");
    deleteNsKinds("two", "foo");
    sync();

    NamespaceManager.set("one");
    Entity fooOne = new Entity("foo");
    service.put(fooOne);

    NamespaceManager.set("two");
    Entity fooTwo = new Entity("foo");
    service.put(fooTwo);
    sync();

    // java.lang.IllegalArgumentException: Namespace of ancestor key and query must match.
    service.prepare(new Query("foo").setAncestor(fooOne.getKey())).asList(withDefaults());
}
 

import com.google.appengine.api.NamespaceManager; //导入依赖的package包/类
@Test
public void testQueryConsidersCurrentNamespaceWhenCreatedNotWhenPreparedOrExecuted() {
    deleteNsKinds("one", "foo");
    deleteNsKinds("two", "foo");
    sync();

    NamespaceManager.set("one");
    Entity fooOne = new Entity("foo");
    service.put(fooOne);

    NamespaceManager.set("two");
    Entity fooTwo = new Entity("foo");
    service.put(fooTwo);
    sync();

    Query query = new Query("foo").setAncestor(fooTwo.getKey()); // query created in namespace "two"

    NamespaceManager.set("one");
    PreparedQuery preparedQuery = service.prepare(query);
    assertEquals(fooTwo, preparedQuery.asSingleEntity());

    service.delete(fooOne.getKey());
    service.delete(fooTwo.getKey());
}