SpringCloud简介
Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发,如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等,都可以用Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子,它只是将各家公司开发的比较成熟、经得起实际考验的服务框架组合起来,通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理,最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

简言之:
spring cloud 是基于【springboot】 的一系列框架的有序集合,通过springboot进行自动的配置,屏蔽掉复杂的配置和实现原理。是属于微服务架构的一站式技术解决方案,提高开发效率。

Spring Cloud包含了:

注册中心:Eureka、consul、Zookeeper、nacos

负载均衡:Ribbon

熔断器:Hystrix

服务通信:Feign

网关:Gateway

配置中心 :config,nacos

消息总线:Bus

集群状态等等功能。

Spring Cloud协调分布式环境中各个微服务,为各类服务提供支持。

springboot 配置云数据库 spring cloud数据库_spring

版本说明:

SpringCloud是一系列框架组合,为了避免与框架版本产生混淆,采用新的版本命名方式,形式为大版本名+子版本名称
大版本名用伦敦地铁站名
子版本名称三种
SNAPSHOT:快照版本,尝鲜版,随时可能修改
M版本,MileStone,M1表示第一个里程碑版本,一般同时标注PRE,表示预览版
SR,Service Release,SR1表示第一个正式版本,同时标注GA(Generally Available),稳定版

什么是微服务架构

将系统按照功能点进行拆分,拆分出独立的微型的系统,这个就是微服务架构。

SOA : 更加侧重于 分层,没有集成的servlet容器 在统一的语言环境实现。
微服务:更加侧重于 功能拆分 三层都有,集成servelt容器,跨平台和语言。

拆分出来SOA/微服务架构需要考虑问题

  • 1 系统通信问题? dubbo
  • 2 服务的治理的问题? zookeeper
  • 3 负载均衡的问题? nginx,ribbon
  • 4 登录一次的问题? sso -->springseucity/cas/
  • 5 配置文件集中管理问题?apollo,nacos,spring cloud config
  • 6 级联失败的问题? hystrix ,alibaba sentinel

spring cloud 和dubbo的区别
dubbo
实现通信的框架
实现通信的协议 RPC
性能高
spring cloud
是一些列框架集合
实现通信 HTTP
性能低

springboot 配置云数据库 spring cloud数据库_ide_02


RPC和HTTP

常见远程调用方式:

RPC:(Remote Produce Call)远程过程调用

1.基于Socket
2.自定义数据格式
3.速度快,效率高
4.典型应用代表:Dubbo,WebService,ElasticSearch集群间互相调用

HTTP:网络传输协议

1.基于TCP/IP
2.规定数据传输格式
3.缺点是消息封装比较臃肿、传输速度比较慢
4.优点是对服务提供和调用方式没有任何技术限定,自由灵活,更符合微服务理念

RPC和HTTP的区别:RPC是根据语言API来定义,而不是根据基于网络的应用来定义。

Http客户端工具:

常见Http客户端工具:HttpClient、OKHttp、URLConnection。

一、入门:

微服务调用
1、Spring的RestTemplate

  • RestTemplate是Rest的HTTP客户端模板工具类
  • 对基于Http的客户端进行封装(可以模拟浏览器发送请求 和接收响应)
  • 实现对象与JSON的序列化与反序列化
  • 不限定客户端类型,目前常用的3种客户端都支持:HttpClient、OKHttp、JDK原生URLConnection(默认方式)

springboot 配置云数据库 spring cloud数据库_spring_03

2、it-rest-provider

1)依赖

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

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

2)创建POJO
3)application.yml

server:
  port: 8001

4)UserController

@RestController
@RequestMapping("/user")
public class UserController {
    @GetMapping("/{id}")
    public User findById(@PathVariable(name = "id") Integer id){
        return (new User(id,  "张三"));
    }
}

5)启动类

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

3、 it-rest-consumer
1)依赖

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

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

2)创建启动类,并在启动类中创建RestTemplate对象

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

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

3)创建POJO: 和provider的POJO一致即可
4)创建controller用于测试远程调用:

@RestController
@RequestMapping("/consumer")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/{id}")
    public User findById(@PathVariable(name = "id") Integer id) {
        //使用restTemplate模拟浏览器发送请求获取远程微服务【provider】的用户的信息
        User userFromProvider = restTemplate.getForObject("http://localhost:8001/user/" + id, User.class);
        //返回前端查看
        return userFromProvider;
    }
}

二、模拟微服务业务场景

总目标:模拟一个最简单的服务调用场景,场景中包括微服务提供者(Producer)和微服务调用者(Consumer)

注意:实际开发中,每个微服务为一个独立的SpringBoot工程。

1、 创建父工程,主要管理子项目的依赖和版本
pom.xml

<groupId>com.itheima</groupId>
    <artifactId>springcloud-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <!--父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>
    <!--SpringCloud包依赖管理-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2、创建服务提供者(producer)工程
每个微服务工程都是独立的工程,连数据库都是独立的,所以我们一会要单独为该服务工程创建数据库。采用Mybatis作为持久层
1)引入依赖

<dependencies>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>
        <!--web起步包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--MySQL驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--测试包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

2)创建POJO

5)创建Mapper/Dao
6)创建Service,并调用Dao
7)创建Controller,并调用Service
8)创建application.yml文件

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/springcloud?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
  application: 
    name: user-provider #应用的名字
server:
  port: 18081

9.创建启动类

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

3、创建服务消费者(consumer)工程
1.创建工程
2.引入依赖

<!--依赖包-->
    <dependencies>
        <!--web起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

3.创建Pojo
4.创建启动类,同时创建RestTemplate对象,并交给SpringIOC容器管理
5.创建application.yml文件,指定端口

server:
  port: 18082
spring:
  application:
    name: user-consumer

6.编写Controller,在Controller中通过RestTemplate调用user-provider的服务

三、Spring Cloud Eureka

1、搭建eureka-server工程

1)引入依赖

<!--依赖包-->
    <dependencies>
        <!--eureka-server依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>
  1. application.yml配置
server:
  port: 7001    #端口号
spring:
  application:
    name: eureka-server # 应用名称,会在Eureka中作为服务的id标识(serviceId)
eureka:
  client:
    register-with-eureka: false   #是否将自己注册到Eureka中
    fetch-registry: false   #是否从eureka中获取服务信息
    service-url:
      defaultZone: http://localhost:7001/eureka # EurekaServer的地址
  instance:
    #服务失效时间: 表示eureka server至上一次收到client的心跳之后,等待下一次心跳的超时时间,在这个时间内若没收到下一次心跳,则将移除该instance
    lease-expiration-duration-in-seconds: 60
  1. 启动类创建,注解@EnableEurekaServer,用于开启Eureka服务
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

2、服务提供者-注册服务

1.引入eureka客户端依赖包

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

2.在application.yml中配置Eureka服务地址

server:
  port: 18081
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: itcast
    url: jdbc:mysql://127.0.0.1:3306/springcloud?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
  application:
    name: user-provider #服务的名字,不同的应用,名字不同,如果是集群,名字需要相同
#指定eureka服务地址
eureka:
  client:
    service-url:
      # EurekaServer的地址
      defaultZone: http://localhost:7001/eurek
  instance:
    #指定IP地址
    ip-address: 127.0.0.1
    #访问服务的时候,推荐使用IP
    prefer-ip-address: true
    #一般不需要改
    #租约续约间隔时间,默认30秒
    lease-renewal-interval-in-seconds: 15

3.在启动类上添加@EnableDiscoveryClient或者@EnableEurekaClient

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

区别:

@EnableDiscoveryClient@EnableEurekaClient都用于开启客户端的发现功能,但@EnableEurekaClient的注册中心只能是Eureka。

3、服务消费者-注册服务中心

1.引入eureka客户端依赖包

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

2.在application.yml中配置Eureka服务地址

server:
  port: 18082
spring:
  application:
    name: user-consumer   #服务名字
#指定eureka服务地址
eureka:
  client:
    service-url:
      # EurekaServer的地址
      defaultZone: http://localhost:7001/eureka

3.在启动类上添加@EnableDiscoveryClient或者@EnableEurekaClient

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

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

4. 消费者通过Eureka访问提供者

import org.springframework.cloud.client.discovery.DiscoveryClient;

@RestController
@RequestMapping("/consumer")
public class UserController {
    @Autowired
    private RestTemplate  restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("/{id}")
    public User findById(@PathVariable(name = "id") Integer id){
        //String url = "http://localhost:18081/user/" + id;

        List<ServiceInstance> instances = discoveryClient.getInstances("USER-PROVIDER");
        ServiceInstance serviceInstance = instances.get(0);
        String url = "http://"+serviceInstance.getHost() + ":" +serviceInstance.getPort() + "/user/" +id;
        return restTemplate.getForObject(url, User.class);
    }
}

5、Eureka详解

5.1 Eureka架构中的三个核心角色

1.服务注册中心:Eureka服务端应用,提供服务注册发现功能,eureka-server
2.服务提供者:提供服务的应用
要求统一对外提供Rest风格服务即可
本例子:user-provider
3.服务消费者:从注册中心获取服务列表,知道去哪调用服务方,user-consumer

5.2 Eureka客户端
服务提供者要向EurekaServer注册服务,并完成服务续约等工作

服务续约:

服务注册完成以后,服务提供者会维持一个心跳,保存服务处于存在状态。这个称之为服务续约(renew)。
1.两个参数可以修改服务续约行为

#租约到期,服务时效时间,默认值90秒
lease-expiration-duration-in-seconds: 150
表示 Eureka Server 在接收到上一个心跳之后等待下一个心跳的秒数(默认 90 秒),若不能在指定时间内收到心跳,则移除此实例,并禁止此实例的流量。

#租约续约间隔时间,默认30秒
lease-renewal-interval-in-seconds: 30
表示 Eureka Client 向 Eureka Server 发送心跳的频率(默认 30 秒),如果在 lease-expiration-duration-in-seconds 指定的时间内未收到心跳,则移除该实例。

2.默认服务超过90秒没有发生心跳,EurekaServer会将服务从列表移除(前提是EurekaServer关闭了自我保护)

服务消费者

启动时,会检测是否获取服务注册信息配置
如果是,则会从 EurekaServer服务列表获取只读备份,缓存到本地
每隔30秒,会重新获取并更新数据
每隔30秒的时间可以通过配置registry-fetch-interval-seconds修改

registry-fetch-interval-seconds: 30

表示eureka client间隔多久去拉取服务注册信息,默认为30秒,对于api-gateway,如果要迅速获取服务注册状态,可以缩小该值,比如5秒

5.3 失效剔除和自我保护
服务下线:
当服务正常关闭操作时,会发送服务下线的REST请求给EurekaServer。
服务中心接受到请求后,将该服务置为下线状态

失效剔除:
服务中心每隔一段时间(默认60秒)将清单中没有续约的服务剔除。
通过eviction-interval-timer-in-ms配置可以对其进行修改,单位是毫秒

自我保护:

Eureka会统计服务实例最近15分钟心跳续约的比例是否低于85%,如果低于则会触发自我保护机制。

springboot 配置云数据库 spring cloud数据库_ci_04


1.自我保护模式下,不会剔除任何服务实例

2.自我保护模式保证了大多数服务依然可用

3.通过enable-self-preservation配置可用关停自我保护,默认值是打开

springboot 配置云数据库 spring cloud数据库_springboot 配置云数据库_05

springboot 配置云数据库 spring cloud数据库_spring_06


各种O:

PO : 持久化对象 setter setter

POJO : 简单JAVA对象

DTO : 数据传输对象 用于系统通信时使用 封装数据(侧重数据)

BO :业务对象 一般用于业务层。

VO :值对象 一般用于web层

ENTITY:持久化对象 一般在ORM框架中的说法。