SpringCloud-Eureka学习

Spring Cloud学习

微服务架构介绍

微服务和普通服务对比

SpringCloud和Dubbo对比

SpringCloud 组件

服务治理组件： Eureka、Consul、Nacos

注册中心

没有注册中心时：当服务提供者地址发生改变时，多个调用者发送请求调用服务时，发现服务地址发生了改变，导致调用失败，想要服务调用成功，则需要每个调用者重新配置服务提供者的最新地址，否则将无法调用成功！

使用注册中心：当服务提供者地址发生改变时，新的地址会被重新注册到注册中心中，当多个调用者发送请求调用服务时，只需要到注册中心中获取到最新地址，然后调用服务即可，不需要调用者手动去修改配置！

项目搭建过程

创建Eureka项目

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>

    <groupId>cn.molu.eureka</groupId>
    <artifactId>SpringCloud-Eureka</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!--  子模块  -->
    <modules>
        <module>eureka-provider</module>
        <module>eureka-consumer</module>
        <module>eureka-server</module>
    </modules>

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

    <properties>
        <project.build.soureEncoding>UTF-8</project.build.soureEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
    </properties>

    <!--  引入Spring Cloud依赖  -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

创建Eureka服务

步骤：

eureka-server依赖

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

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

eureka-server注册中心配置文件

# eureka的注册中心端口
server.port=8761

# eureka 配置
# 1.dashboard：eureka的web控制台配置
# 2.server：eureka的服务端配置
# 3.client：eureka的客户端配置
# 4.instance：eureka的实例配置
# eureka-server：eureka服务，不需要注册，不需要抓取路径
# eureka-client-provider：eureka-client的服务端，需要注册到eureka，不需要抓取路径
# eureka-client-consumer：eureka-client的客户端，不需要注册，需要主动抓取路径

# 主机
eureka.instance.hostname=127.0.0.1
# eureka服务端地址 调用访问地址
eureka.client.service-url.defaultZone=ttp://${eureka.instance.hostname}:${server.port}/eureka/
# 是否将自己的路径注册到eureka，默认true，注册中心不需要把自己注册到eureka，eureka-client的服务端才需要
eureka.client.register-with-eureka=false
# 是否从（eureka）注册中心中抓取路径，默认true，注册中心不需要从自身再抓取路径
eureka.client.fetch-registry=false
# 开启eureka的web控制台（默认为true）
eureka.dashboard.enabled=true
# eureka的web控制台访问路径（默认为 / ）
eureka.dashboard.path=/

创建eureka-client服务端

eureka-provider服务端

    <parent>
        <groupId>cn.molu.eureka</groupId>
        <artifactId>SpringCloud-Eureka</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>cn.molu</groupId>
    <artifactId>eureka-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-provider</name>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

eureka-provider服务端配置文件

# eureka-client服务端口号
server.port=8000
# 当前应用的名称
spring.application.name=eureka-provider

# 主机
eureka.instance.hostname=127.0.0.1
# eureka服务端地址 调用访问地址
eureka.client.service-url.defaultZone=ttp://127.0.0.1:8761/eureka/
# 是否将自己的路径注册到eureka，当前是eureka-client服务需要注册，默认true，可以不用配置
eureka.client.register-with-eureka=true
# 是否从注册中心中抓取路径，当前服务既是调用方又是被调用方，所以需要，默认true，可以不用配置
eureka.client.fetch-registry=true

eureka-provider中的controller中提供的接口可以被远程调用

    @GetMapping("findById/{id}")
    public Goods findById(@PathVariable("id") Long id){
        return goodsService.findById(id);
    }

在eureka-client服务端的启动类中添加@EnableEurekaClient注解

// 启用eureka客户端
@EnableEurekaClient
@SpringBootApplication
public class EurekaProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaProviderApplication.class, args);
    }
}

创建eureka-client客户端

eureka-consumer客户端

    <parent>
        <groupId>cn.molu.eureka</groupId>
        <artifactId>SpringCloud-Eureka</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>cn.molu</groupId>
    <artifactId>eureka-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-consumer</name>

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

eureka-consumer客户端配置文件

# eureka-consumer客户端端口号
server.port=9000
# 当前应用的名称
spring.application.name=eureka-consumer

# 主机
eureka.instance.hostname=127.0.0.1
# eureka服务端地址 调用访问地址
eureka.client.service-url.defaultZone=ttp://127.0.0.1:8761/eureka/
# 是否将自己的路径注册到eureka，当前是eureka-client服务需要注册，默认true，可以不用配置
eureka.client.register-with-eureka=true
# 是否从注册中心中抓取路径，当前服务既是调用方又是被调用方，所以需要，默认true，可以不用配置
eureka.client.fetch-registry=true

eureka-consumer中配置RestTemplate
客户端通过restTemplate在controller中远程调用eureka-provider服务

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

远程调用eureka-provider服务

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("findById/{id}")
    public Map<String, Object> findById(@PathVariable("id") Long id){
    	String providerUrl="http://127.0.0.1:8000/goods/findById/1";
        Map map = restTemplate.getForObject(providerUrl, Map.class);
        System.out.println("map = " + map);
        return map;
    }

在eureka-client客户端的启动类中添加@EnableEurekaClient注解

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

动态获取地址

动态从eureka-server注册中心中获取eureka-provider的路径地址
1.注入 DiscoveryClient 对象，使用@EnableDiscoveryClient激活
2.调用方法

import org.springframework.cloud.client.discovery.DiscoveryClient;
@Resource
private DiscoveryClient discoveryClient;
List<ServiceInstance> instances = discoveryClient.getInstances("EUREKA-PROVIDER");

getInstances(“serviceId”);serviceId就是是注册到eureka-server中的Application的name
因为"EUREKA-PROVIDER"可能是集群环境,所有返回的就是一个List集合

完整代码

@RestController
@RequestMapping("/order/*")
public class OrderController {

    @Resource
    private RestTemplate restTemplate;
    @Resource
    private DiscoveryClient discoveryClient;
    /**
     * 动态从eureka-server注册中心中获取eureka-provider的路径地址
     * 1.注入 DiscoveryClient 对象，使用@EnableDiscoveryClient激活
     * 2.调用方法
     */
    @GetMapping("findAll")
    public Map<String, Object> restFindAll(){
        // getInstances("serviceId");serviceId就是是注册到eureka-server中的Application的name
        List<ServiceInstance> instances = discoveryClient.getInstances("EUREKA-PROVIDER");
        // 因为"EUREKA-PROVIDER"可能是集群环境,所有返回的就是一个List集合
        if (null == instances || instances.isEmpty()) {
            return null;
        }
        // 这里只是注册了 一个实例 所以直接获取0索引即可
        ServiceInstance serviceInstance = instances.get(0);
        String host = serviceInstance.getHost(); // 主机IP
        int port = serviceInstance.getPort(); // 端口号
        String url = String.format("http://%s:%d/goods/findAll", host, port);
        Map map = restTemplate.getForObject(url, Map.class);// 调用具体方法 返回数据对象
        System.out.println("map = " + map);
        return map;
    }
}

在项目的启动类上加上@EnableDiscoveryClient注解（建议加上，新版本可以不用加）

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

eureka相关配置及特性

server：eureka的服务端配置

开启自我保护机制，默认true，可以不用配置（正式库尽量不要配置或修改为false）
eureka.server.enable-self-preservation=true
清理时间间隔，单位毫秒默认是60，可以不用配置
eureka.server.eviction-interval-timer-in-ms=60000

instance：eureka的实例配置

将当前实例的IP注册到eureka-server中，默认是false 注册主机名eureka.instance.hostname=127.0.0.1，开启后不会再注册hostname，而是将该实例（应用）的IP地址注册上去
eureka.instance.prefer-ip-address=true
设置当前实例的IP地址（设置当前应用的IP地址）开启后会将此处的IP注册到eureka-server中去，hostname 和 ip-address将不会再被注册
eureka.instance.ip-address=192.168.188.66
设置web控制台显示的实例id（应用id：IP:应用名称:port）
eureka.instance.instance-id=${eureka.instance.ip-address}:${spring.application.name}:${server.port}

集成Ribbon简化调用

使用Ribbon来简化RestTemplate的调用
在声明RestTemplata的时候加上@LoadBalanced此注解
在使用RestTemplate发起请求需要定义url的host和port，使用Ribbon时直接使用应用服务名称即可

在eureka-consumer声明RestTemplata的时候加上@LoadBalanced此注解

@Configuration
public class RestTemplateConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

在声明RestTemplate的RestTemplateConfig 类中加上@LoadBalanced注解后
直接在OrderController 中的rpcFindById方法中更改远程调用的url地址即可

@RestController
@RequestMapping("/order/*")
public class OrderController {
    @Resource
    private RestTemplate restTemplate;
    /**
     * 使用Ribbon发起远程调用
     * 1.在声明`RestTemplata`的时候加上`@LoadBalanced`此注解
     * 2.在使用`RestTemplate`发起请求需要定义`url`的`host`和`port`，使用`Ribbon`时直接使用应用服务名称即可
     */
    @GetMapping("rpcFindById/{id}")
    public Map<String, Object> rpcFindById(@PathVariable("id") Long id){
       String url = "http://EUREKA-PROVIDER/goods/rpcFindById/"+id;
        Map map = restTemplate.getForObject(url, Map.class);
        return map;
    }
}

Ribbon的负载均衡

使用了Ribbon时，Ribbon会有一个默认的负载均衡策略（轮询）

在eureka-provider中测试Ribbon的默认负载均衡方法
首先GoodsController 类中注入端口号，然后启动erueka-provider服务

@RestController
@RequestMapping("/goods/*")
public class GoodsController {

    @Value("${server.port}")
    private Integer port;
    @Resource
    private GoodsService goodsService;

    @GetMapping("findById/{id}")
    public Goods findById(@PathVariable("id") Long id){
        Goods goods = goodsService.findById(id);
        goods.setTitle(goods.getTitle() + ":" + port);
        return goods;
    }
}

服务启动完成以后，在eureka-provider的配置文件中将原来的端口号8000改为8001

# 服务端口号
server.port=8001
# 当前应用的名称
spring.application.name=eureka-provider

修改完成以后，之前的服务不需要关闭，然后再次启动eureka-provider服务，此时相当于启动了两个eureka-provider服务，一个端口号为8000，另一个的端口号为8001
之后启动项目eureka-consumer，然后调用http:127.0.0.1:9000/order/rpcFindById/1接口，注意观察返回数据中的title所携带的端口号，每次请求时返回的端口号就会发生改变

负载均衡的配置

一、代码配置

使用代码的方式配置Ribbon的负载均衡

@Configuration
public class MyRule{
	@Bean
	public IRule rule(){
		// 使用随机模式（此处有七种模式可以选择）
		return new RandomRule();
	}
}

代码配置完成之后在启动类上在加上@RibbonClient(name = "EUREKA-PROVIDER", configuration = MyRule.class)注解

/**
 * 配置Ribbon的负载均衡策略
 * name：设置服务提供方的应用名称：EUREKA-PROVIDER
 * configuration：设置负载均衡策略的配置的Bean
 */
@EnableEurekaClient
@EnableDiscoveryClient
@SpringBootApplication
@RibbonClient(name = "EUREKA-PROVIDER", configuration = MyRule.class)
public class EurekaConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaConsumerApplication.class, args);
    }
}

二、配置文件配置

在eureka-consumer的配置文件中配置负载均衡策略

# 配置Ribbon的负载均衡策略
EUREKA-PROVIDER.ribbon.NFloadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule

EUREKA-PROVIDER：可变值，设置服务提供发的应用名称
ribbon：固定写法
NFloadBalancerRuleClassName：固定写法
com.netflix.loadbalancer.RandomRule：可变值，根据自己所需的策略模式配置

以上两种配置方式均可以达到配置Ribbon负载均衡的效果