springcloud微服务_01

前言

使用springcloud微服务

一、商城项目概括

1、商城分类

B2B:公司对公司性质的销售方式，比如阿里巴巴。
B2C:公司对个质的销售方式，比如天猫，京东
C2C:个人对个人的销售方式，比如淘宝网。
B2C2C:既支持自营，也支持入住。天猫，京东等 主力模式

2、项目开发流程

  • 对项目的可行性分析，立项。
  • 需求的讨论。产品相关的人员：产品经理或者需求经理，去与客户进行需求
  • 根据需求文档进行需求分析
  • 架构师搭建需求架构
  • java开发人员进行开发
  • 测试
  • 上线

3、项目的开发方式

（1）瀑布式开发

每一个流程事先都是最完美的准备，当我们开发一段时间后，可能需求发生很大的变化，就会给开发带来很大的麻烦
需求收集–>需求设计–>项目设计–>开发–>测试–>上线

（2）迭代式开发

也叫敏捷开发。事先把一个项目分成很多版本：迭代会议
需求收集–>需求设计–>项目设计–>开发–>测试–>上线

4、前后端分离示意图

前端人员负责展示，后端人员以接口方式提供数据
springcloud微服务_01

5、后台架构示意图

springcloud微服务_01

目前项目整体结构图

springcloud微服务_01

二、项目环境搭建流程

1、顶级父工程。aigou_parent

（1）结构图

springcloud微服务_01

（2）在pom.xml中引入依赖

版本控制

<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>
    <springboot.version>2.0.5.RELEASE</springboot.version>
</properties>

<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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${springboot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

2、创建一个注册中心子项目模块。aigou_eureka_7001

（1）结构图

springcloud微服务_01

（2）在pom.xml中引入依赖

<dependencies>
	<!--web和test-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <!--eureka的服务依赖-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

（3）在YAML中配置。application.yml

没有考虑集群

server:
  port: 7001
eureka:
  instance:
    hostname: eureka-7001.com
  client:
    fetch-registry: false #是否注册到eureka
    register-with-eureka: false #是否从服务获取注册信息
    service-url:
      defaultZone: http://www.eureka-7001.com:7001/eureka/ #这里是另一个中心的地址

（4）创建个启动类

Eureka:注册中心 有服务端（注册中心）和客户端（服务提供者、服务消费者，两者都是注册中心的客户端，所以pom/yml/启动类的注意配置都一样）

@SpringBootApplication
@EnableEurekaServer//注册中心服务端
public class EurekaApplication7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication7001.class);
    }
}

（5）启动注册中心7001，并在浏览器中输入地址：http://localhost:7001 开是否成功

3、配置中心。Config Server

之后详说明。结合git讲

4、创建一个路由网关子项目模块。aigou_zuul_server_9527

（1）结构图

springcloud微服务_01

（2）在pom.xml中引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
    </dependency>
</dependencies>

（3）在YAML中配置 。application.yml

server:
  port: 9527
spring:
  application:
    name: AIGOU-ZUUL-GATEWAY
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: gateway-9527.com
    prefer-ip-address: true

（4）创建启动类

注意：路由网关支持注解

@SpringBootApplication
@EnableEurekaClient//开启注册中心客户端支持
@EnableZuulProxy//启动路由网关支持
public class ZuulApplication9527 {
    public static void main(String[] args) {
        SpringApplication.run(ZuulApplication9527.class);
    }
}

（5）测试注册网关。分别启动注册中心7001、路由网关9527，在浏览器输入地址：http://localhost:7001 查看路由网关是否注册到注册中心

springcloud微服务_01

5、创建基础模块的父工程项目。aigou-basic-parent

也是项目aigou_parent的子模块。会有一些工具类等等的基础模块的子模块项目等等。

（1）结构图

springcloud微服务_01

（2）创建基础模块的子模块–>基础模块工具。aigou_basic_util

（3）在子模块中创建工具类AjaxResult。json数据的返回

要在set方法上，直接返回AjaxResult对象。参考stringbuffer，准备用链式结构。当然也可以选择不用，直接new AjaxResult出来，然后一个一个的设置值。
stringbuffer的底层代码：
springcloud微服务_01

public class AjaxResult {
    //操作是否成功。设置默认成功
    private boolean success=true;
    //返回信息。也要设置默认
    private String msg="操作成功";
    //对象值:供我们在返回前台的时候，可以返回一个对象
    private Object object;
    //提供一个静态方法，直接返回AjaxResult对象
    public static AjaxResult me(){
        return new AjaxResult();
    }

    public boolean isSuccess() {
        return success;
    }

    public AjaxResult setSuccess(boolean success) {
        this.success = success;
        return this;
    }

    public String getMsg() {
        return msg;
    }

    public AjaxResult setMsg(String msg) {
        this.msg = msg;
        return this;
    }

    public Object getObject() {
        return object;
    }

    public AjaxResult setObject(Object object) {
        this.object = object;
        return this;
    }

    @Override
    public String toString() {
        return "AjaxResult{" +
                "success=" + success +
                ", msg='" + msg + '\'' +
                ", object=" + object +
                '}';
    }
}
  • 之后会像这样使用链式编程
public static void main(String[] args) {
      //链式编程
      AjaxResult ajaxResult = AjaxResult.me().setSuccess(true).setMsg("sd").setObject("ssdf");
      System.out.println(ajaxResult);
}

三、平台服务搭建

在上面项目环境搭建好的基础上进行。服务就只进行简单的登录业务

1、创建平台的父工程。aigou_plat_parent

既然是微服务架构，那么就会有很多的服务，所以创建个父工程。子工程就有自己的服务aigou_plat_service和公共部分aigou_plat_interface.

aigou_plat_interface: domain,query,client feign接口（内部服务调用）
aigou_plat_service: controller,service,mapper

（1）结构图

springcloud微服务_01

（2）在公共部分的子模块aigou_plat_interface中写一个User类。

public class User {
    private String name;
    private String pwd;
    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }
    public User() {
    }
    //省略get/set方法
}

（3）在公共部分的子模块aigou_plat_interface的pom.xml中引入aigou_basic_util工具模块的依赖

平台服务的公共部分子模块要依赖于公共基础模块的工具类子模块

<dependencies>
   <dependency>
       <groupId>cn.lyq</groupId>
       <artifactId>aigou_basic_util</artifactId>
       <version>1.0-SNAPSHOT</version>
   </dependency>
</dependencies>

（4）在自己的服务子模块aigou_plat_service的pom.xml中引入依赖

自己的服务子模块aigou_plat_service依赖于公共部分的子模块aigou_plat_interface，而公共部分的子模块aigou_plat_interface又依赖于公共基础模块的工具类子模块aigou_basic_util，所以自己的服务子模块aigou_plat_service就依赖于公共基础模块的工具类子模块aigou_basic_util。

<dependencies>
    <!--依赖公共部分子模块-->
    <dependency>
        <groupId>cn.lyq</groupId>
        <artifactId>aigou_plat_interface</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--web，test-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--配置中心支持-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>

    <!-- Eureka 客户端依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

（5）进行自己的服务子模块aigou_plat_service的YAML配置。application.yml

server:
  port: 8001
spring:
  application:
    name: USER-PROVIDER
eureka:
  client:
    service-url:
      defaultZone: http://eureka-7001.com:7001/eureka  #告诉服务提供者要把服务注册到哪儿 #单机环境
  instance:
    prefer-ip-address: true #显示客户端真实ip

（6）创建自己的服务子模块aigou_plat_service的启动类

@SpringBootApplication
@EnableEurekaClient// eureka的客户端
public class PlatServiceProvider8001 {
    public static void main(String[] args) {
        SpringApplication.run(PlatServiceProvider8001.class);
    }
}

（7）再在自己服务的子模块aigou_plat_service中创建个controller类，用来模拟提供的服务。

用到了之前AjaxResult中的链式语法准备。

@RestController
@RequestMapping("/user")
public class UserController {

    //登录是表单提交：所以一般用post方式
    @RequestMapping(value = "/login",method = RequestMethod.POST)
    //@RequestBody:用来接收前台传来的post请求的参数
    public AjaxResult login(@RequestBody User user){
        //登录的逻辑判断。模拟的service。可以直接在前台判断，但是为了安全，后台也要做判断
        //如果传过来的对象user不为空，并且user对象的名字和密码也不为空
        if(user!=null && !StringUtils.isEmpty(user.getName()) && !StringUtils.isEmpty(user.getPwd())){
            String name=user.getName();
            String pwd=user.getPwd();
            //假定的。如果前台传来的名字是zhangsan和密码是aaa
            if("zhangsan".equals(name) && "aaa".equals(pwd)){
                //就直接返回AjaxResult对象。有设置默认值
                return AjaxResult.me();
            }
        }
        //否则传过来的对象不匹配。使用链式语法设置返回的json数据
        return AjaxResult.me().setSuccess(false).setMsg("登录失败");
    }
}

（8）启动测试。分别启动7001注册中心、8001服务提供者、也可以再启动9527路由网关。

  • 都注册到了注册中心
    springcloud微服务_01

（9）问题。

我要测试服务中的UserController接口。还是post请求。如何操作？

2、接口测试第一种方式：postman

解决上述问题;如何进行接口测试

（1）安装postman。

省略安装过程

（2）使用postman接口测试工具结构图

前后端分离开发项目，后台人员就可以这样测试自己写的代码了。
springcloud微服务_01

3、接口测试第二种方式;Swagger接口测试文档

（1）Swagger示意图

springcloud微服务_01

（2）使用Swagger

只需要在你的接口的项目中做一点配置：导入swagger的依赖和一点配置，就可以通过浏览器访问接口

（3）在自己的服务子模块aigou_plat_service的pom.xml中导入Swagger的依赖

引入Swagger的接口测试文档依赖

<dependencies>
    <!--依赖公共部分子模块-->
    <dependency>
        <groupId>cn.lyq</groupId>
        <artifactId>aigou_plat_interface</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--web，test-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--配置中心支持-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>

    <!-- Eureka 客户端依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

    <!--Swagger接口测试文档-->
    <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.9.2</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.9.2</version>
    </dependency>
</dependencies>

（4）在自己的服务子模块aigou_plat_service中创建个包config进行Swagger的配置。Swagger2的配置类

直接拷贝，然后修改

@Configuration
@EnableSwagger2
public class Swagger2 {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("cn.itsource.aigou.controller"))
                //包：就是自己接口的包路径
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("商品系统api")//名字
                .description("商品系统接口文档说明")//额外描述
                .contact(new Contact("wbtest", "", "[email protected]"))
                .version("1.0")// 版本
                .build();
    }
}
  • 解释：
    springcloud微服务_01

（5）启动测试。分别启动7001注册中心、9527网关、8001服务提供者。然后直接在浏览器输入栏输入地址;http://127.0.0.1:8001/swagger-ui.html查看效果

  • 邮箱：
    springcloud微服务_01
  • 测试接口流程图
    springcloud微服务_01

（6）问题

既然是微服务架构，那么就会有很多的服务，也就会到时候存在很多的IP，很多的端口，那么这样对前端来说很麻烦，那么期望的话只需要记住路由网关的IP就好了。

4、解决上述问题。只记住路由网关的IP即可。

（1）在网关的子模块aigou_zuul_server_9527的pom.xml中导入Swagger的依赖

注意：Swagger的依赖配置

<dependencies>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-test</artifactId>
   </dependency>

   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
   </dependency>

   <!--Swagger的依赖。避免前端要记住很多IP和端口等问题-->
   <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
   <dependency>
       <groupId>io.springfox</groupId>
       <artifactId>springfox-swagger2</artifactId>
       <version>2.9.2</version>
   </dependency>
   <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
   <dependency>
       <groupId>io.springfox</groupId>
       <artifactId>springfox-swagger-ui</artifactId>
       <version>2.9.2</version>
   </dependency>
</dependencies>

（2）在网关的子模块aigou_zuul_server_9527中创建一个配置包config。要做相应的配置

  • 第一个配置：拷贝，然后修改即可
@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:8081")
                .contact(new Contact("wbtest", "", "[email protected]"))
                .version("1.0")
                .build();
    }
}
  • 同样的第二个配置

拷贝，然后修改

@Component
@Primary
public class DocumentationConfig implements SwaggerResourcesProvider {
    @Override
    public List<SwaggerResource> get() {
        List resources = new ArrayList<>();
        //aigou网关前缀,employee网关路径   ；swagger的路径 ，以后增加了接口就在这配置就ok
        resources.add(swaggerResource("用户系统", "/aigou/user/v2/api-docs", "2.0"));
        resources.add(swaggerResource("商品系统", "/aigou/product/v2/api-docs", "2.0"));
        resources.add(swaggerResource("基础系统", "/aigou/common/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;
    }
}

springcloud微服务_01

（3）在网关子模块YAML配置中配置。

增加了前缀。

server:
  port: 9527
spring:
  application:
    name: AIGOU-ZUUL-GATEWAY
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: gateway-9527.com
    prefer-ip-address: true
zuul:
    routes:
      aigouUser.serviceId: user-provider
      aigouUser.path: /user/**  # 匹配 /xxx开头的请求映射到user-provider服务上
    ignored-services: "*" #user-provider #忽略直接使用服务名访问  *忽略所有的
    prefix: /aigou   # 访问前缀
  • 解释说明图
    springcloud微服务_01

（4）启动测试。启动7001注册中心、9527网关、8001服务提供者。

（5）在浏览器输入栏中输入地址;http://localhost:9527/swagger-ui.html

springcloud微服务_01

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode