serviceComb的入门
华为的微服务：servicecomb的使用，做了个 小demo
·
ServiceComb
1、概述：
华为云开发的一套开发框架-------------它依赖于Springboot
service-center 相当于 springcloud的eureka，作为注册中心
2、使用service-comb的好处：可以轻松的将服务，发布到云平台（华为云Paas平台）
用serviceComb开发微服务，使用华为云进行微服务的治理
3、servicecomb支持的通信协议：
- http
- RPC
4、使用servicecomb的好处
- 可以轻松的将微服务发布到云平台 华为云Paas平台
- 用servicecomb开发微服务，在借用华为云PAAS平台实现微服务治理
2、入门案例----基础环境的搭建
1、使用serviceComb开发，所需的环境
jdk8 + maven3.5.2 + idea
服务注册中心（简称“CSE”，翻译为“云服务引擎”）---------------需要从官网上，进行下载
图1、
http://servicecomb.apache.org/cn/ 官网地址
图1、
图2、
图3、
微服务中，常用的3个组件：
服务注册中心【简称为CSE cloud service engine 云服务引擎】：用于注册微服务，并且实现微服务的管理
服务消费者：调用微服务
服务提供者：提供微服务的功能
注意：服务的消费者，和 服务器的提供者， 2者之间的关系，不是直接调用，而是间接调用关系【需要经过注册中心ECS，才能进行调用】
这3个组件之间的逻辑关系：
1、服务提供者Provider，向CSE注册中心注册一个微服务
2、服务消费者就可以向CSE注册中心，进行一个操作：服务发现
3、如果在CSE注册中心中，找到了要调用的微服务，就可以发送一个微服务的实例，来给服务器端消费者。
心跳的作用：实现微服务状态的检测
逻辑关系图：
2、启动服务注册中心【有2种方式】
方式1、使用docker来启动
docker pull servicecomb/service-center
docker run -d -p 30100:30100 servicecomb/service-center:latest
方式2、下载CSE服务注册中心【从官网http://servicecomb.apache.org/cn/release/service-center-downloads/进行下载】【我使用这种】
- 1、将下载好的压缩包，进行解压
- 2、注意:在我第一次解压的时候，它是没有data文件夹的 //data文件夹，作用：存储，CSE注册中心，运行时，所产生的数据
目录结构介绍:
start-service-center.bat 用于windows环境下，启动服务器注册中心，所执行的脚本
conf目录 ：存储servicecomb的注册中心的 详细配置
app目录：就是官网提供的一些参考应用
cse解压后的目录结构图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZSvvhQzZ-1663302971588)(图片/image-20210621224807779.png)]
app.conf配置文件的说明
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
###################################################################
# frontend_host_ip：frontend_host_port 微服务提供的可视化页面，所访问的地址----从这个里面，就可以看到，有多少个微服务，注册到CSE注册中心中
###################################################################
frontend_host_ip = 127.0.0.1
frontend_host_port = 30103
# if you want to listen at ipv6 address, then set the httpaddr value like:
# httpaddr+httpport 用于微服务的提供者，要将其，注册到哪个服务器的注册中心上
httpaddr = 127.0.0.1
httpport = 30100
###################################################################
# sever options (deprecated, pls use app.yaml instead)
###################################################################
3、在服务注册中心启动后，我们就可以在 服务 提供/消费者的 microservice.yml文件 上，添加这段配置------配置注册中心的地址和端口号
servicecomb:
service:
registry:
address: http://127.0.0.1:3100 # 服务中心ecs的，地址和端口
3、入门案例—搭建微服务【rest 通信方式】
使用serviceComb提供的脚手架，来快速创建serviceComb项目
1、创建一个springboot项目，啥都不用引入，然后配置pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>demo</name>
<description>Demo project for ServiceComb-Spring</description>
<!--1、代表继承了一个父工程，这个父工程是springboot提供的【默认，创建springboot项目，会自动添加】-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.12.RELEASE</version>
<relativePath/>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!--1、hibernate的校验规则 引入的目的：servicecomb底层校验的时候，用到了他-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>
<!--2、rest的支持-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<!--3、servicecomb的支持-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>spring-boot-starter-provider</artifactId>
</dependency>
<!--4、单元测试，会用到-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<!--实现pom文件的导入【跟继承的效果一样，但是maven也是单继承的，因此为了继承多个，需要使用这种方式，来实现】-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>java-chassis-dependencies</artifactId>
<version>1.0.0-m2</version>
<type>pom</type>
<!--表示把java-chassis-dependencies的pom文件，导入进来-->
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>1.5.12.RELEASE</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
<configuration>
<outputDirectory>target/bin</outputDirectory>
<classifier>exec</classifier>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.6</version>
<configuration>
<archive>
<manifestEntries>
<Class-Path>.</Class-Path>
</manifestEntries>
</archive>
</configuration>
</plugin>
</plugins>
</build>
</project>
2、创建servicecomb所需的配置文件
microservice.yaml------注意文件的后缀名
APPLICATION_ID: start.servicecomb.io #应用程序的编号
service_description:
name: HelloServiceComb #应用程序的名称
version: 0.0.1 #应用程序的版本号
servicecomb:
handler:
chain:
Provider: {} #提供调用链的支持，一般这里不用配置，但是这条配置要写
rest: #表示通信方式走的是 rest方式
address: 0.0.0.0:9080 #走的是哪台服务器 0.0.0.0表示本机地址，也可以写成127.0.0.1---我们要访问接口的地址，就访问这个端口
service:
registry:
address: http://127.0.0.1:30100 #代表服务注册中心的地址
autodiscovery: false #代表我们的服务是否具有自动化建设功能，一般配置为false
3、创建
消费者：HelloConsumer
package com.example.demo;
import org.apache.servicecomb.provider.springmvc.reference.RestTemplateBuilder;
import org.springframework.web.client.RestTemplate;
//服务的消费者
public class HelloConsumer {
//RestTemplate 可以快速请求微服务
private final RestTemplate restTemplate = RestTemplateBuilder.create();
public void invokeHello() {
//service url is : cse://serviceName/operation
String serviceName = "HelloServiceComb"; //与microservice.yml中的service_description.name 对应
restTemplate.getForObject("cse://" + serviceName + "/hello", String.class); //从指定的地址中，获取服务，这里就是获取的生产者的hello接口
}
}
生产者
- 就是我们要写的代码，这里只写了controller
package com.example.demo;
import org.apache.servicecomb.provider.rest.common.RestSchema;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
//服务的生产者
@RestSchema(schemaId = "hello")//指定该类，把类中的方法，发布到注册中心去，并且使用的是REST风格【把类，向cse中进行注册】
@RequestMapping(path = "/")
public class HelloImpl {
@GetMapping(path = "/hello")
public String hello() {
return "Hello World!";
}
}
启动类：DemoApplication
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.apache.servicecomb.springboot.starter.provider.EnableServiceComb;
//项目的启动类
@SpringBootApplication
@EnableServiceComb //代表启动servicecomb应用程序
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
测试，访问效果
访问地址：http://127.0.0.1:9080/hello
效果图：
执行逻辑：通过在消费者中，写的cse协议，我们就会立即从microservice.yml中，找
servicecomb.registry.address:http://127.0.0.1:30100 //1、注册中心的地址
service_description.name:HelloServiceComb //2、找微服务的名称
3、找具体的方法，通过那个cse://微服务名称/接口地址
如图所示：
在消费者中，通过
cse://微服务名称/接口地址【逻辑上，它是消费者】------------------->从而找到我们要访问的接口【逻辑上：它是生产者】
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UOrF5yP3-1663302971589)(图片/image-20210819145237884.png)]](https://img-blog.csdnimg.cn/18a15599b3ad4fd4bcb2488480f1cb59.png)
注意事项：
- 1、我们以后写代码，其实就是写的服务提供者---------------它与springboot的写法，就是在controller上，多加了一个@RestSchema(schemaId = “hello”)注解
4、Rest编程方式
1、父、子工程创建-----servicecomb【架子的搭建】
1、创建父工程
1、先创建父工程----直接创建一个不引入任何依赖的springboot项目
2、然后配置pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<packaging>pom</packaging>
<modules>
<module>service-interfaces</module>
</modules>
<!--1、引入springboot-parent-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.12.RELEASE</version>
<relativePath/>
</parent>
<groupId>com.example</groupId>
<artifactId>demo2</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>demo2</name>
<description>Demo project for Spring Boot</description>
<!--2、设置properties，指定jdk的版本、编码-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<!--3、实现pom文件的导入【跟继承的效果一样，但是maven也是单继承的，因此为了继承多个，需要使用这种方式，来实现】-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>java-chassis-dependencies</artifactId>
<version>1.0.0-m2</version>
<type>pom</type>
<!--表示把java-chassis-dependencies的pom文件，导入进来-->
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<!--4、将maven插件引入进来-->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
3、将工程中，无用的文件，删除掉------------如图所示，这是删除后的样子
2、创建子工程
service-interfaces
1、选中父级工程，然后在其上，进行创建子工程-----------------这里我创建子工程，是使用maven进行创建的
2、创建子工程：
service-interfaces：存放微服务的接口
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NTdc1Lr5-1663302971591)(图片/image-20210819225115004.png)]](https://img-blog.csdnimg.cn/3ed155c740364d918dae7c521045d164.png)
service-provider
创建一个微服务的提供者：service-provider----------------将所需的依赖，放到服务的提供者，因为将来，这个服务的提供者，会注册到服务中心，所有servicecomb依赖，必须添加
1、创建子工程
注意:它需要创建servicecomb的配置文件
2、创建microservice.yaml文件
3、配置pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>demo2</artifactId>
<groupId>com.example</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>service-provider</artifactId>
<dependencies>
<!--1、hibernate的校验规则 引入的目的：servicecomb底层校验的时候，用到了他-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>
<!--2、rest的支持-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<!--3、servicecomb的支持-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>spring-boot-starter-provider</artifactId>
</dependency>
<!--4、添加springboot 与web整合，所需的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
service-consumer
微服务的消费者
1、创建子工程
2、创建servicecomb所需的配置文件：microservice.yaml
3、配置pom.xml文件，注意：微服务提供者所需的依赖，消费也都需要
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>demo2</artifactId>
<groupId>com.example</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>service-consumer</artifactId>
<dependencies>
<!--1、hibernate的校验规则 引入的目的：servicecomb底层校验的时候，用到了他-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>
<!--2、rest的支持-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<!--3、servicecomb的支持-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>spring-boot-starter-provider</artifactId>
</dependency>
<!--4、添加springboot 与web整合，所需的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
最中，项目结构的效果：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bax1VOSd-1663302971591)(图片/image-20210820224831154.png)]
2、将service-interfaces，安装到本地仓库
注意：安装的时候，把pom中，这段配置注释掉，否则可能安装不成功------------因为在加了这个maven插件的情况下，maven会找我们的main主方法，如果没找到，就会报错----------------将父级工程，这个插件注释掉
<!--4、将maven插件引入进来--> <!--<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>-->
如图所示：直接点击 install，就可将service-interfaces服务，安装到本地仓库
3、开发服务的提供者
1、创建如图所示的，包路径
2、创建一个实现接口的，实现类----RestServiceImpl
注意事项:需要在它的pom.xml中，引入本地仓库中的依赖【就是那个install到本地仓库的service-interfaces】
RestServiceImpl
package com.itheima.service.impl;
import com.itheima.service.RestService;
import org.apache.servicecomb.provider.rest.common.RestSchema;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
@RestSchema(schemaId = "hello") //注册微服务到 注册中心【并指定微服务的名字】
@RequestMapping("/hello")
public class RestServiceImpl implements RestService {
@Override
@GetMapping("/sayRest")
public String sayRest(String name) { //实现接口中，对应的方法
return "hello world "+name;
}
}
3、配置pom.xml文件，将service-interfaces引入到，服务者的pom.xml中
//核心代码
<!--把接口模块，引入进来【前提，这个接口模块已经install了，否则有问题】-->
<dependency>
<groupId>com.example</groupId>
<artifactId>service-interfaces</artifactId>
<version>0.0.1-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
完整的pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>demo2</artifactId>
<groupId>com.example</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>service-provider</artifactId>
<dependencies>
<!--1、hibernate的校验规则 引入的目的：servicecomb底层校验的时候，用到了他-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>
<!--2、rest的支持-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<!--3、servicecomb的支持-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>spring-boot-starter-provider</artifactId>
</dependency>
<!--4、添加springmvc-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--把接口模块，引入进来【前提，这个接口模块已经install了，否则有问题】[这个，我这里是通过类，自动导入的]-->
<dependency>
<groupId>com.example</groupId>
<artifactId>service-interfaces</artifactId>
<version>0.0.1-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>
4、要想将我们的微服务注册到 ecs中，需要配置servicecomb的配置文件
microservice.yaml
APPLICATION_ID: start.servicecomb.io
service_description:
name: provider #修改微服务提供者的名称【名字随便取，保证它是唯一的就行了】
version: 0.0.1
servicecomb:
handler:
chain:
Provider: {}
rest:
address: 0.0.0.0:9080
service:
registry:
address: http://127.0.0.1:30100
autodiscovery: false
测试效果：
http://localhost:9080/hello/sayRest?name=chijiawen
图1、
图2、
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-82t96DJ3-1663302971594)(图片/image-20210821102627440.png)]](https://img-blog.csdnimg.cn/20d658434a854337a1b0aa66bd5bbda8.png)
4、开发服务的消费者
作用：它也需要实现这个接口，告诉我们如何去调用，微服务的资源
1、因为我们需要，实现service-interface中的接口----------因此，需要先将其依赖，引入进来
pom.xml
//核心依赖
<!--service-interface的引入 需要指定版本，否则引入失败-->
<dependency>
<groupId>com.example</groupId>
<artifactId>service-interfaces</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
pom.xml完整配置
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>demo2</artifactId>
<groupId>com.example</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>service-consumer</artifactId>
<dependencies>
<!--1、hibernate的校验规则 引入的目的：servicecomb底层校验的时候，用到了他-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>
<!--2、rest的支持-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<!--3、servicecomb的支持-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>spring-boot-starter-provider</artifactId>
</dependency>
<!--4、添加springboot 与web整合，所需的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--service-interface的引入 需要指定版本，否则引入失败-->
<dependency>
<groupId>com.example</groupId>
<artifactId>service-interfaces</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
2、创建接口的实现类
RestConsumerServiceImpl
package com.itheima.servic.impl;
import com.itheima.service.RestService;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
/**
* 消费者的服务接口实现类
*/
@Service //表名它是一个service层
public class RestConsumerServiceImpl implements RestService {
//RestTemplate模板
RestTemplate restTemplate=new RestTemplate();//RestTemplate：使用servicecomb提供的类
@Override
public String sayRest(String name) {
String provideName="provider";//这个微服务的名称，是根据我们要调用的生产者的，它的微服务的名字，在microservice.yaml中可找到
//参数1：url: cse://微服务的名称/要访问的接口
//参数2： 写接收，接口返回的数据类型
String rtnValue = restTemplate.getForObject("cse://" + provideName + "/hello/sayRest", String.class);
return rtnValue;
}
}
3、创建controller
- 注意：需要给controller上，添加@RestSchema(schemaId = “test”) 注解，将其注入到ecs中，进行使用
package com.itheima.servic.controller;
import com.itheima.service.RestService;
import org.apache.servicecomb.provider.rest.common.RestSchema;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestSchema(schemaId = "test")//如果作为servicecomb的某一个微服务的话，需要写这个注解
@RequestMapping("/test")
public class RestConsumerController {
@Autowired //这里注入的就是 restService的实现类RestConsumerServiceImpl
private RestService restService;
@GetMapping("/test")
public String sayRest(String name){
return restService.sayRest(name);
}
}
4、配置servicecomb的配置文件
microservice.yaml
APPLICATION_ID: start.servicecomb.io
service_description:
name: consumer #修改微服务消费者的名称【名字随便取，保证它是唯一的就行了】
version: 0.0.1
servicecomb:
handler:
chain:
Provider: {}
rest:
address: 0.0.0.0:9081 #修改它的请求地址，地址不能跟其他微服务的地址一样，否则就冲突了
service:
registry:
address: http://127.0.0.1:30100
autodiscovery: false
5、测试效果：
1、先把注册中心启动
2、启动provider，服务的提供者
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t6Wsw8Dl-1663302971595)(图片/image-20210821120251299.png)]](https://img-blog.csdnimg.cn/967447d2aa664b9d88c72f68c18b85d8.png)
3、启动consumer，服务的消费者
需要给消费者，创建一个启动类
package com.itheima;
import org.apache.servicecomb.springboot.starter.provider.EnableServiceComb;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableServiceComb
public class ConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerApplication.class,args);
}
}
4、记得将service-interfaces项目，先进行install到本地仓库，然后在启动这个项目
5、启动消费者
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-91bA5TBI-1663302971595)(图片/image-20210821140955306.png)]](https://img-blog.csdnimg.cn/f2cee6fea8b546b2940364d0b34fd95c.png)
6、测试
6.1 直接访问 服务提供者，可以
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2WKCDuvN-1663302971595)(图片/image-20210821144210923.png)]
6.2 直接访问消费者，然后消费者在内部调用，访问生产者服务
本地没有跑通
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nbLsTXyQ-1663302971596)(图片/image-20210821144246538.png)]
5、总结
整体的流程图：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xbO9TohV-1663302971597)(图片/06Rest开发方式的总结.png)]](https://img-blog.csdnimg.cn/3218d424ba9c4adda52ab242d7f39ded.png)
5、Rpc编程方式
1、项目的搭建【架子】
1、直接创建父级工程，配置pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!--1、引入springboot-parent-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.12.RELEASE</version>
<relativePath/>
</parent>
<groupId>com.example</groupId>
<artifactId>demo-rpc</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>demo-rpc</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<!--2、实现pom文件的导入【跟继承的效果一样，但是maven也是单继承的，因此为了继承多个，需要使用这种方式，来实现】-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>java-chassis-dependencies</artifactId>
<version>1.0.0-m2</version>
<type>pom</type>
<!--表示把java-chassis-dependencies的pom文件，导入进来-->
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<!--编译插件-->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
2、创建子工程：service-interfaces
3、创建子工程：rpc-provider
4、创建子工程：rpc-consumer
5、
5.1、在service-interfaces ，创建一个接口：RpcService
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P4OKfYwh-1663302971597)(图片/image-20210821154258124.png)]
package com.itheima.service;
/**
* 开发一个服务接口
*/
public interface RpcService {
String sayRpc(String name);
}
5.2 将父工程的pom.xml中，maven编译插件，注释掉
<!--编译插件-->
<!--<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>-->
2、开发—服务的提供者
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v9POmuTW-1663302971597)(图片/image-20210821170511679.png)]
1、配置pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>demo-rpc</artifactId>
<groupId>com.example</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>rpc-provider</artifactId>
<!--1、指定jdk版本、编码-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<!--2、添加依赖-->
<dependencies>
<!--2.1 servicecomb所需的 校验-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.3.5.Final</version>
</dependency>
<!--2.2 springboot开发所需的-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!--2.3 servicecomb所需的-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>spring-boot-starter-provider</artifactId>
</dependency>
<!--2.4、rpc通信所需的：rpc通信模型-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>transport-highway</artifactId>
</dependency>
<!--2.4、rpc通信所需的：rpc编程模型-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>provider-pojo</artifactId>
</dependency>
<!--引入服务接口-->
<dependency>
<groupId>com.example</groupId>
<artifactId>service-interfaces</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
2、编写代码—开发服务提供者
package com.itheima.service.impl;
import com.itheima.service.RpcService;
import org.apache.servicecomb.provider.pojo.RpcSchema;
/**
* rpc方式---服务的提供者
*/
@RpcSchema(schemaId = "helloRpc") //Rpc的服务，需要通过该注解，来将服务，添加到注册中心
public class RpcProviderServiceImpl implements RpcService {
@Override
public String sayRpc(String name) {
return "hello "+name;
}
}
3、编写启动类
package com.itheima.service.impl;
import org.apache.servicecomb.springboot.starter.provider.EnableServiceComb;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* 服务的启动类
*/
@SpringBootApplication
@EnableServiceComb
public class RpcProviderApplication {
public static void main(String[] args) {
SpringApplication.run(RpcProviderApplication.class,args);
}
}
4、添加servicecomb所需的配置文件
microservice.yaml
APPLICATION_ID: start.servicecomb.io
service_description:
name: serviceprovider-rpc #【修改】
version: 0.0.1
properties:
allowCrossApp: true #允许跨域访问----可以跨域
servicecomb:
handler:
chain:
Provider: {}
highway: #通信方式，使用highway的通信协议
address: 127.0.0.1:9090 #访问地址【修改】
service:
registry:
address: http://127.0.0.1:30100
autodiscovery: false
3、开发—服务的消费者
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ywfUBDMu-1663302971598)(图片/image-20210821170454760.png)]
1、配置pom.xml文件
与provider 服务提供者，相比，它多出了这个依赖
<!--web模块[provider中，没有这个] springmvc所需的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
完整的pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>demo-rpc</artifactId>
<groupId>com.example</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>rpc-consumer</artifactId>
<!--1、指定jdk版本、编码-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!--2.1 servicecomb所需的 校验-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.3.5.Final</version>
</dependency>
<!--2.2 springboot开发所需的-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!--2.3 servicecomb所需的-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>spring-boot-starter-provider</artifactId>
</dependency>
<!--web模块[provider中，没有这个] springmvc所需的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--2.4、rpc通信所需的：rpc通信模型-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>transport-highway</artifactId>
</dependency>
<!--2.4、rpc通信所需的：rpc编程模型-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>provider-pojo</artifactId>
</dependency>
<!--引入服务接口-->
<dependency>
<groupId>com.example</groupId>
<artifactId>service-interfaces</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
2、开发服务的消费者代码
package com.itheima.service.impl;
import com.itheima.service.RpcService;
import org.apache.servicecomb.provider.pojo.RpcReference;
import org.springframework.stereotype.Component;
/**
* rpc---服务的消费方
*/
@Component //将实现类，注入，方便我们接口调用的时候，使用
public class RestConsumerServiceImpl implements RpcService {
/**
* microserviceName【也叫“应用程序编号”】:找到提供服务的那个 提供方 通过 id+服务名称【从microservice.yaml中，查找】
* schemaId： 微服务的名称,从服务的提供方获取【我们要找的那个 从@RpcSchema(schemaId = "helloRpc") 这里找】
*/
@RpcReference(microserviceName = "serviceprovider-rpc",schemaId = "helloRpc")
private RpcService rpcService;//使用服务的提供方------需要@RpcReference来实现。它是从注册中心，推送过来
@Override
public String sayRpc(String name) {
return rpcService.sayRpc(name);
}
}
3、编写一个controller，让外界能够进行访问
package com.itheima.controller;
import com.itheima.service.RpcService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 对外发布的控制器
*/
@RestController
public class RpcConsumerController {
@Autowired
private RpcService rpcService;
@GetMapping("/rpc")
public void rpcInvoke(){
System.out.println(rpcService.sayRpc(" servicecomb rpc "));
}
}
4、编写一个servicecomb的配置文件
microservice.yaml
APPLICATION_ID: start.servicecomb.io
service_description:
name: serviceconsumer-rpc #【修改】
version: 0.0.1
properties:
allowCrossApp: true #允许跨域访问----可以跨域
servicecomb:
handler:
chain:
Provider: {}
highway: #通信方式，使用highway的通信协议
address: 127.0.0.1:9091 #访问地址【每个模块的，访问接口，都必须唯一】【修改】
service:
registry:
address: http://127.0.0.1:30100
autodiscovery: false
5、为了改变项目的启动端口，我要添加一个配置文件
application.properties
#指定项目的启动端口
server.port=8088
6、编写一个启动类
package com.itheima;
import org.apache.servicecomb.springboot.starter.provider.EnableServiceComb;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* 启动类
*/
@SpringBootApplication
@EnableServiceComb
public class RpcConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(RpcConsumerApplication.class,args);
}
}
7、测试，效果
1、先启动 注册中心
2、启动服务的提供方
3、启动服务的消费方
提供方，启动成功的标志：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XMSOnUbs-1663302971598)(图片/image-20210821170700878.png)]
消费方，启动成功的标志：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GD1gXJn3-1663302971598)(图片/image-20210821170639631.png)]
7、测试，是否能够访问 消费者 写的接口
http://127.0.0.1:8088/rpc 注意：如果注册中心地址写为0.0.0.0 我自己的电脑有问题，无法访问，改成127.0.0.1 就可访问了
图1、
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JgZHx9vQ-1663302971604)(图片/image-20210821193559674.png)]
图2、
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gKz7yQlm-1663302971605)(图片/image-20210821190433800.png)]
4、总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4eRgK6cJ-1663302971606)(图片/02RPC开发ServiceComb应用步骤总结.png)]
6、ServiceComb的微服务治理方案
1、修改原有的rpc项目，给他配置 限流、熔断
1、在原有的rpc项目中，给servicie-provider----- 添加pom.xml的依赖
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>demo-rpc</artifactId>
<groupId>com.example</groupId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>rpc-provider</artifactId>
<!--1、指定jdk版本、编码-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<!--2、添加依赖-->
<dependencies>
<!--2.1 servicecomb所需的 校验-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.3.5.Final</version>
</dependency>
<!--2.2 springboot开发所需的-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!--2.3 servicecomb所需的-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>spring-boot-starter-provider</artifactId>
</dependency>
<!--2.4、rpc通信所需的：rpc通信模型-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>transport-highway</artifactId>
</dependency>
<!--2.4、rpc通信所需的：rpc编程模型-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>provider-pojo</artifactId>
</dependency>
<!--引入服务接口-->
<dependency>
<groupId>com.example</groupId>
<artifactId>service-interfaces</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
<!--限流-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>handler-flowcontrol-qps</artifactId>
</dependency>
<!--熔断包-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>handler-bizkeeper</artifactId>
</dependency>
<!--日志追踪-->
<dependency>
<groupId>org.apache.servicecomb</groupId>
<artifactId>handler-tracing-zipkin</artifactId>
</dependency>
</dependencies>
</project>
2、在servicecomb的配置文件中，添加配置
microservice.yaml
APPLICATION_ID: start.servicecomb.io
service_description:
name: serviceprovider-rpc
version: 0.0.1
properties:
allowCrossApp: true #允许跨域访问----可以跨域
servicecomb: #熔断-----------开始
circuitBreaker:
provider:
requestVolumeThreshold: 8
fallbackpolicy:
provider:
policy: returnnull #熔断-----------结束
flowcontrol: #限流---------开始
Provider:
qps:
limit:
gateway: 1 #限流---------结束
handler: #servicecomb提供的默认处理器，来真正的实现 限流、熔断 的提供者
chain:
Provider:
default: qps-flowcontrol-provider,bizkeeper-provider #这是servicecomb 官方写好的一些提供者
highway: #通信方式，使用highway的通信协议
address: 127.0.0.1:9090 #访问地址
service:
registry:
address: http://127.0.0.1:30100
autodiscovery: false
2、测试servicecomb—负载均衡策略
效果：客户端频繁的发送请求，我的 服务提供者如果开启了多个服务，那么这几个服务之间 会采用轮询的方式，来处理请求
注意：
- servicecomb默认，就支持负载均衡策略
1、测试的时候，需要先把 服务提供者的启动类设置为共享（Share）模式。
2、只要添加了上面哪些配置，我们就可以进行测试了
3、如图所示，将服务提供者，idea的运行模式，改为 多实例运行模式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WxgWncwd-1663302971607)(图片/image-20210821205435219.png)]
4、修改service中的代码
第一次启动的代码
package com.itheima.service.impl;
import com.itheima.service.RpcService;
import org.apache.servicecomb.provider.pojo.RpcSchema;
import org.springframework.stereotype.Service;
/**
* rpc方式---服务的提供者
*/
@RpcSchema(schemaId = "helloRpc") //Rpc的服务，需要通过该注解，来将服务，添加到注册中心
public class RpcProviderServiceImpl implements RpcService {
@Override
public String sayRpc(String name) {
System.out.println("服务提供者-2");
return "hello "+name;
}
}
并修改，servicecomb配置文件，项目的访问端口号
APPLICATION_ID: start.servicecomb.io
service_description:
name: serviceprovider-rpc
version: 0.0.1
properties:
allowCrossApp: true #允许跨域访问----可以跨域
servicecomb: #熔断-----------开始
circuitBreaker:
provider:
requestVolumeThreshold: 8
fallbackpolicy:
provider:
policy: returnnull #熔断-----------结束
flowcontrol: #限流---------开始
Provider:
qps:
limit:
gateway: 1 #限流---------结束
handler: #servicecomb提供的默认处理器，来真正的实现 限流、熔断 的提供者
chain:
Provider:
default: qps-flowcontrol-provider,bizkeeper-provider #这是servicecomb 官方写好的一些提供者
highway: #通信方式，使用highway的通信协议
address: 127.0.0.1:9090 #访问地址
service:
registry:
address: http://127.0.0.1:30100
autodiscovery: false
第二次启动的代码
package com.itheima.service.impl;
import com.itheima.service.RpcService;
import org.apache.servicecomb.provider.pojo.RpcSchema;
import org.springframework.stereotype.Service;
/**
* rpc方式---服务的提供者
*/
@RpcSchema(schemaId = "helloRpc") //Rpc的服务，需要通过该注解，来将服务，添加到注册中心
public class RpcProviderServiceImpl implements RpcService {
@Override
public String sayRpc(String name) {
System.out.println("服务提供者-1");
return "hello "+name;
}
}
并修改，servicecomb配置文件，项目的访问端口号
APPLICATION_ID: start.servicecomb.io
service_description:
name: serviceprovider-rpc
version: 0.0.1
properties:
allowCrossApp: true #允许跨域访问----可以跨域
servicecomb: #熔断-----------开始
circuitBreaker:
provider:
requestVolumeThreshold: 8
fallbackpolicy:
provider:
policy: returnnull #熔断-----------结束
flowcontrol: #限流---------开始
Provider:
qps:
limit:
gateway: 1 #限流---------结束
handler: #servicecomb提供的默认处理器，来真正的实现 限流、熔断 的提供者
chain:
Provider:
default: qps-flowcontrol-provider,bizkeeper-provider #这是servicecomb 官方写好的一些提供者
highway: #通信方式，使用highway的通信协议
address: 127.0.0.1:9095 #访问地址
service:
registry:
address: http://127.0.0.1:30100
autodiscovery: false
5、启动消费端的代码【只跑一个就行了】
效果图：
图1、生产者1的截图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-llzinfn2-1663302971607)(图片/image-20210821210721726.png)]
图2、生产者2的截图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DxrtLkq9-1663302971607)(图片/image-20210821210747781.png)]
浏览器的访问地址
http://127.0.0.1:8088/rpc
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0SjsvDl5-1663302971608)(图片/image-20210821210815674.png)]
3、限流策略【商业版，不用写代码，只需在服务器配置一下，即可】
作用：保证系统的稳定运行
ServiceComb 微服务框架限流主要是基于 zuul 网关来实现限流的。因此需要先配置好 zuul 网关。
后端返回429 状态码，表示：请求太多，后端进行了限流，把超出的请求，进行了限制，不让它访问了
4、熔断机制
熔断：系统访问的压力过大，或者系统访问失败，可能会造成不良的后果， 熔断就可解决该问题
典型案例：服务雪崩 例如：服务之间进行调用，其中一个服务挂了，而其他服务还需等待它，来获取数据，这就造成整个服务调用链，处于一直等待状态【当服务能够正常访问了，我们项目就可以在不重启的条件下，进行项目的正常访问了】
为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。
更多推荐
9
1- 0
已为社区贡献1条内容
所有评论(0)