Java Holder类代码示例

import javax.xml.ws.Holder; //导入依赖的package包/类
@Override
public List<Microservice> getAllMicroservices() {
  Holder<GetAllServicesResponse> holder = new Holder<>();
  IpPort ipPort = ipPortManager.getAvailableAddress();

  CountDownLatch countDownLatch = new CountDownLatch(1);
  RestUtils.get(ipPort,
      Const.REGISTRY_API.MICROSERVICE_OPERATION_ALL,
      new RequestParam(),
      syncHandler(countDownLatch, GetAllServicesResponse.class, holder));
  try {
    countDownLatch.await();
    if (holder.value != null) {
      return holder.value.getServices();
    }
  } catch (Exception e) {
    LOGGER.error("query all microservices failed", e);
  }
  return emptyList();
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Test
public void testInvokingServiceFromCXFClient() throws Exception {
    JaxWsProxyFactoryBean proxyFactory = new JaxWsProxyFactoryBean();
    ClientFactoryBean clientBean = proxyFactory.getClientFactoryBean();
    clientBean.setAddress(ADDRESS);
    clientBean.setServiceClass(MyOrderEndpoint.class);
    
    MyOrderEndpoint client = (MyOrderEndpoint) proxyFactory.create();
    
    Holder<String> strPart = new Holder<String>();
    strPart.value = "parts";
    Holder<String> strCustomer = new Holder<String>();
    strCustomer.value = "";

    String result = client.myOrder(strPart, 2, strCustomer);
    assertEquals("Get a wrong order result", "Ordered ammount 2", result);
    assertEquals("Get a wrong parts", "parts", strPart.value);
    assertEquals("Get a wrong customer", "newCustomer", strCustomer.value);
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
public static <VERTICLE extends AbstractVerticle> boolean blockDeploy(Vertx vertx,
    Class<VERTICLE> cls,
    DeploymentOptions options) throws InterruptedException {
  Holder<Boolean> result = new Holder<>();

  CountDownLatch latch = new CountDownLatch(1);
  vertx.deployVerticle(cls.getName(), options, ar -> {
    result.value = ar.succeeded();

    if (ar.failed()) {
      LOGGER.error("deploy vertx failed, cause ", ar.cause());
    }

    latch.countDown();
  });

  latch.await();

  return result.value;
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Test
public void setBodyBuffer() {
  Holder<Buffer> bodyHolder = new Holder<>();
  context = new MockUp<RoutingContext>() {
    @Mock
    HttpServerRequest request() {
      return vertxRequest;
    }

    @Mock
    void setBody(Buffer body) {
      bodyHolder.value = body;
    }
  }.getMockInstance();
  request = new VertxServerRequestToHttpServletRequest(context);

  Buffer bodyBuffer = Buffer.buffer();
  request.setBodyBuffer(bodyBuffer);

  Assert.assertSame(bodyBuffer, bodyHolder.value);
  Assert.assertSame(bodyBuffer, request.getBodyBuffer());
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
private Handler<RestResponse> syncHandlerEx(CountDownLatch countDownLatch, Holder<ResponseWrapper> holder) {
  return restResponse -> {
    RequestContext requestContext = restResponse.getRequestContext();
    HttpClientResponse response = restResponse.getResponse();
    if (response == null) {
      // 请求失败，触发请求SC的其他实例
      if (!requestContext.isRetry()) {
        retry(requestContext, syncHandlerEx(countDownLatch, holder));
      } else {
        countDownLatch.countDown();
      }

      return;
    }

    response.bodyHandler(bodyBuffer -> {
      ResponseWrapper responseWrapper = new ResponseWrapper();
      responseWrapper.response = response;
      responseWrapper.bodyBuffer = bodyBuffer;
      holder.value = responseWrapper;
      countDownLatch.countDown();
    });
  };
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Override
public boolean isSchemaExist(String microserviceId, String schemaId) {
  Holder<GetExistenceResponse> holder = new Holder<>();
  IpPort ipPort = ipPortManager.getAvailableAddress();

  CountDownLatch countDownLatch = new CountDownLatch(1);
  RestUtils.get(ipPort,
      Const.REGISTRY_API.MICROSERVICE_EXISTENCE,
      new RequestParam().addQueryParam("type", "schema")
          .addQueryParam("serviceId", microserviceId)
          .addQueryParam("schemaId", schemaId),
      syncHandler(countDownLatch, GetExistenceResponse.class, holder));
  try {
    countDownLatch.await();
  } catch (Exception e) {
    LOGGER.error("query schema exist {}/{} fail",
        microserviceId,
        schemaId,
        e);
  }
  return holder.value != null;
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Override
public String getSchema(String microserviceId, String schemaId) {
  Holder<GetSchemaResponse> holder = new Holder<>();
  IpPort ipPort = ipPortManager.getAvailableAddress();

  CountDownLatch countDownLatch = new CountDownLatch(1);
  RestUtils.get(ipPort,
      String.format(Const.REGISTRY_API.MICROSERVICE_SCHEMA, microserviceId, schemaId),
      new RequestParam(),
      syncHandler(countDownLatch, GetSchemaResponse.class, holder));
  try {
    countDownLatch.await();
  } catch (Exception e) {
    LOGGER.error("query schema exist {}/{} failed",
        microserviceId,
        schemaId,
        e);
  }
  if (holder.value != null) {
    return holder.value.getSchema();
  }

  return null;
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Override
public Microservice getMicroservice(String microserviceId) {
  Holder<GetServiceResponse> holder = new Holder<>();
  IpPort ipPort = ipPortManager.getAvailableAddress();

  CountDownLatch countDownLatch = new CountDownLatch(1);
  RestUtils.get(ipPort,
      String.format(Const.REGISTRY_API.MICROSERVICE_OPERATION_ONE, microserviceId),
      new RequestParam(),
      syncHandler(countDownLatch, GetServiceResponse.class, holder));
  try {
    countDownLatch.await();
    if (holder.value != null) {
      return holder.value.getService();
    }
  } catch (Exception e) {
    LOGGER.error("query microservice {} failed", microserviceId, e);
  }
  return null;
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Override
public List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) {
  Holder<GetInstancesResponse> holder = new Holder<>();
  IpPort ipPort = ipPortManager.getAvailableAddress();

  CountDownLatch countDownLatch = new CountDownLatch(1);
  RestUtils.get(ipPort,
      String.format(Const.REGISTRY_API.MICROSERVICE_INSTANCE_OPERATION_ALL, providerId),
      new RequestParam().addHeader("X-ConsumerId", consumerId),
      syncHandler(countDownLatch, GetInstancesResponse.class, holder));
  try {
    countDownLatch.await();
    if (holder.value != null) {
      return holder.value.getInstances();
    }
  } catch (Exception e) {
    LOGGER.error("query microservice instances {} failed", providerId, e);
  }
  return null;
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Override
public boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId) {
  Holder<HttpClientResponse> holder = new Holder<>();
  IpPort ipPort = ipPortManager.getAvailableAddress();

  CountDownLatch countDownLatch = new CountDownLatch(1);
  RestUtils.delete(ipPort,
      String.format(Const.REGISTRY_API.MICROSERVICE_INSTANCE_OPERATION_ONE, microserviceId, microserviceInstanceId),
      new RequestParam(),
      syncHandler(countDownLatch, HttpClientResponse.class, holder));
  try {
    countDownLatch.await();
    if (holder.value != null) {
      if (holder.value.statusCode() == Status.OK.getStatusCode()) {
        return true;
      }
      LOGGER.warn(holder.value.statusMessage());
    }
  } catch (Exception e) {
    LOGGER.error("unregister microservice instance {}/{} failed",
        microserviceId,
        microserviceInstanceId,
        e);
  }
  return false;
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Override
public MicroserviceInstance findServiceInstance(String serviceId, String instanceId) {
  try {
    Holder<MicroserviceInstanceResponse> holder = new Holder<>();
    IpPort ipPort = ipPortManager.getAvailableAddress();
    CountDownLatch countDownLatch = new CountDownLatch(1);
    RestUtils.get(ipPort,
        String.format(Const.REGISTRY_API.MICROSERVICE_INSTANCE_OPERATION_ONE, serviceId, instanceId),
        new RequestParam().addHeader("X-ConsumerId", serviceId),
        syncHandler(countDownLatch, MicroserviceInstanceResponse.class, holder));
    countDownLatch.await();
    if (null != holder.value) {
      return holder.value.getInstance();
    }
    return null;
  } catch (Exception e) {
    LOGGER.error("get instance from sc failed");
    return null;
  }
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
private void testPullEvent(Object event) {
  Map<String, MicroserviceVersions> versionsByName = Deencapsulation.getField(microserviceManager, "versionsByName");

  Holder<Integer> count = new Holder<>();
  count.value = 0;
  MicroserviceVersions versions = new MockUp<MicroserviceVersions>() {
    @Mock
    void submitPull() {
      count.value++;
    }
  }.getMockInstance();
  versionsByName.put("ms", versions);

  eventBus.post(event);
  Assert.assertEquals(1, (int) count.value);
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Test
public void testWatchOpen(@Mocked ServiceRegistryConfig serviceRegistryConfig,
    @Mocked ServiceRegistryClient srClient,
    @Mocked Microservice microservice) {
  initWatch(serviceRegistryConfig, srClient, microservice);

  new MockUp<ServiceRegistryClient>(srClient) {
    @Mock
    void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
        AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose) {
      onOpen.success(null);
    }
  };

  Holder<Boolean> openHolder = new Holder<>();
  eventBus.register(new Object() {
    @Subscribe
    public void onOpen(RecoveryEvent event) {
      openHolder.value = true;
    }
  });
  Assert.assertNull(openHolder.value);
  microserviceWatchTask.run();
  Assert.assertTrue(openHolder.value);
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Test
public void testWatchFailed(@Mocked ServiceRegistryConfig serviceRegistryConfig,
    @Mocked ServiceRegistryClient srClient,
    @Mocked Microservice microservice) {
  initWatch(serviceRegistryConfig, srClient, microservice);

  new MockUp<ServiceRegistryClient>(srClient) {
    @Mock
    void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
        AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose) {
      callback.fail(new Error("test failed"));
    }
  };

  Holder<Throwable> holder = new Holder<>();
  eventBus.register(new Object() {
    @Subscribe
    public void onException(ExceptionEvent event) {
      holder.value = event.getThrowable();
    }
  });
  Assert.assertNull(holder.value);
  microserviceWatchTask.run();
  Assert.assertEquals("test failed", holder.value.getMessage());
}
 

import javax.xml.ws.Holder; //导入依赖的package包/类
@Test
public void service() {
  Holder<Boolean> handled = new Holder<>();

  new MockUp<RestServletProducerInvocation>() {
    @Mock
    void invoke(Transport transport, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx,
        List<HttpServerFilter> httpServerFilters) {
      handled.value = true;
    }
  };

  dispatcher.service(request, response);

  Assert.assertTrue(handled.value);
}