SpringCloud 模块间调用

引入包，springboot与 SpringCloud的包的版本要匹配 我的SpringBoot是2.2.4.RELEASE，SpringCloud是Hoxton.SR1

下面是客户端：

     <dependencies>
  <!-- 客户端导这个-->  
       <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.1.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>


    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
            </dependency>
        </dependencies>
    </dependencyManagement>

启动类上必须有 @EnableEurekaClient，调用别的模块服务的调用类 通过项目名访问必须加@LoadBalanced 这个注解

@PropertySource(value = {"classpath:application.yml", "file:config/application.yml"}, ignoreResourceNotFound = true)
@SpringBootApplication
@EnableSwagger2
@EnableScheduling
@EnableEurekaClient
public class DataApiApplication {

    public static void main(String[] args) {
        SpringApplication.run(DataApiApplication.class, args);
    }

    @Bean
    @LoadBalanced  //注解表明这个restRemplate开启负载均衡的功能,通过项目名访问必须加这个注解
    public RestOperations restTemplate(RestTemplateBuilder builder) {
        return builder.build();
    }
}

调用的工具类

import com.photon.common.DataEntity.Model.Request.Common.PagingRequest;
import com.photon.common.DataEntity.Model.Request.Common.Request;
import com.photon.common.DataEntity.Model.Response.Common.PagingResponse;
import com.photon.common.DataEntity.Model.Response.Common.Response;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestOperations;

import java.util.HashMap;
import java.util.Map;

/**
 * @Description http远程调用
 * @Author 李修睿
 * @Date 2023/1/5 8:49
 */
@Component
public class HttpRemoteCall {

    @Autowired
    private RestOperations restTemplate;

    /**
     * 访问DBACCESS的连接
     */
    private final String DATAHANDDLER_ADDRESS = "http://DATAHANDLER/";

    /**
     * @Description 普通远程调用
     * @Param [path, accessToken, request]
     * @Return com.photon.common.databean.Response<T>
     * @Author 李修睿
     * @Date 2023/1/5 8:58
     */
    public <T, E> Response<T> call(String path, String accessToken, Request<E> request) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("access_token", accessToken);
        HttpEntity<Request> formEntity = new HttpEntity<>(request, headers);
        ResponseEntity<Response> forEntity = restTemplate.postForEntity(DATAHANDDLER_ADDRESS + path, formEntity, Response.class);
        Response<T> response = forEntity.getBody();

        return response;
    }


    /**
     * @Description 普通远程调用
     * @Param [path, accessToken, request]
     * @Return com.photon.common.databean.Response<T>
     * @Author 李修睿
     * @Date 2023/1/5 8:58
     */
    public <T> Response<T> call(String path, String accessToken) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("access_token", accessToken);
        HttpEntity formEntity = new HttpEntity(headers);
        ResponseEntity<Response> forEntity = restTemplate.postForEntity(DATAHANDDLER_ADDRESS + path, formEntity, Response.class);
        Response<T> response = forEntity.getBody();

        return response;
    }

    /**
     * @Description 普通远程调用
     * @Param [path, accessToken, request]
     * @Return com.photon.common.databean.Response<T>
     * @Author 李修睿
     * @Date 2023/1/5 8:58
     */
    public <T, E> Response<T> call(String path, Request<E> request) {
        HttpHeaders headers = new HttpHeaders();
        HttpEntity<Request> formEntity = new HttpEntity<>(request, headers);
        ResponseEntity<Response> forEntity = restTemplate.postForEntity(DATAHANDDLER_ADDRESS + path, formEntity, Response.class);
        Response<T> response = forEntity.getBody();

        return response;
    }

    /**
     * @Description 普通远程调用
     * @Param [path, accessToken, request]
     * @Return com.photon.common.databean.Response<T>
     * @Author 李修睿
     * @Date 2023/1/5 8:58
     */
    public <T> Response<T> call(String path, String accessToken, Map<Object, Object> queryParams) {
        Map<Object, Object> params = new HashMap<Object, Object>();
        params.put("queryParams", queryParams);
        Request request = new Request();
        request.setParams(params);

        HttpHeaders headers = new HttpHeaders();
        headers.set("access_token", accessToken);
        HttpEntity<Request> formEntity = new HttpEntity<Request>(request, headers);
        ResponseEntity<Response> forEntity = restTemplate.postForEntity(DATAHANDDLER_ADDRESS + path, formEntity, Response.class);
        Response<T> response = forEntity.getBody();
        return response;
    }

    /**
     * @Description 分页远程调用
     * @Param [path, accessToken, request]
     * @Return com.photon.common.databean.PagingResponse<T>
     * @Author 李修睿
     * @Date 2023/1/5 8:59
     */
    public <T, E> PagingResponse<T> pagingCall(String path, String accessToken, PagingRequest<E> request) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("access_token", accessToken);
        HttpEntity<PagingRequest> formEntity = new HttpEntity<>(request, headers);
        ResponseEntity<PagingResponse> forEntity = restTemplate.postForEntity(DATAHANDDLER_ADDRESS + path, formEntity, PagingResponse.class);
        PagingResponse<T> response = forEntity.getBody();

        return response;
    }

    /**
     * @Description 分页远程调用
     * @Param [path, accessToken, request]
     * @Return com.photon.common.databean.PagingResponse<T>
     * @Author 李修睿
     * @Date 2023/1/5 8:59
     */
    public <T, E> PagingResponse<T> pagingCall(String path, PagingRequest<E> request) {
        HttpHeaders headers = new HttpHeaders();
        HttpEntity<PagingRequest> formEntity = new HttpEntity<PagingRequest>(request, headers);
        ResponseEntity<PagingResponse> forEntity = restTemplate.postForEntity(DATAHANDDLER_ADDRESS + path, formEntity, PagingResponse.class);
        PagingResponse<T> response = forEntity.getBody();
        return response;
    }


    public <T> PagingResponse<T> pagingCall(String path, String accessToken, Map<Object, Object> queryParams) {
        PagingRequest request = new PagingRequest();
        if (queryParams.containsKey("pageNum")
                && queryParams.containsKey("pageSize")) {
            request.setPageSize(Integer.parseInt(queryParams.get("pageSize").toString()));
            request.setPageNum(Integer.parseInt(queryParams.get("pageNum").toString()));
        }

        Map<Object, Object> params = new HashMap<Object, Object>();
        params.put("queryParams", queryParams);
        request.setParams(params);

        HttpHeaders headers = new HttpHeaders();
        headers.set("access_token", accessToken);
        HttpEntity<PagingRequest> formEntity = new HttpEntity<>(request, headers);
        ResponseEntity<PagingResponse> forEntity = restTemplate.postForEntity(DATAHANDDLER_ADDRESS + path, formEntity, PagingResponse.class);
        PagingResponse<T> response = forEntity.getBody();

        return response;
    }
}

配置文件是这个

eureka:
  instance:
    instance-id: ${spring.cloud.client.ip-address}:${server.port}
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 10
    lease-expiration-duration-in-seconds: 30
  client:
    service-url:
      defaultZone: http://username:password@localhost:8761/eureka/  #服务中心地址    
    healthcheck:
      enabled: true
info:
  name: ${spring.application.name}
  company: photon