SpringCloud搭建保姆级教程

一、搭建服务注册与发现中⼼

使⽤Spring Cloud Netflix 中的 Eureka 搭建服务注册与发现中⼼

1、创建SpringBoot应用添加依赖

1、spring web
2、eureka server

2、配置服务注册与发现中⼼

## 设置服务注册与发现中⼼的端⼝
server:
  port: 8761
## 在微服务架构中,服务注册中⼼是通过服务应⽤的名称来区分每个服务的
## 我们在创建每个服务之后,指定当前服务的 应⽤名/项⽬名
spring:
  application: null
  name: service-eureka
eureka:
  client:
    ## ip 就是服务注册中⼼服务器的ip,port 就是服务注册与发现中⼼设置的port
    service-url:
      defaultZone: 'http://192.168.54.59:8761/eureka'
    ## 设置服务注册与发现中⼼是否为为集群搭建(如果为集群模式,多个eureka节点之间需要相互注册)
    register-with-eureka: false
     ## 设置服务注册与发现中是否作为服务进⾏注册
    fetch-registry: false

3、在启动类添加@EnableEurekaServer注解

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

4、运⾏及访问

二、服务注册

创建保存订单的服务(order-add)注册到服务注册与发现中⼼

1、创建SpringBoot应⽤

创建spring boot应⽤,完成功能开发

2、注册服务

将能够完成特定业务的SpringBoot应⽤作为服务提供者,注册到服务注册与发现中⼼

2.1、添加依赖eureka-server

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

2.2、配置application.yml

server:
  port: 9001
## 当前应⽤名会作为服务唯⼀标识注册到eureka
spring:
  application:
    name: order-add
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: 'jdbc:mysql://localhost:3306/db_2010_sc?characterEncoding=utf-8'
    username: root
    password: admin123
mybatis:
  mapper-locations: 'classpath:mappers/*'
  type-aliases-package: com.qfedu.order.beans
## 配置Eureka服务注册与发现中⼼的地址
eureka:
  client: 
      service-url:
        defaultZone: 'http://localhost:8761/eureka'

2.3、在当前服务应⽤的启动类添加 @EnableEurekaClient 注解

@SpringBootApplication
@MapperScan("com.qfedu.order.dao")
@EnableEurekaClient
public class OrderAddApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderAddApplication.class, args);
    }
}

三、服务发现-Ribbon

服务消费者(api-order-add)通过eureka查找服务提供者(order-add),通过服务调⽤组件调⽤提供者
  • eureka server
  • ribbon

1、基础配置

Ribbon客户端已经停更进维啦

1.1、创建SpringBoot应⽤,添加依赖 

  • eureka server
  • ribbon

1.2、配置application.yml

server:
  port: 8001
spring:
  application: 
    name: api-order-add
eureka:
  client: 
    service-url: 
        defaultZone: 'http://localhost:8761/eureka'

1.3、在启动类添加 @EnableDiscoveryClient注解 

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

2、服务调⽤

2.1、配置RestTemplate

@Configuration
public class AppConfig {
    @LoadBalanced //启⽤Ribbon(负载均衡)
    @Bean
     public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

2.2、在Service中注⼊RestTemplate对象调⽤服务

@Service
public class OrderAddServiceImpl implements OrderAddService {
    @Autowired
    private RestTemplate restTemplate;
    @Override
    public ResultVO saveOrder(Order order) {
        //1. 调⽤ order-add服务进⾏保存
        ResultVO vo = restTemplate.postForObject("http://order-add/order/add", order, ResultVO.class);
        //2. 调⽤ orderitem-add 保存订单快照
        //3. 调⽤ stock-update 修改商品库存
        //4. 调⽤ shopcart-del 删除购物⻋记录
        return null;
    }
}

3、Ribbon服务调⽤说明

@LoadBalanced注解是Ribbon的⼊⼝,在RestTemplate对象上添加此注解之后,再使
⽤RestTemplate发送REST请求的时候,就可以通过Ribbon根据服务名称从Eureka中查
找服务对应的访问地址列表,再根据负载均衡策略(默认轮询)选择其中的⼀个,然后
完成服务的调⽤
  • 获取服务列表
  • 根据负载均衡策略选择服务
  • 完成服务调⽤

四、基于Ribbon进⾏服务调⽤的参数传递

1、RestTemplate发送调⽤请求的⽅法

SpringCloud的服务调⽤是基于REST的,因此当服务提供者规定了请求的⽅式,服务消
费者必须发送对应⽅式的请求才能完成服务的调⽤,RestTemplate提供了多个⽅法⽤于
发送不同形式的请求。
//post⽅式请求
restTemplate.postForObject();
//get⽅式请求
restTemplate.getForObject();
//delete⽅式请求
restTemplate.delete();
//put⽅式请求
restTemplate.put();

2、put/post请求传参

1、服务消费者请求传参
//参数1:访问服务的url
//参数2:传递的对象参数
//参数3:指定服务提供者返回的数据类型
ResultVO vo = restTemplate.postForObject("http://order-add/order/add",order, ResultVO.class);

2、服务提供者接收参数

@PostMapping("/add")
public ResultVO addOrder(@RequestBody Order order){
   return orderService.saveOrder(order);
}

3、get请求传参

1、服务消费者请求传参 

String userId = order.getUserId();
ResultVO vo = restTemplate.getForObject("http://order-add/order/add?userId="+userId, ResultVO.class);

2、服务提供者接收参数 

@GetMapping("/add")
public ResultVO addOrder(Order order){
    return orderService.saveOrder(order);
}
@GetMapping("/add")
public ResultVO addOrder(String userId){
    //return orderService.saveOrder(order);
}

五、服务发现-Feign

1、基础配置

1.1、创建SpringBoot应⽤,添加依赖

spring web
eureka server
OpenFeign

1.2、配置application.yml

server:
  port: 8002
spring:
  application:
    name: api-order-add-feign
eureka:
  client:
    service-url:
      defaultZone: 'http://localhost:8761/eureka'

1.3、在启动类添加注解

@SpringBootApplication
@EnableDiscoveryClient //声明为服务消费者
@EnableFeignClients //声明启⽤feign客户端
public class ApiOrderAddFeignApplication {
    public static void main(String[] args) {
        SpringApplication.run(ApiOrderAddFeignApplication.class, args);
    }
}

2、服务调⽤

使⽤Feign进⾏服务调⽤的时候,需要⼿动创建⼀个服务访问客户端(接⼝)

2.1、创建Feign客户端

@FeignClient("order-add")
public interface OrderAddClient {
    @PostMapping("order/add")
     public ResultVO addOrder(Order order);
}

2.2、使⽤Feign客户端调⽤服务

@Service
public class OrderAddServiceImpl implements OrderAddService {
    @Autowired
    private OrderAddClient orderAddClient;
    @Override
    public ResultVO saveOrder(Order order) {
        //1. 调⽤ order-add服务进⾏保存
        ResultVO vo = orderAddClient.addOrder(order);
        //2. 调⽤ orderitem-add 保存订单快照
        //3. 调⽤ stock-update 修改商品库存
        //4. 调⽤ shopcart-del 删除购物⻋记录
        return vo;
    }
}

3、Feign传参

3.1、POST请求

1、通过请求体传递对象

服务提供者
@PostMapping("/add")
public ResultVO addOrder(@RequestBody Order order){
    System.out.println("-------------------order-add");
    System.out.println(order);
    return orderService.saveOrder(order);
}
服务消费者(Feign客户端)
@FeignClient("order-add")
public interface OrderAddClient {
    @PostMapping("order/add")
     public ResultVO addOrder(Order order);
}

2、通过请求⾏传参

服务提供者
@PostMapping("/add")
public ResultVO addOrder(@RequestBody Order order,String str){
    System.out.println("-------------------order-add");
    System.out.println(order);
    System.out.println(str);
    return orderService.saveOrder(order);
}
服务消费者(Feign客户端)
//1.对⽤POST请求调⽤服务,Feign客户端的⽅法参数默认为body传值(body只能有⼀个值)
//2.如果有多个参数,则需要通过@RequestParam声明参数为请求⾏传值
@PostMapping("order/add")
public ResultVO addOrder(Order order,@RequestParam("str") String str);

3、Get请求

Get请求调⽤服务,只能通过url传参在Feign客户端的⽅法中,如果不指定参数的传值⽅式,则默认为body传参,Get请求也不例外;
因此对于get请求传递参数,必须通过@RequestParam注解声明

 

服务提供者
@GetMapping("/get")
public Order addOrder(String orderId){
    return new Order();
}
服务消费者(Feign客户端)
@GetMapping("order/get")
public Order getOrder(@RequestParam("orderId") String orderId);

六、服务注册与发现中⼼的可靠性和安全性

1、可靠性

在微服务架构系统中,服务消费者是通过服务注册与发现中⼼发现服务、调⽤服务的,
服务注册与发现中⼼服务器⼀旦挂掉,将会导致整个微服务架构系统的崩溃,如何保证
Eureka的可靠性呢?
  • 使⽤eureka集群
Eureka集群搭建
相互注册、相互发现
## 设置服务注册与发现中⼼的端⼝
server:
  port: 8761
## 在微服务架构中,服务注册中⼼是通过服务应⽤的名称来区分每个服务的
## 我们在创建每个服务之后,指定当前服务的 应⽤名/项⽬名
spring:
  application:
    name: service-eureka
eureka:
  client:
    ## 设置服务注册与发现中⼼是否为集群搭建
    register-with-eureka: true
    ## 设置服务注册与发现中是否作为服务进⾏注册
    fetch-registry: true
    ## ip 就是服务注册中⼼服务器的ip
    ## port 就是服务注册与发现中⼼设置的port
    service-url:
      defaultZone: 'http://192.168.54.10:8761/eureka'
    

2、安全性

当完成Eureka的搭建之后,只要知道ip和port就可以随意的注册服务、调⽤服务,这是
不安全的,我们可以通过设置帐号和密码来限制服务的注册及发现。
  • 在eureka中整合Spring Security安全框架实现帐号和密码验证

2.1、添加SpringSecurity的依赖

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

2.2、设置访问eureka的帐号和密码

spring:
  security:
    user:
      name: zhangsan
      password: 123456

2.3、配置Spring Security

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
     protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable();
        // 设置当前服务器的所有请求都要使⽤spring security的认证
        http.authorizeRequests().anyRequest().authenticated().and().httpBasic();
    }
}

2.4、服务提供者和服务消费者连接到注册中⼼都要帐号和密码

eureka:
  client:
    service-url:
      defaultZone: 'http://zhangsan:123456@localhost:8761/eureka'

七、熔断器-Hystrix

服务故障的雪崩效应:当A服务调⽤B服务时,由于B服务的故障导致A服务处于阻塞状态,当量的请求可能会导致A服务因资源耗尽⽽出现故障。
为了解决服务故障的雪崩效应,出现了熔断器模型。

1、熔断器介绍

熔断器作⽤:
1、服务降级 :⽤户请求A服务,A服务调⽤B服务,当B服务出现故障或者在特定的时间段内
不能给A服务响应,为了避免A服务因等待B服务⽽产⽣阻塞,A服务就不等B服务的结果
了,直接给⽤户⼀个降级响应
2、服务熔断 :⽤户请求A服务,A服务调⽤B服务,当B服务出现故障的频率过⾼达到特定阈
值(5s 20次)时,当⽤户再请求A服务时,A服务将不再调⽤B服务,直接给⽤户⼀个降
级响应

2、熔断器的原理

3、基于Ribbon服务调⽤的熔断器使⽤

3.1、服务消费者的服务降级

1、添加熔断器依赖 hystrix

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

2、在启动类添加 @EnableHystrix 注解

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

3、在调⽤服务提供者的业务处理⽅法中,进⾏降级配置

@Service
public class OrderAddServiceImpl implements OrderAddService {
   @Autowired
   private RestTemplate restTemplate;
   @HystrixCommand(fallbackMethod ="fallbackSaveOrder",commandProperties = {
        @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value="3000")
      }
   )
   public ResultVO saveOrder(Order order) {
      //1. 调⽤ order-add服务进⾏保存
      //参数1:访问服务的url
      //参数2:传递的对象参数
      //参数3:指定服务提供者返回的数据类型
      ResultVO vo = restTemplate.postForObject("http://order-add/order/add",order, ResultVO.class);
      System.out.println(vo);
      return vo;
  }
  /**
   * 降级⽅法:与业务⽅法拥有相同的参数和返回值
   * @return
   */
  public ResultVO fallbackSaveOrder(Order order){
      return ResultVO.fail("⽹络异常,请重试!",null);
  }
}

3.2、服务提供者的服务降级

1、配置步骤⼀致
2、服务提供者接⼝降级
@RestController
@RequestMapping("/order")
public class OrderController {
   @Autowired
   private OrderService orderService;
   @HystrixCommand(fallbackMethod ="fallbackAddOrder",commandProperties = {
      @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value="3000")
      }
   )
   @PostMapping("/add")
   public ResultVO addOrder(@RequestBody Order order){
      System.out.println("-------------------order-add");
      System.out.println(order);
      try {
          Thread.sleep(5000);
      }
      catch (InterruptedException e) {
          e.printStackTrace();
      }
      return orderService.saveOrder(order);
  }
  public ResultVO fallbackAddOrder(@RequestBody Order order){
      System.out.println("-------------------order-add--fallback");
      return ResultVO.fail("订单保存失败!",null);
  }
}

1、服务熔断配置

熔断器状态:闭合、打开、半开
服务熔断配置
  @HystrixCommand(fallbackMethod ="fallbackSaveOrder",commandProperties = {
    @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value="3000"),
     @HystrixProperty(name="circuitBreaker.enabled",value="true"),//启⽤服务熔断
    @HystrixProperty(name="circuitBreaker.sleepWindowInMilliseconds",value="10000"),//时间
    @HystrixProperty(name="circuitBreaker.requestVolumeThreshold",value="10"),//请求次数
    @HystrixProperty(name="circuitBreaker.errorThresholdPercentage",value="50"),//服务错误率
    }
  )
  public ResultVO saveOrder(Order order) {
    //1. 调⽤ order-add服务进⾏保存
    ResultVO vo = restTemplate.postForObject("http://orderadd/order/add", order, ResultVO.class);
    System.out.println(vo);
    return vo;
  }
  /**
  * 降级⽅法:与业务⽅法拥有相同的参数和返回值
  * @return
  */
  public ResultVO fallbackSaveOrder(Order order){
    return ResultVO.fail("⽹络异常,请重试!",null);
  }
服务熔断:当⽤户请求服务A,服务A调⽤服务B时,如果服务B的故障率达到特定的
阈值时,熔断器就会被打开⼀个时间周期(默认5s,可⾃定义),在这个时间周期
内如果⽤户请求服务A,服务A将不再调⽤服务B,⽽是直接响应降级服务。

4、基于Feign服务调⽤的熔断器使⽤

Feign是基于Ribbon和Hystrix的封装

4.1、Feign中的熔断器使⽤

1、添加依赖(SpringBoot 2.3.11 、Spring Cloud H)

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>2.3.11.RELEASE</version>
   <relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
   <java.version>1.8</java.version>
   <spring-cloud.version>Hoxton.SR11</spring-cloud.version>
</properties>
<dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

2、在application.yml启⽤熔断器机制

feign:
  hystrix:
    enabled: true    

3、在启动类添加 @EnableHystrix

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

4、创建服务降级处理类

5、FeignClient的服务降级类:

  5.1.必须实现Feign客户端接⼝

  5.2.必须交给Spring容器管理

@Component
public class OrderAddClientFallback implements OrderAddClient {
    public ResultVO addOrder(Order order, String str) {
        System.out.println("-------addOrder的降级服务");
        return ResultVO.fail("fail",null);
    }
    public Order getOrder(String orderId) {
        System.out.println("-------getOrder的降级服务");
        return new Order();
    }
}

6、在Feign客户端指定降级处理类

@FeignClient(value = "order-add", fallback =OrderAddClientFallback.class)
public interface OrderAddClient {
    //1.对⽤POST请求调⽤服务,Feign客户端的⽅法参数默认为body传值(body只能有⼀个值)
    //2.如果有多个参数,则需要通过@RequestParam声明参数为请求⾏传值
    @PostMapping("order/add")
    public ResultVO addOrder(Order order,@RequestParam("str") String str);
@GetMapping(
"order/get") public Order getOrder(@RequestParam("orderId") String orderId); }

7、Service类通过Feign客户端调⽤服务

@Service
public class OrderAddServiceImpl implements OrderAddService {
    @Autowired
    private OrderAddClient orderAddClient;
    //当我们创建Feign客户端的降级类并交给Spring管理后 在Spring容器中就会出现两个OrderAddClient对象
    @Override
    public ResultVO saveOrder(Order order) {
        //1. 调⽤ order-add服务进⾏保存
        ResultVO vo = orderAddClient.addOrder(order,"测试字符串");
        Order order1 = orderAddClient.getOrder("订单编号");
        System.out.println(order1);
        return vo;
    }
}

5、Ribbon 参数配置

ribbon:
  ## Ribbon建⽴连接最⼤等待时间
  ConnectTimeout: 1000
  ## 在当前服务提供者尝试连接次数
  MaxAutoRetries: 2
  ## 与服务提供者通信时间
  ReadTimeout: 5000

## 设置熔断器服务降级时间 (默认 1000)
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 8000

6、熔断器仪表盘监控

查看各个服务的熔断器状态面板:
  • 熔断器仪表盘

6.1、搭建熔断器仪表盘

1、创建SpringBoot项⽬,添加依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-hystrixdashboard</artifactId>
</dependency>

2、配置仪表盘的port和appName

server:
  port: 9999
spring:
  application:
    name: hystrix-dashboard
hystrix:
  dashboard:
    proxy-stream-allow-list: localhost

3、启动类添加 @EanbleHystrixDashboard 注解

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

4、访问 http://localhost:9999/hystrix

6.2、配置使⽤了熔断器的服务可被监控

1、添加依赖

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

2、配置(给每个需要监控熔断器的项目配置)

@Configuration
public class DashBoardConfig {
     @Bean
     public ServletRegistrationBean getServletRegistrationBean(){
        HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet);
        registrationBean.setName("HystrixMetricsStreamServlet");
        registrationBean.setLoadOnStartup(1);
        registrationBean.addUrlMappings("/hystrix.stream");
        return registrationBean;
    }
}

3、查看指定服务的熔断器⼯作参数

 

 

posted @ 2023-09-20 16:03  佛祖让我来巡山  阅读(548)  评论(0编辑  收藏  举报

佛祖让我来巡山博客站 - 创建于 2018-08-15

开发工程师个人站,内容主要是网站开发方面的技术文章,大部分来自学习或工作,部分来源于网络,希望对大家有所帮助。

Bootstrap中文网