com.castsoftware.java.service
See REST service call for Java - 1.0 - Release Notes for more information.
This extension provides support for some web services calls from Java.
| Native |
|
|---|---|
| JAX-RS |
|
| Spring |
|
| Apache |
|
| Vert.x |
|
| Other |
|
| Function Points (transactions) | Quality and Sizing |
|---|---|
 |  |
AIP Core release | Supported |
|---|---|
| 8.3.x | |
This extension is compatible with the following DBMS servers:
| CAST AIP release | CSS | Oracle | Microsoft |
|---|---|---|---|
| All supported releases | | | |
| Installation of any compatible release of AIP Core (see table above) |
The REST Service Calls for Java extension requires that ≥ 1.2.8-funcrel of the JEE Analyzer is also installed and used in order to ensure the most complete set of results. This dependency with the JEE Analyzer is not automatically handled when downloading the REST Service Calls for Java extension via CAST Extension Downloader, CAST Server Manager or AIP Console, therefore you must MANUALLY download and install the JEE Analyzer before starting an analysis.
Please see:
Package your JEE code as described in JEE - Prepare and deliver the source code - the REST Service Calls for Java extension will be run when you perform the analysis.
This extension analyzes web service calls made from Java code through classic fluent APIs. For example with com.sun.jersey:
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
class Main
{
public static void main(String[] args) {
Client client = Client.create();
WebResource webResource = client
.resource("http://localhost:8080/RESTfulExample/rest/json/metallica/get");
ClientResponse response = webResource.accept("application/json")
.get(ClientResponse.class);
}
} |
Usage of org.springframework.cloud.client.loadbalancer.LoadBalancerClient allows to choose a service to call so impacts the URL called:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.client.RestTemplate;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.client.ServiceInstance;
import java.net.URI;
class Main
{
@Autowired
private LoadBalancerClient loadBalancerClient;
void f()
{
RestTemplate client ;
ServiceInstance serviceInstance = loadBalancerClient.choose("user-auth");
String path = serviceInstance.getUri().toString() + "/oauth/token";
client.put(path, client);
}
} |
Feign is a declarative web service client which makes writing web service clients easier. Native sample: "RequestLine" annotation indicates the presence of feign web service:
interface GitHub {
@RequestLine("GET /repos/{owner}/{repo}/contributors")
List<Contributor> contributors(@Param("owner") String owner, @Param("repo") String repo);
}
public static class Contributor {
String login;
int contributions;
}
public class MyApp {
public static void main(String... args) {
GitHub github = Feign.builder()
.decoder(new GsonDecoder())
.target(GitHub.class, "https://api.github.com");
// Fetch and print a list of the contributors to this library.
List<Contributor> contributors = github.contributors("OpenFeign", "feign");
for (Contributor contributor : contributors) {
System.out.println(contributor.login + " (" + contributor.contributions + ")");
}
}
} |
"FeignClient" annotation associated with "RequestMapping" and "GetMapping" annotations indicates the presence of feign web service:
import java.util.List;
@FeignClient(
name = "${client.name}",
path= "${client.path}",
configuration = FeignConfiguration.class
)
public interface ClientConfiguration {
@RequestMapping(method = RequestMethod.POST, value = "/services/clients")
List<SupplierTransitionDTO> getData(@RequestBody List<String> codes) throws FeignException;
} |
@FeignClient(name = "Client", url = "${build.api.url}", path = "/api/v1")
public interface ClientConfiguration {
@GetMapping("/sites/{site-id}/clients")
ConsentResponse getConfiguration(
@PathVariable("site-id") String siteId,
@RequestParam("types") List<ConfigType> types);
} |
With Retrofit 2, endpoints are defined inside an interface using special retrofit annotations to encode details about the parameters and request method. Annotations like "GET", "POST", "PUT", "DELETE" and "PATCH", for example:
import retrofit2.http.GET;
public interface ExampleGetService {
@GET("getservice.example")
Single<ExampleApi> getMode();
} |
The following objects are displayed in CAST Enlighten:
| Icon | Description |
|---|---|
| Delete Resource Service |
| Get Resource Service |
| Post Resource Service |
| Put Resource Service |
 | Patch Resource Service |
None.
class MyHttpCall
{
void execute(String url, String method)
{
Client client = ClientBuilder.newClient();
WebTarget myResource = client.target(url);
if (method == "GET")
{
String response = myResource.request(MediaType.TEXT_PLAIN).get(String.class);
}
else if (method == "PUT")
{
myResource.request(MediaType.TEXT_PLAIN).put(null);
}
}
}
|
