微服务学习——远程调用

二十三年蝉&

于 2024-08-15 14:42:35 发布

阅读量1.1k

点赞数 29

文章标签：微服务 java 运维

本文链接：https://blog.csdn.net/q12ERTYU/article/details/141217078

版权

微服务服务之间远程调用的几种方式（RestTemplate、Eureka、Nacos、feign）

1.RestTemple

在调用方的启动类中声明一个bean

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

    //实现远程调用
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

然后在需要导入的接口实现中，使用restTemplate.getForObject(url,XX.class)

@Autowired
private RestTemplate restTemplate;

public Order queryOrderById(Long orderId) {
    // 1.查询订单
    Order order = orderMapper.findById(orderId);
    // 4.返回
    //2.远程调用查询user
    String url="http://127.0.0.1:8081/user/"+order.getUserId();
    User user=restTemplate.getForObject(url,User.class);
    order.setUser(user);
    return order;

2.Eureka注册中心

1 order-service如何得知user-service实例地址？

获取地址信息的流程如下：

1.user-service服务实例启动后，将自己的信息注册到eureka-server（Eureka服务端）。这个叫服务注册

2.eureka-server保存服务名称到服务实例地址列表的映射关系

3. order-service根据服务名称，拉取实例地址列表。这个叫服务发现或服务拉取

2.order-service如何从多个user-service实例中选择具体的实例？

order-service从实例列表中利用负载均衡算法选中一个实例地址，

向该实例地址发起远程调用

3.order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳
当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除
order-service拉取服务时，就能将故障实例排除了

具体使用：

1.引入SpringCloud为eureka提供的starter依赖

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

2.给eureka-server服务编写一个启动类，

一定要添加一个@EnableEurekaServer注解，开启eureka的注册中心功能：

package cn.itcast.eureka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

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

编写一个application.properties文件，内容如下：

server.port=8761
spring.application.name=eureka-server
eureka.client.service-url.defaultzone=http://127.0.0.1:8761/eureka

在服务提供方user-service的pom文件中，引入下面的eureka-client依赖：

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka- client</artifactId>
</dependency>

在服务提供方user-service中，修改application.properties文件，添加服务名称、eureka地址：

spring.application.name=userservice
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka

同样对于服务的调用方：order-service也增加相同的依赖，修改application.properties文件

对于服务调用方：order-service，在启动类中增加一个注解@LoadBalanced

//实现远程调用
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}

在调用时，将之前的url中IP地址和端口替换成服务名即可：

public Order queryOrderById(Long orderId) {
    // 1.查询订单
    Order order = orderMapper.findById(orderId);
    // 4.返回
    //2.远程调用查询user
    String url="http://userservice/user/"+order.getUserId();
    User user=restTemplate.getForObject(url,User.class);
    order.setUser(user);
    return order;
}

以上过程就能实现将服务注册到eureka注册中心中，并且实现服务间可直接通过服务名即可相互调用，但是不建议循环依赖。

3.Nacos服务注册、配置中心

服务注册：

本地解压安装好nacos，并使用单机的方式启动nacos服务，在浏览器http://127.0.01:8848/nacos可以访问服务信息
在cloud-demo父工程的pom文件中的<dependencyManagement>中引入SpringCloudAlibaba的依赖：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.2.6.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

然后在user-service和order-service中的pom文件中引入nacos-discovery依赖：

<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

配置服务的nacos地址、集群以及负载均衡的规则

spring.cloud.nacos.server-addr=localhost:8848
spring.cloud.nacos.discovery.cluster-name=HZ
userservice.ribbon.NFLoadBalancerRuleClassName=com.alibaba.cloud.nacos.ribbon.NacosRule

可复制多个服务生产者（配置端口，集群名称）：

-Dserver.port=8083 -Dspring.cloud.nacos.discovery.cluster-name=SH

nacos的负载均衡会优先考虑同一个集群中的服务实例进行调用，而在同一个集群中则是以随机的方式调用服务实例，这是可以选择同一个服务下不同实例的权重来改变负载均衡的选择。

服务统一配置：

在nacos首页【配置管理】-【配置列表】-点击+号添加配置，然后在弹出的表单中，填写配置信息：

Data ID: userservice-dev.properties
Group: DEFAULT_GROUP
描述：开发环境配置
配置格式：properties
配置内容：pattern.dateformat=yyyy-MM-dd HH:mm:ss

微服务要拉取nacos中管理的配置，并且与本地的application.yml配置合并，才能完成项目启动。

但如果尚未读取application.yml，又如何得知nacos地址呢？

因此spring引入了一种新的配置文件：bootstrap.yaml文件，会在application.yml之前被读取，流程就是在项目启动时会读取先bootstrap.yaml和nacos上的配置信息，并整合到项目中，读取application.properties文件，创建spring容器并加载bean

首先，在user-service服务中，引入nacos-config的客户端依赖：

<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

然后，在user-service中添加一个bootstrap.properties文件，内容如下：

spring.application.name=userservice
spring.profiles.active=dev
spring.cloud.nacos.server-addr=localhost:8848
spring.cloud.nacos.config.file-extension=properties

在user-service中的UserController中添加业务逻辑，读取pattern.dateformat配置：

@Value("${pattern.dateformat}")
private String dateformat;

@GetMapping("now")
public String now(){
return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
}

4.feign远程调用

1使用RestTemplate的方式存在一些问题：

代码可读性差，编程体验不统一
参数复杂URL难以维护

2可以创建一个新的module将feign的功能代码独立出来,并将对应的实体类也转移到新module中

3 首先在module服务的pom文件中引入feign的依赖：

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

创建UserClient接口：

@FeignClient(value ="userservice",configuration = DefaultFeignConfiguration.class)
public interface UserClient {
@GetMapping("/user/{id}")
User findById(@PathVariable("id") Long id);
}

在order-service项目中导入feign-api服务的依赖：

<dependency>
    <groupId>cn.itcast.demo</groupId>
    <artifactId>feign-api</artifactId>
    <version>1.0</version>
</dependency>

修改order-service中的OrderService类中的queryOrderById方法，使用Feign客户端代替RestTemplate：

@Autowired
private UserClient userClient;

public Order queryOrderById(Long orderId) {
    // 1.查询订单
    Order order = orderMapper.findById(orderId);
    // 4.返回
    //2.远程调用查询user
    User user=userClient.findById(order.getUserId());
    order.setUser(user);
    return order;
}