Java Client.register方法代码示例

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
public Scim2Provisioner(final String target, final String oauthToken,
                        final String username, final String password,
                        final Scim2PrincipalAttributeMapper mapper) {
    final ClientConfig config = new ClientConfig();
    final ApacheConnectorProvider connectorProvider = new ApacheConnectorProvider();
    config.connectorProvider(connectorProvider);
    final Client client = ClientBuilder.newClient(config);
    
    if (StringUtils.isNotBlank(oauthToken)) {
        client.register(OAuth2ClientSupport.feature(oauthToken));
    }
    if (StringUtils.isNotBlank(username) && StringUtils.isNotBlank(password)) {
        client.register(HttpAuthenticationFeature.basic(username, password));
    }
    
    final WebTarget webTarget = client.target(target);
    this.scimService = new ScimService(webTarget);
    this.mapper = mapper;
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
@Test
@RunAsClient
public void testAbort() throws Exception {
	logger.info("Registering Client Abort Filters");
	Client client = newClient();
	client.register(new MyClientResponseFilter());
	client.register(new MyClientRequestFilter());
	client.register(new BlockChainFilter());
	WebTarget target = client.target(url + "myjaxrs/simple/");

	WebTarget resourceTarget = target.path("/valuesget");
	resourceTarget = resourceTarget.queryParam("OrderID", "111").queryParam("UserName", "Luke");

	logger.info("Invoking REST Service: " + resourceTarget.getUri().toString());
	Invocation invocation = resourceTarget.request().buildGet();
	Response response = invocation.invoke();

	assertEquals(
			"MyClientRequestFilter is not executed because BlockChainFilter blocks it. So no header is saved: ", "",
			response.getHeaderString(CONTENT_TYPE_STRING));
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
@Test
public void testRegister() throws Exception {
	logger.info("start Register test");
	Client client = newClient();
	Map<Class<?>, Integer> myContracts = new HashMap<Class<?>, Integer>();
	myContracts.put(Feature.class, 1200);
	client.register(MyComponent.class, myContracts);
	Configuration configuration = client.getConfiguration();
	Set<Class<?>> classes = configuration.getClasses();
	for (Class<?> clazz : classes) {
		if (MyComponent.class.isAssignableFrom(clazz)) {
			Map<Class<?>, Integer> contracts = configuration.getContracts(clazz);
			int priority = contracts.get(Feature.class);
			assertTrue("Only standard: Feature, DynamicFeature, WriterInterceptor, "
					+ "ReaderInterceptor, ContainerResponseFilter, " + "ContainerRequestFilter, "
					+ "ClientResponseFilter, ClientRequestFilter, " + "ExceptionMapper, MessageBodyWriter, "
					+ "MessageBodyReader,ParamConverterProvider or implemented: InjectorFactory, "
					+ "StringParameterUnmarshaller, StringConverter, " + "ContextResolver, PostProcessInterceptor, "
					+ "PreProcessInterceptor, ClientExecutionInterceptor, ClientExceptionMapper"
					+ "can be registered as contracts. Registered priority", priority == 1200);
		}
	}
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
@Test
@RunAsClient
public void testGet() throws Exception {
	logger.info("Registering Client Level Filters");
	Client client = newClient();
	client.register(new OtherClientResponseFilter());
	WebTarget target = client.target(url + "myjaxrs/simple/");
	target.register(new OtherClientRequestFilter());

	WebTarget resourceTarget = target.path("/valuesget");
	resourceTarget = resourceTarget.queryParam("OrderID", "111").queryParam("UserName", "Luke");
	resourceTarget.register(new MyClientResponseFilter());
	resourceTarget.register(new MyClientRequestFilter());

	logger.info("Invoking REST Service: " + resourceTarget.getUri().toString());
	Invocation invocation = resourceTarget.request().buildGet();
	Response response = invocation.invoke();
	String respContent = "";

	if (response.hasEntity())
		respContent = response.readEntity(String.class);

	assertEquals("Response--> ", "111-Luke", respContent);
	assertEquals("Content Type after changing in ClientResponseFilter: ", TEXT_HTML,
			response.getHeaderString(CONTENT_TYPE_STRING));
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
public Coreference(Config config) {

		log.info("Will use remote coreference resource at: '{}'", config.getString("url"));

		final Client webClient = ClientBuilder.newClient();
		webClient.register(JacksonFeature.class);

		this.textTarget = webClient
                .target(config.getString("url"))
                .path(config.getString("text-path"));
        this.wikiTarget = webClient
                .target(config.getString("url"))
                .path(config.getString("wiki-path"));
        this.wikiLinkTarget = webClient
                .target(config.getString("url"))
                .path(config.getString("wiki-link-path"));

		log.info("Coreference initialized");
	}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
private RegistryEndpoints getRegistryClient(ImageRef imageRef) {
	if (!proxyClients.containsKey(imageRef.getRegistryUrl())) {

		ObjectMapper mapper = new ObjectMapper();
		mapper.registerModule(new JavaTimeModule());

		Client client = ClientBuilder.newClient()
				.register(new JacksonJaxbJsonProvider(mapper, new Annotations[] {Annotations.JACKSON}))
				.register(JacksonFeature.class);
		String auth = config.getAuthFor(imageRef.getRegistryName());
		if (auth != null) {
			String[] credentials = new String(Base64.getDecoder().decode(auth), StandardCharsets.UTF_8).split(":");
			client.register(HttpAuthenticationFeature.basicBuilder().credentials(credentials[0], credentials[1]));
		}
		WebTarget webTarget = client.target(imageRef.getRegistryUrl());
		proxyClients.put(imageRef.getRegistryUrl(), WebResourceFactory.newResource(RegistryEndpoints.class, webTarget));
	}
	return proxyClients.get(imageRef.getRegistryUrl());
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
/**
 * Build a Jersey http client instance
 *
 * @return Client
 */
@Bean
public Client restClient() {
    final ClientConfig cc = new ClientConfig().register(new JacksonFeature());
    final HttpAuthenticationFeature httpAuthenticationFeature = HttpAuthenticationFeature.basic(cloudKarafkaApiKey, "");

    final Client client = ClientBuilder.newClient(cc);
    client.register(httpAuthenticationFeature);

    return client;
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
@Test
public void testConfiguration() throws Exception {
	logger.info("start REST Configuration test");
	Client client = newClient();
	Configuration configuration = client.getConfiguration();
	Set<Class<?>> classes = configuration.getClasses();
	for (Class<?> clazz : classes) {
		assertTrue("verify if the class is a rest component or provider",
				MessageBodyReader.class.isAssignableFrom(clazz) || MessageBodyWriter.class.isAssignableFrom(clazz)
						|| clazz.isAnnotationPresent(Provider.class)
						|| DynamicFeature.class.isAssignableFrom(clazz));
		Map<Class<?>, Integer> contracts = configuration.getContracts(clazz);
		assertFalse("each class has different contracts", contracts.isEmpty());
		for (Class<?> contract : contracts.keySet()) {
			int value = contracts.get(contract);
			assertTrue("verify if the contract is a rest component or provider",
					value == 5000 || value == 4000 || value == 3000 || value == 0);
		}
	}
	Set<Object> instances = configuration.getInstances();
	assertTrue("by default there are not instances", instances.isEmpty());
	Map<String, Object> properties = configuration.getProperties();
	assertTrue("by default there are not properties", properties.isEmpty());
	MyComponent myComponent = new MyComponent();
	client.register(myComponent);
	instances = configuration.getInstances();
	assertFalse("Added instance", instances.isEmpty());
	for (Object instance : instances) {
		if (instance instanceof MyComponent)
			assertTrue("MyComponent is registered and active", configuration.isEnabled((Feature) instance));
	}
	assertEquals("Added property through MyComponent", 1, properties.size());
	boolean property = (Boolean) properties.get("configured_myComponent");
	assertEquals("configured_myComponent ok!", true, property);
	assertEquals("type CLIENT by default", CLIENT, configuration.getRuntimeType());
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
@Test
@RunAsClient
public void testMD5() throws Exception {
	logger.info("start JaxRS Post test");
	Client client = newClient();
	client.register(ContentMD5Writer.class);
	Response response = client.target(url + "myjaxrs/simple/valuesget").request().get();
	String md5 = response.getHeaderString(CONTENT_MD5_STRING);
	assertEquals("Content-MD5: ", "hcEzFGyuhOARcfBb4bM1sw==", md5);

}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
@Test
@RunAsClient
public void testReader() throws Exception {
	logger.info("start JaxRS Post test");
	Client client = newClient();
	client.register(ClientFirstReaderInterceptor.class);
	client.register(ClientSecondReaderInterceptor.class);
	Entity<String> value = entity("my test", TEXT_PLAIN);
	Response response = client.target(url + "myjaxrs/simple/values").request().post(value);
	String result = response.readEntity(String.class);
	assertEquals("The ServerReaderInterceptor is not registered because has SERVER runtime type ",
			"Order successfully placed .Request changed in ClientFirstReaderInterceptor. Request changed in ClientSecondReaderInterceptor.",
			result);
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
public boolean addServer(String url, String username, String password) {
    Client client = createClient();
    serverList.add(client);

    HttpAuthenticationFeature feature = HttpAuthenticationFeature.basic(username, password);
    client.register(feature);
    
    WebTarget target = client.target(url);
    serverTargetsList.add(target);
    
    return true;
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
/**
 * Add IDS server
 * 
 * @param url url address of IDS server
 * @param username username for IDS server
 * @param password password for IDS server
 * @return true if successful
 */
public boolean addServer(String url, String username, String password) {
    Client client = createClient();
    serverList.add(client);

    HttpAuthenticationFeature feature = HttpAuthenticationFeature.basic(username, password);
    client.register(feature);
    
    //WebTarget target = client.target(url).path("ss7fw_api/1.0/eval_sccp_message_in_ids");
    WebTarget target = client.target(url);
    serverTargetsList.add(target);
    
    return true;
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
/**
 * Gets a client web resource builder for the base XOS REST API
 * with an optional additional URI.
 *
 * @return web resource builder
 * @deprecated in Cardinal Release
 */
@Deprecated
private Invocation.Builder getClientBuilder(String uri) {
    String baseUrl = "http://" + xosServerAddress + ":"
            + Integer.toString(xosServerPort);
    Client client = ClientBuilder.newClient();
    client.register(HttpAuthenticationFeature.basic("[email protected]", "letmein"));
    WebTarget wt = client.target(baseUrl
            + XOS_TENANT_BASE_URI + uri);
    return wt.request(JSON_UTF_8.toString());
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
@Bean
public WebTarget tccCoordinatorClient() {
	Client client = ClientBuilder.newClient();
	client.register(new JacksonJaxbJsonProvider());
	client.register(new TransactionProvider());
	WebTarget target = client.target(tccCoordinatorBaseUrl);
	return target.path("/coordinator");
}
 

import javax.ws.rs.client.Client; //导入方法依赖的package包/类
private void authenticate(Client client, String username, String password) {
    client.register(HttpAuthenticationFeature.basic(username, password));
}