<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itcast.demo</groupId>
    <artifactId>cloud-demo</artifactId>
    <version>1.0</version>
    <modules>
        <module>user-service</module>
        <module>order-service</module>
    </modules>

    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.9.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
        <mysql.version>5.1.47</mysql.version>
        <mybatis.version>2.1.1</mybatis.version>
        <mybatisplus.version>3.4.2</mybatisplus.version>
    </properties>

    <dependencyManagement>
        <dependencies>
             <!-- springCloud的父工程，管理依赖 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- mysql驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!--mybatis-->
           <!-- <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.version}</version>
            </dependency>-->
            <!--mybatisplus起步依赖-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatisplus.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

子工程pom.xml文件，在<parent>中导入父工程的依赖管理

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud-demo</artifactId>
        <groupId>cn.itcast.demo</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>order-service</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--&lt;!&ndash;mybatis&ndash;&gt;
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>-->
        <!--mybatisplus起步依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

order-service的application.yml文件

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://192.168.230.100:3306/cloud_order?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver
#mybatis:
#  type-aliases-package: cn.itcast.user.pojo
#  configuration:
#    map-underscore-to-camel-case: true
# 设置mp运行时行为
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: cn.itcast.user.pojo
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS

user-service的application.yml文件

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://192.168.230.100:3306/cloud_user??useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver
mybatis:
  type-aliases-package: cn.itcast.user.pojo
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS

在order-service工程中使用restTemplate调用user-service工程的接口

order-service就是服务消费者，user-service就是服务提供者

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);

        //2.使用restTemplate向user-service服务发送请求获取用户数据
        String url="http://localhost:8081/user/"+order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
        order.setUser(user);
        // 4.返回
        return order;
    }
}

提供者与消费者

在服务调用关系中，会有两个不同的角色：

服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）

服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）

但是，服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言。

如果服务A调用了服务B，而服务B又调用了服务C，服务B的角色是什么？

对于A调用B的业务而言：A是服务消费者，B是服务提供者
对于B调用C的业务而言：B是服务消费者，C是服务提供者

因此，服务B既可以是服务提供者，也可以是服务消费者。

Eureka注册中心

假如我们的服务提供者user-service部署了多个实例，如图：

有以下几个问题：

order-service在发起远程调用的时候，该如何得知user-service实例的ip地址和端口？
有多个user-service实例地址，order-service调用时该如何选择？
order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

Eureka的结构和作用

解决之前的问题。

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

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

user-service服务实例启动后，将自己的信息注册到eureka-server（Eureka服务端）。这个叫服务注册
eureka-server保存服务名称到服务实例地址列表的映射关系
order-service根据服务名称，拉取实例地址列表。这个叫服务发现或服务拉取

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

order-service从实例列表中利用负载均衡算法选中一个实例地址
向该实例地址发起远程调用

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

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

注意：一个微服务，既可以是服务提供者，又可以是服务消费者，因此eureka将服务注册、服务发现等功能统一封装到了eureka-client端

注意：只有将当前服务注册到eureka服务端，才可以来去其他服务的实例地址

搭建eureka

搭建eureka-server

1.首先大家注册中心服务端：eureka-server，这必须是一个独立的微服务

2.导入eureka依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>cn.itcast.demo</groupId>
        <artifactId>cloud-demo</artifactId>
        <version>1.0</version>
    </parent>

    <groupId>org.example</groupId>
    <artifactId>eureka-server</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
<!--        导入eureka依赖，因为cloud-demo父工程管理的spring-cloud各种组件的依赖，所以不用指定版本号-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

</project>

3.编写配置类，并使用@EnableEurekaServer，开启eureka服务端

@SpringBootApplication
@EnableEurekaServer//开启eureka
public class EurekaApp {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApp.class,args);
    }
}

4.编写application.yml配置文件

server:
  port: 10086
spring:
  application:
    name: eureka-server #配置这个服务的名字
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka #默认的注册地址

5.启动访问

注册eureka客户端

1.引入依赖

在user-service的pom文件中，引入下面的eureka-client依赖：

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

2.在application.yml文件中编写eureka服务端地址进行连接，并给这个服务起一个名字

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

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://192.168.230.130:3306/cloud_user??useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: user-service
#mybatis:
#  type-aliases-package: cn.itcast.user.pojo
#  configuration:
#    map-underscore-to-camel-case: true
# 设置mp运行时行为
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: cn.itcast.user.pojo
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
eureka:
  client:
    service-url: #eureka的服务端地址
      defaultZone: http://127.0.0.1:10086/eureka

3.启动eureka服务端和两个子工程的服务

4.启动多个user-service实例，搭建集群

设置端口号

启动之后user-service服务变成2个

在order-service工程下使用eureka根据微服务的名字来获取 user-service的ip地址和端口号

1.使用@LoadBalanced注解，让restTemplate开启微服务负载均衡

    //配置restTemplate bean
    @Bean
    @LoadBalanced//让restTemplate开启微服务负载均衡
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

2.直接使用user-service服务的名字代替ip地址和端口号

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);

        //2.使用restTemplate向user-service服务发送请求获取用户数据
//        String url="http://localhost:8081/user/"+order.getUserId();
        String url="http://user-service/user/"+order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
        order.setUser(user);
        // 4.返回
        return order;
    }
}

3.在user-service子工程中添加端口号标识，来确定访问了哪个user-service(有两个端口号不同的服务)

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;
    @Value("${server.port}")
    private Integer port;

    public User queryById(Long id) {
        User user= userMapper.findById(id);
        user.setUsername(user.getUsername()+port);
        return user;
    }
}

4.测试

可以发现eureka默认的负载均衡默认策略是轮询模式

Ribbon负载均衡

我们添加了@LoadBalanced注解，即可实现负载均衡功能，这是什么原理呢？

负载均衡原理

SpringCloud底层其实是利用了一个名为Ribbon的组件，来实现负载均衡功能的。

SpringCloudRibbon的底层采用了一个拦截器LoadBalancerIntercepor，拦截了RestTemplate发出的请求，对地址做了修改。用一幅图来总结一下：

基本流程如下：

拦截我们的RestTemplate请求http://userservice/user/1
RibbonLoadBalancerClient会从请求url中获取服务名称，也就是user-service
DynamicServerListLoadBalancer根据user-service到eureka拉取服务列表
eureka返回列表，localhost:8081、localhost:8082
IRule利用内置负载均衡规则，从列表中选择一个，例如localhost:8081
RibbonLoadBalancerClient修改请求地址，用localhost:8081替代userservice，得到http://localhost:8081/user/1，发起真实请求

负载均衡策略

负载均衡的规则都定义在IRule接口中，而IRule有很多不同的实现类：

不同规则的含义如下：

内置负载均衡规则类	规则描述
RoundRobinRule	简单轮询服务列表来选择服务器。
AvailabilityFilteringRule	对以下两种服务器进行忽略：（1）在默认情况下，这台服务器如果3次连接失败，这台服务器就会被设置为“短路”状态。短路状态将持续30秒，如果再次连接失败，短路的持续时间就会几何级地增加。（2）并发数过高的服务器。如果一个服务器的并发连接数过高，配置了AvailabilityFilteringRule规则的客户端也会将其忽略。并发连接数的上限，可以由客户端的..ActiveConnectionsLimit属性进行配置。
WeightedResponseTimeRule	为每一个服务器赋予一个权重值。服务器响应时间越长，这个服务器的权重就越小。这个规则会随机选择服务器，这个权重值会影响服务器的选择。
ZoneAvoidanceRule	以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。
BestAvailableRule	忽略那些短路的服务器，并选择并发数较低的服务器。
RandomRule	随机选择一个可用的服务器。
RetryRule	重试机制的选择逻辑

默认的实现就是ZoneAvoidanceRule，是一种轮询方案

自定义负载均衡策略

通过定义IRule实现可以修改负载均衡规则，有两种方式：

第一种：代码实现，重新维护一个IRule类型的bean,覆盖默认的IRule

   //自定义一个负载均衡Rule bean覆盖默认的负载均衡Rule
    @Bean
    public IRule randomRule(){
        return new RandomRule();
    }

第二种：配置文件方式：在order-service的application.yml文件中，直接修改IRule的配置

user-service: # 给某个微服务配置负载均衡规则，这里是user-service服务
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则

饥饿加载

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，采取eureka下拉取指定服务的ip端口，第一次请求时间会很长。

而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，但是启动项目的时间会比较长,通过下面配置开启饥饿加载：

ribbon:
  eager-load:
    enabled: true
    clients: user-service # 指定对哪个微服务进行饥饿加载

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » 微服务概述

点赞(0) 打赏

本文分类：文章资讯
本文标签：微服务概述
浏览次数：320 次浏览
本文链接：https://freeymw.com/article/31840.html

上一篇 > Android车载——VehicleHal运行流程（Android 11）
下一篇 > 微服务（二）

评论列表共有 0 条评论

暂无评论

微服务概述

服务架构

单体架构

分布式架构

微服务

SpringClound微服务

总结

服务拆分和远程调用

服务拆分原则

服务拆分例子

准备两个数据库，给两个独立的模块（服务）准备一个数据库

准备一个父工程管理依赖，两个子工程