Java API的调用方式

Hardy Army

已于 2024-06-05 08:17:47 修改

阅读量786

点赞数 30

文章标签： java 开发语言

于 2024-05-23 17:09:51 首次发布

本文链接：https://blog.csdn.net/weixin_44073008/article/details/139142102

版权

假设给定一个API接口，通过这个API可以去获取到第三方系统的token。那么在分布式系统中，我们一共有多少种方式可以去实现API的调用呢？

下面我们就来探讨下Java中，API的调用方式吧。

实际项目中，我们可以采用多种方式来调用API去获取第三方系统的token，这些方法包括但不限于：

1.HttpURLConnection：通过使用Java提供的HttpURLConnection类，可以建立HTTP连接并发送请求到API端，获取返回结果。

2.HttpClient：使用Apache HttpClient库来发送HTTP请求，并接收API的响应。这个库提供了丰富的功能来处理HTTP请求和响应，适用于多种请求类型。

3.Spring RestTemplate：在Spring框架中可以使用RestTemplate类，它封装了HTTP请求的发送和响应处理，提供了便捷的API请求方式。

4.OkHttp：使用第三方库OkHttp来发送网络请求，它提供了更加灵活和高效的方式发送HTTP请求。

5.Java标准库中的其他HTTP客户端（如URLConnection）：使用Java标准库提供的其他HTTP客户端进行HTTP请求的发送。

6.第三方库（如Retrofit、Feign等）：借助第三方库来简化API请求的发送和结果的处理，根据实际需求选择合适的库。

@Data
@Configuration
@ConfigurationProperties(prefix = "third.rest")
public class ThirdPartyConfig{

    private String url;

    private String clientId;

    private String clientSecret;

}

下面，我将展示几种API调用方法的实现示例：

使用RestTemplate类调用API

@Autowired
private RestTemplate restTemplate;
@Autowired
private ObjectMapper objectMapper;

private String getToekn() {
      String getTokenUrl = thirdPartyConfig.getUrl();
      // 设置HTTP头，请求体格式为JSON格式
      HttpHeaders headers = new HttpHeaders();
      headers.setContentType(MediaType.APPLICATION_JSON);
	  // 构建请求体
      Map<String, Object> requestMap = new HashMap<>(16);
      requestMap.put("clientId", thirdPartyConfig.getClientId());
      requestMap.put("clientSecret", thirdPartyConfig.getClientSecret());
      // 将Map转换为JSON字符串
      String requestBody;
      try {
          requestBody = objectMapper.writeValueAsString(requestMap);
      } catch (JsonProcessingException e) {
          throw new RuntimeException("转换第三方接口入参JSON格式失败", e);
      }
      HttpEntity<String> requestEntity = new HttpEntity<>(requestBody, headers);

      try {
      	  // 发送请求并处理响应
          ResponseEntity<String> responseEntity = restTemplate.postForEntity(getTokenUrl, requestEntity, String.class);
          if (responseEntity.getStatusCode() == HttpStatus.OK) {
              JSONObject json = JSONObject.parseObject(responseEntity.getBody());
              JSONObject bodyJson = json.getJSONObject("body");
              return bodyJson.getString("access_token");
          } else {
              // 处理错误情况，抛出异常或其他处理方式
              throw new RuntimeException("获取第三方接口token异常。 Response status: " + responseEntity.getStatusCodeValue());
          }
      } catch (RestClientException ex) {
          // 处理异常情况，根据具体需要决定如何处理异常
          throw new RuntimeException("获取第三方接口token异常", ex);
      }
 }

使用OkHttp调用API

添加依赖，在pom.xml文件中添加如下依赖：

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
</dependency>

使用OKHttp请求API接口

OkHttpClient client = new OkHttpClient();

// 构建请求体
Request request = new Request.Builder()
    .url("https://api.example.com/openapi/oauth/token")
    .post(RequestBody.create(
        MediaType.parse("application/json; charset=utf-8"),
        "{\"clientId\":\"client_id\",\"clientSecret\":\"client_secret\"}"
    ))
    .build();

try {
    okhttp3.Response response = client.newCall(request).execute();
    if (response.isSuccessful()) {
        // 请求成功，处理响应体
        String responseBody = response.body().string();
        // 解析响应体，获取令牌
        // 例如使用JSON库解析响应体
    } else {
        // 请求失败，处理错误情况
        System.out.println("请求失败: " + response.code() + " " + response.message());
    }
} catch (IOException e) {
    e.printStackTrace();
}
client.dispatcher().executorService().shutdown();
client.connectionPool().evictAll();

使用OpenFegin调用API

使用OpenFeign来调用API，首先需要在项目的pom.xml文件中添加OpenFeign的依赖。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

定义Feign接口

@FeignClient(name = "thirdClient")
public interface ThirdClient{
    @PostMapping("/openapi/oauth/token")
    String getToken(@RequestHeader("Content-Type") String contentType,
                    @RequestBody Map<String, Object> requestMap);
}

配置Fegin客户端

@Configuration
public class FeignConfig {
    @Bean
    public ThirdClient thirdClient() {
        return new ThirdClient() {
            @Override
            public String getToken(String contentType, Map<String, Object> requestMap) {
                // 这里可以添加自定义的逻辑，比如日志记录等
                return null;
            }
        };
    }
}

调用Feign接口，在业务逻辑中注入TopssClient接口，并使用它来调用API。、

@Service
public class TokenService {
    private final ThirdClient thirdClient;

    @Autowired
    public TokenService(ThirdClient thirdClient) {
        this.thirdClient= thirdClient;
    }

    public String getToken() {
        Map<String, Object> requestMap = new HashMap<>();
        requestMap.put("clientId", thirdPartyConfig.getClientId());
        requestMap.put("clientSecret", thirdPartyConfig.getClientSecret());

        try {
            String token = thirdClient.getToken("application/json", requestMap);
            // 处理token
            return token;
        } catch (Exception ex) {
            // 异常处理
        }
        return null;
    }
}

在Spring Boot的主类或者配置类上添加@EnableFeignClients注解来启用Feign。

@SpringBootApplication
@EnableFeignClients
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

使用RPC去调用API

使用RPC的形式去调用API，通常意味着你将使用一个RPC框架来简化客户端和服务端之间的通信。RPC框架隐藏了底层的网络通信细节，使得远程调用看起来就像是调用本地方法一样简单。

不过，RPC通常用于内部服务之间的通信，而不是直接用于调用外部API。如果需要调用外部系统的API，就需要在服务实现中构建HTTP请求，或者使用现有的HTTP客户端库（如Apache HttpClient、OkHttp等）来发送请求。所以这里只假设调用的是内部API的情况：

在项目的pom.xml文件中添加依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dubbo</artifactId>
</dependency>

创建服务接口，定义获取token的远程调用方法。

@Reference
public interface TokenService {
    String getToken(Map<String, Object> requestMap);
}

实现接口，编写业务逻辑

public class TokenServiceImpl implements TokenService {
    @Override
    public String getToken(Map<String, Object> requestMap) {
        // 这里实现具体的调用逻辑，比如构建HTTP请求等
    }
}

调用远程服务

package com.example.client;

import com.example.TokenService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SomeBusinessService {
    @Reference
    private TokenService tokenService;

    public void someBusinessMethod() {
        Map<String, Object> requestMap = new HashMap<>();
        // 填充请求参数
        String token = tokenService.getToken(requestMap);
        // 使用token进行后续操作
    }

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        // 扫描包含服务接口和实现的包
        context.scan("com.example"); 
        context.refresh();

        SomeBusinessService businessService = context.getBean(SomeBusinessService.class);
        businessService.someBusinessMethod();
    }
}