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

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协调分布式环境中各个微服务，为各类服务提供支持。

版本说明：

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
性能低

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(默认方式)

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>

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

3. 启动类创建，注解@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%，如果低于则会触发自我保护机制。

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

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

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

各种O:

PO : 持久化对象 setter setter

POJO : 简单JAVA对象

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

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

VO ：值对象 一般用于web层

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