springcloud

Posted 2021-06-28 xue_yun_xiang

一、微服务框架

微服务 就是将一个应用按照功能进项拆分，每一个功能都是一个独立的应用，应用之间可以通过http/tcp 请求互相调用

java 微服务中最常用的框架springcloud

springcloud

springcloud 就是基于springboot实现的微服务框架，springcloud可以认为是一个标准，一套接口/规范，基于这种规范有了两大类实现

springcloud netflix

springcloud netflix 是 springcloud第一代版本 ，有美国 网飞（视屏网站，租赁cd,dvd）开发
组件：eureka ribbon zull hystrix

springcloud alibaba

springcloud alibaba 是 springcloud第二代版本 ，有阿里公司开发，因为springcloud netflix 公司停止维护和更新

二、组件

Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

RocketMQ：一款开源的分布式消息系统，基于高可用分布式集群技术，提供低延时的、高可靠的消息发布与订阅服务。

Dubbo：Apache Dubbo™ 是一款高性能 Java RPC 框架。

Seata：阿里巴巴开源产品，一个易于使用的高性能微服务分布式事务解决方案。

Alibaba Cloud OSS: 阿里云对象存储服务（Object Storage Service，简称 OSS），是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。

Alibaba Cloud SchedulerX: 阿里中间件团队开发的一款分布式任务调度产品，提供秒级、精准、高可靠、高可用的定时（基于 Cron 表达式）任务调度服务。

Alibaba Cloud SMS: 覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

Nacos

Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。

简单说就是微服务的：注册中心和配置中心

服务发现和服务健康监测
所有有的服务都会在启动时候注册到nacos ,
订单依赖用户，用户服务器增加，用户服务会动态注册到nacos,订单模块可以 动态的感知 用户模块的增加
服务健康监测：如果用户服务某一台机器下线，nacos 也可以通过心跳机制感知到

动态配置服务
可以最为配置中心
简单的说就是将 应用中的配置文件application.properties 放到nacos ，我们通过配置nacos 中的配置文件就可以完成所有服务的配置

动态 DNS 服务
dns: dns作用将域名翻译为 ip
nacos 中的dns 也是 将服务名翻译为 服务对应的ip 端口

服务及其元数据管理
存储服务的元数据

1、安装

1.下载nacos
2.解压安装
3.启动:双击 startup.cmd
4:访问http://localhost:8848/nacos/index.html(如果有需要输入 用户名：nacos 密码：nacos)

2、# 创建spring服务（provider）注册到nacos中

1、创建一个springcloud-maven 父子工程

 <!--
        packaging  默认 jar   将当前工程打成jar
                    war       将当前工程打成 war
                    pom       设置当前工程师父子工程 此pom时父工程
    -->
    <packaging>pom</packaging>

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

    <properties>
        <!-- Environment Settings -->
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <!-- Spring Settings -->
        <spring-cloud.version>Hoxton.SR1</spring-cloud.version>
        <spring-cloud-alibaba.version>2.2.0.RELEASE</spring-cloud-alibaba.version>
    </properties>

    <!--
     dependencyManagement  作用就是 控制 子工程jar包依赖，子工程 引入jar 不需要配置<version>
                       让所有的子工程以来的 jar 版本和 父工程保持一致
                       不会引入依赖
    -->
    <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>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2、创建子工程服务提供者 springcloudalibaba-provider

3、引入依赖

<dependencies>

        <!--springBoot 相关  -->
        <!--
            spring web 必须引入
        -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- spring 监控相关依赖  可以查看当前 jvm 的内存占用 有哪些conteroller 有哪些bean -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!--  单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- alibaba.cloud 相关-->
        <!--
            alibaba-nacos  服务注册 发现  jar
        -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!--
                -alibaba-nacos 服务配置 jar
        -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>


    </dependencies>

4、创建子工程配置文件

server.port=8090

#为当前应用起 一个名字  改名字也是一个服务名
spring.application.name=springcloudalibaba-provider

#配置nacos  服务地址 作用包含了spring.cloud.nacos.discovery.server-addr
spring.cloud.nacos.server-addr=localhost:8848


#spring.cloud.nacos.discovery.server-addr=localhost:8848

#暴漏端点  将所有的的接口进行监控
management.endpoints.web.exposure.include=*

5、子工程启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient // 激活nacos 服务注册发现
public class ProviderApplication {

    public static void main(String[] args) {

        SpringApplication.run(ProviderApplication.class, args);

    }

}

6、创建子工程controller

/**
 * 当前写的接口 不仅可以被前端调用  还可以被其他的 服务调用 ，当前应用做大的作用就是 提供服务给其他应用
 */
@RestController
public class HelloController {

//@Value的作用是通过注解将常量、配置文件中的值、其他bean的属性值注入到变量中，作为变量的初始值。
    @Value("${server.port}")
    private int port;


    @RequestMapping("/getMessage/{msg}")
    public String  getMessage(@PathVariable("msg") String msg){

        System.out.println("getMessage----port:"+port+"----msg = " + msg);

        return "getMessage----port:"+port+"----msg = " + msg;
    }

    @RequestMapping("/say")
    public String say( String msg){

        System.out.println("say----port:"+port+"----msg = " + msg);

        return "say----port:"+port+"----msg = " + msg;
    }

}

7、启动子工程，检查nacos

3、创建服务消费者

1、创建服务消费者 springcloudalibaba-customer 子工程

2、创建配置文件

3、启动类

4、创建配置类

5、测试类

4、使用ribbon 负载均衡器发起网络请求

ribbon

是一个客户端的负载均衡器，它提供对大量的HTTP和TCP客户端的访问控制
可以实现服务的远程调用和服务的负载均衡协调

1、先将消费者工程中 CustomerConfig1，CustomerController1注释

2、导入ribbon 依赖

<!-- 引入负载均衡-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon
            </artifactId>
        </dependency>

3、创建 ribbon 配置文件

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class CustomerRibbonConfig2 {


    @LoadBalanced// 让RestTemplate 使用ribbon 进行负载均衡
    @Bean// 将 RestTemplate 加入到容器中
    public RestTemplate restTemplate(){

        return  new RestTemplate();
    }


    /**
     * 配置ribbon
     * @return
     */
    @Bean
    public IRule iRule(){
        //创建一个随机的负载均衡策略
        IRule rule = new RandomRule();


        //2.权重响应时间分配规则 代替ResponseTimeRule 响应时间加权策略
//        WeightedResponseTimeRule responseTimeRule=new WeightedResponseTimeRule();
//        //3.最低并发策略 分配的时候选择目前并发量最小的
//        BestAvailableRule bestAvailableRule=new BestAvailableRule();
//        //4.轮训策略
//        RoundRobinRule roundRobinRule=new RoundRobinRule();
//        //5.重试策略 如果在配置时间内，无法选择服务，尝试选择一个服务 重试机制
//        RetryRule retryRule=new RetryRule();
//        //6.区域感知策略 就近访问
//        ZoneAvoidanceRule zoneAvoidanceRule=new ZoneAvoidanceRule();
         7.可用过滤策略 可用根据阈值进行服务过滤
//        AvailabilityFilteringRule filteringRule=new AvailabilityFilteringRule();

        return rule;
    }

}

4、创建测试Controller

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;

@RestController
public class CustomerController2 {

    @Autowired
    private RestTemplate restTemplate;



    @RequestMapping("/test1")// 目标是调用   @RequestMapping("/getMessage/{msg}")
    public String test1(){


        // url 请求的路径
        // responseType 请求相应的类型
        // uriVariables   请求的参数
        // String url = "http://localhost:8090/getMessage/uuuu";
        // ribbon 会自动将 服务名 ---》 服务实例的ip:端口
        return restTemplate.getForObject("http://springcloudalibaba-provider/getMessage/uuuu", String.class );
    }


    @RequestMapping("/test2")
    public String test2(){


        // 调用key  value  接口需要 hashmap 传参
        HashMap<String,Object> param = new HashMap<>();
        param.put("msg", "hello word");
        // ribbon 会自动将 服务名 ---》 服务实例的ip:端口
        return restTemplate.getForObject("http://springcloudalibaba-provider/say?msg={msg}", String.class ,param);
    }
}

5、服务提供 接受json 转 对象

1、创建公共模块

2、创建 公共实体类

import java.io.Serializable;

public class Student implements Serializable {

    private  int id;

    private String name;

    private int age;

    private String sex;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\\'' +
                ", age=" + age +
                ", sex='" + sex + '\\'' +
                '}';
    }
}

3、点击父工程 install

4、在服务提供者 和 消费者 工程都引入 公共模块

  <!-- 引入公共 模块-->
        <dependency>
            <groupId>com.qfedu</groupId>
            <artifactId>springcloudalibaba-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

5、在服务提供者 增加

  // 更新学生  当前服务提供者 需要Student
//                  服务消费者 也需要Student
// 所以 我们需要将   Student 写在公共的 模块中（一个子工程）

    /**
     * 当前 方法 需要被消费者 远程调用 通过RestTemplate
     *   调用使用 传递对象 接受 的必须是json  @RequestBody Student student
     * @param student
     * @return
     */
    // 接受json 转对象
    @RequestMapping("/updateStudent")
    public Student updateStudent(@RequestBody Student student){

        System.out.println("updateStudent----port:"+port+"student = " + student);
        return student;
    }

6、在消费者工程发起 调用

  /**
     * 调用   服务提供者 springcloudalibaba-provider 中的 /updateStudent 并且传递json数据
     * @return
     */
    @RequestMapping("/test3")
    public Student test3(){

        Student student = new Student();
        student.setId(1000);
        student.setAge(18);
        student.setName("xxx");
        student.setSex("F");

        //  restTemplate.postForEntity 将 对象 以post json数据发送请求  服务提供者必须以json 转对象接受数据 public Student updateStudent(@RequestBody Student student){
        return  restTemplate.postForEntity("http://springcloudalibaba-provider/updateStudent", student,Student.class).getBody();
    }

7、重新运行两个 工程 ，测试

服务提供者 可以接收
1.restful @PathVariable
2.keyvalue @ReqtuestParam
3.json–>转对象 @RequestBody

bug解决

springboot启动失败

Error creating bean with name ‘bootstrapImportSelectorConfiguration’: Initialization of bean failed

原因：版本为2.1._
解决：
把父工程的版本调为2.2.4