• 微服务环境搭建

    目录

    案例准备

    技术选型

    模块设计

    微服务调用

    创建一个父工程 

     版本对应：

     创建基础模块

    创建实体类

    创建用户微服务

    对pom文件进行更改

    微服务模块设计

    创建商品微服务

     创建订单微服务

    测试微服务

     用户微服务controller层

    商品微服务controller层

     启动微服务

     在网页上测试

    订单微服务调用其他微服务 

     订单微服务controller层

    运行结果

    我们本次是使用的电商项目中的商品、订单、用户为案例进行讲解。

    案例准备

    技术选型

    maven：3.5.4

    数据库：MySQL 5.7

    持久层: SpingData Jpa/Mybatis-plus

    其他: SpringCloud Alibaba 技术栈

    模块设计

    springcloud-shop父工程

    shop-common 公共模块【实体类】

    shop-user 用户微服务 【端口: 807x】

    shop-product 商品微服务 【端口: 808x】

    shop-order 订单微服务 【端口: 809x】

    微服务调用

    在微服务架构中，最常见的场景就是微服务之间的相互调用。我们以电商系统中常见的用户下单为 例来演示微服务的调用：客户向订单微服务发起一个下单的请求，在进行保存订单之前需要调用商品微 服务查询商品的信息。 我们一般把服务的主动调用方称为服务消费者，把服务的被调用方称为服务提供者。 在这种场景下，订单微服务就是一个服务消费者， 商品微服务就是一个服务提供者。

    创建一个父工程 

     

    新工程需要更改Maven仓库地址

    由于这里不需要写代码，我们将src删除

    pom.xml文件中添加下面内容，锁定版本依赖

    2. <properties>
    3.     <java.version>1.8java.version>
    4.     <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    5.     <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    6.     <spring-boot.version>2.3.2.RELEASEspring-boot.version>
    7.     <spring-cloud.version>Hoxton.SR9spring-cloud.version>
    8.     <spring-cloud-alibaba.version>2.2.6.RELEASEspring-cloud-alibaba.version>
    9. properties>
    10.  
    11. <dependencyManagement>
    12.     <dependencies>
    13.         
    14.         <dependency>
    15.             <groupId>org.springframework.bootgroupId>
    16.             <artifactId>spring-boot-dependenciesartifactId>
    17.             <version>${spring-boot.version}version>
    18.             <type>pomtype>
    19.             <scope>importscope>
    20.         dependency>
    21.     dependencies>
    22.  
    23. dependencyManagement>

     我们所创建的模块会继承版本，由于微服务架构是由单个单个的SpringBoot项目组合而成的，所有需要锁定版本依赖，如果版本不一致的话，在之后的项目开发中写同样的代码会出现各种各样的问题

     版本对应：

    https://github.com/alibaba/spring-cloud-alibaba/wiki/%E7%89%88%E6%9C%AC%E8%AF%B4%E6%98%8E
     

     创建基础模块

    再建一个Maven，作为我们的一个公共模块

     Maven项目比SpringBoot项目的优点在于，它可以选择继承父模块 

    导入基础模块的依赖

    2.     <dependencies>
    3.         <dependency>
    4.             <groupId>org.springframework.bootgroupId>
    5.             <artifactId>spring-boot-starter-data-jpaartifactId>
    6.         dependency>
    7.         <dependency>
    8.             <groupId>org.projectlombokgroupId>
    9.             <artifactId>lombokartifactId>
    10.         dependency>
    11.         <dependency>
    12.             <groupId>com.alibabagroupId>
    13.             <artifactId>fastjsonartifactId>
    14.             <version>1.2.56version>
    15.         dependency>
    16.         <dependency>
    17.             <groupId>mysqlgroupId>
    18.             <artifactId>mysql-connector-javaartifactId>
    19.             <version>5.1.44version>
    20.         dependency>
    21.     dependencies>

     可以看见，我们刚刚创建的模块自动添加了父模块

    对应的父模块也自动添加了子模块 

    如果创建的是Maven项目的话，继承父模块是可以直接加好的，但SpringBoot项目则需要直接手动添加

    创建实体类

    我们在common项目中添加点代码，我们的公共模块主要就是添加一些实体类，工具包等等。

    用户实体类

    1. package com.oyang.model;
    2.  
    3. import lombok.Data;
    4.  
    5. //用户
    6. @Data//不再去写set和get方法
    7. @NoArgsConstructor
    8. @AllArgsConstructor
    9. public class User {
    10.     private Integer uid;//主键
    11.     private String username;//用户名
    12.     private String password;//密码
    13.     private String telephone;//手机号
    14. }

     商品实体类

    1. package com.oyang.model;
    2.  
    3. import lombok.Data;
    4.  
    5. //商品
    6. @Data
    7. @NoArgsConstructor
    8. @AllArgsConstructor
    9. public class Product {
    10.     private Integer pid;//主键
    11.  
    12.     private String pname;//商品名称
    13.     private Double pprice;//商品价格
    14.     private Integer stock;//库存
    15. }

    订单实体

    1. package com.oyang.model;
    2.  
    3. import lombok.Data;
    4.  
    5. //订单
    6. @Data
    7. @NoArgsConstructor
    8. @AllArgsConstructor
    9. public class Order {
    10.     private Long oid;//订单id
    11.  
    12.     //用户
    13.     private Integer uid;//用户id
    14.     private String username;//用户名
    15.  
    16.     //商品
    17.     private Integer pid;//商品id
    18.     private String pname;//商品名称
    19.     private Double pprice;//商品单价
    20.  
    21.     //数量
    22.     private Integer number;//购买数量
    23. }

    由于我们要做微服务。比如用户微服务，商品微服务，订单微服务而微服务所对应的肯定有对应的实体类

    创建用户微服务

    步骤:

    1 创建模块 导入依赖

    2 创建SpringBoot主类

    3 加入配置文件

    4 创建必要的接口和实现类(controller service dao)

    新建一个SpringBoot模块命名为shop-user ，然后进行下面操作

     不用去勾选，这里版本不对应

     这里是没有继承父模块的，所以我们需要自己添加。

    对pom文件进行更改

    只剩下两行，再添加继承父模块的代码，我们直接去common工程拷贝就行 下面的依赖也需要做出改变

    1. <dependencies>
    2.     
    3.     <dependency>
    4.         <groupId>org.springframework.bootgroupId>
    5.         <artifactId>spring-boot-starter-webartifactId>
    6.     dependency>
    7.     
    8.     <dependency>
    9.         <groupId>com.oyanggroupId>
    10.         <artifactId>shop-commonartifactId>
    11.         <version>1.0-SNAPSHOTversion>
    12.     dependency>
    13. dependencies>

     由此可见，在基础模块里面，我们可以定义一些共用的pom依赖，比如：数据库连接、解析JSON对象、Lombok组件

    由于微服务要同时启动，所以我们需要更改端口名

    微服务模块设计

    上面有提到

    1. springcloud-shop父工程
    2. shop-common 公共模块【实体类】
    3. shop-user 用户微服务 【端口: 807x】
    4. shop-product 商品微服务 【端口: 808x】
    5. shop-order 订单微服务 【端口: 809x】

     修改yml文件

    创建商品微服务

    ---与用户微服务一样的操作，这里就不意义演示了

    更改pom

    添加下面依赖

    1. <dependencies>
    2.     
    3.     <dependency>
    4.         <groupId>org.springframework.bootgroupId>
    5.         <artifactId>spring-boot-starter-webartifactId>
    6.     dependency>
    7.     
    8.     <dependency>
    9.         <groupId>com.oyanggroupId>
    10.         <artifactId>shop-commonartifactId>
    11.         <version>1.0-SNAPSHOTversion>
    12.     dependency>
    13. dependencies>

     更改yml文件

     创建订单微服务

    ---与用户微服务一样的操作，这里就不意义演示了

    更改pom

    添加依赖

    1. <dependencies>
    2.     
    3.     <dependency>
    4.         <groupId>org.springframework.bootgroupId>
    5.         <artifactId>spring-boot-starter-webartifactId>
    6.     dependency>
    7.     
    8.     <dependency>
    9.         <groupId>com.oyanggroupId>
    10.         <artifactId>shop-commonartifactId>
    11.         <version>1.0-SNAPSHOTversion>
    12.     dependency>
    13. dependencies>

     更改yml文件

    测试微服务

    我们模拟场景：订单微服务调用商品的微服务以及用户的微服务（跨项目调用功能） 

     用户微服务controller层

    1. package com.oyang.shopuser.controller;
    2.  
    3. import com.oyang.model.User;
    4. import org.springframework.web.bind.annotation.PathVariable;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.RestController;
    7.  
    8. /**
    9.  * @author oyang
    10.  * @site https://blog.csdn.net
    11.  * @qq 1828190940
    12.  * @create  2022-11-24 16:07
    13.  */
    14.  @RestController
    15.  @RequestMapping("/user")
    16. public class UserController {
    17.  
    18.      //获取单个用户
    19.     @RequestMapping("/get/{id}")
    20.     public User get(@PathVariable("id") Integer id){
    21.         return new User(id,"oyang","123","15580XXXXXX");
    22.     }
    23. }

    商品微服务controller层

    1. package com.oyang.shopproduct.controller;
    2.  
    3. import com.oyang.model.Product;
    4. import org.springframework.web.bind.annotation.PathVariable;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.RestController;
    7.  
    8. /**
    9.  * @author oyang
    10.  * @site https://blog.csdn.net
    11.  * @qq 1828190940
    12.  * @create  2022-11-24 16:07
    13.  */
    14.  @RestController
    15.  @RequestMapping("/product")
    16. public class ProductController {
    17.     //返回商品信息
    18.     @RequestMapping("/get/{pid}")
    19.     public Product get(@PathVariable("pid") Integer pid){
    20.         return new Product(pid,"凡人修仙传",30d,30);
    21.     }
    22. }

     启动微服务

    我们先测试一下能否启动项目

    这里test中Junit报了错，我们直接把它删掉，因为用不到 再次启动可以看见，我们的用户微服务已经启动成功了 

    将商品微服务启动

     在网页上测试

     用户微服务

    商品微服务 

    订单微服务调用其他微服务 

    微服务之间采用Restful等轻量级http协议相互调用

    在启动类中添加

    1. @Bean
    2. public RestTemplate restTemplate(){
    3.     return new RestTemplate();
    4. }

     可这个需要在配置类中才有效，为什么可以加载启动类呢？

    原因是启动类中@SpringBootApplication注解包含了配置类，代表当前启动类就可以当做一个配置类来使用

     订单微服务controller层

    1. package com.oyang.shoporder.controller;
    2.  
    3. import com.oyang.model.Order;
    4. import com.oyang.model.Product;
    5. import com.oyang.model.User;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.web.bind.annotation.PathVariable;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9. import org.springframework.web.bind.annotation.RestController;
    10. import org.springframework.web.client.RestTemplate;
    11.  
    12. /**
    13.  * @author oyang
    14.  * @site https://blog.csdn.net
    15.  * @qq 1828190940
    16.  * @create  2022-11-24 16:07
    17.  */
    18. @RestController
    19. @RequestMapping("/order")
    20. public class OrderController {
    21.  
    22.     @Autowired
    23.     private RestTemplate restTemplate;
    24.  
    25.     @RequestMapping("/get/{uid}/{pid}")
    26.     public Order get(@PathVariable("uid") Integer uid,@PathVariable("pid") Integer pid){
    27.         /**
    28.          * 要在订单微服务中调用 用户微服务、商品微服务--也就意味着跨项目调用
    29.          * httpClients
    30.          */
    31.         //得到用户对象
    32.         User user = restTemplate.getForObject("http://localhost:8070/user/get/" + uid, User.class);
    33.         //得到商品对象
    34.         Product product = restTemplate.getForObject("http://localhost:8080/product/get/" + pid, Product.class);
    35.         Order order = new Order();
    36.         order.setUsername(user.getUsername());
    37.         order.setUid(user.getUid());
    38.         order.setPprice(product.getPprice());
    39.         order.setPname(product.getPname());
    40.         order.setPid(product.getPid());
    41.         order.setOid(System.currentTimeMillis());//随机生成id
    42.         order.setNumber(product.getStock());
    43.         return order;
    44.     }
    45. }

    运行结果

     

  • 相关阅读:
    一道简单题引发的思考
    leetcode 47. 全排列 II(java)
    SpringMVC（一）
    浅谈齿轮行业MES解决方案的模块和功能
    Unity中的协程
    mxnet gluon GRU 文档
    BSV上的高效 zk-SNARK：技术解释
    Zookeeper的api使用
    Bootstrap，浅入一下。
    分组查询以及筛选的区别
  • 原文地址：https://blog.csdn.net/weixin_65211978/article/details/128083577