Spring Cloud与微服务之商品微服务

比眉伴天荒 2022-04-05 12:27 454阅读 0赞

文章目录

  • 微服务间的调用场景
  • 项目结构
    • springcloud-goods-item项目结构
    • springcloud-goods-item2项目结构
  • 源码
    • springcloud-goods-item源码
    • springcloud-goods-item2部分源码
  • 结果分析
    • 查看Eureka中的服务注册信息
    • 请求商品条目信息

微服务间的调用场景

  在使用Spring Cloud微服务时，经常会用到微服务模块间的调用场景。

  比如说我们这里有两个微服务，其一是商品微服务；其二是订单微服务，此时我们想要查询订单微服务中的信息时，订单微服务就会向商品微服务中请求对应的商品条目信息，于是就出现了微服务间的调用场景。

项目结构

springcloud-goods-item项目结构

在这里插入图片描述

springcloud-goods-item2项目结构

在这里插入图片描述

源码

springcloud-goods-item源码

  JdbcConfigBean源码：

  1. package com.lyc.configBean;
  3. import lombok.*;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.cloud.context.config.annotation.RefreshScope;
  6. import org.springframework.stereotype.Component;
  8. @Getter
  9. @Setter
  10. @Builder
  11. @ToString
  12. @NoArgsConstructor
  13. @AllArgsConstructor
  14. @Component  //加入到Spring容器
  15. @RefreshScope
  16. public class JdbcConfigBean { 
  18.     @Value("${jdbc.url}")
  19.     private String url;
  21.     @Value("${jdbc.username}")
  22.     private String username;
  24.     @Value("${jdbc.password}")
  25.     private String password;
  27.     @Value("${jdbc.driverClassName}")
  28.     private String driverClassName;
  30. }

  ItemController源码：

  1. package com.lyc.controller;
  3. import com.lyc.configBean.JdbcConfigBean;
  4. import com.lyc.item.entity.Item;
  5. import com.lyc.service.ItemService;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.web.bind.annotation.GetMapping;
  9. import org.springframework.web.bind.annotation.PathVariable;
  10. import org.springframework.web.bind.annotation.RestController;
  12. @Slf4j
  13. @RestController
  14. public class ItemController { 
  16.     @Autowired
  17.     private ItemService itemService;
  18.     @Autowired
  19.     private JdbcConfigBean jdbcConfigBean;
  21.     @GetMapping("/item/{id}")
  22.     public Item queryItemById(@PathVariable("id") Long id){ 
  23.         log.info("----------springcloud-goods-item中的方法----------");
  24.         return this.itemService.queryItemById(id);
  25.     }
  27.     @GetMapping(value = "test")
  28.     public String test(){ 
  29.         return this.jdbcConfigBean.toString();
  30.     }
  32. }

  ItemService源码：

  1. package com.lyc.service;
  3. import com.lyc.item.dao.ItemDao;
  4. import com.lyc.item.entity.Item;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  8. @Service
  9. public class ItemService { 
  11.     @Autowired
  12.     ItemDao itemDao;
  14.     /** * 模拟实现商品查询 * @param id * @return */
  15.     public Item queryItemById(Long id){ 
  16.        return itemDao.queryItemById(id);
  17.     }
  19. }

  ItemApplication源码：

  1. package com.lyc;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  7. @EnableEurekaServer   //申明这是一个Eureka服务
  8. @SpringBootApplication   //申明这是一个Spring Boot项目
  9. public class ItemApplication { 
  11.     public static void main(String[] args) { 
  12.         SpringApplication.run(ItemApplication.class,args);
  13.     }
  15. }

  application.yml源码：

  1. server:
  2.   port: 8081  #服务端口
  4. spring:
  5.   application:
  6.     name: springcloud-goods-item  #指定服务名
  8. eureka:
  9.   client:
  10.     registerWithEureka: true #是否将自己注册到Eureka服务中，默认为true
  11.     fetchRegistry: true #是否从Eureka中获取注册信息，默认为true
  12.     serviceUrl: #Eureka客户端与Eureka服务端进行交互的地址
  13.       defaultZone: http://root:root123@127.0.0.1:6868/eureka/,http://root:root123@127.0.0.1:6869/eureka/
  14.   instance:
  15.     prefer-ip-address: true #将自己的ip地址注册到Eureka服务中
  16.     ip-address: 127.0.0.1
  17.     instance-id: ${spring.application.name}:${server.port} #指定实例id
  19. management:
  20.   security:
  21.     enabled: false #是否开启安全认证

  bootstrap.yml源码：

  1. eureka:
  2.   client:
  3.     serviceUrl: #Eureka客户端与Eureka服务端进行交互的地址
  4.       defaultZone: http://root:root123@127.0.0.1:6868/eureka/
  6. spring:
  7.   cloud:
  8.     config:
  9.       name: microservice
  10.       #uri: http://127.0.0.1:6688/ #对应配置服务中的应用名称
  11.       profile: dev #对应配置服务中的{profile}
  12.       label: master #对应的分支
  13.       discovery:
  14.         enabled: true #启用发现服务功能
  15.         service-id: springcloud-config-server #指定服务名称
  17.   rabbitmq: #RabbitQM相关的配置
  18.     host: 127.0.0.1
  19.     port: 5672
  20.     username: guest
  21.     password: guest

  pom.xml源码：

  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springcloud-parent</artifactId>
  7.         <groupId>com.lyc</groupId>
  8.         <version>1.0-RELEASE</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>springcloud-goods-item</artifactId>
  13.     <packaging>jar</packaging>
  15.     <name>SpringCloud微服务：：商品服务1</name>
  16.     <url>http://www.example.com</url>
  18.     <properties>
  19.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  20.     </properties>
  22.     <!--导入SpringCloud的依赖管理-->
  23.     <dependencyManagement>
  24.         <dependencies>
  25.             <dependency>
  26.                 <groupId>org.springframework.cloud</groupId>
  27.                 <artifactId>spring-cloud-dependencies</artifactId>
  28.                 <version>Dalston.SR3</version>
  29.                 <type>pom</type>
  30.                 <scope>import</scope>
  31.             </dependency>
  32.         </dependencies>
  33.     </dependencyManagement>
  35.     <dependencies>
  36.         <dependency>
  37.             <groupId>org.springframework.boot</groupId>
  38.             <artifactId>spring-boot-starter-web</artifactId>
  39.         </dependency>
  40.         <!--导入Eureka服务的依赖-->
  41.         <dependency>
  42.             <groupId>org.springframework.cloud</groupId>
  43.             <artifactId>spring-cloud-starter-eureka-server</artifactId>
  44.         </dependency>
  45.         <!-- 添加config client依赖 -->
  46.         <dependency>
  47.             <groupId>org.springframework.cloud</groupId>
  48.             <artifactId>spring-cloud-starter-config</artifactId>
  49.         </dependency>
  50.         <dependency>
  51.             <groupId>org.springframework.boot</groupId>
  52.             <artifactId>spring-boot-starter-actuator</artifactId>
  53.         </dependency>
  54.         <dependency>
  55.             <groupId>org.springframework.cloud</groupId>
  56.             <artifactId>spring-cloud-starter-bus-amqp</artifactId>
  57.         </dependency>
  58.         <dependency>
  59.             <groupId>com.lyc</groupId>
  60.             <artifactId>springcloud-goods-db</artifactId>
  61.         </dependency>
  62.     </dependencies>
  64.     <build>
  65.         <finalName>${project.artifactId}</finalName>
  66.     </build>
  68. </project>

springcloud-goods-item2部分源码

  由于模拟分布式的要求，因而这里创建了两个springcloud-goods-item，其中第二个被命名为springcloud-goods-item2，他们中的大部分代码都是相同的，所以说这里仅仅是贴出其中的不同部分。

  • 由ItemApplication变更为Item2Application。
  • application.yml中的端口号由8081变更为8083
  • pom.xml中的名称也做类似的修改。

结果分析

查看Eureka中的服务注册信息

  同时启动springcloud-goods-item与springcloud-goods-item2，由于我们在项目的application.yml中已经配置了将自身注册到Eureka以及从Eureka中获取服务，因而我们可以在Eureka中查看到相应的服务注册项。

在这里插入图片描述

  由于我们两个项目中的application.yml配置的服务名都是如下配置

  1. spring:
  2.   application:
  3.     name: springcloud-goods-item  #指定服务名

  因而我们可以在Eureka中看到两个相同的服务名:springcloud-goods-item。

请求商品条目信息

  假如说我们要访问springcloud-goods-item中的商品条目，我们可以这么写：

  1. http://127.0.0.1:8081/item/1

  其请求的结果如下：

在这里插入图片描述

  从上面的结果中，我们可以看到，我们成功的查询出了自己想要的数据。

  其中这里的商品信息就是从springcloud-goods-db中取出来的，而由于我们的springcloud-goods-item本身没有商品实体类Item，而该实体类是存放到统一的springcloud-goods-db中，我们在springcloud-goods-item中通过如下方式引入的springcloud-goods-db。

  1. <dependency>
  2.     <groupId>com.lyc</groupId>
  3.     <artifactId>springcloud-goods-db</artifactId>
  4. </dependency>

  而由于在springcloud-goods-db中我们通过@Component将ItemDao类声明为一个组件，因而我们在springcloud-goods-item的ItemService类中，通过如下方式注入：

  1. @Autowired
  2. ItemDao itemDao;

  这样我们就可以在ItemService中正常的使用ItemDao中的方法了，当然，如果将其换成Mybatis，其原理也是一样的。

发表评论

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

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

相关阅读

    相关 微服务与Spring Cloud

    微服务与Spring Cloud   要想搭建一套微服务架构需要考虑如下几个问题： 1、微服务之间的通信协议，需要使用同一的通信协议； 2、网络拥塞与延迟，一个请求跨多

    叁歲伎倆叁歲伎倆/ 0 赞/ 277 阅读