• SpringCloudAlibaba实战-快速上手

    写在前面：在学习了很多理论知识后，虽然对理论知识有了个概念，但是搭建项目的配置步骤做的少，还是不熟，方便日后复习，在此记录一下。

    一、创建父项目

    1. 创建项目基础信息

    1. 选择项目基础信息

    2.选择依赖

            因为创建的是springcloudAlibaba项目，有固定的版本对应，需要自己调整，所以这里的版本默认就可以，依赖也不用选，后面根据需要添加就行。

    3.点击创建后项目如下

    4.删除无关项

    构建微服务，这个项目作为父项目，将无关的结构删除，保留项目的pom.xml即可。

    2.设置项目版本

    1. 查看版本关系

    版本说明 · alibaba/spring-cloud-alibaba Wiki · GitHubSpring Cloud Alibaba provides a one-stop solution for application development for the distributed solutions of Alibaba middleware. - 版本说明 · alibaba/spring-cloud-alibaba Wikiicon-default.png?t=N7T8https://github.com/alibaba/spring-cloud-alibaba/wiki/%E7%89%88%E6%9C%AC%E8%AF%B4%E6%98%8E/662c076ef8f4af0ec94caa86ade169442684904f

    2.版本选择

            找到分支部分，选则一个Spring Cloud Alibaba Version，则可以确定Spring Cloud Version和Spring Boot Version。

            再往下滑动，可以看到组件版本关系，这样就可以确定适配的各组件版本了。当然这个在maven中不用自己显示配置， 都在上面集中管理了。下面这些，只是组件下载时，我们需要回来参照，，文章后面以nocos为例说明。

    3. 配置父pom.xml

       这里我选择版本对应如下：

    •         2.2.6.RELEASE
    •         2.3.2.RELEASE
    •         Hoxton.SR9
    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <modelVersion>4.0.0modelVersion>
    5.     <groupId>com.xixijungroupId>
    6.     <artifactId>spring-cloud-blogartifactId>
    7.     <version>0.0.1-SNAPSHOTversion>
    8.     <name>spring-cloud-blogname>
    9.  
    10.     <packaging>pompackaging>
    11.  
    12.     <properties>
    13.         <java.version>1.8java.version>
    14.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    15.         <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    16.         <spring.cloud.alibaba.version>2.2.6.RELEASEspring.cloud.alibaba.version>
    17.         <spring.boot.version>2.3.2.RELEASEspring.boot.version>
    18.         <spring.cloud.version>Hoxton.SR9spring.cloud.version>
    19.     properties>
    20.  
    21.     <dependencies>
    22.         <dependency>
    23.             <groupId>org.springframework.bootgroupId>
    24.             <artifactId>spring-boot-starterartifactId>
    25.         dependency>
    26.  
    27.         <dependency>
    28.             <groupId>org.springframework.bootgroupId>
    29.             <artifactId>spring-boot-starter-testartifactId>
    30.             <scope>testscope>
    31.             <exclusions>
    32.                 <exclusion>
    33.                     <groupId>org.junit.vintagegroupId>
    34.                     <artifactId>junit-vintage-engineartifactId>
    35.                 exclusion>
    36.             exclusions>
    37.         dependency>
    38.     dependencies>
    39.     
    40.     <dependencyManagement>
    41.         <dependencies>
    42.             
    43.             <dependency>
    44.                 <groupId>org.springframework.bootgroupId>
    45.                 <artifactId>spring-boot-starter-parentartifactId>
    46.                 <version>${spring.boot.version}version>
    47.                 <type>pomtype>
    48.                 <scope>importscope>
    49.             dependency>
    50.             
    51.             <dependency>
    52.                 <groupId>com.alibaba.cloudgroupId>
    53.                 <artifactId>spring-cloud-alibaba-dependenciesartifactId>
    54.                 <version>${spring.cloud.alibaba.version}version>
    55.                 <type>pomtype>
    56.                 <scope>importscope>
    57.             dependency>
    58.             
    59.             <dependency>
    60.                 <groupId>org.springframework.cloudgroupId>
    61.                 <artifactId>spring-cloud-dependenciesartifactId>
    62.                 <version>${spring.cloud.version}version>
    63.                 <type>pomtype>
    64.                 <scope>importscope>
    65.             dependency>
    66.  
    67.         dependencies>
    68.     dependencyManagement>
    69.  
    70.     <build>
    71.         <plugins>
    72.             <plugin>
    73.                 <groupId>org.apache.maven.pluginsgroupId>
    74.                 <artifactId>maven-compiler-pluginartifactId>
    75.                 <version>3.8.1version>
    76.                 <configuration>
    77.                     <source>1.8source>
    78.                     <target>1.8target>
    79.                     <encoding>UTF-8encoding>
    80.                 configuration>
    81.             plugin>
    82.         plugins>
    83.     build>
    84.  
    85. project>

    pom.xml说明；

    properties中配置统一版本管理

    在propertie中可以自定义变量，来进行版本管理

    一般设置为：artifactId.versiom。

    引用：${artifactId.versiom}

    示例：

    1. <properties>
    2.     <spring.boot.version>2.3.2.RELEASEspring.boot.version>
    3. properties> 
    4.  
    5. <dependency>
    6.     <groupId>org.springframework.bootgroupId>
    7.     <artifactId>spring-boot-starter-parentartifactId>
    8.     <version>${spring.boot.version}version>
    9.     <type>pomtype>
    10.     <scope>importscope>
    11. dependency>

    dependencyManagement集中化的依赖管理

            在Maven中，dependencyManagement 元素是用来为所有子项目提供一个集中化的依赖管理。当你有多个模块或项目，并且它们共享相同的依赖时，dependencyManagement 非常有用。

    具体来说，dependencyManagement 的作用有以下几点：

    1. 版本管理：你可以在一个中心的地方管理所有依赖的版本号，这样当你需要更新版本时，只需要在一个地方修改。

    2. 范围（Scope）管理：你可以设定依赖的范围（如 import, compile, runtime, test 等）。

    3. 排除不需要的传递依赖：通过 标签，你可以集中管理哪些传递依赖应该被排除。

    4. 简化依赖声明：在子模块中，你只需要指定依赖的 artifactId 和 groupId，而不需要指定版本号或其他信息，因为它们会继承自父项目中的 dependencyManagement。

    type属性

      type 属性用于指定依赖的类型。默认情况下，这个值是 jar，意味着依赖是一个Java ARchive文件。其他可能的类型包括：

    • pom：Project Object Model 文件。这种类型通常用于从其他 POM 文件中导入配置。
    • war：Web Application Archive 文件，用于Java web应用程序。
    • ear：Enterprise Archive 文件，用于Java EE应用程序。
    • ejb：Enterprise JavaBeans Archive 文件。
    • rar：Resource Adapter Archive 文件，用于Java EE连接资源。
    • par：Persistence Archive 文件，用于持久化模块。
    • 自定义类型：也可以定义自己的类型。

    Scope属性

      scope 用于控制依赖的可见性和传递性。常见的范围有 compile, provided, runtime, test, system。

    • compile：默认范围，依赖在所有的生命周期阶段都可用。
    • provided：假定 JDK 或者容器已提供该依赖，仅用于编译和测试，不会打包。
    • runtime：不需要用于编译，但是需要在运行时。
    • test：只在测试阶段使用。
    • system：类似于 provided，但你需要显式地提供依赖的路径。

    二、创建子项目

    以nacos为例，创建子项目。

    1. 创建order-nacos

    1. 新建模块

    2.模块设置

    3.依赖选择

            后面还需要手动更改pom,所以直接创建即可。

     Idea中模块不高亮问题

     原因：曾经创建过类似的名称的模块，然后删除了,所以被maven给排除了。

    解决办法：

    1. 打开设置
    2. 构建、执行、部署
    3. 构建工具
    4. Maven
    5. 已忽略文件
    6. 取消勾选模块后点击应用即可

    4. 设置模块pom

               这里的parent设置为父项目的工件信息，然后导入nacos的依赖，因为父项目中集中管理了版本，所以不需要显示设置版本。

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <modelVersion>4.0.0modelVersion>
    5.     <parent>
    6.         <groupId>com.xixijungroupId>
    7.         <artifactId>spring-cloud-blogartifactId>
    8.         <version>0.0.1-SNAPSHOTversion>
    9.     parent>
    10.  
    11.     <groupId>com.xixijungroupId>
    12.     <artifactId>order-nacosartifactId>
    13.  
    14.     <dependencies>
    15.         <dependency>
    16.             <groupId>org.springframework.bootgroupId>
    17.             <artifactId>spring-boot-starter-webartifactId>
    18.         dependency>
    19.  
    20.         <dependency>
    21.             <groupId>com.alibaba.cloudgroupId>
    22.             <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
    23.         dependency>
    24.     dependencies>
    25.  
    26.     <properties>
    27.         <maven.compiler.source>8maven.compiler.source>
    28.         <maven.compiler.target>8maven.compiler.target>
    29.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    30.     properties>
    31.  
    32. project>

       父项目中引入模块，刷新模块即可：

    5. 填充代码

    （1）项目结构

    （2）OrderController.java

    1. package com.xixijun.order.controller;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5. import org.springframework.web.bind.annotation.RestController;
    6. import org.springframework.web.client.RestTemplate;
    7.  
    8. @RestController
    9. @RequestMapping("/order")
    10. public class OrderController {
    11.  
    12.     @Autowired
    13.     private RestTemplate restTemplate;
    14.  
    15.     @RequestMapping("/add")
    16.     public String add(){
    17.         System.out.println("下单成功！");
    18.         String msg = restTemplate.getForObject("http://stock-service/stock/reduct", String.class);
    19.         return "hello world = " + msg;
    20.     }
    21. }

     (3) OrderApplication.java

    1. package com.xixijun.order;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5. import org.springframework.boot.web.client.RestTemplateBuilder;
    6. import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    7. import org.springframework.context.annotation.Bean;
    8. import org.springframework.web.client.RestTemplate;
    9.  
    10. @SpringBootApplication
    11. public class OrderApplication {
    12.     public static void main(String[] args) {
    13.         SpringApplication.run(OrderApplication.class);
    14.     }
    15.  
    16.     /**
    17.      * 需要家LoadBalanced注解，加载负载均衡器，否则会报错
    18.      * @param builder
    19.      * @return
    20.      */
    21.     @Bean
    22.     @LoadBalanced
    23.     public RestTemplate restTemplate(RestTemplateBuilder builder){
    24.         RestTemplate restTemplate = builder.build();
    25.         return restTemplate;
    26.  
    27.     }
    28. }

    (4) application.yml

    1. server:
    2.   port: 8020
    3.   #应用名称
    4. spring:
    5.   application:
    6.     name: order-service
    7.   cloud:
    8.     nacos:
    9.       server-addr: localhost:8848
    10.       discovery:
    11.         username: nacos
    12.         password: nacos
    13.         namespace: public

    2. 创建stock-nacos

            创建步骤同order-nacos一致，更换名称即可。

    1. 填充代码

    （1）项目结构

    （2）StockController.java

    1. package com.xixijun.stock.controller;
    2.  
    3. import org.springframework.beans.factory.annotation.Value;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5. import org.springframework.web.bind.annotation.RestController;
    6. import org.springframework.web.client.RestTemplate;
    7.  
    8. @RestController
    9. @RequestMapping("/stock")
    10. public class StockController {
    11.  
    12.     @Value("${server.port}")
    13.     String port;
    14.  
    15.     @RequestMapping("/reduct")
    16.     public String reduct(){
    17.         System.out.println("扣减库存！");
    18.         return "扣减库存！ port = " + port;
    19.     }
    20. }

    因为stock-nacos没有调用服务，所以没有配置restTemplate。

    （3）application.yml

    1. server:
    2.   port: 8021
    3.  
    4.   #应用名称
    5. spring:
    6.   application:
    7.     name: stock-service
    8.   cloud:
    9.     nacos:
    10.       server-addr: localhost:8848
    11.       discovery:
    12.         username: nacos
    13.         password: nacos
    14.         namespace: public

    三、配置Nacos

            nacos配置，可以选择多种方式安装，这里快速上手选择使用window单机版。

    1. 选择版本

    在本文第一章创建父项目的第二小节设置项目版本时，我们引入了项目的版本，其中指定了适配的组件版本，因为我选择的是2.2.6.RELESE版本，所以对应的nacos版本选择1.4.2。

    2. 下载nacos

    (1)下载地址

    Release 1.4.2 (Apr 29th, 2021) · alibaba/nacos · GitHuban easy-to-use dynamic service discovery, configuration and service management platform for building cloud native applications. - Release 1.4.2 (Apr 29th, 2021) · alibaba/nacosicon-default.png?t=N7T8https://github.com/alibaba/nacos/releases/tag/1.4.2(2)下滑到尾部点击下载zip文件

    （3）解压后文件内容

    （4）修改配置

    进入bin目录，修改startup.cmd.将下面的cluster（集群模式），修改为standalone（单机模式）。保存后退出。

    （5）输入cmd,回车

    （6）输入startup.cmd

    出现successfully则说明运行成功，如下所示：

    （7）客户端界面访问

    网址：http://localhost:8848/nacos/icon-default.png?t=N7T8http://localhost:8848/nacos/#/serviceManagement?dataId=&group=&appName=&namespace=&pageSize=&pageNo=默认账号：nacos

    默认密码：nacos

    简单介绍一下，当服务模块启动后，注册中心就会出现启动的服务，如果服务模块没有配置正确，就不会被加载进来。查看地址：服务管理\服务列表。

    四、启动项目

    1. 启动 OrderApplication 和 StockApplication

    统一管理面板

     如下图所示，可以查看统一管理面板，第一次进入可能没有，需要点击加号\设置运行配置类型\选择Spring Boot选项即可。

    2. 查看服务注册中心

            如下所示，服务都正确加载，项目是可以的。

    3. 访问地址项目功能

    网址：http://localhost:8020/order/add

            至此，一个快速应用springcloudAlibaba的项目搭建完毕，恭喜道友在学习之路上更进一步。这学习大道茫茫，然而你我都是这条路上的苦行僧，在此留下心得，祝你我都能修的圆满。咱们下一个路口（BUG）见！

  • 相关阅读:
    基于SpringBoot的时间管理系统
    【RocketMQ】消息的消费
    481. 神奇字符串
    数据湖在爱奇艺数据中台的应用
    镜像永久挂载
    pyqt5 处理传入 接受信号练习
    算法训练.
    C语言程序编译全流程，从源代码到二进制
    orm双下滑线
    pytorch初学笔记（一）：如何加载数据和Dataset实战
  • 原文地址：https://blog.csdn.net/qq_47959003/article/details/134043725