springcloud2.X核心组件搭建教程(eureka、config、stream、feign、hystrix、zuul)

1.基于springboot2.0.5，springcloud2.X(Finchley.SR1)，本文会先搭建一个简单的springcloud示例，包括feign、hystrix、zuul、springcloud-config、springcloud-stream这些的整合。2.项目模块说明eureka-server 注册中心config-server 配置中心user-servi...

凶狠的士兵76

5946人浏览 · 2018-10-14 21:03:05

凶狠的士兵76 · 2018-10-14 21:03:05 发布

1.基于springboot2.0.5，springcloud2.X(Finchley.SR1)，本文会先搭建一个简单的springcloud示例，包括feign、hystrix、zuul、springcloud-config、springcloud-stream这些的整合。

2.项目模块说明

eureka-server 注册中心

config-server 配置中心

user-service 用户服务

order-service 订单服务

message-service 消息服务

gateway 路由服务

consumer 前端服务

2.开始

2.1 注册中心

依赖如下：

        <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-web</artifactId>
        </dependency>

application.yml

server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false #是否将自身注册到eureka
    fetchRegistry: false #是否抓取注册信息
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

启动类加上注解@EnableEurekaServer

2.2 服务提供者

order-service，message-service，user-service，三者依赖都一样：

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

order-service的配置文件：

spring:
  application:
    name: order-service

server:
  port: 8763

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

user-service的配置文件：

spring:
  application:
    name: user-service

server:
  port: 8762

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

message-service的配置文件：

spring:
  application:
    name: message-service

server:
  port: 8764

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

然后我们分别启动这4个项目，浏览器输入http://localhost:8761/ 可以看到服务启动成功。

2.3 整合feign和hystrix

2.3.1 新建模块consumer，前端模块，consumer不需要注册到eureka，在这里我们通过consumer去调用服务集群。

2.3.2 consumer引入feign依赖

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        </dependency>

2.3.3 给order-service新建一个简单的controller

@RestController
public class OrderController {

    static Logger log = LogManager.getLogger(OrderController.class);

    @RequestMapping(value = "/get")
    public OrderEntity get(LocalDateTime dateTime){
        OrderEntity orderEntity = new OrderEntity();
        orderEntity.setId(8L);
        orderEntity.setCustomerName("test测试");
        orderEntity.setDate(dateTime);
        return orderEntity;
    }

    @RequestMapping(value = "/getById")
    public OrderEntity get(Long id){
        OrderEntity orderEntity = new OrderEntity();
        orderEntity.setId(id);
        orderEntity.setCustomerName("test测试");
        orderEntity.setDate(LocalDateTime.now());
        return orderEntity;
    }

    @RequestMapping(value = "/normal")
    public String normal(){

        return "1";
    }

    @RequestMapping(value = "/abnormal")
    public String abNormal() throws InterruptedException {
        log.info("abnormal-start:{}",LocalDateTime.now());
        Thread.sleep(8000);
        log.info("abnormal-end:{}",LocalDateTime.now());
        return "2";
    }

    @RequestMapping(value = "/abnormalWithCallBack")
    public String abnormalWithCallBack() throws InterruptedException {
        log.info("abnormalWithCallBack-start:{}",LocalDateTime.now());
        Thread.sleep(6000);
        log.info("abnormalWithCallBack-end:{}",LocalDateTime.now());
        return "3";
    }

}

2.3.4 consumer模块中新建feign客户端

@FeignClient(name = "order",url = "http://localhost:8861/order",fallbackFactory = OrderClientFallBack.class)
public interface OrderClient {

    @RequestMapping(method = RequestMethod.GET,value = "/get")
    OrderEntity getOne(LocalDateTime dateTime);

    @RequestMapping(method = RequestMethod.GET,value = "/getById")
    OrderEntity getOne(Long id);

    @RequestMapping(method = RequestMethod.GET,value = "/normal")
    String normal();

    @RequestMapping(method = RequestMethod.GET,value = "/abnormal")
    String abnormal();

    @RequestMapping(method = RequestMethod.GET,value = "/abnormalWithCallBack")
    String abnormalWithCallBack();
}

fallback处理：

@Component
public class OrderClientFallBack implements FallbackFactory<OrderClient> {

    static Logger log = LogManager.getLogger(OrderClientFallBack.class);

    @Override
    public OrderClient create(Throwable throwable) {
        return new OrderClient() {

            @Override
            public OrderEntity getOne(LocalDateTime dateTime) {
                return null;
            }

            @Override
            public OrderEntity getOne(Long id) {
                return null;
            }

            @Override
            public String normal() {
                return null;
            }

            @Override
            public String abnormal() {
                return null;
            }

            @Override
            public String abnormalWithCallBack() {
                log.info("abnormalWithCallBack - fail");
                return "abnormalWithCallBack - fail";
            }
        };

    }
}

consumer配置文件如下：增加超时时间的设置(feign默认1秒钟超时)，并打开feign-hystrix（默认是关），一般可以将hystrix的超时时间设置的比feign的超时时间长一些，否则feign的重试(如果配置了)将会失效。

spring:
  application:
    name: consumer
server:
  port: 8862

feign:
  client:
    config:
      default:
        connectTimeout: 7000
        readTimeout: 7000
  hystrix:
    enabled: true

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 8000

2.3.5 consumer增加controller

@RestController
@RequestMapping(value = "/consumer/test")
public class ConsumerController {

    static Logger log = LogManager.getLogger(ConsumerController.class);

    @Autowired
    OrderClient orderClient;

    @RequestMapping(value = "/order/get" )
    public OrderEntity get(){
        return orderClient.getOne(LocalDateTime.now());
    }

    @RequestMapping(value = "/order/getById" )
    public OrderEntity getById(){
        return orderClient.getOne(8L);
    }

    @RequestMapping(value = "/order/normal" )
    public String normal(){
        return orderClient.normal();
    }

    @RequestMapping(value = "/order/abnormal" )
    public String abnormal(){
        return orderClient.abnormal();
    }

    @RequestMapping(value = "/order/abnormalWithCallBack" )
    public String abnormalWithCallBack(){
        try {
            String returnStr = orderClient.abnormalWithCallBack();
            log.info("s:{}",returnStr);
            return returnStr;
        }catch (Exception e){
            //FeignException
            log.error("xxx",e);
            return "catch Exception";
        }
    }
}

2.3.6 启动类上加上@EnableFeignClients、@EnableHystrixDashboard、@EnableCircuitBreaker。

2.4 整合zuul

新建gateway项目，依赖如下：

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

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

配置文件如下：

spring:
  application:
    name: gateway

server:
  port: 8861

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

zuul:
  routes:
    order:
      path: /order/**
      serviceId: order-service
#      url: http://localhost:8763
    user:
      path: /user/**
      serviceId: user-service
  host:
    connect-timeout-millis: 10000
    socket-timeout-millis: 10000

order-service:
  ribbon:
    ReadTimeout: 10000
    ConnectTimeout: 10000

#超时配置说明：
#如果路由方式是serviceId的方式，配置为：zuul:routes:order:serviceId，那么ribbon的超时配置生效（order-service:ribbon:ReadTimeout）
#如果如果是url的方式，配置为：zuul:routes:order:url，则zuul.host开头的生效。

启动类加上注解@EnableZuulProxy开启zuul

到这里有几个超时时间要注意以下，一个是consumer的feign客户端超时时间，一个是consumer启用的hystrix的超时时间，还有一个是zuul的超时时间。只要其中一个超时了，就会触发fallback。

2.5 整合spring cloud cofig

先在git上准备一下环境，如下：

其中test内容为：

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://192.168.1.101:3306/test?characterEncoding=utf8&useSSL=false
    username: root
    password: root

version: test

test-string: abcdefghijk

新建config-server项目：

依赖如下：

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>

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

配置文件如下：

spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://github.com/pjypjy/learning-config #uri
          search-paths: /** #配置文件目录
      label: master
      username: solider #github账号
      password: 123456 #github密码

server:
  port: 8862

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

启动类加上注解@EnableConfigServer

为order-service增加配置文件bootstrap.yml:

spring:
  cloud:
    config:
      discovery:
        enabled: true
        service-id: config-server
      profile: test

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

并且为order-service增加依赖:

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--<version>5.1.47</version>-->
            <version>8.0.12</version>
        </dependency>

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

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

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

order-service增加请求处理:

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    Environment environment;

    @RequestMapping(value = "/config/query")
    public List<Map<String, Object>> query() {
        String sql = "select * from user_info ";
        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
        return list;
    }

    @RequestMapping(value = "/config/version")
    public String version() {
        String version = environment.getProperty("version");
        return version;
    }

    @RequestMapping(value = "/config/testString")
    public String testString() {
        String version = environment.getProperty("test-string");
        return version;
    }

    @RequestMapping(value = "/config/refresh")
    public String refresh() {
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders requestHeaders = new HttpHeaders();
        requestHeaders.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<String> requestEntity = new HttpEntity<>(null,requestHeaders);
        ResponseEntity<String> stringResponseEntity = restTemplate.postForEntity("http://localhost:8763/actuator/refresh", requestEntity, String.class);
        return stringResponseEntity.getStatusCode().value() + ":" +stringResponseEntity.getBody();
    }

order-service配置文件修改：这里需暴露refresh

management:
  endpoints:
    web:
      exposure:
        include: ["refresh"]

然后先启动config-server，再重新启动order-service，测试一下，dataSource成功创建，可以查询出数据，然后访问/config/testString，得到字符串:abcdefghijk，然后我们将github上的test-string项改为:abc，访问/config/refresh，发送post请求让order-service重新拉取配置，然后再访问/config/testString可以得到:abc。

2.6 整合spring cloud stream

为order-service、user-service、message-service增加依赖：

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

配置文件也统一增加rabbitmq的配置信息：

order-service的部分配置如下：

spring:
  application:
    name: order-service
  rabbitmq:
    host: 192.168.1.102
    port: 5672
    username: root
    password: root
    virtual-host: test
  cloud:
    stream:
      bindings:
        myTest:
          group: groupA

message-service的部分配置如下：

spring:
  application:
    name: message-service
  rabbitmq:
    host: 192.168.1.102
    port: 5672
    username: root
    password: root
    virtual-host: test

user-service部分配置如下：

spring:
  application:
    name: user-service
  rabbitmq:
    host: 192.168.1.102
    port: 5672
    username: root
    password: root
    virtual-host: test

首先是接收端：

为这order-service、message-service项目增加接收端：

public interface ReceiveService {

    @Input("myTest")
    SubscribableChannel receive();

}

启动类增加代码:

    @StreamListener("myTest")
    public void myReceive1(byte[] msg){
        System.out.println("===receive:"+new String(msg));
    }

启动类增加注解

@EnableBinding(value = {ReceiveService.class})

然后我们把user-service改造成发送端

为user-service增加发送端：

public interface ReceiveService {

    @Input("myTest")
    SubscribableChannel receive();

}

为user-service增加注解：

@EnableBinding(value = {SendService.class})

为user-service增加controller：

@RestController
public class UserController {

    @Autowired
    SendService sendService;


    /**
     * 1.如果在配置文件中未配置消费者组，系统会自动生成一个临时队列，连接断开，队列消失，队列名:myTest.anonymous.fsd15hu64....随机生成
     * 2.如果配置了消费者组，则自动生成队列为: myTest.消费者组名称 (非临时队列)
     * 3.默认发送消息，会向所有消费者组推送消息，如果一个有多个消费者 在 同一个消费者组里，消息会轮询发给这个组里的消费者
     * @return
     */
    @RequestMapping(value = "/mySend")
    public boolean mySend(){
        Message msg = MessageBuilder.withPayload("from: user-service  to: order-service".getBytes()).build();
        boolean send = sendService.send().send(msg);
        return send;
    }

}

访问/mySend可以看到message-service和order-service都能接收到消息，要注意，这里没有为message-service配置消费者组，springcloud stream会自动创建临时队列，用于order-service接收消息。order-service设置了消费者组则自动生成队列为: myTest.消费者组名称 (非临时队列)。消息会推送给所有消费者组，如果有多个项目都用了同一个消费者组(如groupA)，消息将会轮询发送给这些项目。

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...