1. Nacos介绍
Nacos:是一个应用于服务注册与发现,配置管理的平台。孵化与阿里巴巴。
官网地址:https://nacos.io/zh-cn/docs/quick-start.html
2.构建Nacos服务
2.1 确保电脑已配置JAVA_HOME环境变量(Nacos启动需要)
2.2 Nacos下载:
网址:https://github.com/alibaba/nacos/releases
选择对应版本直接下载,解压。
2.3 初始化配置
第一步:mysql中创建nacos_config数据库:
create database nacos_config default character set utf8;
第二步:nacos_config数据库中执行conf文件下的nacos-mysql.sql文件;
use nacos_config;
source D:/Java/nacos_server/conf/nacos-mysql.sql;
执行成功后,会在nacos_config数据库中创建一些表:
2.4 打开 /nacos/conf/application.properties文件,基于当前环境配置要连接的数据库,连接数据库时使用的用户名和密码(假如前面有#号要将其去掉)
2.5 服务启动与访问
进入到nacos的bin目录通过指令启动。
Windows启动命令(standalone代表着单机模式运行,非集群模式)
startup.cmd -m standalone
Linux/Mac启动命令(standalone代表着单机模式运行,非集群模式)
./startup.sh -m standalone
访问Nacos服务:浏览器输入 http://localhost:8848/nacos,出现如下登录页面:
3.服务注册与调用入门
3.1 业务描述
创建两个项目Module分别为服务提供者和服务消费者,两者都注册到NacosServer中(这个server本质上就是一个web服务,端口默认为8848),然后服务提供者可以为服务消费者提供远端调用服务。
3.2 搭建整体代码机构。
创建父工程(01-sca)用来定义依赖版本
pom.xml(01-sca):
<?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.huo</groupId>
<artifactId>01-sca</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<modules>
<module>sca-provider</module>
<module>sca-consumer</module>
</modules>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<!--定义依赖版本-->
<dependencyManagement>
<dependencies>
<!--定义springBoot依赖版本-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.3.2.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--定义springCloud依赖版本-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Hoxton.SR9</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--定义springCloudAlibaba依赖版本-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>2.2.6.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
3.3 生成者服务创建及注册。
创建服务提供者工程 sca-provider,继承parent工程(01-sca)。
pom.xml(sca-provider):
<?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>01-sca</artifactId>
<groupId>com.huo</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>sca-provider</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<!--服务提供方-->
<dependencies>
<!--web依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--服务的注册和发现(我们要将服务注册到nacos)-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
</dependencies>
</project>
配置application.yml实现服务注册。
server:
port: 8081
spring:
application:
name: sca-provider #服务名
cloud:
nacos:
discovery: #服务注册和发现的配置
server-addr: localhost:8848 #nacos服务地址
创建启动类:
package com.huo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ProviderApplication {
public static void main(String[] args) {
SpringApplication.run(ProviderApplication.class,args);
}
}
启动启动类然后刷新nacos服务。
3.4 消费者服务发现及调用
在sca-provider项目中创建服务提供方对象,基于此对象对外提供服务:
创建ProviderController类
package com.huo.provider.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class ProviderController {
@Value("${server.port: 8080}")
private String serverPort;
@GetMapping("/provider/echo/{msg}")
public String doRestEcho1(@PathVariable("msg") String msg){
return String.format("%s say hello %s",serverPort,msg);
}
}
创建服务消费者工程 sca-consumer,继承parent工程(01-sca)。
pom.xml(sca-consumer):
<?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>01-sca</artifactId>
<groupId>com.huo</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>sca-consumer</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<!--服务提供方-->
<dependencies>
<!--web依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--服务的注册和发现(我们要将服务注册到nacos)-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
</dependencies>
</project>
配置application.yml实现服务注册。
server:
port: 8090
spring:
application:
name: sca-consumer
cloud:
nacos:
discovery:
server-addr: localhost:8848
创建消费方(sca-Consumer)启动类:
package com.huo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
@SpringBootApplication
public class ConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerApplication.class,args);
}
}
启动启动类然后刷新nacos服务。
3.4.1 基于RestTemplate对象进行远端服务调用
在sca-consumer启动类中添加创建RestTemplate对象的方法。
/**
* 创建RestTemplate对象,我们可以基于此对象进行远端服务
* 调用,此对象封装了远程服务调用的协议和相关方法。
*/
@Bean
public RestTemplate restTemplate(){
return new RestTemplate();
}
定义sca-consumer服务的消费端controller,在此对象方法内部实现远端服务调用
package com.huo.consumer.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
@RestController
public class ConsumerController {
//@Autowired //属性注入(不能使用final修饰)
private RestTemplate restTemplate;
@Autowired //构造注入(假如只有一个构造方法autowired也可以省略)
public ConsumerController(RestTemplate restTemplate){
this.restTemplate=restTemplate;
}
@GetMapping("/consumer/doRestEcho1")
public String doRestEcho1(){
String url="http://localhost:8081/provider/echo/{msg}";//定义远端服务的url地址
return restTemplate.getForObject(url,String.class,999);//String.class为url对应服务的响应结果类型
}
}
启动消费者服务,进行访问测试。
在浏览器输入地址:http://localhost:8090/consumer/doRestEcho2
3.4.2 服务负载均衡设计及实现
方法一:LoadBalancerClient应用
LoadBalancerClient对象可以从nacos中基于服务名获取服务实例,然后在工程中基于特定算法实现负载均衡方式的调用。
在ConsumerController类中,注入LoadBalancerClient对象,并添加方法:
//基于此对象从nacos中动态获取服务列表,并基于内置负载均衡算法获取服务实例
@Autowired
private LoadBalancerClient loadBalancerClient;
@GetMapping("/consumer/doRestEcho2")
public String doRestEcho2(){
//方案一:自己实现负载均衡算法
/*String url1="http://localhost:8081/provider/echo/{msg}";//定义远端服务的url地址
String url2="http://localhost:8082/provider/echo/{msg}";//定义远端服务的url地址
String[] urlArray={url1,url2};
String url=urlArray[new Random().nextInt(urlArray.length)];
return restTemplate.getForObject(url,String.class,999);//String.class为url对应服务的响应结果类型
*/
//方案二:从nacos中动态动态获取服务列表,并基于内置负载均衡算法获取服务实例
ServiceInstance serviceInstance = loadBalancerClient.choose("sca-provider");
String url="http://%s:%s/provider/echo/{msg}";
url=String.format(url,serviceInstance.getHost(),serviceInstance.getPort());
return restTemplate.getForObject(url,String.class,999);
}
修改sca-provider的配置文件端口,启动两个提供方服务。
启动csa-consumer项目模块,通过浏览器访问consumer服务的doRestEcho2来检测页面数据变化。
方法二:@LoadBalanced应用
注解方式实现 使用RestTemplate进行远程服务调用时的负载均衡
在ConsumerApplication类中添加RestTemplate对象
@Bean
@LoadBalanced
public RestTemplate restTemplate(){
return new RestTemplate();
}
在需要RestTemplate需要负载均衡调用的地方进行依赖注入。
ConsumerController类中注入restTemplate对象,添加方法
package com.huo.consumer.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
@RestController
public class ConsumerController {
@Autowired
private RestTemplate restTemplate;
@Value("${spring.application.name: sca-provide}")
private String serverName;
@GetMapping("/consumer/doRestEcho3")
public String doRestEcho3() {
String url = "http://sca-provider/provider/echo/{msg}";
return restTemplate.getForObject(url,String.class,serverName);
}
}
RestTemplate在发送请求的时候会被LoadBalancerInterceptor拦截,它的作用就是用于RestTemplate的负载均衡。
Ribbon负载均衡策略
修改负载均衡策略方法 默认为轮训策略
方法一:在启动类中配置负载均衡策略
@Bean
public IRule rule(){
return new RandomRule();
}
方法二:在配置文件application.yml中配置负载均衡策略
sca-provider: #基于服务名指定负载均衡策略
ribbon:
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
3.4.3 基于Feign的远程服务调用
Feign是一种声明式Web服务客户端,通Feign可以简化服务消费方调用远程服务提供的方法。
Feign应用实践
第一步:在服务消费方,添加项目依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
第二步:在启动类添加@EnableFeignClients注解
@SpringBootApplication
@EnableFeignClients
public class ConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerApplication.class,args);
}
}
第三步:定义Http请求API,基于此API借助OpenFeign访问远端服务
package com.huo.consumer.service;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
@FeignClient(name = "sca-provider")//服务提供者名称
public interface RemoteProviderService {
@GetMapping("provider/echo/{msg}")//前提是远端需要有这个服务
public String echoMessage(@PathVariable("msg") String string);
}
其中,@FeignClient描述的接口底层会为其创建实现类。
第四步:创建FeignConsumerController中并添加feign访问
package com.huo.consumer.controller;
import com.huo.consumer.service.RemoteProviderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class FeignConsumerController {
@Autowired
private RemoteProviderService remoteProviderService;
/*基于feign方式的服务调用*/
@GetMapping("/consumer/echo/{msg}")
public String doFeignEcho(@PathVariable("msg") String msg){
//基于feign方式进行远端服务调用
return remoteProviderService.echoMessage(msg);
}
}
第五步:启动消费者服务,在浏览器中直接通过feign客户端进行访问
当进行远程服务调用时,调用的服务突然不可用,一般服务消费端会给出容错方案
Feign应用中通过FallbackFactory接口的实现类进行默认的相关处理
第一步:定义FallbackFactory接口的实现
package com.huo.consumer.service;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;
/*基于此对象处理RemoteProviderService接口调用时出现的服务中断超时等问题*/
@Component
public class ProviderFallbackFactory
implements FallbackFactory<RemoteProviderService> {
/**
* 此方法会在RemoteProviderService接口服务调用时,出现了异常后执行
*/
@Override
public RemoteProviderService create(Throwable throwable) {
return msg->{
return "服务维护中";
};
}
}
第二步:在Feign访问接口中应用FallbackFactory对象
@FeignClient(name = "sca-provider",//服务提供者名称
contextId = "remoteProviderService",//ioc管理名称
fallbackFactory=ProviderFallbackFactory.class)
public interface RemoteProviderService {
@GetMapping("provider/echo/{msg}")//前提是远端需要有这个服务
String echoMessage(@PathVariable("msg") String string);
}
第三步:在配置文件application.yml中添加如下配置,启动feign方式调用时的服务中断处理机制。
feign:
hystrix:
enabled: true
3.4.4 Feign调用过程分析
- 通过@EnableFeignCleints注解告诉springCloud,启动Feign Starter组件
- Feign Starter 会在项目启动过程中注册全局配置,扫描包下所有@FeignClient注解描述的接口,然后由系统底层创建接口实现类(JDK代理),并构建类的对象,然后交给spring管理(注册 ioc 容器)。
- Feign接口被调用时,底层代理对象会将接口中的请求通过编码器创建Request对象,基于此对象进行远程过程调用。
- Feign客户端请求对象会经Ribbon进行负载均衡,挑选出一个健康的Server实例。
- Feign客户端会携带Request调用远端服务并返回一个响应。
- Feign客户端对象对Response信息进行解析然后返回客户端。
3.5 小节总结
- 将服务注册到nacos为了更好的查找这些服务
- nacos通过检测心跳包来判定服务实例的状态
- 实现nacos服务注册需要添加什么依赖:web , discovery
- 注册中心使用的设计模式:中介者模式
- 服务之间进行服务调用时,使用的API:RestTemplate,用此对象之前先要创建这个对象并交给spring管理
- RestTemplate服务调用的设计模式:模板方法模式
- LoadBalancerClient对象的作用:获取服务实例,然后在本地负载均衡
- LoadBalancerClient的具体实现:RibbonLoadBalancerClient
- Ribbon是什么:一个负载均衡组件,此组件中定义了一些负载均衡算法
- 负载均衡算法:随机,轮巡,hash,重试
- 如何配置负载均衡算法:配置类@Bean、配置文件application.yml
- 基于Feign可以更加友好的实现服务调用,简化服务消费方对服务提供方方法的调用
- @FeignClient注解:告诉Feign Starter在项目启动时,为项目启动时,为此注解描述的接口创建实现类-代理类)
- Feign方式的调用,底层使用Ribbon来实现负载均衡
- @EnableFeignCleints 描述配置类
4.服务配置中心应用
配置中心最基础的功能就是存储一个键值对,当用户发布一个配置(configKey),然后客户端获取这个配置项(configValue);进阶的功能就是当某个配置发生变更时,不停机就可以动态刷新服务内部的配置项。
4.1 Nacos配置入门案例
第一步:创建ProviderLogController对象(sca-provider)
package com.huo.provider.controller;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 基于日志对象进行日志输出测试
*/
@Slf4j
@RestController
public class ProviderLogController {
@GetMapping("/provider/log/doLog01")
public String doLog01(){
log.trace("===trace===");
log.debug("===debug===");
log.info("===info===");
log.warn("===warn===");
log.error("===error===");
return "log config test";
}
}
第二步:在sca-provider项目中添加配置依赖:
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
第三步:将sca-provider的application.yml文件名修改为bootstrap.yml(启动优先级最高),并添加配置中心配置。
server:
port: 8082
spring:
application:
name: sca-provider #服务名
cloud:
nacos:
discovery: #服务注册和发现的配置
server-addr: localhost:8848 #nacos服务地址
config: #服务配置
server-addr: localhost:8848
file-extension: yml
第四步:在nacos配置中心,新建配置
Data ID的值要与bootstrap.yml中定义的spring.application.name的值相同,配置发布后,会在配置列表中,显示配置
打开浏览器 输入 http://localhost:8082/provider/log/doLog01,检查idea控制台日志输出,打卡nacos控制台修改日志级别后,再次查看控制台日志输出。
4.2 @RefreshScope注解的应用
nacos配置中心,有系统内部对配置变化的感知,还有外部系统对配置的感知,实现系统在浏览器中看到日志级别的变化
第一步:在ProviderLogController类的上面添加@RefreshScope注解
@RefreshScope
@Slf4j
@RestController
public class ProviderLogController {.....}
第二步:在ProviderLogController类中添加一个获取日志级别的属性和方法
@Value("${logging.level.com.huo:error}")
private String logLevel;
@GetMapping("/provider/log/doLog02")
public String doLog02(){
log.info("log level is {}",logLevel);
return "log level is "+logLevel;
}
打开浏览器 输入 http://localhost:8082/provider/log/doLog02进行访问测试
4.3 Nacos配置管理模型
4.3.1 命名空间设计
Nacos中的命名空间一般用于配置隔离,这种命名空间的定义一般会按照环(开发,生产等)进行设计和实现,默认创建的配置存储到了public命名空间
第一步:创建新命名空间
命名空间创建成功后
将public配置进行克隆到dev命名空间中。克隆完成后:
在bootstrap.yml配置文件中添加配置,配置命名空间的id
spring:
cloud:
nacos:
config:
namespace: 62597859-8184-4d8c-b78f-59bc5b070d7d
然后修改dev命名空间中的配置,通过访问 http://localhost:8082/provider/log/doLog02进行测试
4.3.2 分组设计及实现
在指定命名空间下,按照环境或服务做好了配置以后,有时还需要基于服务做分组配置,一个服务在不同的时间节点切换不同的配置。
第一步:在dev命名空间中新增配置信息
useLocalCache为自己定义的配置值,表示是否使用本地缓存
第二步:修改bootstrap.yml配置类,在其内部指定新建的分组
spring:
cloud:
nacos:
config:
group: DEFAULT_GROUP_51
第三步:新建ProviderCacheController类,添加属性与方法获取新建分组配置的值
package com.huo.provider.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class ProviderCacheController {
@Value("${useLocalCache: false}")
private String useLocalCache;
@RequestMapping("/provider/cache1")
public String doUseLocalCache1(){
return "useLocalCache : "+ useLocalCache;
}
}
通过访问 http://localhost:8082/provider/cache1进行测试
4.3.2 共享配置设计及读取
同一个namespace的多个配置文件中都有相同配置时,可以对这些配置进行提取,然后存储到nacos配置中心的一个或多个指定配置文件,哪个微服务需要,就在服务的配置中设置读取即可。
第一步 在nacos中创建一个共享配置文件
第二步:在指定的微服务配置文件中设置共享配置文件的读取
spring:
cloud:
nacos:
config:
shared-configs[0]: #共享配置1
data-id: app-public.yml
refresh: true #默认为false,共享配置更新,引用此配置的地方是否需要更新
shared-configs[1]: #共享配置2
data-id: sca-provider.yml
refresh: true
第三步 新建ProviderSecretController类,添加属性与方法获取新建分组配置的值
package com.huo.provider.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RefreshScope
@RestController
public class ProviderSecretController {
@Value("${app.name: huo}")
private String name;
@GetMapping("/provider/secret")
public String doGetSecret(){
return "app name : "+ name;
}
}
通过访问 http://localhost:8082/provider/secret进行测试
4.4 小节总结
- 一般会将经常变化的配置信息(连接池,日志,线程池,限流熔断)写在配置中心
- 一般不会将服务端口,服务名,服务的注册地址,配置中心信息写入配置中心
- bootstrap.yml文件被读取的优先级比较高,可以在服务启动时读取配置中心的数据
- 客户端获取配置中心的配置信息以后,会将配置信息在本地内存中存储一份