1.项目概述

1.1.项目演示

  1. 运行 “饿了么项目（Spring Cloud版）” ，演示应用程序效果，演示 “点餐业务线” 整体流程。

1.2.项目目标

  1. 本项目主要是在“饿了么项目（SpringBoot版）”的基础上，升级为 Spring Cloud 微服务版。
  2. 本项目完成后，学员将能够使用 Spring Cloud 技术实现分布式微服务系统基础设施的开发。

1.3.项目学习路线图

对于初学者来说，建议要遵循以下路线图来学习：
p01_01.png

1.4.项目架构图

elm.png

  • 分阶段实施的说明：
    1. 第一阶段：只完成简单的微服务拆分与调用。
    2. 第二阶段：添加Eureka注册中心服务，以及搭建Eureka高可用服务集群。
    3. 第三阶段：添加基于Feign的内部服务调用，以及负载均衡。
    4. 第四阶段：添加服务消费者的Hystrix熔断降级处理。
    5. 第五阶段：添加Gateway微服务网关，并实现Gateway的熔断降级、负载均衡、跨域配置等处理。
    6. 第六阶段：添加Config集中配置管理，以及搭建Config高可用服务集群。
    7. 第七阶段：添加Bus配置刷新。

1.5.微服务拆分

如何进行微服务的拆分，目前并没有一个明确的标准可以参考。即便是有一些理论（比如：AKF拆分原则），也仅仅是理论上的。所以这里结合一些查阅的资料，总结一下微服务拆分的原则：

  1. 单一职责，高内聚低耦合。（简单的来说：一张表一个微服务）
  2. 服务粒度适中。（粒度不要太细，一个事务一个微服务）
  3. 以业务模型切入。（用户模块、产品模块、订单模块，都可以成为一个微服务）
  4. 考虑团队结构。（有一种理论认为：微服务的本质是团队分工问题，所以有几个团队，就拆分几个服务）
  5. 渐进式拆分。（刚开始不要划分太细，可以随着迭代过程逐步优化）
  6. 避免环形依赖与双向依赖。（服务拆分最多三层，两次单向调用）

据此，本项目微服务拆分如下：

  • 六个微服务：商家、食品、购物车、订单、送货地址、用户。
  • 商家、食品、购物车、订单：这四个微服务搭建集群，保证高可用。
  • 送货地址、用户：不搭建集群。
  • 商家微服务与食品微服务为内部调用关系。

2.搭建Spring Cloud工程

本阶段项目完成总架构图中的第一阶段，实现最简单的微服务拆分与调用。
elm.png

2.1.创建elm父工程

创建 Maven Project 父工程（工程名：springcloud_demo；Packaging：pom）
p01_03.png
删除src目录，并修改pom.xml文件

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.neusoft</groupId>
  6.     <artifactId>spring_cloud_demo</artifactId>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <packaging>pom</packaging>
  10.     <!-- 统一JAR包和版本号的管理 -->
  11.     <properties>
  12.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  13.         <maven.compiler.source>1.8</maven.compiler.source>
  14.         <maven.compiler.target>1.8</maven.compiler.target>
  15.     </properties>
  17.     <!-- 
  18.         dependmanagement是用在父工程中声明依赖，不引用。子模块继承之后再引包。 
  19.              作用是，锁定版本，子模块不用写grouid and version 
  20.     -->
  21.     <dependencyManagement>
  23.         <dependencies>
  24.             <!--boot 2.3.3 -->
  25.             <dependency>
  26.                 <groupId>org.springframework.boot</groupId>
  27.                 <artifactId>spring-boot-dependencies</artifactId>
  28.                 <version>2.3.3.RELEASE</version>
  29.                 <type>pom</type>
  30.                 <!-- Maven也是单继承。这里继承了spring-boot中的dependencyManagement 
  31.                      但是下面还要继承spring-cloud中的dependencyManagement。 
  32.                     使用scope=import就可以实现多继承了 
  33.                 -->
  34.                 <scope>import</scope>
  35.             </dependency>
  37.             <!--cloud hoxton.sr9 -->
  38.             <dependency>
  39.                 <groupId>org.springframework.cloud</groupId>
  40.                 <artifactId>spring-cloud-dependencies</artifactId>
  41.                 <version>Hoxton.SR9</version>
  42.                 <type>pom</type>
  43.                 <scope>import</scope>
  44.             </dependency>
  46.         </dependencies>
  48.     </dependencyManagement>
  50.     <!-- 创建完子工程后，此处自动添加子工程模块 -->
  51.     <!--
  52.     <modules>
  53.         <module>...</module>
  54.     </modules>
  55.     -->
  57. </project>

注意：根据Spring官方提供的SpringCloud与SpringBoot版本兼容说明中，SpringCloud的Hoxton版本必须使用SpringBoot的2.2.x或2.3.x版本。

2.2.创建用户微服务

在父工程下，创建 Maven Module 子工程（工程名：user_server_10100；Packaging：jar）

2.2.1.修改pom.xml文件

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>com.neusoft</groupId>
  7.         <artifactId>springcloud_elm</artifactId>
  8.         <version>0.0.1-SNAPSHOT</version>
  9.     </parent>
  10.     <artifactId>user_server_10100</artifactId>
  12.     <dependencies>
  13.         <!--以下是boot -->
  14.         <dependency>
  15.             <groupId>org.springframework.boot</groupId>
  16.             <artifactId>spring-boot-starter-web</artifactId>
  17.         </dependency>
  19.         <!--热部署 gav -->
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-devtools</artifactId>
  23.             <scope>runtime</scope>
  24.             <optional>true</optional>
  25.         </dependency>
  27.         <!--数据层相关依赖 -->
  28.         <dependency>
  29.             <groupId>org.mybatis.spring.boot</groupId>
  30.             <artifactId>mybatis-spring-boot-starter</artifactId>
  31.             <version>2.0.1</version>
  32.         </dependency>
  34.         <dependency>
  35.             <groupId>mysql</groupId>
  36.             <artifactId>mysql-connector-java</artifactId>
  37.             <version>5.1.6</version>
  38.             <scope>runtime</scope>
  39.         </dependency>
  40.     </dependencies>
  41. </project>

2.2.2.创建主启动类

  1. package com.neusoft;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class MyApplication {
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(MyApplication.class, args);
  11.     }
  12. }

2.2.3.创建共通返回数据

在po包下创建CommonResult类，作为共通数据格式响应给前端。

  1. package com.neusoft.po;
  3. import java.io.Serializable;
  5. public class CommonResult<T> implements Serializable{
  7.     private Integer code;
  8.     private String message;
  9.     private T result;
  11.     public CommonResult() {}
  13.     public CommonResult(Integer code,String message,T result) {
  14.         this.code = code;
  15.         this.message = message;
  16.         this.result = result;
  17.     }
  19.     public Integer getCode() {
  20.         return code;
  21.     }
  22.     public void setCode(Integer code) {
  23.         this.code = code;
  24.     }
  25.     public String getMessage() {
  26.         return message;
  27.     }
  28.     public void setMessage(String message) {
  29.         this.message = message;
  30.     }
  31.     public T getResult() {
  32.         return result;
  33.     }
  34.     public void setResult(T result) {
  35.         this.result = result;
  36.     }
  37. }

2.2.4.创建Controller控制器

  1. package com.neusoft.controller;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.web.bind.annotation.CrossOrigin;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.PathVariable;
  7. import org.springframework.web.bind.annotation.PostMapping;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  11. import com.neusoft.po.CommonResult;
  12. import com.neusoft.po.User;
  13. import com.neusoft.service.UserService;
  15. @CrossOrigin("*")   //跨域处理
  16. @RestController
  17. @RequestMapping("/UserController")
  18. public class UserController {
  20.     @Autowired
  21.     private UserService userService;
  23.     @GetMapping("/getUserByIdByPass/{userId}/{password}")
  24.     public CommonResult<User> getUserByIdByPass(
  25.                @PathVariable("userId") String userId,
  26.                @PathVariable("password") String password) throws Exception{
  27.         User param = new User();
  28.         param.setUserId(userId);
  29.         param.setPassword(password);
  30.         User user = userService.getUserByIdByPass(param);
  31.         return new CommonResult(200,"success",user);
  32.     }
  34.     @GetMapping("/getUserById/{userId}")
  35.     public CommonResult<Integer> getUserById(@PathVariable("userId") String userId) throws Exception{
  36.         int result = userService.getUserById(userId);
  37.         return new CommonResult(200,"success",result);
  38.     }
  40.     @PostMapping("/saveUser/{userId}/{password}/{userName}/{userSex}")
  41.     public CommonResult<Integer> saveUser(
  42.                @PathVariable("userId") String userId,
  43.                @PathVariable("password") String password,
  44.                @PathVariable("userName") String userName,
  45.                @PathVariable("userSex") Integer userSex) throws Exception{
  46.         User param = new User();
  47.         param.setUserId(userId);
  48.         param.setPassword(password);
  49.         param.setUserName(userName);
  50.         param.setUserSex(userSex);
  51.         int result = userService.saveUser(param);
  52.         return new CommonResult(200,"success",result);
  53.     }
  54. }

2.2.5.创建service、mapper等组件

在 “饿了么项目（SpringBoot版）” 中有详细代码，这里不再累述。

2.2.6.创建application.yml配置文件

  1. server:
  2.     port: 10100
  4. logging:
  5.     level:
  6.         org.springframework: debug
  7.         com.neusoft.mapper: debug
  9. spring:
  10.     application:
  11.         name: user-server
  12.     datasource:
  13.         username: root
  14.         password: 123
  15.         url: jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
  16.         driver-class-name: com.mysql.jdbc.Driver
  18. mybatis:
  19.     mapper-locations: classpath:mapper/*.xml
  20.     type-aliases-package: com.neusoft.po

2.2.7.启动并测试

浏览器地址栏输入：http://localhost:10100/user/getUserByIdByPass/12345671111/123 测试是否能正确返回数据。

2.2.8.修改Vue前端

Vue前端工程修改一下几处：

  1. 删除 main.js 文件中的：axios.defaults.baseURL = ‘http://localhost:8080/‘; 因为不同微服务的IP和端口都不一致。
  2. 使用axios请求时，一律修改成 restful 形式：
    //登录请求
    let url = http://localhost:10100/UserController/getUserByIdByPass/${this.userId}/${this.password};
    //遵循rest规范，所以查询使用get
    this.$axios.get(url).then(response=>{
    //这里注意写法的改变：response.data.result
    let user = response.data.result;
    1.  if(user==null||user==''){
    2.      alert('用户名或密码不正确！');
    3.  }else{
    4.      //sessionstorage有容量限制，为了防止数据溢出，所以不将userImg数据放入session中
    5.      user.userImg = '';
    6.      this.$setSessionStorage('user',user);
    7.      this.$router.go(-1);
    8.  }
    9. }).catch(error=>{
    10.  console.error(error);
    11. });

2.3.创建食品微服务

在父工程下，创建 Maven Module 子工程（工程名：food_server_10200；Packaging：jar）

食品微服务工程中的pom.xml文件、主启动类、CommonResult类等，与用户微服务一致，这里不再累述。

2.3.1.创建Controller控制器

  1. @CrossOrigin("*")
  2. @RestController
  3. @RequestMapping("/FoodController")
  4. public class FoodController {
  6.     @Autowired
  7.     private FoodService foodService;
  9.     @GetMapping("/listFoodByBusinessId/{businessId}")
  10.     public CommonResult<List> listFoodByBusinessId(@PathVariable("businessId") Integer businessId) throws Exception{
  11.         List<Food> list = foodService.listFoodByBusinessId(businessId);
  12.         return new CommonResult(200,"success",list);
  13.     }
  14. }

2.3.2.创建application.yml配置文件

  1. server:
  2.     port: 10200
  4. logging:
  5.     level:
  6.         org.springframework: debug
  7.         com.neusoft.mapper: debug
  9. spring:
  10.     application:
  11.         name: food-server
  12.     datasource:
  13.         username: root
  14.         password: 123
  15.         url: jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
  16.         driver-class-name: com.mysql.jdbc.Driver
  18. mybatis:
  19.     mapper-locations: classpath:mapper/*.xml
  20.     type-aliases-package: com.neusoft.po

2.4.创建商家微服务

在父工程下，创建 Maven Module 子工程（工程名：business_server_10300；Packaging：jar）

2.4.1.创建主启动类

  1. @SpringBootApplication
  2. public class MyApplication {
  3.     //向容器中添加RestTemplate实例
  4.     @Bean
  5.     public RestTemplate getRestTemplate() {
  6.         return new RestTemplate();
  7.     }
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(MyApplication.class, args);
  11.     }
  12. }

2.4.2.创建Controller控制器

  1. @CrossOrigin("*")
  2. @RestController
  3. @RequestMapping("/BusinessController")
  4. public class BusinessController {
  6.     @Autowired
  7.     private BusinessService businessService;
  8.     @Autowired
  9.     private RestTemplate restTemplate;
  11.     @GetMapping("/listBusinessByOrderTypeId/{orderTypeId}")
  12.     public CommonResult<List> listBusinessByOrderTypeId(@PathVariable("orderTypeId") Integer orderTypeId) throws Exception{
  13.         List<Business> list = businessService.listBusinessByOrderTypeId(orderTypeId);
  14.         return new CommonResult(200,"success",list);
  15.     }
  17.     @GetMapping("/getBusinessById/{businessId}")
  18.     public CommonResult<Business> getBusinessById(@PathVariable("businessId") Integer businessId) throws Exception{
  19.         Business business = businessService.getBusinessById(businessId);
  20.         //在商家微服务中调用食品微服务
  21.         CommonResult<List> result = restTemplate.getForObject("http://localhost:10200/FoodController/listFoodByBusinessId/"+businessId, CommonResult.class);
  22.         if(result.getCode()==200) {
  23.             business.setFoodList(result.getResult());
  24.         }
  25.         return new CommonResult(200,"success",business);
  26.     }
  27. }

服务消费者调用服务提供者时，采用的是：主机地址与端口使用硬编码形式。等到第2阶段项目时，会配置Eureka服务注册中心，这里就可以不硬编码了，而是从Eureka服务中获取主机地址与端口。

2.4.3.创建application.yml配置文件

  1. server:
  2.     port: 10300
  4. spring:
  5.     application:
  6.         name: business-server
  7.     #业务配置    
  8.     datasource:
  9.         username: root
  10.         password: 123
  11.         url: jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
  12.         driver-class-name: com.mysql.jdbc.Driver    
  14. #业务配置 
  15. logging:
  16.     level: 
  17.         org.springframework: debug
  18.         com.neusoft.mapper: debug
  19. #业务配置
  20. mybatis:
  21.     mapper-locations: classpath:mapper/*.xml
  22.     type-aliases-package: com.neusoft.po

2.5.创建购物车微服务

在父工程下，创建 Maven Module 子工程（工程名：cart_server_10400；Packaging：jar）

2.5.1.创建Controller控制器

  1. @CrossOrigin("*")
  2. @RestController
  3. @RequestMapping("/CartController")
  4. public class CartController {
  6.     @Autowired
  7.     private CartService cartService;
  9.     @GetMapping("/listCart/{userId}")
  10.     public CommonResult<List> listCart(@PathVariable("userId") String userId) throws Exception{
  11.         Cart param = new Cart();
  12.         param.setUserId(userId);
  13.         List<Cart> list = cartService.listCart(param);
  14.         return new CommonResult(200,"success",list);
  15.     }
  17.     @GetMapping("/listCart/{userId}/{businessId}")
  18.     public CommonResult<List> listCart(
  19.                @PathVariable("userId") String userId,
  20.                @PathVariable("businessId") Integer businessId) throws Exception{
  21.         Cart param = new Cart();
  22.         param.setUserId(userId);
  23.         param.setBusinessId(businessId);
  24.         List<Cart> list = cartService.listCart(param);
  25.         return new CommonResult(200,"success",list);
  26.     }
  28.     @PostMapping("/saveCart/{userId}/{businessId}/{foodId}")
  29.     public CommonResult<Integer> saveCart(
  30.                @PathVariable("userId") String userId,
  31.                @PathVariable("businessId") Integer businessId,
  32.                @PathVariable("foodId") Integer foodId) throws Exception{
  33.         Cart param = new Cart();
  34.         param.setUserId(userId);
  35.         param.setBusinessId(businessId);
  36.         param.setFoodId(foodId);
  37.         int result = cartService.saveCart(param);
  38.         return new CommonResult(200,"success",result);
  39.     }
  41.     @PutMapping("/updateCart/{userId}/{businessId}/{foodId}/{quantity}")
  42.     public CommonResult<Integer> updateCart(
  43.                @PathVariable("userId") String userId,
  44.                @PathVariable("businessId") Integer businessId,
  45.                @PathVariable("foodId") Integer foodId,
  46.                @PathVariable("quantity") Integer quantity) throws Exception{
  47.         Cart param = new Cart();
  48.         param.setUserId(userId);
  49.         param.setBusinessId(businessId);
  50.         param.setFoodId(foodId);
  51.         param.setQuantity(quantity);
  52.         int result = cartService.updateCart(param);
  53.         return new CommonResult(200,"success",result);
  54.     }
  56.     @DeleteMapping("/removeCart/{userId}/{businessId}/{foodId}")
  57.     public CommonResult<Integer> removeCart(
  58.                @PathVariable("userId") String userId,
  59.                @PathVariable("businessId") Integer businessId,
  60.                @PathVariable("foodId") Integer foodId) throws Exception{
  61.         Cart param = new Cart();
  62.         param.setUserId(userId);
  63.         param.setBusinessId(businessId);
  64.         param.setFoodId(foodId);
  65.         int result = cartService.removeCart(param);
  66.         return new CommonResult(200,"success",result);
  67.     }
  68. }

2.5.2.创建application.yml配置文件

  1. server:
  2.     port: 10400
  4. spring:
  5.     application:
  6.         name: cart-server
  7.     #业务配置    
  8.     datasource:
  9.         username: root
  10.         password: 123
  11.         url: jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
  12.         driver-class-name: com.mysql.jdbc.Driver    
  14. #业务配置 
  15. logging:
  16.     level: 
  17.         org.springframework: debug
  18.         com.neusoft.mapper: debug
  19. #业务配置
  20. mybatis:
  21.     mapper-locations: classpath:mapper/*.xml
  22.     type-aliases-package: com.neusoft.po

2.6.创建送货地址微服务

在父工程下，创建 Maven Module 子工程（工程名：deliveryaddress_server_10500；Packaging：jar）

2.6.1.创建Controller控制器

  1. @CrossOrigin("*")
  2. @RestController
  3. @RequestMapping("/DeliveryAddressController")
  4. public class DeliveryAddressController {
  6.     @Autowired
  7.     private DeliveryAddressService deliveryAddressService;
  9.     @GetMapping("/listDeliveryAddressByUserId/{userId}")
  10.     public CommonResult<List> listDeliveryAddressByUserId(@PathVariable("userId") String userId) throws Exception{
  11.         List<DeliveryAddress> list = deliveryAddressService.listDeliveryAddressByUserId(userId);
  12.         return new CommonResult(200,"success",list);
  13.     } 
  15.     @GetMapping("/getDeliveryAddressById/{daId}")
  16.     public CommonResult<DeliveryAddress> getDeliveryAddressById(@PathVariable("daId") Integer daId) throws Exception{
  17.         DeliveryAddress deliveryAddress = deliveryAddressService.getDeliveryAddressById(daId);
  18.         return new CommonResult(200,"success",deliveryAddress);
  19.     } 
  21.     @PostMapping("/saveDeliveryAddress/{contactName}/{contactSex}/{contactTel}/{address}/{userId}")
  22.     public CommonResult<Integer> saveDeliveryAddress(
  23.                @PathVariable("contactName") String contactName,
  24.                @PathVariable("contactSex") Integer contactSex,
  25.                @PathVariable("contactTel") String contactTel,
  26.                @PathVariable("address") String address,
  27.                @PathVariable("userId") String userId) throws Exception{
  28.         DeliveryAddress param = new DeliveryAddress();
  29.         param.setContactName(contactName);
  30.         param.setContactSex(contactSex);
  31.         param.setContactTel(contactTel);
  32.         param.setAddress(address);
  33.         param.setUserId(userId);
  34.         int result = deliveryAddressService.saveDeliveryAddress(param);
  35.         return new CommonResult(200,"success",result);
  36.     } 
  38.     @PutMapping("/updateDeliveryAddress/{daId}/{contactName}/{contactSex}/{contactTel}/{address}")
  39.     public CommonResult<Integer> updateDeliveryAddress(
  40.                @PathVariable("daId") Integer daId,
  41.                @PathVariable("contactName") String contactName,
  42.                @PathVariable("contactSex") Integer contactSex,
  43.                @PathVariable("contactTel") String contactTel,
  44.                @PathVariable("address") String address) throws Exception{
  45.         DeliveryAddress param = new DeliveryAddress();
  46.         param.setDaId(daId);
  47.         param.setContactName(contactName);
  48.         param.setContactSex(contactSex);
  49.         param.setContactTel(contactTel);
  50.         param.setAddress(address);
  51.         int result = deliveryAddressService.updateDeliveryAddress(param);
  52.         return new CommonResult(200,"success",result);
  53.     } 
  55.     @DeleteMapping("/removeDeliveryAddress/{daId}")
  56.     public CommonResult<Integer> removeDeliveryAddress(@PathVariable("daId") Integer daId) throws Exception{
  57.         int result = deliveryAddressService.removeDeliveryAddress(daId);
  58.         return new CommonResult(200,"success",result);
  59.     } 
  60. }

2.6.2.创建application.yml配置文件

  1. server:
  2.     port: 10500
  4. spring:
  5.     application:
  6.         name: deliveryaddress-server
  7.     #业务配置    
  8.     datasource:
  9.         username: root
  10.         password: 123
  11.         url: jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
  12.         driver-class-name: com.mysql.jdbc.Driver    
  14. #业务配置 
  15. logging:
  16.     level: 
  17.         org.springframework: debug
  18.         com.neusoft.mapper: debug
  19. #业务配置
  20. mybatis:
  21.     mapper-locations: classpath:mapper/*.xml
  22.     type-aliases-package: com.neusoft.po

2.7. 创建订单服务

在父工程下，创建 Maven Module 子工程（工程名：orders_server_10600；Packaging：jar）

2.7.1.创建Controller控制器

  1. @CrossOrigin("*") 
  2. @RestController
  3. @RequestMapping("/OrdersController")
  4. public class OrdersController {
  6.     @Autowired
  7.     private OrdersService ordersService;
  9.     @PostMapping("/createOrders/{userId}/{businessId}/{daId}/{orderTotal}")
  10.     public CommonResult<Integer> createOrders(
  11.                @PathVariable("userId") String userId,
  12.                @PathVariable("businessId") Integer businessId,
  13.                @PathVariable("daId") Integer daId,
  14.                @PathVariable("orderTotal") Double orderTotal) throws Exception{
  15.         Orders orders = new Orders();
  16.         orders.setUserId(userId);
  17.         orders.setBusinessId(businessId);
  18.         orders.setDaId(daId);
  19.         orders.setOrderTotal(orderTotal);
  20.         int orderId = ordersService.createOrders(orders);
  21.         return new CommonResult(200,"success（10600）",orderId);
  22.     }
  24.     @GetMapping("/getOrdersById/{orderId}")
  25.     public CommonResult<Orders> getOrdersById(
  26.                @PathVariable("orderId") Integer orderId) throws Exception{
  27.         Orders orders = ordersService.getOrdersById(orderId);
  28.         return new CommonResult(200,"success（10600）",orders);
  29.     }
  31.     @GetMapping("/listOrdersByUserId/{userId}")
  32.     public CommonResult<List> listOrdersByUserId(
  33.                @PathVariable("userId") String userId) throws Exception{
  34.         List<Orders> list = ordersService.listOrdersByUserId(userId);
  35.         return new CommonResult(200,"success（10600）",list);
  36.     }
  37. }

2.7.2.创建application.yml配置文件

  1. server:
  2.     port: 10600
  4. spring:
  5.     application:
  6.         name: orders-server
  7.     #业务配置    
  8.     datasource:
  9.         username: root
  10.         password: 123
  11.         url: jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
  12.         driver-class-name: com.mysql.jdbc.Driver     
  14. #业务配置 
  15. logging:
  16.     level: 
  17.         org.springframework: debug
  18.         com.neusoft.mapper: debug
  19. #业务配置
  20. mybatis:
  21.     mapper-locations: classpath:mapper/*.xml
  22.     type-aliases-package: com.neusoft.po