org.jboss.resteasy.client.jaxrs.ResteasyWebTarget Java Examples

@Override
protected Object buildProxy(ClientTransportConfig transportConfig) throws SofaRpcException {
    SofaResteasyClientBuilder builder = new SofaResteasyClientBuilder();

    ResteasyClient client = builder
        .registerProvider().logProviders()
        .establishConnectionTimeout(transportConfig.getConnectTimeout(), TimeUnit.MILLISECONDS)
        .socketTimeout(transportConfig.getInvokeTimeout(), TimeUnit.MILLISECONDS)
        .connectionPoolSize(Math.max(transportConfig.getConnectionNum(), MIN_CONNECTION_POOL_SIZE))
        .build();

    ProviderInfo provider = transportConfig.getProviderInfo();
    String url = "http://" + provider.getHost() + ":" + provider.getPort()
        + StringUtils.CONTEXT_SEP + StringUtils.trimToEmpty(provider.getPath());
    ResteasyWebTarget target = client.target(url);
    return target.proxy(ClassUtils.forName(transportConfig.getConsumerConfig().getInterfaceId()));
}
 

public UmaPermissionService createPermissionService(UmaMetadata metadata, ClientHttpEngine engine) {
    ResteasyWebTarget target = newClient(engine).target(new ResteasyUriBuilder().uri(metadata.getPermissionEndpoint()));
    return target.proxy(UmaPermissionService.class);
}
 

public UmaTokenService createTokenService(UmaMetadata metadata, ClientHttpEngine engine) {
    ResteasyWebTarget target = newClient(engine).target(new ResteasyUriBuilder().uri(metadata.getTokenEndpoint()));
    return target.proxy(UmaTokenService.class);
}
 

public static List<String> getCompactDiscs() {

		ResteasyClient rsClient = new ResteasyClientBuilder().disableTrustManager().build();

		Form form = new Form().param("grant_type", "client_credentials");
		ResteasyWebTarget resourceTarget = rsClient.target(urlAuth);
		resourceTarget.register(new BasicAuthentication("andres", "andres"));
		AccessTokenResponse accessToken = resourceTarget.request().post(Entity.form(form),
				AccessTokenResponse.class);
		try {
			String bearerToken = "Bearer " + accessToken.getToken();
			Response response = rsClient.target(urlDiscs).request()
					.header(HttpHeaders.AUTHORIZATION, bearerToken).get();
			return response.readEntity(new GenericType<List<String>>() {
			});
		} finally {
			rsClient.close();
		}

	}
 

@Test
public void createAndGetPerson(@ArquillianResteasyResource( "hike-manager/persons" ) ResteasyWebTarget webTarget) throws Exception {
	// Create a person
	Invocation createPerson = invocationBuilder( webTarget ).buildPost(
			jsonEntity( "{ 'firstName' : 'Saundra', 'lastName' : 'Smith' } " )
	);

	Response response = createPerson.invoke();
	assertEquals( HttpStatus.SC_CREATED, response.getStatus() );

	String location = response.getHeaderString( "Location");
	assertNotNull( location );
	response.close();

	// Get the person
	Invocation getPerson = invocationBuilder( webTarget, "/" + getId( location ) ).buildGet();
	response = getPerson.invoke();
	assertEquals( HttpStatus.SC_OK, response.getStatus() );

	JSONAssert.assertEquals(
			"{ 'firstName' : 'Saundra', 'lastName' : 'Smith' }",
			response.readEntity( String.class ),
			false
	);
	response.close();
}
 

@Test
public void testAddMovie() {

    final ResteasyClient client = new ResteasyClientBuilder().build();
    final ResteasyWebTarget target = client.target(FULL_PATH);
    final ServicesInterface proxy = target.proxy(ServicesInterface.class);

    Response moviesResponse = proxy.addMovie(batmanMovie);
    moviesResponse.close();
    moviesResponse = proxy.addMovie(transformerMovie);

    if (moviesResponse.getStatus() != Response.Status.CREATED.getStatusCode()) {
        System.out.println("Failed : HTTP error code : " + moviesResponse.getStatus());
    }

    moviesResponse.close();
    System.out.println("Response Code: " + moviesResponse.getStatus());
}
 

@Test
public void testAddMovieMultiConnection() {

    final PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
    final CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(cm).build();
    final ApacheHttpClient4Engine engine = new ApacheHttpClient4Engine(httpClient);
    final ResteasyClient client = new ResteasyClientBuilder().httpEngine(engine).build();
    final ResteasyWebTarget target = client.target(FULL_PATH);
    final ServicesInterface proxy = target.proxy(ServicesInterface.class);

    final Response batmanResponse = proxy.addMovie(batmanMovie);
    final Response transformerResponse = proxy.addMovie(transformerMovie);

    if (batmanResponse.getStatus() != Response.Status.CREATED.getStatusCode()) {
        System.out.println("Batman Movie creation Failed : HTTP error code : " + batmanResponse.getStatus());
    }
    if (batmanResponse.getStatus() != Response.Status.CREATED.getStatusCode()) {
        System.out.println("Batman Movie creation Failed : HTTP error code : " + batmanResponse.getStatus());
    }

    batmanResponse.close();
    transformerResponse.close();
    cm.close();

}
 

@Test
public void testDeleteMovie() {

    final ResteasyClient client = new ResteasyClientBuilder().build();
    final ResteasyWebTarget target = client.target(FULL_PATH);
    final ServicesInterface proxy = target.proxy(ServicesInterface.class);

    Response moviesResponse = proxy.addMovie(batmanMovie);
    moviesResponse.close();
    moviesResponse = proxy.deleteMovie(batmanMovie.getImdbId());

    if (moviesResponse.getStatus() != Response.Status.OK.getStatusCode()) {
        System.out.println(moviesResponse.readEntity(String.class));
        throw new RuntimeException("Failed : HTTP error code : " + moviesResponse.getStatus());
    }

    moviesResponse.close();
    System.out.println("Response Code: " + moviesResponse.getStatus());
}
 

@Test
public void testUpdateMovie() {

    final ResteasyClient client = new ResteasyClientBuilder().build();
    final ResteasyWebTarget target = client.target(FULL_PATH);
    final ServicesInterface proxy = target.proxy(ServicesInterface.class);

    Response moviesResponse = proxy.addMovie(batmanMovie);
    moviesResponse.close();
    batmanMovie.setTitle("Batman Begins");
    moviesResponse = proxy.updateMovie(batmanMovie);

    if (moviesResponse.getStatus() != Response.Status.OK.getStatusCode()) {
        System.out.println("Failed : HTTP error code : " + moviesResponse.getStatus());
    }

    moviesResponse.close();
    System.out.println("Response Code: " + moviesResponse.getStatus());
}
 

@Override
public String submitPlannings(String sessionId, PathSegment pathSegment, Map<String, String> jobContentXmlString)
        throws JobCreationRestException, NotConnectedRestException, IOException {

    checkAccess(sessionId, "plannings");

    Map<String, String> jobVariables = workflowVariablesTransformer.getWorkflowVariablesFromPathSegment(pathSegment);

    if (jobContentXmlString == null || jobContentXmlString.size() != 1) {
        throw new JobCreationRestException("Cannot find job body: code " + HttpURLConnection.HTTP_BAD_REQUEST);
    }

    Map<String, Object> requestBody = new HashMap<>(2);
    requestBody.put("variables", jobVariables);
    requestBody.put("xmlContentString", jobContentXmlString.entrySet().iterator().next().getValue());

    Response response = null;
    try {
        ResteasyProviderFactory providerFactory = ResteasyProviderFactory.getInstance();
        SchedulerRestClient.registerGzipEncoding(providerFactory);
        ResteasyClient client = new ResteasyClientBuilder().providerFactory(providerFactory).build();
        ResteasyWebTarget target = client.target(PortalConfiguration.JOBPLANNER_URL.getValueAsString());
        response = target.request()
                         .header("sessionid", sessionId)
                         .post(Entity.entity(requestBody, "application/json"));

        if (HttpURLConnection.HTTP_OK != response.getStatus()) {
            throw new IOException(String.format("Cannot access resource %s: code %d",
                                                PortalConfiguration.JOBPLANNER_URL.getValueAsString(),
                                                response.getStatus()));
        }
        return response.readEntity(String.class);
    } finally {
        if (response != null) {
            response.close();
        }
    }

}
 

public boolean delete(String sessionId, String dataspacePath, String path, List<String> includes,
        List<String> excludes) throws Exception {
    StringBuffer uriTmpl = (new StringBuffer()).append(restEndpointURL)
                                               .append(addSlashIfMissing(restEndpointURL))
                                               .append("data/")
                                               .append(dataspacePath)
                                               .append('/');

    ResteasyClient client = buildResteasyClient(providerFactory);

    ResteasyWebTarget target = client.target(uriTmpl.toString()).path(path);
    if (includes != null && !includes.isEmpty()) {
        target = target.queryParam("includes", includes.toArray(new Object[includes.size()]));
    }
    if (excludes != null && !excludes.isEmpty()) {
        target = target.queryParam("excludes", excludes.toArray(new Object[excludes.size()]));
    }
    Response response = null;
    try {
        response = target.request().header("sessionid", sessionId).delete();
        if (response.getStatus() != HttpURLConnection.HTTP_NO_CONTENT) {
            if (response.getStatus() == HttpURLConnection.HTTP_UNAUTHORIZED) {
                throw new NotConnectedRestException("User not authenticated or session timeout.");
            } else {
                throwException(String.format("Cannot delete file(s). Status code: %s", response.getStatus()),
                               response);
            }
        }
        return true;
    } finally {
        if (response != null) {
            response.close();
        }
    }
}
 

public ListFile list(String sessionId, String dataspacePath, String pathname) throws Exception {
    StringBuffer uriTmpl = (new StringBuffer()).append(restEndpointURL)
                                               .append(addSlashIfMissing(restEndpointURL))
                                               .append("data/")
                                               .append(dataspacePath)
                                               .append('/');

    ResteasyClient client = buildResteasyClient(providerFactory);

    ResteasyWebTarget target = client.target(uriTmpl.toString()).path(pathname).queryParam("comp", "list");
    Response response = null;
    try {
        response = target.request().header("sessionid", sessionId).get();
        if (response.getStatus() != HttpURLConnection.HTTP_OK) {
            if (response.getStatus() == HttpURLConnection.HTTP_UNAUTHORIZED) {
                throw new NotConnectedRestException("User not authenticated or session timeout.");
            } else {
                throwException(String.format("Cannot list the specified location: %s", pathname), response);
            }
        }
        return response.readEntity(ListFile.class);
    } finally {
        if (response != null) {
            response.close();
        }
    }
}
 

public Map<String, Object> metadata(String sessionId, String dataspacePath, String pathname) throws Exception {
    StringBuffer uriTmpl = (new StringBuffer()).append(restEndpointURL)
                                               .append(addSlashIfMissing(restEndpointURL))
                                               .append("data/")
                                               .append(dataspacePath)
                                               .append(escapeUrlPathSegment(pathname));

    ResteasyClient client = buildResteasyClient(providerFactory);

    ResteasyWebTarget target = client.target(uriTmpl.toString());
    Response response = null;
    try {
        response = target.request().header("sessionid", sessionId).head();
        if (response.getStatus() != HttpURLConnection.HTTP_OK) {
            if (response.getStatus() == HttpURLConnection.HTTP_UNAUTHORIZED) {
                throw new NotConnectedRestException("User not authenticated or session timeout.");
            } else {
                throwException(String.format("Cannot get metadata from %s in %s.", pathname, dataspacePath),
                               response);
            }
        }
        MultivaluedMap<String, Object> headers = response.getHeaders();
        Map<String, Object> metaMap = Maps.newHashMap();
        if (headers.containsKey(HttpHeaders.LAST_MODIFIED)) {
            metaMap.put(HttpHeaders.LAST_MODIFIED, headers.getFirst(HttpHeaders.LAST_MODIFIED));
        }
        return metaMap;
    } finally {
        if (response != null) {
            response.close();
        }
    }
}
 

private static SchedulerRestInterface createRestProxy(ResteasyProviderFactory provider, String restEndpointURL,
        ClientHttpEngine httpEngine) {
    ResteasyClient client = buildResteasyClient(provider);
    ResteasyWebTarget target = client.target(restEndpointURL);
    SchedulerRestInterface schedulerRestClient = target.proxy(SchedulerRestInterface.class);
    return createExceptionProxy(schedulerRestClient);
}
 

private static RMRestInterface createRestProxy(ResteasyProviderFactory provider, String restEndpointURL,
        ClientHttpEngine httpEngine) {
    ResteasyClient client = buildResteasyClient(provider);
    ResteasyWebTarget target = client.target(restEndpointURL);
    RMRestInterface rmRestInterface = target.proxy(RMRestInterface.class);
    return createExceptionProxy(rmRestInterface);
}
 

AbstractScimClient(String domain, Class<T> serviceClass) {
    /*
     Configures a proxy to interact with the service using the new JAX-RS 2.0 Client API, see section
     "Resteasy Proxy Framework" of RESTEasy JAX-RS user guide
     */
    if (System.getProperty("httpclient.multithreaded") == null) {
        client = new ResteasyClientBuilder().build();
    } else {
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
        //Change defaults if supplied
        getIntegerProperty("httpclient.multithreaded.maxtotal").ifPresent(cm::setMaxTotal);
        getIntegerProperty("httpclient.multithreaded.maxperroute").ifPresent(cm::setDefaultMaxPerRoute);
        getIntegerProperty("httpclient.multithreaded.validateafterinactivity").ifPresent(cm::setValidateAfterInactivity);

        logger.debug("Using multithreaded support with maxTotalConnections={} and maxPerRoutConnections={}", cm.getMaxTotal(), cm.getDefaultMaxPerRoute());
        logger.warn("Ensure your oxTrust 'rptConnectionPoolUseConnectionPooling' property is set to true");

        CloseableHttpClient httpClient = HttpClients.custom()
	.setDefaultRequestConfig(RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD).build())
        		.setConnectionManager(cm).build();
        ApacheHttpClient4Engine engine = new ApacheHttpClient4Engine(httpClient);

        client = new ResteasyClientBuilder().httpEngine(engine).build();
    }
    ResteasyWebTarget target = client.target(domain);

    scimService = target.proxy(serviceClass);
    target.register(ListResponseProvider.class);
    target.register(AuthorizationInjectionFilter.class);
    target.register(ScimResourceProvider.class);

    ClientMap.update(client, null);
}
 

public TokenManager(Config config, Client client) {
    this.config = config;
    ResteasyWebTarget target = (ResteasyWebTarget) client.target(config.getServerUrl());
    if (!config.isPublicClient()) {
        target.register(new BasicAuthFilter(config.getClientId(), config.getClientSecret()));
    }
    this.tokenService = target.proxy(TokenService.class);
    this.accessTokenGrantType = config.getGrantType();

    if (CLIENT_CREDENTIALS.equals(accessTokenGrantType) && config.isPublicClient()) {
        throw new IllegalArgumentException("Can't use " + GRANT_TYPE + "=" + CLIENT_CREDENTIALS + " with public client");
    }
}
 

public <T> T getResource(String sessionId, String url, Class<T> clazz) throws IOException {
    Response response = null;
    try {
        ResteasyWebTarget target = client.target(url);
        response = target.request().header("sessionid", sessionId).get();
        if (responseIsNotHttpOk(response)) {
            throw new IOException(String.format("Cannot access resource %s: code %d", url, response.getStatus()));
        }
        return (T) response.readEntity(clazz);
    } finally {
        if (response != null) {
            response.close();
        }
    }
}
 

public StocksRepositoryImpl() {
	Client pseClient = new ResteasyClientBuilder()
			.httpEngine(new URLConnectionEngine())
			.register(StocksProvider.class)
			.build();
	this.pseClient = ((ResteasyWebTarget) pseClient.target("http://www.pse.com.ph/stockMarket")).proxy(PseClient.class);
	
	// TODO make this async
	Client gaClient = new ResteasyClientBuilder()
			.httpEngine(new URLConnectionEngine())
			.build();
	this.gaClient = ((ResteasyWebTarget) gaClient.target("http://www.google-analytics.com")).proxy(GaClient.class);
}
 

@Before
public void setUp() {
	Client client = new ResteasyClientBuilder()
			.httpEngine(new URLConnectionEngine())
			.register(StocksProvider.class)
			.build();
	ResteasyWebTarget target = (ResteasyWebTarget) client.target("http://www.google-analytics.com");
	gaClient = target.proxy(GaClient.class);
}
 

@Before
public void setUp() {
	Client client = new ResteasyClientBuilder()
			.httpEngine(new URLConnectionEngine())
			.register(StocksProvider.class)
			.build();
	ResteasyWebTarget target = (ResteasyWebTarget) client.target("https://www.pse.com.ph/stockMarket");
	pseClient = target.proxy(PseClient.class);
}
 

public IntrospectionService createIntrospectionService(String p_url, ClientHttpEngine engine) {
    ResteasyClient client = new ResteasyClientBuilder().httpEngine(engine).build();
    ResteasyWebTarget target = client.target(UriBuilder.fromPath(p_url));
    IntrospectionService proxy = target.proxy(IntrospectionService.class);

    return proxy;
}
 

public U2fConfigurationService createMetaDataConfigurationService(String u2fMetaDataUri) {
    ResteasyClient client = new ResteasyClientBuilder().httpEngine(engine).build();
    ResteasyWebTarget target = client.target(UriBuilder.fromPath(u2fMetaDataUri));
    U2fConfigurationService proxy = target.proxy(U2fConfigurationService.class);

    return proxy;
}
 

public AuthenticationRequestService createAuthenticationRequestService(U2fConfiguration metadataConfiguration) {
    ResteasyClient client = new ResteasyClientBuilder().httpEngine(engine).build();
    ResteasyWebTarget target = client.target(UriBuilder.fromPath(metadataConfiguration.getAuthenticationEndpoint()));
    AuthenticationRequestService proxy = target.proxy(AuthenticationRequestService.class);

    return proxy;
}
 

public RegistrationRequestService createRegistrationRequestService(U2fConfiguration metadataConfiguration) {
    ResteasyClient client = new ResteasyClientBuilder().httpEngine(engine).build();
    ResteasyWebTarget target = client.target(UriBuilder.fromPath(metadataConfiguration.getRegistrationEndpoint()));
    RegistrationRequestService proxy = target.proxy(RegistrationRequestService.class);

    return proxy;
}
 

public static void main(String[] args) throws Exception {

		String truststorePath = "C:/Users/Andres/jboss/2do_jboss/jboss-as-7.1.1.Final/standalone/configuration/client-truststore.ts";
		String truststorePassword = "changeit";
		truststorePath = EnvUtil.replace(truststorePath);

		KeyStore truststore = loadKeyStore(truststorePath, truststorePassword);

		ResteasyClient client = new ResteasyClientBuilder()
				.disableTrustManager().trustStore(truststore).build();

		Form form = new Form().param("grant_type", "client_credentials");
		ResteasyWebTarget target = client
				.target("https://localhost:8443/oauth-server/j_oauth_token_grant");
		target.register(new BasicAuthentication("andres", "andres"));

		AccessTokenResponse tokenResponse = target.request().post(
				Entity.form(form), AccessTokenResponse.class);
		Response response = client
				.target("https://localhost:8443/discstore/discs")
				.request()
				.header(HttpHeaders.AUTHORIZATION,
						"Bearer " + tokenResponse.getToken()).get();
		try {
			String xml = response.readEntity(String.class);
			System.out.println(xml);
		} finally {
			client.close();
		}

	}
 

private Invocation.Builder invocationBuilder(ResteasyWebTarget webTarget, String path) {
	Invocation.Builder builder = path != null ? webTarget.path( path ).request() : webTarget.request();

	builder.acceptEncoding( "UTF-8" );
	builder.accept( MediaType.APPLICATION_JSON );

	return builder;
}
 

@Test
public void testListAllMovies() {

    final ResteasyClient client = new ResteasyClientBuilder().build();
    final ResteasyWebTarget target = client.target(FULL_PATH);
    final ServicesInterface proxy = target.proxy(ServicesInterface.class);

    Response moviesResponse = proxy.addMovie(transformerMovie);
    moviesResponse.close();
    moviesResponse = proxy.addMovie(batmanMovie);
    moviesResponse.close();

    final List<Movie> movies = proxy.listMovies();
    System.out.println(movies);
}
 

@Test
public void testMovieByImdbId() {

    final String transformerImdbId = "tt0418279";

    final ResteasyClient client = new ResteasyClientBuilder().build();
    final ResteasyWebTarget target = client.target(FULL_PATH);
    final ServicesInterface proxy = target.proxy(ServicesInterface.class);

    final Response moviesResponse = proxy.addMovie(transformerMovie);
    moviesResponse.close();

    final Movie movies = proxy.movieByImdbId(transformerImdbId);
    System.out.println(movies);
}
 

Keycloak(String serverUrl, String realm, String username, String password, String clientId, String clientSecret, String grantType, Client resteasyClient, String authtoken) {
    config = new Config(serverUrl, realm, username, password, clientId, clientSecret, grantType);
    client = resteasyClient != null ? resteasyClient : newRestEasyClient(null, null, false);
    authToken = authtoken;
    tokenManager = authtoken == null ? new TokenManager(config, client) : null;

    target = (ResteasyWebTarget) client.target(config.getServerUrl());
    target.register(newAuthFilter());
}