SpringCloud分布式微服务基本构建

lllshixiong

已于 2023-05-18 16:45:00 修改

阅读量356

点赞数

分类专栏：笔记文章标签： java spring boot spring 后端分布式

于 2020-11-16 23:11:59 首次发布

本文链接：https://blog.csdn.net/Lan_____/article/details/109700099

版权

笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

微服务架构

相关依赖
1.搭建微服务需要知道springcloud的常用组件
2.项目组件搭建
3.项目服务搭建
4.sytem-common
5.system-server
6.Swagger配置

1.搭建微服务需要知道springcloud的常用组件

在这里插入图片描述

组件涵义：
zuul：网关，可以理解为是一个海关，只要你需要进入这个微服务就需要通过他的同意即需要遵循zuul yml中的配置条件
eureka：服务注册与发现，如果需要搭建一个微服务都需要注册在eureka里面，也就是需要告诉eureka他自己的ip，端口号，服务名等等。这样做的动机就是为了以后一个微服务需要去调用另一个微服务的时候只需要知道他的服务名就行了，这里不用端口号的原因就是为了不让别人知道不然造成不安全的因素，服务名你就可以自己定义，只要自己能够知道就行。
config-server：服务配置，所有微服务的yml或者properties配置文件都需要交给config-server去管理，通过config-server把这些配置文件集中收集起来，上传到云服务器中去，这样需要注意一个启动的顺序，需要先启动eureka->config-server…因为这里是所有的服务都是注册到了eureka中去的必须先起，config-server第二个起的原因就是因为它收集了所有服务的yml配置(除了eureka)如果没起config-server就起其他服务这样就会造成服务在启动的时候找不到文件而导致报错
ribbon：负载均衡，它存在的作用就是当一个服务需要去调用另外一个服务的时候但是这个服务却做了集群处理，这样就会导致不知道该去调用哪一个，集成ribbon他就会根据他自己内置的轮询算法(默认)，随机算法等等，计算调用那一个
feign：它的底层就是ribbon，也是负载均衡，概念和上面都是一样，只是用法不同，后面会在项目中仔细说明用法
hystrix：熔断器，他是一种自我保护机制，为了防止服务于服务之间的调用的时候出现故障而导致整个服务的终断

2.项目组件搭建

因为springcloud是基于springboot实现的服务与治理的一个工具，用于微服务架构中的管理需协调，所以这里需要在创maven项目的时候就需要导入springboot的依赖

项目的基本架构
在这里插入图片描述

springcloid-hrm-parent中pom的依赖
需要导入springboot，springcloud和公共的依赖

<packaging>pom</packaging>
    <!--公共的一些配置-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR1</spring-cloud.version>
    </properties>
    <!--1.管理 SpringBoot的jar包-->
    <parent>
        <groupId> org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
    </parent>
    <!--2.管理 SpringCloud的jar包
    -->
    <dependencyManagement>
        <dependencies>

            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!--3.这里是所有子项目都可以用的jar包-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

注意：如果在这里放入依赖的话就说明这个项目下的所有子项目都能够使用，所以放入其他依赖时慎重
先做hrm-support-parent中的配置
在这里插入图片描述

2.1 eureka

配置步骤导包开启主类以及pom.xml如下

2.1.1 导入依赖

eureka-server

2.1.2 主启动类

@springboot(springboot必配)@enableEurekaserver（开启eureka服务）

2.1.2 配置yml

可以去spring.io官网查看，里就可以通过yml的配置添加集群

server:
  port: 1010  #端口
eureka:
  instance:
    hostname: localhost #主机
  client: #客户端配置
    registerWithEureka: false  #EurekaServer自己不要注册到EurekaServer自己 ，只有EurekaClient才注册
    fetchRegistry: false  #EurekaServer不要拉取服务的通信地址列表 ，只有EurekaClient才拉取地址列表
    serviceUrl:  #注册中心的注册地址
      defaultZone: http://localhost:1010/eureka/  #http://${eureka.instance.hostname}:${server.port}/eureka/
  server:
    enable-self-preservation: false #关闭自我保护警告

2.2 zuul

配置步骤导包开启主类以及pom.xml如下

2.2.1 导入依赖

eureka-client，zuul依赖以及springboot的web依赖，config客户端依赖，swagger相关依赖

2.2.2 主启动类

@springboot@enbaleEurekaClient@@EnableZuulProxy

2.2.3 配置yml

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1010/eureka/
  instance:
    prefer-ip-address: true # 以端口号注册
    instance-id: zuul-server
server:
  port: 1020
spring:
  application:
    name: zuul-server  # 取名字
zuul:
  prefix: "/hrm"  #统一访问前缀
  ignoredServices: "*"  #禁用掉使用浏览器通过服务名的方式访问服务
  routes:
    hrm-system: "/system/**"   #指定pay-server这个服务使用 /pay路径来访问  - 别名

2.3 config-server

配置步骤导包开启主类写yml配置

2.3.1 导入依赖

eureka-client，springboot-web以及config-server

2.3.2 主启动类

@springboot@enableEurekaclient@@EnableConfigServer

2.3.3 配置yml

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1010/eureka/
  instance:
    prefer-ip-address: true #使用ip地址注册
    instance-id: config-server:1030  #指定服务的id
server:
  port: 1030
spring:
  application:
    name: config-server  #服务名
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/pethome1/config-server-hrm.git #仓库url
          username: xxxxxx@qq.com	#仓库是私有的需要账号
          password: xxxxxxxxxx  #仓库密码

3.项目服务搭建

在这里插入图片描述

3.1.system-server基本搭建

3.1.1.导入依赖

eureka-client;web;config-client
可以把公共包抽取到一个basic-server模块

3.1.2.主启动类

@SpringBootApplication， @EnableEurekaClient

3.1.3.yml配置

	①.eureka注册基本配置
	②.把配置推送到云端
	③.配置bootstrap.yml

application.yml中：

#注册到EurekaServer
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1010/eureka/
  #使用ip地址进行注册
  instance:
    prefer-ip-address: true
    #要指定服务的实例ID
    instance-id:  system-server:1040
server:
  port: 1040
spring:
  application:
    name: system-server #服务名

bootstrap.yml中

#配置中心的地址
spring:
  cloud:
    config:
      uri: http://localhost:1030 #zuul要从配置中心拉取文件
      #你要拉取具体的哪个配置文件
      name: application-system  #配置文件名字   dev是环境
      profile: dev #环境  组成完整的文件名：application-zuul-dev.yml
      label: master #主分支

3.2.mybatisplus代码生成器

3.2.1.搭建code-create模块，导包

mybatisplus ; mysql驱动；velocity
在这里插入图片描述

3.2.2.创建一个properties

1.修改代码输出路径
2.创建数据库，配置连接信息

#代码输出基本路径
OutputDir=D:/Javayuan/java-ruanjian/Ideaspace/hrm/hrm-parent/hrm-system-parent/hrm-system-server-1040/src/main/java
        
#mapper.xml SQL映射文件目录
OutputDirXml=D:/Javayuan/java-ruanjian/Ideaspace/hrm/hrm-parent/hrm-system-parent/hrm-system-server-1040/src/main/resources

#domain的输出路径
OutputDirBase=D:/Javayuan/java-ruanjian/Ideaspace/hrm/hrm-parent/hrm-system-parent/hrm-system-common/src/main/java

#设置作者
author=whale.lan

#自定义包路径:基础包的路径
parent=cn.lan.hrm

#数据库连接信息
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///hrm-system
jdbc.user=root
jdbc.pwd=123456

3.2.2.拷贝模板 resources/templates/模板

controller.java.vm

@RestController
@RequestMapping("/${table.entityPath}")
public class ${entity}Controller {
    @Autowired
    public ${table.serviceName} ${table.entityPath}Service;

    /**
    * 保存和修改公用的
    * @param ${table.entityPath}  传递的实体
    * @return Ajaxresult转换结果
    */
    @RequestMapping(value="/save",method= RequestMethod.POST)
    public AjaxResult save(@RequestBody ${entity} ${table.entityPath}){
        try {
            if(${table.entityPath}.getId()!=null){
                ${table.entityPath}Service.updateById(${table.entityPath});
            }else{
                ${table.entityPath}Service.insert(${table.entityPath});
            }
            return AjaxResult.me();
        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.me().setSuccess(false).setMessage("保存对象失败！"+e.getMessage());
        }
    }

    /**
    * 删除对象信息
    * @param id
    * @return
    */
    @RequestMapping(value="/{id}",method=RequestMethod.DELETE)
    public AjaxResult delete(@PathVariable("id") Long id){
        try {
            ${table.entityPath}Service.deleteById(id);
            return AjaxResult.me();
        } catch (Exception e) {
        e.printStackTrace();
            return AjaxResult.me().setSuccess(false).setMessage("删除对象失败！"+e.getMessage());
        }
    }

    //获取用户
    @RequestMapping(value = "/{id}",method = RequestMethod.GET)
    public ${entity} get(@PathVariable("id")Long id)
    {
        return ${table.entityPath}Service.selectById(id);
    }


    /**
    * 查看所有的员工信息
    * @return
    */
    @RequestMapping(value = "/list",method = RequestMethod.GET)
    public List<${entity}> list(){

        return ${table.entityPath}Service.selectList(null);
    }


    /**
    * 分页查询数据
    *
    * @param query 查询对象
    * @return PageList 分页对象
    */
    @RequestMapping(value = "/pagelist",method = RequestMethod.POST)
    public PageList<${entity}> json(@RequestBody ${entity}Query query)
    {
        Page<${entity}> page = new Page<${entity}>(query.getPage(),query.getRows());
        page = ${table.entityPath}Service.selectPage(page);
        return new PageList<${entity}>(page.getTotal(),page.getRecords());
    }
}

query.java.vm

public class ${table.entityName}Query extends BaseQuery{
}

3.2.3.拷贝一个测试代码

注意配置文件名和表名

/**
 * 生成代码的主类
 */
public class GenteratorCode {

    public static void main(String[] args) throws InterruptedException {
        //用来获取Mybatis-Plus.properties文件的配置信息
        ResourceBundle rb = ResourceBundle.getBundle("mybatiesplus-config-system"); //不要加后缀
        AutoGenerator mpg = new AutoGenerator();
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        gc.setOutputDir(rb.getString("OutputDir"));
        gc.setFileOverride(false);
        gc.setActiveRecord(true);// 开启 activeRecord 模式
        gc.setEnableCache(false);// XML 二级缓存
        gc.setBaseResultMap(true);// XML ResultMap
        gc.setBaseColumnList(false);// XML columList
        gc.setAuthor(rb.getString("author"));
        mpg.setGlobalConfig(gc);
        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setDbType(DbType.MYSQL);
        dsc.setTypeConvert(new MySqlTypeConvert());
        dsc.setDriverName(rb.getString("jdbc.driver"));
        dsc.setUsername(rb.getString("jdbc.user"));
        dsc.setPassword(rb.getString("jdbc.pwd"));
        dsc.setUrl(rb.getString("jdbc.url"));
        mpg.setDataSource(dsc);
        // 表策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setTablePrefix(new String[] { "t_" });// 此处可以修改为您的表前缀
        strategy.setNaming(NamingStrategy.underline_to_camel);// 表名生成策略

        strategy.setInclude(new String[]{
             "t_systemdictionary",
             "t_systemdictionaryitem"
        }); // 需要生成的表

        mpg.setStrategy(strategy);
        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setParent(rb.getString("parent"));  //cn.itsource.hrm
        pc.setController("web.controller"); //cn.itsource.hrm.web.controller
        pc.setService("service");
        pc.setServiceImpl("service.impl");
        pc.setEntity("domain");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);

        // 注入自定义配置，可以在 VM 中使用 cfg.abc 【可无】
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                Map<String, Object> map = new HashMap<String, Object>();
                map.put("abc", this.getConfig().getGlobalConfig().getAuthor() + "-rb");
                this.setMap(map);
            }
        };

        List<FileOutConfig> focList = new ArrayList<FileOutConfig>();

        //controller的输出配置
        focList.add(new FileOutConfig("/templates/controller.java.vm") {
            @Override
            public String outputFile(TableInfo tableInfo) {
                //合并好的内容输出到哪儿？
                return rb.getString("OutputDir")+ "/cn/lan/hrm/web/controller/" + tableInfo.getEntityName() + "Controller.java";
            }
        });
        //query的输出配置
        focList.add(new FileOutConfig("/templates/query.java.vm") {
            @Override
            public String outputFile(TableInfo tableInfo) {
                return rb.getString("OutputDirBase")+ "/cn/lan/hrm/query/" + tableInfo.getEntityName() + "Query.java";
            }
        });

        // 调整 domain 生成目录演示
        focList.add(new FileOutConfig("/templates/entity.java.vm") {
            @Override
            public String outputFile(TableInfo tableInfo) {
                return rb.getString("OutputDirBase")+ "/cn/lan/hrm/domain/" + tableInfo.getEntityName() + ".java";
            }
        });

        // 调整 xml 生成目录演示
        focList.add(new FileOutConfig("/templates/mapper.xml.vm") {
            @Override
            public String outputFile(TableInfo tableInfo) {
                return rb.getString("OutputDirXml")+ "/cn/lan/hrm/mapper/" + tableInfo.getEntityName() + "Mapper.xml";
            }
        });
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // 自定义模板配置，可以 copy 源码 mybatis-plus/src/main/resources/templates 下面内容修改，
        // 放置自己项目的 src/main/resources/templates 目录下, 默认名称一下可以不配置，也可以自定义模板名称
        TemplateConfig tc = new TemplateConfig();
        tc.setService("/templates/service.java.vm");
        tc.setServiceImpl("/templates/serviceImpl.java.vm");
        tc.setMapper("/templates/mapper.java.vm");
        tc.setEntity(null);
        tc.setController(null);
        tc.setXml(null);
        // 如上任何一个模块如果设置 空 OR Null 将不生成该模块。
        mpg.setTemplate(tc);

        // 执行生成
        mpg.execute();
    }
}

3.2.4.执行main生成代码

4.sytem-common

1.增加mybatisplus的包
2.为baseic-common增加query包
3.为baseic-util增加util包
4.sytem-common依赖basic-common，basic-util

5.system-server

5.1导入依赖

sytem-common ；驱动包，druid连接池

5.2.增加配置yml

datasource（5个配置项）
mybatis-plus（mapper-locations）

#注册到EurekaServer
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1010/eureka/
  #使用ip地址进行注册
  instance:
    prefer-ip-address: true
    #要指定服务的实例ID
    instance-id:  system-server:1040
server:
  port: 1040
spring:
  application:
    name: system-server #服务名
  datasource:
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///hrm-system
    type: com.alibaba.druid.pool.DruidDataSource
mybatis-plus:
  mapper-locations: classpath:cn/lan/hrm/mapper/*Mapper.xml

5.3.拷贝配置类

//Spring boot方式
@Configuration
@MapperScan("cn.lan.hrm.mapper") //mapper接口扫描
@EnableTransactionManagement  //事务管理
public class MybatisPlusConfig {

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

6.Swagger配置

6.1system-server集成

6.1.1.导入Swagger两个依赖

6.1.2.拷贝配置：

注意要把controller路径改一下

@Configuration
@EnableSwagger2
public class Swagger2 {
 
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                //对外暴露服务的包,以controller的方式暴露,所以就是controller的包.
                .apis(RequestHandlerSelectors.basePackage("cn.lan.hrm.web.controller"))
                .paths(PathSelectors.any())
                .build();
    }


    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("平台服务api")
                .description("平台服务接口文档说明")
                .contact(new Contact("whale.lan", "", "whale.lan@lan.cn"))
                .version("1.0")
                .build();
    }

}

6.1.3.测试

http://localhost:1040/swager-ui.html

6.2zuul-server集成

6.2.1.导入Swagger两个依赖

6.2.2.配置路由

sytem-server: /system/**

6.2.3.拷贝配置类

①SwaggerConfig：termsOfServiceUrl改成zuul地址

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo());
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("人力资源系统")
                .description("人力资源接口文档说明")
                .termsOfServiceUrl("http://localhost:1020")
                .contact(new Contact("whale.lan", "", "whale.lan@lan.cn"))
                .version("1.0")
                .build();
    }
}

②DocumentationConfig修改：添加swagger资源

@Component
@Primary
public class DocumentationConfig implements SwaggerResourcesProvider {
    @Override
    public List<SwaggerResource> get() {
       List resources = new ArrayList<>();
       //   /前缀/服务路由/v2/api-docs
       resources.add(swaggerResource("系统管理", "/hrm/system/v2/api-docs", "2.0"));
       return resources;
    }

    private SwaggerResource swaggerResource(String name, String location, String version) {
        SwaggerResource swaggerResource = new SwaggerResource();
        swaggerResource.setName(name);
        swaggerResource.setLocation(location);
        swaggerResource.setSwaggerVersion(version);
        return swaggerResource;
    }
}

以上总结： 1、因为所有的微服务都需要注册导eureka中去所以对于其他的服务来说eureka都是client所有每个需要都是需要导入eureka-client包的依赖，并且config-server也是一样的道理，对于所有的微服务都需要把自己的yml配置文件交给config-server，所以对于他来说其他的微服务就是一个client都需要导入config-client
2、因为所有的微服务都把自己的yml配置问文件都交给config-server，所以当你启动其他微服务的时候需要去拉去自己的配置文件就需要在原来创建yml的位置创建一个bootstrap.yml配置文件去拉取自己的yml配置文件，这里不需要把原来的配置文件删除，如果在bootstrap中没有找到文件它就会去执行原来的那个yml配置文件，所以这里存在一个yml的优先级
bootstrap.yml > application.yml & application.properties