搭建一个完整的微服务项目

蔚落 2023-10-01 19:48 87阅读 0赞

一.项目技术架构

1.技术栈

前台技术
Node.js、Npm、Vue.js、WebPack、Vue Cli、Element UI
后台架构
微服务架构：按照功能拆分N多个服务，每个服务可以独立技术选型,独立开发,独立部署,独立运维.，单个服务使用基于ssm的springboot，服务间通过spring cloud协调。

2.后端项目微服务原型搭建

2.1 项目基本模块搭建

  1. hrm-parent
  2. hrm-basic-parent        //项目基本模块
  3.     hrm-basic-utils        //公共工具模块
  4.     hrm-basic-common    //公共代码模块
  6. hrm-support-parent        //springcloud微服务支持模块
  7.     hrm-eureka-server-1010    
  8.     hrm-gateway-zuul-1020
  9.     hrm-config-server-1030
  11. hrm-system-parent    
  12.     hrm-systemmanage-common        //针对系统管理服务公共代码如：domain,query
  13.     hrm-systemmanage-service-2010    //针对于系统管理的微服务
2.1.1 hrm-parent的搭建
  1. Maven结构
  2. 先在顶层父模块进行设置管理依赖包和版本号以及一些公共的jar包。
  3. <parent>
  4.     <groupId>org.springframework.boot</groupId>
  5.     <artifactId>spring-boot-starter-parent</artifactId>
  6.     <version>2.0.5.RELEASE</version>
  7. </parent>
  9. <properties>
  10.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  11.     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  12.     <java.version>1.8</java.version>
  13.     <spring-cloud.version>Finchley.SR1</spring-cloud.version>
  14. </properties>
  16. <!--所有子模块一定要用到的公共的jar包-->
  17. <dependencies>
  18.     <dependency>
  19.         <groupId>junit</groupId>
  20.         <artifactId>junit</artifactId>
  21.         <version>4.12</version>
  22.     </dependency>
  23. </dependencies>
  25. <dependencyManagement>
  26.     <dependencies>
  27.         <dependency>
  28.             <!--springcloud版本管理，springcloud相关模块引入是就不需要制定版本了-->
  29.             <groupId>org.springframework.cloud</groupId>
  30.             <artifactId>spring-cloud-dependencies</artifactId>
  31.             <version>${spring-cloud.version}</version>
  32.             <type>pom</type>
  33.             <scope>import</scope>
  34.         </dependency>
  35.     </dependencies>
  36. </dependencyManagement>
  37. SpringCloud组件之五大神兽：
  38. 服务注册发现——Netflix Eureka ：  帮我们服务的通信地址的
  39. 客服端负载均衡——Netflix Ribbon\Feign ： 解决网络通信的
  40. 断路器——Netflix Hystrix ：解决微服务故障的
  41. 服务网关——Netflix Zuul ：微服务的大门(安保部门)
  42. 分布式配置——Spring Cloud Config ：统一管理微服务的配置
2.1.2.Eureka注册中心

Eureka是netflix的一个子模块，也是核心模块之一，Eureka是一个基于REST的服务，用于定位服务，以实现云端中间层服务发现和故障转移。服务注册与发现对于微服务架构来说是非常重要的，有了服务发现和注册，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务，而不需要修改服务调用的配置文件了，功能类似于dubbo的注册中心，比如zookeeper。

2.1.2.1创建项目

在hrm-parent里面的hrm-support-parent进行模块化搭建注册中心
必须模块化搭建，依赖父项目
在注册中心的pom.xml导包

  1. <!--Eureka服务端支持-->
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  5.         </dependency>

配置yml

  1. server:
  2.   port: 1010
  3. eureka: #Eureka的配置
  4.   instance:
  5.     hostname: localhost #主机
  6.   client: #对Eureka客户端配置
  7.     registerWithEureka: false #注册中心自己 ， 不准向注册中心自己注册
  8.     fetchRegistry: false #注册中心不需要 获取服务的通信地址清单
  9.     serviceUrl: #注册中心 服务的注册地址
  10.       #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  11.       defaultZone: http://localhost:1010/eureka/

在配置类上写上相应注解之后main启动

  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. public class EurekaServerApplication1010 {
  5.     public static void main(String[] args) {
  7.         SpringApplication.run(EurekaServerApplication1010.class);
  8.     }
  9. }

看到这个界面代表注册中心启动成功

2.1.3.config-server

创建网关项目
导包

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  5.         </dependency>
  6.         <!--  集成Web的jar包-->
  7.         <dependency>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-web</artifactId>
  10.         </dependency>
  11.         <dependency>
  12.             <groupId>org.springframework.cloud</groupId>
  13.             <artifactId>spring-cloud-config-server</artifactId>
  14.         </dependency>
  15.     </dependencies>

配置yml文件

  1. eureka:
  2.   client:
  3.     serviceUrl:
  4.       defaultZone: http://localhost:1010/eureka/ #注册中心服务端的注册地址
  5.   instance:
  6.     prefer-ip-address: true #使用ip进行注册
  7.     instance-id: config-server:1030  #服务注册到注册中心的id
  8. server:
  9.   port: 1030
  10. #应用的名字
  11. spring:
  12.   application:
  13.     name: config-server
  14.   #码云配置
  15.   cloud:
  16.     config:
  17.       server:
  18.         git:
  19.           uri: https://gitee.com/lxx/xx.git  #你的仓库地址（gtihub、gtilab、码云）
  20.           username: xx@qq.com  #你的仓库的账户
  21.           password: xxx #你账户的密码
  22.           search-paths: hrm-parent/configfiles #从git 仓库的哪个目录找配置文件

配置类打上注解

  1. @SpringBootApplication
  2. @EnableConfigServer
  3. public class ConfigServerApplication1030 {
  5.     public static void main(String[] args) {
  7.         SpringApplication.run(ConfigServerApplication1030.class);
  8.     }
  9. }

启动之后测试
http://localhost:1030/application-zuul-dev.yml 能读取配置文件，配置中心就ok了

2.1.4.Zuul GateWay

创建项目
导包

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.cloud</groupId>
  8.             <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
  9.         </dependency>
  10.         <dependency>
  11.             <groupId>org.springframework.boot</groupId>
  12.             <artifactId>spring-boot-starter-web</artifactId>
  13.         </dependency>
  14.         <dependency>
  15.             <groupId>org.springframework.cloud</groupId>
  16.             <artifactId>spring-cloud-starter-config</artifactId>
  17.         </dependency>
  18.     </dependencies>

配置application-zuul-dev.yml文件，上传你的仓库。

  1. server:
  2.   port: 1020
  3. #应用的名字
  4. spring:
  5.   application:
  6.     name: zuul-gateway
  7. zuul:
  8.   ignored-services: "*"   #禁止使用服务名字进行访问
  9.   prefix: "/hrm" #统一的前缀
  10.   routes: #配置路由，指定服务的访问路径
  11.     pay-server: "/pay/**"
  12.     course-server: "/course/**"
  13.     system-server: "/system/**"
  14.     redis-server: "/redis/**"
  15. ribbon:
  16.   ConnectTimeout: 250 # 连接超时时间(ms)
  17.   ReadTimeout: 2000 # 通信超时时间(ms)
  18.   OkToRetryOnAllOperations: true # 是否对所有操作重试
  19.   MaxAutoRetriesNextServer: 2 # 同一服务不同实例的重试次数
  20.   MaxAutoRetries: 1 # 同一实例的重试次数
  21. hystrix:
  22.   command:
  23.     default:
  24.       execution:
  25.         isolation:
  26.           thread:
  27.             timeoutInMillisecond: 3000 # 熔断超时时长：3000ms

配置bootstrap.yml文件

  1. spring:
  2.   cloud:
  3.     config:
  4.       uri: http://localhost:1030
  5.       name:  application-zuul
  6.       profile: dev    #环境  组成完整的文件名

在配置类配置

  1. @SpringBootApplication
  2. @EnableZuulProxy
  3. public class ZuulServerApplication1020 {
  5.     public static void main(String[] args) {
  7.         SpringApplication.run(ZuulServerApplication1020.class);
  8.     }
  9. }

启动之后能从你的仓库拿到你配置文件启动就ok了（如果报错，例如端口8080或者其他都是没有从你仓库拿到你的配置文件）。

2.1.5 system-2010（步骤同上，差不多）

创建项目
导包

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.boot</groupId>
  8.             <artifactId>spring-boot-starter-web</artifactId>
  9.         </dependency>
  10.         <dependency>
  11.             <groupId>org.springframework.cloud</groupId>
  12.             <artifactId>spring-cloud-starter-config</artifactId>
  13.         </dependency>
  14.     </dependencies>

在application-system-dev.yml配置之后上传你的仓库

  1. eureka:
  2.   client:
  3.     serviceUrl:
  4.       defaultZone: http://localhost:1010/eureka/ #注册中心服务端的注册地址
  5.   instance:
  6.     prefer-ip-address: true #使用ip进行注册
  7.     instance-id: system-server:2010  #服务注册到注册中心的id
  8. server:
  9.   port: 2010
  10. #应用的名字
  11. spring:
  12.   application:
  13.     name: system-server

配置bootstrap.yml文件

  1. spring:
  2.   cloud:
  3.     config:
  4.       uri: http://localhost:1030
  5.       name:  application-system
  6.       profile: dev    #环境  组成完整的文件名

在配置类打上注解并启动，启动成功就OK

  1. @SpringBootApplication
  2. public class SystemServerApplication2010 {
  4.     public static void main(String[] args) {
  6.         SpringApplication.run(SystemServerApplication2010.class);
  7.     }
  8. }

在hrm-basic-parent里面创建hrm-code-generate（代码生成）
创建项目
导包

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>com.baomidou</groupId>
  4.             <artifactId>mybatis-plus-boot-starter</artifactId>
  5.         </dependency>
  6.         <!--模板引擎-->
  7.         <dependency>
  8.             <groupId>org.apache.velocity</groupId>
  9.             <artifactId>velocity-engine-core</artifactId>
  10.             <version>2.0</version>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>mysql</groupId>
  14.             <artifactId>mysql-connector-java</artifactId>
  15.         </dependency>
  16.     </dependencies>

创建代码生成的类

  1. package com.tys.hrm;
  3. import com.baomidou.mybatisplus.generator.AutoGenerator;
  4. import com.baomidou.mybatisplus.generator.InjectionConfig;
  5. import com.baomidou.mybatisplus.generator.config.*;
  6. import com.baomidou.mybatisplus.generator.config.converts.MySqlTypeConvert;
  7. import com.baomidou.mybatisplus.generator.config.po.TableInfo;
  8. import com.baomidou.mybatisplus.generator.config.rules.DbType;
  9. import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
  11. import java.util.*;
  13. //代码生成的主类
  14. public class GenteratorCode {
  17.     //运行main方法就可以生成代码了
  18.     public static void main(String[] args) throws InterruptedException {
  20.         //用来获取Mybatis-Plus.properties文件的配置信息
  21.         //不要加后缀
  22.         ResourceBundle rb = ResourceBundle.getBundle("mybatiesplus-config-course");
  23.         AutoGenerator mpg = new AutoGenerator();
  24.         // 全局配置
  25.         GlobalConfig gc = new GlobalConfig();
  26.         gc.setOutputDir(rb.getString("OutputDir"));
  27.         gc.setFileOverride(true);
  28.         gc.setActiveRecord(true);// 开启 activeRecord 模式
  29.         gc.setEnableCache(false);// XML 二级缓存
  30.         gc.setBaseResultMap(true);// XML ResultMap
  31.         gc.setBaseColumnList(false);// XML columList
  32.         gc.setAuthor(rb.getString("author"));
  33.         mpg.setGlobalConfig(gc);
  34.         // 数据源配置
  35.         DataSourceConfig dsc = new DataSourceConfig();
  36.         dsc.setDbType(DbType.MYSQL);
  37.         dsc.setTypeConvert(new MySqlTypeConvert());
  38.         dsc.setDriverName("com.mysql.jdbc.Driver");
  39.         dsc.setUsername(rb.getString("jdbc.user"));
  40.         dsc.setPassword(rb.getString("jdbc.pwd"));
  41.         dsc.setUrl(rb.getString("jdbc.url"));
  42.         mpg.setDataSource(dsc);
  43.         // 策略配置
  44.         StrategyConfig strategy = new StrategyConfig();
  45.         strategy.setTablePrefix(new String[] {
  46.      "t_" });// 此处可以修改为您的表前缀
  47.         strategy.setNaming(NamingStrategy.underline_to_camel);// 表名生成策略
  48.         strategy.setInclude(new String[]{
  49.     "t_course_type"}); // 需要生成的表 ：
  50.         mpg.setStrategy(strategy);
  51.         // 包配置
  52.         PackageConfig pc = new PackageConfig();
  53.         pc.setParent(rb.getString("parent")); //基本包 cn.itsource.system
  54.         pc.setController("web.controller");
  55.         pc.setService("service");
  56.         pc.setServiceImpl("service.impl");
  57.         pc.setEntity("domain");
  58.         pc.setMapper("mapper");
  59.         mpg.setPackageInfo(pc);
  61.         // 注入自定义配置，可以在 VM 中使用 cfg.abc 【可无】
  62.         InjectionConfig cfg = new InjectionConfig() {
  64.             @Override
  65.             public void initMap() {
  67.                 Map<String, Object> map = new HashMap<String, Object>();
  68.                 map.put("abc", this.getConfig().getGlobalConfig().getAuthor() + "-rb");
  69.                 this.setMap(map);
  70.             }
  71.         };
  73.         List<FileOutConfig> focList = new ArrayList<FileOutConfig>();
  76.         // 调整 controller 生成目录演示
  77.         focList.add(new FileOutConfig("/templates/controller.java.vm") {
  79.             @Override
  80.             public String outputFile(TableInfo tableInfo) {
  82.                 //controller输出完整路径
  83.                 return rb.getString("OutputDir")+ "/com/tys/hrm/course/web/controller/" + tableInfo.getEntityName() + "Controller.java";
  84.             }
  85.         });
  86.         // 调整 query 生成目录演示
  87.         focList.add(new FileOutConfig("/templates/query.java.vm") {
  89.             @Override
  90.             public String outputFile(TableInfo tableInfo) {
  92.                 //query输出完整路径
  93.                 return rb.getString("OutputDirBase")+ "/com/tys/hrm/course/query/" + tableInfo.getEntityName() + "Query.java";
  94.             }
  95.         });
  96.         // 调整 domain 生成目录演示 ， 你的domain到底要输出到哪儿？？？？，你的domain怎么输出
  97.         focList.add(new FileOutConfig("/templates/entity.java.vm") {
  99.             @Override
  100.             public String outputFile(TableInfo tableInfo) {
  102.                 //domain输出完整路径
  103.                 return rb.getString("OutputDirBase")+ "/com/tys/hrm/course/domain/" + tableInfo.getEntityName() + ".java";
  104.             }
  105.         });
  107.         // 调整 xml 生成目录演示
  108.         focList.add(new FileOutConfig("/templates/mapper.xml.vm") {
  110.             @Override
  111.             public String outputFile(TableInfo tableInfo) {
  113.                 return rb.getString("OutputDirXml")+ "/com/tys/course/mapper/" + tableInfo.getEntityName() + "Mapper.xml";
  114.             }
  115.         });
  116.         cfg.setFileOutConfigList(focList);
  117.         mpg.setCfg(cfg);
  119.         // 自定义模板配置，可以 copy 源码 mybatis-plus/src/main/resources/templates 下面内容修改，
  120.         // 放置自己项目的 src/main/resources/templates 目录下, 默认名称一下可以不配置，也可以自定义模板名称
  121.         TemplateConfig tc = new TemplateConfig();
  122.         tc.setService("/templates/service.java.vm");
  123.         tc.setServiceImpl("/templates/serviceImpl.java.vm");
  124.         tc.setEntity(null);
  125.         tc.setMapper("/templates/mapper.java.vm");
  126.         tc.setController(null);
  127.         tc.setXml(null);
  128.         // 如上任何一个模块如果设置 空 OR Null 将不生成该模块。
  129.         mpg.setTemplate(tc);
  130.         // 执行生成
  131.         mpg.execute();
  132.     }
  133. }

创建mybatiesplus-config-course.properties文件

  1. #此处为本项目src所在路径（代码生成器输出路径）,注意一定是当前项目所在的目录哟
  2. #mapper,servier,controller输出目录
  3. OutputDir=E:/IdeaProjects/hrm/hrm-parent/hrm-course-parent/hrm-course-service-2020/src/main/java
  5. #mapper.xml SQL映射文件目录
  6. OutputDirXml=E:/IdeaProjects/hrm/hrm-parent/hrm-course-parent/hrm-course-service-2020/src/main/resources
  8. #domain,query输出的目录
  9. OutputDirBase=E:/IdeaProjects/hrm/hrm-parent/hrm-course-parent/hrm-course-common/src/main/java
  10. #设置作者
  11. author=tys
  12. #自定义包路径
  13. parent=com.tys.hrm.course
  14. #数据库连接信息
  15. jdbc.driver=com.mysql.jdbc.Driver
  16. jdbc.url=jdbc:mysql:///hrm-course
  17. jdbc.user=root
  18. jdbc.pwd=123456

然后去system模块添加依赖包
在hrm-system-common导包

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>com.tys</groupId>
  4.             <artifactId>hrm-basic-common</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>com.baomidou</groupId>
  8.             <artifactId>mybatis-plus-boot-starter</artifactId>
  9.             <version>2.2.0</version>
  10.         </dependency>
  11.     </dependencies>

因为生成的mapper、service、controller需连接数据库，所以hrm-system-service-2010也要导包

  1. <dependency>
  2.             <groupId>com.tys</groupId>
  3.             <artifactId>hrm-system-common</artifactId>
  4.         </dependency>
  5.         <dependency>
  6.             <groupId>mysql</groupId>
  7.             <artifactId>mysql-connector-java</artifactId>
  8.         </dependency>
  9.         <dependency>
  10.             <groupId>com.alibaba</groupId>
  11.             <artifactId>druid</artifactId>
  12.             <version>1.1.11</version>
  13.         </dependency>
  14.         <dependency>
  15.             <groupId>com.tys</groupId>
  16.             <artifactId>hrm-basic-utils</artifactId>
  17.         </dependency>

让后直接点代码生成类的main方法自动生成代码，这样，domain、query、mapper、service、controller都创建完成了

2.1.6 course-server（步骤同system，差不多）

创建完成之后，用代码生成器生成course的所有。

2.2.接口文档Swagger

在创建的所有代码生成的服务（system、course）导包 和网关zuul服务也到入swagger包

  1. <!--引入swagger支持-->
  2.     <dependency>
  3.         <groupId>io.springfox</groupId>
  4.         <artifactId>springfox-swagger2</artifactId>
  5.         <version>2.9.2</version>
  6.     </dependency>
  7.     <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
  8.     <dependency>
  9.         <groupId>io.springfox</groupId>
  10.         <artifactId>springfox-swagger-ui</artifactId>
  11.         <version>2.9.2</version>
  12.     </dependency>

在这些包里面创建swagger的类创建接口文档

  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import springfox.documentation.builders.ApiInfoBuilder;
  4. import springfox.documentation.builders.PathSelectors;
  5. import springfox.documentation.builders.RequestHandlerSelectors;
  6. import springfox.documentation.service.ApiInfo;
  7. import springfox.documentation.service.Contact;
  8. import springfox.documentation.spi.DocumentationType;
  9. import springfox.documentation.spring.web.plugins.Docket;
  10. import springfox.documentation.swagger2.annotations.EnableSwagger2;
  12. @Configuration
  13. @EnableSwagger2
  14. public class Swagger2 {
  16.     @Bean
  17.     public Docket createRestApi() {
  19.         return new Docket(DocumentationType.SWAGGER_2)
  20.                 .apiInfo(apiInfo())
  21.                 .select()
  22.                 //对外暴露服务的包,以controller的方式暴露,所以就是controller的包.
  23.                 .apis(RequestHandlerSelectors.basePackage("com.tys.hrm.course.web.controller"))
  24.                 .paths(PathSelectors.any())
  25.                 .build();
  26.     }
  27.     private ApiInfo apiInfo() {
  29.         return new ApiInfoBuilder()
  30.                 .title("平台服务api")
  31.                 .description("平台服务接口文档说明")
  32.                 .contact(new Contact("yhptest", "", "yhp@itsource.cn"))
  33.                 .version("1.0")
  34.                 .build();
  35.     }
  36. }

然后重新启动，访问http://localhost:2020/swagger-ui.html、http://localhost:2010/swagger-ui.html
在zuul创建一个配置config包，创建swagger类

  1. package com.tys.hrm.config;
  3. import org.springframework.context.annotation.Primary;
  4. import org.springframework.stereotype.Component;
  5. import springfox.documentation.swagger.web.SwaggerResource;
  6. import springfox.documentation.swagger.web.SwaggerResourcesProvider;
  8. import java.util.ArrayList;
  9. import java.util.List;
  11. @Component
  12. @Primary
  13. public class DocumentationConfig implements SwaggerResourcesProvider {
  15.     @Override
  16.     public List<SwaggerResource> get() {
  18.         List resources = new ArrayList<>();
  19.         resources.add(swaggerResource("系统管理", "/hrm/system/v2/api-docs", "2.0"));
  20.         resources.add(swaggerResource("课程管理", "/hrm/course/v2/api-docs", "2.0"));
  21.         return resources;
  22.     }
  23.     private SwaggerResource swaggerResource(String name, String location, String version) {
  25.         SwaggerResource swaggerResource = new SwaggerResource();
  26.         swaggerResource.setName(name);
  27.         swaggerResource.setLocation(location);
  28.         swaggerResource.setSwaggerVersion(version);
  29.         return swaggerResource;
  30.     }
  31. }
  33. package com.tys.hrm.config;
  35. import org.springframework.context.annotation.Bean;
  36. import org.springframework.context.annotation.Configuration;
  37. import springfox.documentation.builders.ApiInfoBuilder;
  38. import springfox.documentation.service.ApiInfo;
  39. import springfox.documentation.service.Contact;
  40. import springfox.documentation.spi.DocumentationType;
  41. import springfox.documentation.spring.web.plugins.Docket;
  42. import springfox.documentation.swagger2.annotations.EnableSwagger2;
  44. @Configuration
  45. @EnableSwagger2
  46. public class SwaggerConfig {
  48.     @Bean
  49.     public Docket createRestApi() {
  51.         return new Docket(DocumentationType.SWAGGER_2)
  52.                 .apiInfo(apiInfo());
  53.     }
  54.     private ApiInfo apiInfo() {
  56.         return new ApiInfoBuilder()
  57.                 .title("资源管理系统")
  58.                 .description("资源管理系统接口文档说明")
  59.                 .termsOfServiceUrl("http://localhost:1020")
  60.                 .contact(new Contact("yphtest", "", "yhp@itsoruce.cn"))
  61.                 .version("1.0")
  62.                 .build();
  63.     }
  64. }

然后重启zuul服务，访问http://localhost:1020/swagger-ui.html

2.3.elementui+vue

前端启动 npm run dev
因为前后端分离，访问后台会出现跨域问题，跨越配置-在zuul进行配置(所有前端统一入口)。

  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.web.cors.CorsConfiguration;
  4. import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
  5. import org.springframework.web.filter.CorsFilter;
  7. @Configuration
  8. public class GlobalCorsConfig {
  10.     @Bean
  11.     public CorsFilter corsFilter() {
  13.         //1.添加CORS配置信息
  14.         CorsConfiguration config = new CorsConfiguration();
  15.         //1) 允许的域,不要写*，否则cookie就无法使用了
  16.         config.addAllowedOrigin("http://127.0.0.1:6001");
  17. config.addAllowedOrigin("http://localhost:6001");
  18.         //2) 是否发送Cookie信息
  19.         config.setAllowCredentials(true);
  20.         //3) 允许的请求方式
  21.         config.addAllowedMethod("OPTIONS");
  22.         config.addAllowedMethod("HEAD");
  23.         config.addAllowedMethod("GET");
  24.         config.addAllowedMethod("PUT");
  25.         config.addAllowedMethod("POST");
  26.         config.addAllowedMethod("DELETE");
  27.         config.addAllowedMethod("PATCH");
  28.         // 4）允许的头信息
  29.         config.addAllowedHeader("*");
  30.         //2.添加映射路径，我们拦截一切请求
  31.         UrlBasedCorsConfigurationSource configSource = new
  32.                 UrlBasedCorsConfigurationSource();
  33.         configSource.registerCorsConfiguration("/**", config);
  34.         //3.返回新的CorsFilter.
  35.         return new CorsFilter(configSource);
  36.     }
  37. }

配置之后重启zuul服务。刷新前端就能访问了。

2.4.redis+feign

在这里插入图片描述

2.4.1.搭建项目结构
  1. hrm-redis-parent
  2.     hrm-redis-client
  3.     hrm-redis-service-2030
2.4.1.1 redis

搭建 hrm-redis-service-2030 导入依赖

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.boot</groupId>
  8.             <artifactId>spring-boot-starter-web</artifactId>
  9.         </dependency>
  10.         <dependency>
  11.             <groupId>org.springframework.cloud</groupId>
  12.             <artifactId>spring-cloud-starter-config</artifactId>
  13.         </dependency>
  14.         <dependency>
  15.             <groupId>redis.clients</groupId>
  16.             <artifactId>jedis</artifactId>
  17.         </dependency>
  18.         <dependency>
  19.             <groupId>com.tys</groupId>
  20.             <artifactId>hrm-basic-utils</artifactId>
  21.         </dependency>
  22.     </dependencies>

准备Redis工具类

  1. 配置文件 redis.properties
  2. redis.host=127.0.0.1
  3. redis.port=6379
  4. redis.password=123456
  5. redis.timeout=5000

RedisUtil

  1. import redis.clients.jedis.Jedis;
  2. import redis.clients.jedis.JedisPool;
  3. import redis.clients.jedis.JedisPoolConfig;
  5. import java.io.IOException;
  6. import java.util.Properties;
  8. /**
  9.  * 获取连接池对象
  10.  */
  11. public enum RedisUtils {
  13.     INSTANCE;
  14.     static JedisPool jedisPool = null;
  15.     static {
  17.         //1 创建连接池配置对象
  18.         JedisPoolConfig config = new JedisPoolConfig();
  19.         //2 进行配置-四个配置
  20.         config.setMaxIdle(1);//最小连接数
  21.         config.setMaxTotal(11);//最大连接数
  22.         config.setMaxWaitMillis(10 * 1000L);//最长等待时间
  23.         config.setTestOnBorrow(true);//测试连接时是否畅通
  24.         //3 通过配置对象创建连接池对象
  25.         Properties properties = null;
  26.         try {
  28.             properties = new Properties();            properties.load(RedisUtils.class.getClassLoader().getResourceAsStream("redis.properties"));
  29.         } catch (IOException e) {
  31.             e.printStackTrace();
  32.         }
  33.         String host = properties.getProperty("redis.host");
  34.         String port = properties.getProperty("redis.port");
  35.         String password = properties.getProperty("redis.password");
  36.         String timeout = properties.getProperty("redis.timeout");
  37.         jedisPool = new JedisPool(config, host, Integer.valueOf(port),Integer.valueOf(timeout), password);
  38.     }
  39.     //获取连接
  40.     public Jedis getSource() {
  42.         return jedisPool.getResource();
  43.     }
  44.     //关闭资源
  45.     public void closeSource(Jedis jedis) {
  47.         if (jedis != null) {
  49.             jedis.close();
  50.         }
  51.     }
  52.     /**
  53.      * 设置字符值
  54.      *
  55.      * @param key
  56.      * @param value
  57.      */
  58.     public void set(String key, String value) {
  60.         Jedis jedis = getSource();
  61.         jedis.set(key, value);
  62.         closeSource(jedis);
  63.     }
  64.     /**
  65.      * 设置
  66.      * @param key
  67.      * @param value
  68.      */
  69.     public void set(byte[] key, byte[] value) {
  71.         Jedis jedis = getSource();
  72.         jedis.set(key, value);
  73.         closeSource(jedis);
  74.     }
  75.     /**
  76.      *
  77.      * @param key
  78.      * @return
  79.      */
  80.     public byte[]  get(byte[] key) {
  82.         Jedis jedis = getSource();
  83.         try {
  85.             return jedis.get(key);
  86.         } catch (Exception e) {
  88.             e.printStackTrace();
  89.         } finally {
  91.             closeSource(jedis);
  92.         }
  93.         return null;
  94.     }
  95.     /**
  96.      * 设置字符值
  97.      *
  98.      * @param key
  99.      */
  100.     public String get(String key) {
  102.         Jedis jedis = getSource();
  103.         try {
  105.             return jedis.get(key);
  106.         } catch (Exception e) {
  108.             e.printStackTrace();
  109.         } finally {
  111.             closeSource(jedis);
  112.         }
  113.         return null;
  114.     }
  115. }

编写RedisController

  1. /**
  2.  * redis的接口
  3.  */
  4. @RestController
  5. @RequestMapping("/redis")
  6. public class RedisController {
  9.     @GetMapping("/get/{key}")
  10.     public AjaxResult get(@PathVariable("key")String key){
  12.         String result = RedisUtils.INSTANCE.get(key);
  13.         return AjaxResult.me().setResultObj(result);
  14.     }
  15.     @PostMapping("/set")
  16.     public AjaxResult set(@RequestParam("key")String key,@RequestParam("value")String value){
  18.         RedisUtils.INSTANCE.set(key,value);
  19.         return AjaxResult.me();
  20.     }
  21.     @PostMapping("/setex")
  22.     public AjaxResult setex(@RequestParam("key")String key,
  23.                           @RequestParam("value")String value,
  24.                           @RequestParam("seconds")int seconds){
  26.         RedisUtils.INSTANCE.setex(key,value,seconds);
  27.         return AjaxResult.me();
  28.     }
  29. }

配置application-redis-dev.yml，配置成功上传仓库

  1. eureka:
  2.   client:
  3.     serviceUrl:
  4.       defaultZone: http://localhost:1010/eureka/ #注册中心地址 
  5.   instance:
  6.     prefer-ip-address: true #使用ip地址注册
  7.     instance-id: redis-service  #指定服务的id
  8. server:
  9.   port: 2030
  10. spring:
  11.   application:
  12.     name: redis-service

再配合bootstrap.yml

  1. spring:
  2.   cloud:
  3.     config:
  4.       uri: http://localhost:1030
  5.       name:  application-redis
  6.       profile: dev    #环境  组成完整的文件名
2.4.1.2 feign

hrm-redis-feign导包

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-openfeign</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>com.tys</groupId>
  8.             <artifactId>hrm-basic-utils</artifactId>
  9.         </dependency>
  10.     </dependencies>

再里面写一个feign接口

  1. //value属性：调用目标服务的服务名
  2. @FeignClient(value = "redis-server")
  3. public interface RedisFeignClient {
  6.     //设置值
  7.     @PostMapping("/redis/set")
  8.     AjaxResult set(@RequestParam("key")String key, @RequestParam("value")String value);
  10.     @GetMapping("/redis/get/{key}")
  11.     AjaxResult get(@PathVariable("key")String key);
  12. }

在需要缓存的地方依赖hrm-redis-feign项目
在这个微服务类开启配置

  1. @SpringBootApplication
  2. @MapperScan("com.tys.hrm.course.mapper")
  3. @EnableTransactionManagement
  4. @EnableFeignClients("com.tys.hrm.feignclients")
  5. public class CourseServerApplication2020 {
  8.     public static void main(String[] args) {
  10.         SpringApplication.run(CourseServerApplication2020.class);
  11.     }
  12.     /**
  13.      * 分页插件
  14.      */
  15.     @Bean
  16.     public PaginationInterceptor paginationInterceptor() {
  18.         return new PaginationInterceptor();
  19.     }
  20. }

修改这个服务的service.iml的增删改查方法，添加缓存

  1. package com.tys.hrm.course.service.impl;
  3. import com.alibaba.fastjson.JSON;
  4. import com.baomidou.mybatisplus.service.impl.ServiceImpl;
  5. import com.tys.hrm.constants.RedisKeyConstants;
  6. import com.tys.hrm.course.domain.CourseType;
  7. import com.tys.hrm.course.mapper.CourseTypeMapper;
  8. import com.tys.hrm.course.service.ICourseTypeService;
  9. import com.tys.hrm.feignclients.RedisFeignClient;
  10. import com.tys.hrm.util.AjaxResult;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.stereotype.Service;
  14. import java.io.Serializable;
  15. import java.util.ArrayList;
  16. import java.util.List;
  18. /**
  19.  * <p>
  20.  * 课程目录 服务实现类
  21.  * </p>
  22.  */
  23. @Service
  24. public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {
  27.     @Autowired
  28.     private RedisFeignClient redisFeignClient;
  30.     //重置Redis中的课程分类
  31.     private  List<CourseType> resetRedisForCourseType(){
  33.         // 如果Reids没有就从Mysql中查
  34.         List<CourseType> courseTypes = baseMapper.selectList(null);
  35.         //  Mysql查到之后同步一份到Redis
  36.         redisFeignClient.set(RedisKeyConstants.COURSE_TYPE, JSON.toJSONString(courseTypes));
  37.         return courseTypes;
  38.     }
  40.     @Override
  41.     public boolean insert(CourseType entity) {
  44.         boolean insertSucess = super.insert(entity);
  45.         resetRedisForCourseType();
  46.         return insertSucess;
  47.     }
  49.     @Override
  50.     public boolean deleteById(Serializable id) {
  53.         boolean deleteSucess = super.deleteById(id);
  54.         resetRedisForCourseType();
  55.         return deleteSucess;
  56.     }
  58.     @Override
  59.     public boolean updateById(CourseType entity) {
  62.         boolean updateSuccess = super.updateById(entity);
  63.         resetRedisForCourseType();
  64.         return updateSuccess;
  65.     }
  67.     @Override
  68.     public List<CourseType> treeData() {
  70.         List<CourseType> courseTypes = null;
  71.         // 查询课程分类的时候先查询Redis
  72.         AjaxResult ajaxResult = redisFeignClient.get(RedisKeyConstants.COURSE_TYPE);
  73.         //判断是否有结果
  74.         if(ajaxResult.isSuccess() && null != ajaxResult.getResultObj()){
  76.             //Redis中有数据
  77.             //如果Redis有就直接返回、
  78.             String jsonFromRedis = ajaxResult.getResultObj().toString();
  79.             //存在redis中的数据 ，要不要有层级结构 :放没有处理过的list
  80.             courseTypes = JSON.parseArray(jsonFromRedis , CourseType.class);
  81.         }else{
  83.             courseTypes = resetRedisForCourseType();
  84.         }
  85.         //1.查询所有的课程类型
  86.         //List<CourseType> courseTypes = baseMapper.selectList(null);
  87.         //2.先过滤出一级分类
  88.         //用来封装一级分类，当然每个一级分类的children中有其子分类
  89.         List<CourseType> primaryCourseType = new ArrayList<>();
  90.         for(CourseType courseType : courseTypes){
  92.             //如果pid==0，那么就是一级分类
  93.             if(courseType.getPid().longValue() == 0){
  95.                 primaryCourseType.add(courseType);//1037
  96.             }else{
  98.                 //2.如果不是一级分类，就要知道自己的父分类，装到自己的父分类的 children
  99.                 //courseType :当前分类，根据当前分类的pid 就是父分类的id
  100.                 CourseType currentPrimaryCourseType = null; //1037
  101.                 for(CourseType pcourseType : courseTypes ){
  103.                     if(courseType.getPid().longValue() == pcourseType.getId().longValue()){
  105.                         //如果当前分类（courseType）的pid 和某个分类的id相等，那么这个某个分类就是当前分类的父分类
  106.                         currentPrimaryCourseType = pcourseType;
  107.                         break;
  108.                     }
  109.                 }
  110.                 if(currentPrimaryCourseType != null){
  112.                     //3.如果找到了父分类，就把当前分类加入父分类的children中
  113.                     currentPrimaryCourseType.getChildren().add(courseType);
  114.                 }
  115.             }
  116.         }
  117.         return primaryCourseType;
  118.     }
  119. }

重启这个微服务和redis服务，开启redis

  1. redis-server.exe redis.windows.conf

然后去测试，第一次进数据库查询，并缓存到redis中，第二次查询则直接进缓存，其他操作 增删改 操作之后，进行更新缓存。

在feign接口打上注解，调用托底类

  1. @FeignClient(value = "redis-server",fallbackFactory = RedisFeignFallbackFactory.class)

在feign接口实现方法 重写方法

  1. package com.tys.hrm.fallback;
  3. import com.tys.hrm.feignclients.RedisFeignClient;
  4. import com.tys.hrm.util.AjaxResult;
  5. import feign.hystrix.FallbackFactory;
  6. import org.springframework.stereotype.Component;
  7. @Component
  8. public class RedisFeignFallbackFactory implements FallbackFactory<RedisFeignClient> {
  11.     @Override
  12.     public RedisFeignClient create(Throwable throwable) {
  14.         return new RedisFeignClient() {
  16.             //托底方法
  17.             @Override
  18.             public AjaxResult set(String key, String value) {
  20.                 throwable.printStackTrace();
  21.                 return AjaxResult.me().setSuccess(false).setMessage("Redis服务不可用["+throwable.getMessage()+"]");
  22.             }
  23.             @Override
  24.             public AjaxResult get(String key) {
  26.                 throwable.printStackTrace();
  27.                 return AjaxResult.me().setSuccess(false).setMessage("Redis服务不可用["+throwable.getMessage()+"]");
  28.             }
  29.         };
  30.     }
  31. }
2.4.1.3 fastdfs

导包

  1. <dependencies>
  2.         <dependency>
  3.         <groupId>org.springframework.cloud</groupId>
  4.         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  5.     </dependency>
  6.         <!--  集成Web的jar包-->
  7.         <dependency>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-web</artifactId>
  10.         </dependency>
  12.         <dependency>
  13.             <groupId>org.springframework.cloud</groupId>
  14.             <artifactId>spring-cloud-starter-config</artifactId>
  15.         </dependency>
  17.         <dependency>
  18.             <groupId>com.tys</groupId>
  19.             <artifactId>hrm-basic-utils</artifactId>
  20.         </dependency>
  22.         <!--引入swagger支持-->
  23.         <dependency>
  24.             <groupId>io.springfox</groupId>
  25.             <artifactId>springfox-swagger2</artifactId>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>io.springfox</groupId>
  29.             <artifactId>springfox-swagger-ui</artifactId>
  30.         </dependency>
  32.         <dependency>
  33.             <groupId>org.csource</groupId>
  34.             <artifactId>fastdfs-client-java</artifactId>
  35.             <exclusions>
  36.                 <exclusion>
  37.                     <groupId>org.slf4j</groupId>
  38.                     <artifactId>slf4j-log4j12</artifactId>
  39.                 </exclusion>
  40.             </exclusions>
  41.         </dependency>
  43.         <dependency>
  44.             <groupId>commons-io</groupId>
  45.             <artifactId>commons-io</artifactId>
  46.         </dependency>
  47.     </dependencies>

导入工具类fastdfs

  1. package com.tys.hrm.utils;
  3. import org.csource.common.NameValuePair;
  4. import org.csource.fastdfs.*;
  6. public class FastDfsApiOpr {
  9.     public static String CONF_FILENAME  = FastDfsApiOpr.class.getClassLoader()
  10.             .getResource("fdfs_client.conf").getFile();
  13.     /**
  14.      * 上传文件
  15.      * @param file
  16.      * @param extName
  17.      * @return
  18.      */
  19.     public static  String upload(byte[] file,String extName) {
  22.         try {
  24.             ClientGlobal.init(CONF_FILENAME);
  26.             TrackerClient tracker = new TrackerClient();
  27.             TrackerServer trackerServer = tracker.getTrackerServer();
  28.             //TrackerServer trackerServer = tracker.getConnection();
  29.             StorageServer storageServer = null;
  31.             StorageClient storageClient = new StorageClient(trackerServer, storageServer);
  32.             NameValuePair nvp [] = new NameValuePair[]{
  34.                     new NameValuePair("age", "18"),
  35.                     new NameValuePair("sex", "male")
  36.             };
  37.             String fileIds[] = storageClient.upload_file(file,extName,nvp);
  39.             System.out.println(fileIds.length);
  40.             System.out.println("组名：" + fileIds[0]);
  41.             System.out.println("路径: " + fileIds[1]);
  42.             return  "/"+fileIds[0]+"/"+fileIds[1];
  44.         } catch (Exception e) {
  46.             e.printStackTrace();
  47.             return  null;
  48.         }
  49.     }
  50.     /**
  51.      * 上传文件
  52.      * @param extName
  53.      * @return
  54.      */
  55.     public static  String upload(String path,String extName) {
  58.         try {
  60.             ClientGlobal.init(CONF_FILENAME);
  62.             TrackerClient tracker = new TrackerClient();
  63.             TrackerServer trackerServer = tracker.getTrackerServer();
  64.             //TrackerServer trackerServer = tracker.getConnection();
  65.             StorageServer storageServer = null;
  66.             StorageClient storageClient = new StorageClient(trackerServer, storageServer);
  67.             String fileIds[] = storageClient.upload_file(path, extName,null);
  69.             System.out.println(fileIds.length); 
  70.             System.out.println("组名：" + fileIds[0]); 
  71.             System.out.println("路径: " + fileIds[1]);
  72.             return  "/"+fileIds[0]+"/"+fileIds[1];
  74.         } catch (Exception e) {
  76.             e.printStackTrace();
  77.             return  null;
  78.         }
  79.     }
  81.     /**
  82.      * 下载文件
  83.      * @param groupName
  84.      * @param fileName
  85.      * @return
  86.      */
  87.     public static byte[] download(String groupName,String fileName) {
  89.         try {
  92.             ClientGlobal.init(CONF_FILENAME);
  94.             TrackerClient tracker = new TrackerClient();
  95.             TrackerServer trackerServer = tracker.getTrackerServer();
  96.             //TrackerServer trackerServer = tracker.getConnection();
  97.             StorageServer storageServer = null;
  99.             StorageClient storageClient = new StorageClient(trackerServer, storageServer);
  100.             byte[] b = storageClient.download_file(groupName, fileName);
  101.             return  b;
  102.         } catch (Exception e) {
  104.             e.printStackTrace();
  105.             return  null;
  106.         }
  107.     }
  109.     /**
  110.      * 删除文件
  111.      * @param groupName
  112.      * @param fileName
  113.      */
  114.     public static void delete(String groupName,String fileName){
  116.         try {
  118.             ClientGlobal.init(CONF_FILENAME);
  120.             TrackerClient tracker = new TrackerClient();
  121.             TrackerServer trackerServer = tracker.getTrackerServer();
  122.             //TrackerServer trackerServer = tracker.getConnection();
  123.             StorageServer storageServer = null;
  125.             StorageClient storageClient = new StorageClient(trackerServer,
  126.                     storageServer);
  127.             int i = storageClient.delete_file(groupName,fileName);
  128.             System.out.println( i==0 ? "删除成功" : "删除失败:"+i);
  129.         } catch (Exception e) {
  131.             e.printStackTrace();
  132.             throw  new RuntimeException("删除异常,"+e.getMessage());
  133.         }
  134.     }
  135. }

直接复制swagger
创建web.controller层

  1. package com.tys.hrm.web.controller;
  3. import com.tys.hrm.util.AjaxResult;
  4. import com.tys.hrm.utils.FastDfsApiOpr;
  5. import org.apache.commons.io.FilenameUtils;
  6. import org.springframework.web.bind.annotation.*;
  7. import org.springframework.web.multipart.MultipartFile;
  9. import java.io.IOException;
  11. //文件统一处理
  12. @RestController
  13. @RequestMapping("/fastdfs")
  14. public class FastDfsController {
  17.     //文件上传
  18.     @PostMapping("/upload")
  19.     public AjaxResult upload(MultipartFile file) throws Exception {
  22.         //把文件上传到Fastdfs云服务器
  23.         try {
  25.             //原生的文件名：a.jpg :commons-io
  26.             String extension = FilenameUtils.getExtension(file.getOriginalFilename());
  28.             String filePath = FastDfsApiOpr.upload(file.getBytes() , extension);
  29.             return AjaxResult.me().setResultObj(filePath);
  30.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.             return AjaxResult.me().setSuccess(false).setMessage("文件上传失败");
  34.         }
  35.     }
  37.     @DeleteMapping("/remove")
  38.     public AjaxResult delete(@RequestParam("path") String path) throws Exception{
  40.         try{
  42.             /*把组名前面的/去掉
  43.              * substring(int beginIndex) 返回字符串的子字符串。
  44.              * substring(int beginIndex, int endIndex) beginIndex起始索引(包含)索引从0开始。endIndex结束索引(不包括).
  45.              * indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
  46.              * */
  47.             String pathTmp = path.substring(1);
  48.             //得到groupName
  49.             String groupName =  pathTmp.substring(0, pathTmp.indexOf("/"));
  50.             //得到fileName
  51.             String fileName = pathTmp.substring(pathTmp.indexOf("/")+1);
  52.             System.out.println(groupName);
  53.             System.out.println(fileName);
  54.             FastDfsApiOpr.delete(groupName, fileName);
  55.             return  AjaxResult.me();
  56.         }catch (Exception e){
  58.             e.printStackTrace();
  59.             return AjaxResult.me().setSuccess(false).setResultObj("删除失败！" + e.getMessage());
  60.         }
  61.     }
  62. }

设置fastDFS配置文件(fdfs_client.conf)

  1. connect_timeout = 2
  2. network_timeout = 30
  3. charset = UTF-8
  4. http.tracker_http_port = 80
  5. http.anti_steal_token = no
  6. http.secret_key = FastDFS1234567890
  8. tracker_server=118.25.154.214:22122  #服务器配置了fastDFS的IP
  10. connection_pool.enabled = true
  11. connection_pool.max_count_per_entry = 500
  12. connection_pool.max_idle_time = 3600
  13. connection_pool.max_wait_time_in_ms = 1000

发表评论

表情：
评论列表 （有 0 条评论，87人围观）

还没有评论，来说两句吧...

相关阅读

    相关 如何快速搭建一个微服务架构？

    微服务火了很久，但网上很少有文章能做到成熟地将技术传播出来，同时完美地照顾“初入微服务领域人员”，从 0 开始，采用通俗易懂的语言去讲解微服务架构的系列。所以，我们策划了这篇文

    小灰灰小灰灰/ 0 赞/ 871 阅读

    相关 springcloud微服务-项目搭建

    前言：      乐优商城这个视频还可以，于是拿来练练手，我对着视频搭环境一直在service服务模块卡住了，注册中心和网关可以启动，服务模块却一直启动不了，报各种奇怪的错，

    小灰灰小灰灰/ 0 赞/ 425 阅读