首先在这之前我们要先搭建一个nacos做注册中心,我用的宝塔面板,用docker搭建的,方便一些
这个我们首先要搭好,因为后面我们要用
访问nacos
这里我们可以看到里面没有数据
搭建一个父项目
我在D盘的cloudtest文件夹下面创建了一个名字为springcloud的父项目
配置仓库
把父项目打成pom,防止打成jar包
添加依赖和版本号管理,这里面的springcloud和springcloudAlibaba和boot的版本最好去官网查看对应的,不要乱配置,容易出问题不兼容
<!-- 统一管理jar包版本 -->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<junit.version>4.12</junit.version>
<log4j.version>1.2.17</log4j.version>
<lombok.version>1.18.24</lombok.version>
<mysql.version>8.0.21</mysql.version>
<druid.version>1.1.21</druid.version>
<mybatis-plus.spring.boot.version>3.5.1</mybatis-plus.spring.boot.version>
</properties>
<!-- 子类管理版本-->
<dependencyManagement>
<dependencies>
<!--spring boot 2.2.2-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.2.2.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--spring cloud Hoxton.SR1-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Hoxton.SR1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--spring cloud alibaba 2.1.0.RELEASE-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>2.1.0.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--mysql数据库-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!--druid数据源-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>${druid.version}</version>
</dependency>
<!--mybatisPlus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis-plus.spring.boot.version}</version>
</dependency>
<!--日志-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
</dependency>
<!--日志-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<!--简化实体类开发-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
<optional>true</optional>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
然后创建一个公共的子模块Module,用来存放公共的内容
添加依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.1.0</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
然后在这创建一个返回数据的公共类和一个后面要用的实体类
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
//状态码
private Integer code;
//信息
private String message;
//传递的数据
private T data;
public CommonResult(Integer code, String message){
this(code,message,null);
}
}
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
private int id;
private int age;
private String name;
}
如果出现依赖没有依赖上的情况
也就是这里没有Dependencies,或者依赖报红的情况,解决方法:
创建一个服务提供者
添加依赖,这里的common就是刚刚的那个公共模块
<dependencies>
<dependency>
<groupId>com.lou</groupId>
<artifactId>common</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<!--Nacos-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-nacos-discovery</artifactId>
</dependency>
<!--mysql-connector-java-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--jdbc-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
接下来我们用mybatisx插件生成代码
没有的去插件管理那里下载一下,就是那个黑色的小鸟
然后创建一个springcloudtest数据库和一个student表
然后在idea里面连上数据库
点击加号
然后地址,这里我的数据用的是本地的数据库,也就是localhost,然后填好用户名和密码和数据库名称,然后点击测试连接,,从图中看到我这个是测试连接成功了
连接上后的效果
找到表名右键
这module path是模块路径,base package就是生成在哪个包下,relative package是实体类存在的包
然后你就神奇的发现
是不是很神奇,然后只要编写controller
import com.lou.pojo.CommonResult;
import com.lou.pojo.Student;
import com.lou.service.StudentService;
import lombok.extern.slf4j.Slf4j;
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;
import javax.annotation.Resource;
@RestController
@Slf4j
public class StudentController {
@Value("${server.port}")
private String serverPort;
@Resource
private StudentService studentService;
@GetMapping("/student/get/{id}")
public CommonResult getStudentById(@PathVariable("id") Integer id){
Student result = studentService.getById(id);
System.out.println("调用成功");
if (result !=null) {
return new CommonResult(200, "获取数据成功" + ":" + serverPort, result);
} else {
return new CommonResult(500, "获取数据失败", null);
}
}
}
添加一个yml文件
端口号我用的8001,数据库就是之前配置的那个本地的数据库,然后name就是服务器名字,然后server-adder后面是我的nacos地址,x.x.x.x就是nacos地址ip,大家可以把地址换一下
server:
port: 8001
spring:
application:
name: provide
cloud:
nacos:
discovery:
server‐addr: x.x.x.x:8848
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/springcloudtest?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT
username: root
password: root
添加启动类
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@MapperScan(basePackages = "com.lou.mapper")
public class ProvideApplication {
public static void main(String[] args) {
SpringApplication.run(ProvideApplication.class,args);
}
}
启动成功
访问
然后再看看nacos注册中心,下面就是注册上了
然后建立一个服务的消费者
添加依赖
<dependencies>
<dependency>
<groupId>com.lou</groupId>
<artifactId>common</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--Nacos-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-nacos-discovery</artifactId>
</dependency>
<!--openfeign依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
添加yml文件,端口号我用的8005,x.x.x.x是我nacos的IP地址
server:
port: 8005
spring:
application:
name: consumer
cloud:
nacos:
discovery:
server‐addr: x.x.x.x:8848
接下来我用两种方法进行远程的调用,第一种用RestTemplate,第二种用openFeign
第一种:
建立一个配置文件包生产RestTemplate用容器管理
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
@SpringBootApplication
@EnableFeignClients//开启openfeign注解
public class ConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerApplication.class,args);
}
}
编写controller调用服务者
import com.lou.pojo.CommonResult;
import lombok.extern.slf4j.Slf4j;
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.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
import java.net.URI;
@RestController
@Slf4j
public class ConsumerController {
@Resource
private RestTemplate restTemplate;
//负载均衡
@Autowired
LoadBalancerClient loadBalancerClient;
@GetMapping("/student/get/{id}")
public CommonResult getPaymentById(@PathVariable("id")Integer id){
//nacos的服务名称,也就是服务yml里面的name
String serviceId="provide";
ServiceInstance serviceInstance = loadBalancerClient.choose(serviceId);
URI uri = serviceInstance.getUri();
return restTemplate.getForObject(uri+"/student/get/"+id, CommonResult.class,id);
}
}
启动服务
启动成功,访问
查看注册中心
第二种:
编写openFign接口
import com.lou.pojo.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
@FeignClient(value = "provide")//被调用的微服务的名称
public interface StudentFeign {
//被调用的方法
@GetMapping("/student/get/{id}")
public CommonResult findById(@PathVariable(value="id") Integer id);
}
import com.lou.feign.StudentFeign;
import com.lou.pojo.CommonResult;
import lombok.extern.slf4j.Slf4j;
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.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
import java.net.URI;
@RestController
@Slf4j
public class ConsumerController {
@Resource
private RestTemplate restTemplate;
@Autowired
private StudentFeign studentFeign;
//负载均衡
@Autowired
LoadBalancerClient loadBalancerClient;
@GetMapping("/student/get/{id}")
public CommonResult getPaymentById(@PathVariable("id")Integer id) {
return studentFeign.findById(id);
}
}
然后访问也是没毛病的
写到这,真累,估计你也看不到这
接下来就是我们启动多个服务试试,看看对于消费方访问的哪一个,怎么访问的
调出services
如果这里没有
解决方法:
这样下面就有了
然后如果没有显示启动的模块
解决方法
然后点进去,找到springboot点击就是我那个样子的了
用8002启动
右键启动
查看nacos
然后用消费者进行看一看调用哪个
清一下看的清楚
第一次调的8001
第二次调的8002
第三次8001
由此可见是轮询的方式,其实这个是默认的,其实也是配置的,大家有兴趣可以研究一下
接下来配置一个网关
现在是四点39,还有一个小时11分钟下班
依赖:
<dependencies>
<!-- swagger2依赖 (网关不写业务,但是需要聚合所有服务的接口方便查看)-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>swagger-bootstrap-ui</artifactId>
<version>1.9.5</version>
</dependency>
<!--gateway-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!-- SpringCloudAlibaba版本父工程已控制不用写版本号 -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-nacos-discovery</artifactId>
</dependency>
</dependencies>
用Swagger自动生成文档
import org.springframework.cloud.gateway.discovery.DiscoveryClientRouteDefinitionLocator;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import springfox.documentation.swagger.web.SwaggerResource;
import springfox.documentation.swagger.web.SwaggerResourcesProvider;
import java.util.ArrayList;
import java.util.List;
@Component
@Primary
public class SwaggerProvider implements SwaggerResourcesProvider {
/**
* swagger的api json文档路径
*/
public static final String API_URI = "/v2/api-docs";
/**
* Eureka发现功能的方法的名字,注册的服务会加入这个前缀
*/
public static final String EUREKA_SUB_PFIX = "CompositeDiscoveryClient_";
/**
* 服务发现的路由处理器
*/
private final DiscoveryClientRouteDefinitionLocator routeLocator;
public SwaggerProvider(DiscoveryClientRouteDefinitionLocator routeLocator) {
this.routeLocator = routeLocator;
}
@Override
public List<SwaggerResource> get() {
List<SwaggerResource> resources = new ArrayList<>();
List<String> routes = new ArrayList<>();
//从DiscoveryClientRouteDefinitionLocator 中取出routes,构造成swaggerResource
routeLocator.getRouteDefinitions().subscribe(routeDefinition -> {
resources.add(swaggerResource(
//获取id(服务注册的id)
routeDefinition.getId()
//去除CompositeDiscoveryClient_前缀
.substring(EUREKA_SUB_PFIX.length()),
//获取路由定义信息列表
routeDefinition.getPredicates()
//获取路径信息PredicateDefinition{name='Path', args={pattern=/byb-provider2/**}}
.get(0)
.getArgs()
//将pattern中的/**替换为服务swagger文档路径
.get("pattern")
.replace("/**", API_URI)));
});
return resources;
}
private SwaggerResource swaggerResource(String name, String location) {
SwaggerResource swaggerResource = new SwaggerResource();
swaggerResource.setName(name);
swaggerResource.setLocation(location);
swaggerResource.setSwaggerVersion("2.0");
return swaggerResource;
}
}
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;
import springfox.documentation.swagger.web.*;
import java.util.Optional;
@RestController
@RequestMapping("/swagger-resources")
public class SwaggerHandler {
@Autowired(required = false)
private SecurityConfiguration securityConfiguration;
@Autowired(required = false)
private UiConfiguration uiConfiguration;
private final SwaggerResourcesProvider swaggerResources;
@Autowired
public SwaggerHandler(SwaggerResourcesProvider swaggerResources) {
this.swaggerResources = swaggerResources;
}
@GetMapping("/configuration/security")
public Mono<ResponseEntity<SecurityConfiguration>> securityConfiguration() {
return Mono.just(new ResponseEntity<>(
Optional.ofNullable(securityConfiguration).orElse(SecurityConfigurationBuilder.builder().build()), HttpStatus.OK));
}
@GetMapping("/configuration/ui")
public Mono<ResponseEntity<UiConfiguration>> uiConfiguration() {
return Mono.just(new ResponseEntity<>(
Optional.ofNullable(uiConfiguration).orElse(UiConfigurationBuilder.builder().build()), HttpStatus.OK));
}
@GetMapping("")
public Mono<ResponseEntity> swaggerResources() {
return Mono.just((new ResponseEntity<>(swaggerResources.get(), HttpStatus.OK)));
}
}
新建两个yml文件
server:
port: 8000
spring:
profiles:
active: dev
Spring:
application:
name: gateway
cloud:
nacos:
discovery:
server-addr: x.x.x.x:8848
gateway:
discovery:
locator:
enabled: true #表明gateway开启服务注册和发现的功能,并且spring cloud gateway自动根据服务发现为每一个服务创建了一个router,这个router将以服务名开头的请求路径转发到对应的服务
lower-case-service-id: true #是将请求路径上的服务名配置为小写(因为服务注册的时候,向注册中心注册时将服务名转成大写的了
routes:
- id: consumer #自定义id,无意义但不能重复,最好跟服务名保持一致
uri: lb://consumer # 注册中心中的服务吗
predicates:
- Path=/consumer/** # 转发该路径
filters:
- StripPrefix=1 #必须加上StripPrefix=1,否则访问服务时会带上user
# 经过gateWay网关时,需要在网关统一配置跨域请求,全部通过
globalcors:
cors-configurations:
'[/**]':
allowed-origins: "*"
allowed-headers: "*"
allow-credentials: true
allowed-methods:
- GET
- POST
- DELETE
- PUT
- OPTION
上面其实和一个是一样,不过我多加一个就是为了加一个环境,用dev环境
x.x.x.x就是nacos的IP地址,predicates断言,filters过滤器
路由(Route):路由是网关的基本构件。它由ID、目标URI、一组断言和一组过滤器组成。如果断言为真,则匹配该路由。gateway使用类RouteDefinition表示路由定义。
断言(Predicate):参照Java8的新特性Predicate。Predicate接受一个输入参数,返回一个布尔值结果,输入参数可以是HTTP请求的任何部分,比如报文头、参数、报文体,而且还可以将多个断言组合在一起。
过滤器(Filter):可以在发送到目标URI之前或之后修改请求和响应。
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class, args);
}
}
启动....
成功
访问:这里可以看到网关搭建成功
nacos注册中心:没有问题
还有35分钟下班.......
然后搭建一个链路追踪我这里直接用zipkin整合在一起了
consumer,provide,gateway模块添加依赖
<!--zipkin-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>
consumer的yml
server:
port: 8005
logging:
level:
cn.ebuy: DEBUG
root: INFO # 添加日志级别
org.springframework.web.servlet.DispatcherServlet: DEBUG
org.springframework.cloud.sleuth: DEBUG
spring:
application:
name: consumer
zipkin:
base-url: http://x.x.x.x:9411 #zipkin server的请求地址
sender:
type: web # 请求方式,默认以http的方式向zipkin server发送追踪数据
sleuth:
sampler:
probability: 1.0 # 采样的百分比
cloud:
nacos:
discovery:
server‐addr: x.x.x.x:8848
provide的yml
server:
port: 8001
logging:
level:
cn.ebuy: DEBUG
root: INFO # 添加日志级别
org.springframework.web.servlet.DispatcherServlet: DEBUG
org.springframework.cloud.sleuth: DEBUG
spring:
application:
name: provide
zipkin:
base-url: http://x.x.x.x:9411 #zipkin server的请求地址
sender:
type: web # 请求方式,默认以http的方式向zipkin server发送追踪数据
sleuth:
sampler:
probability: 1.0 # 采样的百分比
cloud:
nacos:
discovery:
server‐addr: x.x.x.x:8848
datasource:
type: com.alibaba.druid.pool.DruidDataSource # 当前数据源操作类型
driver-class-name: com.mysql.cj.jdbc.Driver # mysql驱动包 com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/springcloudtest?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT
username: root
password: root
gateway-dev的yml
Spring:
application:
name: gateway
zipkin:
base-url: http://x.x.x.x:9411 #zipkin server的请求地址
sender:
type: web # 请求方式,默认以http的方式向zipkin server发送追踪数据
sleuth:
sampler:
probability: 1.0 # 采样的百分比
cloud:
nacos:
discovery:
server-addr: x.x.x.x:8848
gateway:
discovery:
locator:
enabled: true #表明gateway开启服务注册和发现的功能,并且spring cloud gateway自动根据服务发现为每一个服务创建了一个router,这个router将以服务名开头的请求路径转发到对应的服务
lower-case-service-id: true #是将请求路径上的服务名配置为小写(因为服务注册的时候,向注册中心注册时将服务名转成大写的了
routes:
- id: consumer #自定义id,无意义但不能重复,最好跟服务名保持一致
uri: lb://consumer # 注册中心中的服务吗
predicates:
- Path=/consumer/** # 转发该路径
filters:
- StripPrefix=1 #必须加上StripPrefix=1,否则访问服务时会带上user
# 经过gateWay网关时,需要在网关统一配置跨域请求,全部通过
globalcors:
cors-configurations:
'[/**]':
allowed-origins: "*"
allowed-headers: "*"
allow-credentials: true
allowed-methods:
- GET
- POST
- DELETE
- PUT
- OPTION
logging:
level:
cn.ebuy: DEBUG
root: INFO # 添加日志级别
org.springframework.web.servlet.DispatcherServlet: DEBUG
org.springframework.cloud.sleuth: DEBUG
然后不要急启动,搭建zipkin
然后启动jar包,我用的宝塔面板启动
上面的x.x.x.x都是你服务器的ip地址
然后重启项目(四个都重启)
访问
访问自己搭建的zipkin,可以看到访问日志,下面后面三个是刚加的,另外两个是之前的(和这次没有关系)
查找可以详细的看到这个情况
最后写一个nacos做配置文件的测试吧
拿provide模块做测试,获取nacos配置的信息
连接nacos
provide添加依赖
<!-- SpringCloud Ailibaba Nacos Config -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-nacos-config</artifactId>
</dependency>
然后application改成bootstrap,区别大家百度吧,然后加nacos-config配置,最后yml文件
server: port: 8001 logging: level: cn.ebuy: DEBUG root: INFO # 添加日志级别 org.springframework.web.servlet.DispatcherServlet: DEBUG org.springframework.cloud.sleuth: DEBUG spring: application: name: provide zipkin: base-url: http://x.x.x.x:9411 #zipkin server的请求地址 sender: type: web # 请求方式,默认以http的方式向zipkin server发送追踪数据 sleuth: sampler: probability: 1.0 # 采样的百分比 cloud: nacos: config: file-extension: yml server‐addr: x.x.x.x:8848 discovery: server‐addr: x.x.x.x:8848 datasource: type: com.alibaba.druid.pool.DruidDataSource # 当前数据源操作类型 driver-class-name: com.mysql.cj.jdbc.Driver # mysql驱动包 com.mysql.jdbc.Driver url: jdbc:mysql://localhost:3306/springcloudtest?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT username: root password: root profiles: active: dev
然后编写访问数据的控制层
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
//配置发布之后,动态刷新配置
@RefreshScope
@RestController
@RequestMapping("/provider")
public class ProviderController
{
// 使用原生注解@Value()导入配置
@Value("${user.id}")
private String id;
@Value("${user.name}")
private String name;
@GetMapping("/getNacosConfig")
public String providerTest()
{
return "我是provider,已成功获取nacos配置中心的数据:(id:" + id + ",name:" + name+")";
}
}
然后重启provide模块
访问
拿到了
下班........................