搭建一个SpringCloud项目

早起的小娄

已于 2023-06-14 14:58:49 修改

阅读量424

点赞数 3

于 2023-06-13 18:50:31 首次发布

本文链接：https://blog.csdn.net/qheuwq/article/details/131186711

版权

首先在这之前我们要先搭建一个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模块

访问