【例子】springcloud微服务搭建（一）注册中心+生产者+消费者+feign+负载均衡+熔断器

最新推荐文章于 2024-09-10 09:00:15 发布

御坂镜

最新推荐文章于 2024-09-10 09:00:15 发布

阅读量479

点赞数

分类专栏： lovelive

本文链接：https://blog.csdn.net/misakakagami/article/details/103506138

版权

lovelive 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一概述

本次先不管网关，先搭套微服务例子。包含一个注册中心eureka，两个生产者微服务，一个消费者微服务。生产消费者之间可使用RestTemplate直接调用http接口，也可使用feign调用。导入actuator依赖，feign简单搭配ribbon、hystrix做个demo，观察效果。

二搭建

A 搭建注册中心

1 idea中新建module，选择eureka service，一路next直到finish。或者pom配置：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.eurka</groupId>
    <artifactId>eurka</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eurka</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

主要是其中的 spring-cloud-starter-netflix-eureka-server

2 依赖导入完成，编辑application.xml

#本微服务的端口
server.port=8761
#本微服务的host
eureka.instance.hostname=localhost
#本微服务不在注册中心注册
eureka.client.register-with-eureka=false
#本微服务不从注册中心获取地址列表
eureka.client.fetch-registry=false
#本微服务挂靠的默认注册中心
eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka

#主动清理间隔，默认60秒
eureka.server.eviction-interval-timer-in-ms=5000
#保护机制，失效的微服务不会删除true/删除flase 开发环境使用
#eureka.server.enable-self-preservation=false

3 编辑application.java

package com.eurka.eurka;

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

@SpringBootApplication
@EnableEurekaServer
public class EurkaApplication {

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

}

主要是添加注解@EnableEurekaServer标记本服务为注册中心服务器

监听类：

package com.eurka.eurka;

import com.netflix.appinfo.InstanceInfo;
import org.springframework.cloud.netflix.eureka.server.event.*;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class EurekaListener {

    //下线
    @EventListener
    public void listen(EurekaInstanceCanceledEvent e){
        String appName = e.getAppName();
        String id = e.getServerId();
        System.out.println("cancel "+appName+" "+id);
    }

    //注册
    @EventListener
    public void listen(EurekaInstanceRegisteredEvent e){
        InstanceInfo i = e.getInstanceInfo();
        System.out.println("regist "+i);
    }

    //续约
    @EventListener
    public void listen(EurekaInstanceRenewedEvent e){
        String name = e.getAppName();
        System.out.println("renew "+name);
    }


    //续约
    @EventListener
    public void listen(EurekaRegistryAvailableEvent e){
        System.out.println("e start ");
    }

    //启动
    @EventListener
    public void listen(EurekaServerStartedEvent e){
        System.out.println("e server start ");
    }
}

4 保存编译启动，可访问 http://localhost:8761/ 查看注册中心详情。

B 搭建生产者

1 idea新建module，步骤、pom同注册中心。如果是即生产又消费的则同后叙消费者。为了监控健康、使用请求进行下线上线，还需导入actuator依赖


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

2 编辑application.xml

#本微服务端口
server.port=8763
#本微服务默认挂靠的注册中心地址
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
#本微服务的名字
spring.application.name=service-hi


#每5秒发送一次心跳
eureka.instance.lease-renewal-interval-in-seconds=5
#15秒没发送就从注册中心删除（不太灵
eureka.instance.lease-expiration-duration-in-seconds=15
#开启健康检查，需要依赖actuator
eureka.client.healthcheck.enabled=true

#actuator暴露所有节点，用于监控服务健康状况、控制下线上线
management.endpoints.web.exposure.include=*

其中微服务的名字会在注册中心展示，多个名字相同的会合并一行并由负载均衡选择一个调用。其它微服务使用RestTemplate通过此名字代替URL调用本服务。心跳删除不太灵，注册中心可能启动保护模式保持注册地址存在。开启actuator后，可使用get方式访问http://微服务地址/actuator/xxx查看健康状况，其中actuator/service-registry查看服务状态，以post方式、json格式发送请求 {"status":"DOWN"} 可使本微服务在注册中心下线，仍可继续处理请求，待其他微服务更新列表后不再访问本服务可关闭，或发送{"status":"UP"}重新上线。

3 编辑入口类

package com.product.product;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient
@RestController
public class ProductApplication {

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

    @Value("${server.port}")
    String port;

    @RequestMapping("/hi")
    public String home(@RequestParam String name,@RequestParam String time){
        System.out.println("product1 sleep "+time);
        if(time!=null&&!"".equals(time)){
            try {
                new Thread().sleep(Integer.parseInt(time));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return "hi "+name+" port:"+port;
    }

}

添加@EnableEurekaClient标注本微服务是注册中心客户端。懒得写controller了直接在启动类写个api。参数name直接展示，参数time为生产者接口阻断时间（毫秒），用于之后查看熔断器超时效果。

4 启动，访问http://localhost:8763/hi?name=xx可显示 hi xx port:8763，证明生产者接口畅通；增加参数time，可发现会阻断time值时长；查看注册中心，可看到生产者已挂靠。

C 搭建另一个生产者

步骤同上，注意application.xml中端口使用另一个。查看注册中心可发现两个生产者都挂靠，并合并为一行，因为服务名都是SERVICE-HI。可通过展示的端口号区分调用的哪个生产者的api。

D 搭建消费者

1 idea新建module，除eureka service外还选择ribbon、hystrix，如果使用feign还需手写补充openfeign（feign已不推荐，且idea不提供），或编辑pom（此处未导入actuator）

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cus</groupId>
    <artifactId>cus</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>cus</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    </properties>

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

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2 编辑application.xml


#本微服务名称
spring.application.name=ribbon-cus
#本微服务端口
server.port=9000
#本微服务默认挂靠的注册中心
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

#开启feign的熔断
feign.hystrix.enabled=true

#设置熔断器超时时间（毫秒），需大于ribbon的超时，写在注解中未起效果
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=10000
#feign内置的ribbon读取结果超时时间（毫秒），需大于连接超时时间
ribbon.ReadTimeout=2000
#ribbon连接超时时间，需小于读取结果时间
ribbon.ConnectTimeout=100
#总尝试连接次数为（重连次数+1）*（重试微服务数+1），全部失败后调用fallback方法（注解）
#ribbon重连次数，不包括首次连接
ribbon.MaxAutoRetries=3
#ribbon重试其它微服务次数，不包括首次连接。若微服务总数小于此数字，会重复连接现有的微服务。
ribbon.MaxAutoRetriesNextServer=2
#ribbon刷新缓存列表间隔
ribbon.ServerListRefreshInterval=5000

3 编辑类

入口：

package com.cus.cus;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
@EnableCircuitBreaker
public class CusApplication {

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

    /*@Bean
    @LoadBalanced
    RestTemplate restTemplate(){
        return new RestTemplate();
    }*/
}

注释部分为RestTemplate。注解EnableDiscoveryClient标注本微服务为消费者，EnableFeignClients开启feign，EnableCiruitBreaker开启熔断。

controller：

package com.cus.cus;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class IndexCon {
    /*@Autowired
    RestTemplate r;

    @RequestMapping(value="/rc",method = RequestMethod.GET)
    public String index(@RequestParam String name){
        return r.getForEntity("http://SERVICE-HI/hi?name="+name,String.class).getBody();
    }*/

    @Autowired
    public IndexSer i;

    @RequestMapping(value="/rc")
    public String index(@RequestParam String name,@RequestParam String time){
        String res = i.aa(name,time);
        return res;
    }
}

注释部分为RestTemplate方式调用，可见调用路径为生产者配置的、展示在注册中心的微服务名称。

service：

package com.cus.cus;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class IndexSer {

    @Autowired
    Feign f;

    @HystrixCommand(fallbackMethod = "fallback")
//,commandProperties = {@HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value="5000")})不起效果的注解，丢人，在application.property里配了
    public String aa(String name,String time){
        String res = "";
        res = f.aa(name,time);
        return res;
    }

    public String fallback(String name,String time){
        return "hystrix fall back "+name+" "+time;
    }
}

业务层调用feign。使用HystrixCommand注解标记此方法，fallbackMethod指定异常后调用的备用方法，~~commandProperties配置了超时时间（3毫秒）~~（此处注解不起作用，改为在配置文件里配置）。~~此处不可捕获调用feign的异常，否则无法调用熔断备用方法。~~（~~注解改为配置文件配置后就没这问题了~~)（确实不能捕获，由熔断器自行处理就行，熔断器依靠此方法抛出的异常来捕获进入熔断备用方法，若手动捕获则无法触发机制，相当于没用熔断器）

feign接口：

package com.cus.cus;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(value="SERVICE-HI")
public interface Feign {

    @RequestMapping(value="/hi")
    String aa(@RequestParam String name,@RequestParam String time);

}

本feign接口代理服务名为SERVICE-HI的api，内容与相应微服务的api一致。

4 启动，访问 http://localhost:9000/rc?name=as&time=10 ，可快速返回生产者的内容，多次访问后两个生产者的端口号都可能出现。访问http://localhost:9000/rc?name=as&time=1000 可正常返回，time改为5000则返回fall back，表示调用超时，进入了fallback方法，查看生产者的控制台可观察打印结果，总次数符合消费者的配置。

三总结

1 注册中心eureka：注册中心就导个依赖写个入口再配几句，需要的话加个监听类。注册中心接受各个微服务的注册，并监听心跳，若心跳停止则进入保护模式，若配置了清除无效地址则会删除。服务启动、注册、续约、下线等事件可被监听，用于记录日志、发送提醒。各个微服务配置挂靠的注册中心以进行注册，并定期拉取地址列表、更新ribbon负载均衡的地址缓存。

2 微服务客户端可为生产者也可为消费者也可两者都是；

3 服务调用feign和负载均衡ribbon：客户端可通过restTemplate类调用其他微服务接口，或通过feign调用。feign内置ribbon负载均衡，当发起feign调用时，ribbon根据调用接口的注解从地址列表中筛选出指定名称的微服务，然后根据策略（默认轮询）选出一条具体地址，拼接为最终调用路径；ribbon定期从注册中心拉取地址列表。

4 熔断器hystrix：在入口启用熔断、在需要熔断保护的方法添加注解，标注备用方法，在配置文件启用熔断feign.hystrix.enabled=true。当被注解方法中的feign调用重连次数耗尽、超时，即执行备用方法，替代调用的feign接口，并对被调微服务做降级、不再连接直到恢复通畅等处理。

5 添加actuator依赖，可通过地址/actoator/xxx查看微服务健康信息，暴露节点后可通过请求操作下线上线。