zoukankan html css js c++ java

【SpringCloud】快速入门（一）

SpringCloud简介

　　Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智能路由，微代理，控制总线）。分布式系统的协调导致了样板模式, 使用Spring Cloud开发人员可以快速地支持实现这些模式的服务和应用程序。他们将在任何分布式环境中运行良好，包括开发人员自己的笔记本电脑，裸机数据中心，以及Cloud Foundry等托管平台。

　　官网：https://spring.io/projects/spring-cloud

　　特点

　　Spring Cloud专注于为典型的用例和可扩展性机制（包括其他用例）提供良好的开箱即用体验。

分布式/版本化配置
服务注册和发现
路由
服务到服务的呼叫
负载均衡
断路器
全局锁
领导选举和集群状态
分布式消息传递

　　Spring Cloud 架构图

SpringCloud项目搭建

　　学习SpringCloud先要有，SpringBoot的相关知识，参考【SpringBoot】SpringBoot快速入门（一）

　　SpringBoot 是基于 SpringFramework 来构建的，SpringFramework 是一种 J2EE 的框架，SpringBoot 是一种快速构建 Spring 应用，SpringCloud 是构建 Spring Boot 分布式环境，也就是常说的云应用，SpringBoot 中流砥柱，承上启下　　

　　本例项目架构

　　环境准备

　　1）JDK 环境必须是 1.8 及以上，本例使用版本：1.8.0_181

　　2）Maven 项目管理工具，3.6.0及以上版本，本例使用版本：3.6.3

　　3）开发工具使用 IDEA

搭建项目父工程

　　1、新建一个maven空工程test-springcloud

　　2、编写pom文件，引入项目所需要依赖的包

　　　　本例使用的SpringBoot版本是2.2.5.RELEASE，SpringCloud版本是Hoxton.SR3

　　　　使用其他版本，需要注意SpringBoot和SpringCloud版本的兼容问题

 1 <!-- spring boot -->
 2 <dependency>
 3     <groupId>org.springframework.boot</groupId>
 4     <artifactId>spring-boot-dependencies</artifactId>
 5     <version>2.2.5.RELEASE</version>
 6     <type>pom</type>
 7     <scope>import</scope>
 8 </dependency>
 9 <!-- spring cloud -->
10 <dependency>
11     <groupId>org.springframework.cloud</groupId>
12     <artifactId>spring-cloud-dependencies</artifactId>
13     <version>Hoxton.SR3</version>
14     <type>pom</type>
15     <scope>import</scope>
16 </dependency>

　　　　完整pom文件如下：

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <project xmlns="http://maven.apache.org/POM/4.0.0"
  3          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     <modelVersion>4.0.0</modelVersion>
  6 
  7     <groupId>com.test</groupId>
  8     <artifactId>test-springcloud</artifactId>
  9     <version>1.0-SNAPSHOT</version>
 10     <packaging>pom</packaging>
 11 
 12 
 13     <modules>
 14         <module>test-springcloud-eureka-server8761</module>
 15         <module>test-springcloud-order8000</module>
 16         <module>test-springcloud-provider-payment8001</module>
 17     </modules>
 18 
 19 
 20     <!-- 统一管理jar包版本 -->
 21     <properties>
 22         <spring-boot.version>2.2.5.RELEASE</spring-boot.version>
 23         <spring-cloud.version>Hoxton.SR3</spring-cloud.version>
 24         <!--        <spring-cloud-alibaba.version>2.1.0.RELEASE</spring-cloud-alibaba.version>-->
 25         <mybatis-spring-boot.version>2.1.2</mybatis-spring-boot.version>
 26         <mysql.version>8.0.12</mysql.version>
 27         <druid.version>1.1.21</druid.version>
 28         <lombok.version>1.18.12</lombok.version>
 29         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 30         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 31         <java.version>1.8</java.version>
 32     </properties>
 33 
 34 
 35     <!-- 依赖管理：子模块继承后，提供作用：锁定版本 + 子module 不用写 version -->
 36     <dependencyManagement>
 37         <dependencies>
 38             <!-- spring boot -->
 39             <dependency>
 40                 <groupId>org.springframework.boot</groupId>
 41                 <artifactId>spring-boot-dependencies</artifactId>
 42                 <version>${spring-boot.version}</version>
 43                 <type>pom</type>
 44                 <scope>import</scope>
 45             </dependency>
 46             <!-- spring cloud -->
 47             <dependency>
 48                 <groupId>org.springframework.cloud</groupId>
 49                 <artifactId>spring-cloud-dependencies</artifactId>
 50                 <version>${spring-cloud.version}</version>
 51                 <type>pom</type>
 52                 <scope>import</scope>
 53             </dependency>
 54             <!-- spring cloud alibaba -->
 55             <!--            <dependency>-->
 56             <!--                <groupId>com.alibaba.cloud</groupId>-->
 57             <!--                <artifactId>spring-cloud-alibaba-dependencies</artifactId>-->
 58             <!--                <version>${spring-cloud-alibaba.version}</version>-->
 59             <!--                <type>pom</type>-->
 60             <!--                <scope>import</scope>-->
 61             <!--            </dependency>-->
 62 
 63             <!-- mybatis -->
 64             <dependency>
 65                 <groupId>org.mybatis.spring.boot</groupId>
 66                 <artifactId>mybatis-spring-boot-starter</artifactId>
 67                 <version>${mybatis-spring-boot.version}</version>
 68             </dependency>
 69 
 70             <!-- mysql -->
 71             <dependency>
 72                 <groupId>mysql</groupId>
 73                 <artifactId>mysql-connector-java</artifactId>
 74                 <version>${mysql.version}</version>
 75             </dependency>
 76 
 77             <!-- druid -->
 78             <dependency>
 79                 <groupId>com.alibaba</groupId>
 80                 <artifactId>druid-spring-boot-starter</artifactId>
 81                 <version>${druid.version}</version>
 82             </dependency>
 83 
 84             <!-- lombok -->
 85             <dependency>
 86                 <groupId>org.projectlombok</groupId>
 87                 <artifactId>lombok</artifactId>
 88                 <version>${lombok.version}</version>
 89             </dependency>
 90 
 91             <!-- test -->
 92             <dependency>
 93                 <groupId>org.springframework.boot</groupId>
 94                 <artifactId>spring-boot-starter-test</artifactId>
 95                 <version>${spring-boot.version}</version>
 96                 <scope>test</scope>
 97                 <exclusions>
 98                     <exclusion>
 99                         <groupId>org.junit.vintage</groupId>
100                         <artifactId>junit-vintage-engine</artifactId>
101                     </exclusion>
102                 </exclusions>
103             </dependency>
104         </dependencies>
105     </dependencyManagement>
106 
107     <!-- SpringBoot打包插件，可以将代码打包成一个可执行的jar包 -->
108     <build>
109         <finalName>${project.artifactId}</finalName>
110         <plugins>
111             <plugin>
112                 <groupId>org.apache.maven.plugins</groupId>
113                 <artifactId>maven-compiler-plugin</artifactId>
114                 <configuration>
115                     <source>${java.version}</source>
116                     <target>${java.version}</target>
117                 </configuration>
118             </plugin>
119             <plugin>
120                 <groupId>org.springframework.boot</groupId>
121                 <artifactId>spring-boot-maven-plugin</artifactId>
122                 <version>${spring-boot.version}</version>
123                 <configuration>
124                     <fork>true</fork>
125                     <addResources>true</addResources>
126                 </configuration>
127             </plugin>
128         </plugins>
129     </build>
130 </project>
131 
132 pom.xml

pom.xml

　　3、项目结构图如下：

搭建Eureka注册中心

　　即Eureka的服务端

　　1、在父项目上，new module 新建一个模块Eureka注册中心，及Eureka服务端 test-springboot-eureka-server8761

　　2、编写pom.xml文件

　　　　Eureka服务端依赖如下：

1 <!-- eureka server -->
2 <dependency>
3     <groupId>org.springframework.cloud</groupId>
4     <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
5 </dependency>

　　　　完整pom.xml文件如下：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          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>test-springcloud</artifactId>
 7         <groupId>com.test</groupId>
 8         <version>1.0-SNAPSHOT</version>
 9     </parent>
10     <modelVersion>4.0.0</modelVersion>
11 
12     <artifactId>test-springcloud-eureka-server8761</artifactId>
13 
14     <dependencies>
15         <!-- eureka server -->
16         <dependency>
17             <groupId>org.springframework.cloud</groupId>
18             <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
19         </dependency>
20 
21         <!-- spring boot -->
22         <dependency>
23             <groupId>org.springframework.boot</groupId>
24             <artifactId>spring-boot-starter-web</artifactId>
25         </dependency>
26         <dependency>
27             <groupId>org.springframework.boot</groupId>
28             <artifactId>spring-boot-starter-actuator</artifactId>
29         </dependency>
30         <dependency>
31             <groupId>org.springframework.boot</groupId>
32             <artifactId>spring-boot-devtools</artifactId>
33             <scope>runtime</scope>
34             <optional>true</optional>
35         </dependency>
36 
37         <dependency>
38             <groupId>org.springframework.boot</groupId>
39             <artifactId>spring-boot-starter-test</artifactId>
40             <scope>test</scope>
41         </dependency>
42 
43     </dependencies>
44 
45     <build>
46         <finalName>test-springcloud-eureka-server8761</finalName>
47     </build>
48 </project>

pom.xml

　　3、编写application.yml配置文件

 1 # 端口
 2 server:
 3   port: 8761
 4 
 5 spring:
 6   application:
 7     name: cloud-eureka-server
 8 
 9 # Eureka配置
10 eureka:
11   instance:
12     # eureka服务端的实例名称
13     hostname: localhost
14   client:
15     # false表示不向注册中心注册自己
16     register-with-eureka: false
17     # false表示自己端就是注册中心，职责就是维护服务实例，并不需要去检查服务
18     fetch-registry: false
19     # 设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址
20     service-url:
21       defaultZone: http://localhost:8761/eureka

　　4、编辑SpringBoot启动类EurekaMain8761.java，并使用@EnableEurekaServer

1 // Eureka服务端
2 @EnableEurekaServer
3 @SpringBootApplication
4 public class EurekaMain8761 {
5     public static void main(String[] args) {
6         SpringApplication.run(EurekaMain8761.class, args);
7     }
8 }

　　5、启动test-springboot-eureka-server8761项目，使用地址：http://localhost:8761/，进行访问

搭建支付模块、服务提供者

　　即Eureka客户端

　　需要准备一个test_springcloud的mysql数据库，新建一张表payment，内容如下：

 1 SET NAMES utf8mb4;
 2 SET FOREIGN_KEY_CHECKS = 0;
 3 
 4 -- ----------------------------
 5 -- Table structure for payment
 6 -- ----------------------------
 7 DROP TABLE IF EXISTS `payment`;
 8 CREATE TABLE `payment` (
 9   `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
10   `serial` varchar(255) DEFAULT '' COMMENT '流水号',
11   PRIMARY KEY (`id`)
12 ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
13 
14 -- ----------------------------
15 -- Records of payment
16 -- ----------------------------
17 BEGIN;
18 INSERT INTO `payment` VALUES (1, 'No.1');
19 INSERT INTO `payment` VALUES (2, 'No.2');
20 INSERT INTO `payment` VALUES (3, 'No.3');
21 COMMIT;
22 
23 SET FOREIGN_KEY_CHECKS = 1;

View Code

　　1、在父项目上，new module 新建一个模块支付模块，即Eureka客户端 test-springcloud-provider-payment8001

　　2、编写payment模块的pom.xml文件，引入Eureka 客户端依赖

1 <!-- eureka client -->
2 <dependency>
3     <groupId>org.springframework.cloud</groupId>
4     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
5 </dependency>

　　　　完整pom.xml文件如下：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          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>test-springcloud</artifactId>
 7         <groupId>com.test</groupId>
 8         <version>1.0-SNAPSHOT</version>
 9     </parent>
10     <modelVersion>4.0.0</modelVersion>
11 
12     <artifactId>test-springcloud-provider-payment8001</artifactId>
13 
14     <dependencies>
15 
16         <!-- eureka client -->
17         <dependency>
18             <groupId>org.springframework.cloud</groupId>
19             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
20         </dependency>
21 
22         <!-- spring boot -->
23         <dependency>
24             <groupId>org.springframework.boot</groupId>
25             <artifactId>spring-boot-starter-web</artifactId>
26         </dependency>
27         <dependency>
28             <groupId>org.springframework.boot</groupId>
29             <artifactId>spring-boot-starter-actuator</artifactId>
30         </dependency>
31         <dependency>
32             <groupId>org.springframework.boot</groupId>
33             <artifactId>spring-boot-starter-jdbc</artifactId>
34         </dependency>
35         <dependency>
36             <groupId>org.springframework.boot</groupId>
37             <artifactId>spring-boot-devtools</artifactId>
38             <scope>runtime</scope>
39             <optional>true</optional>
40         </dependency>
41         <dependency>
42             <groupId>org.mybatis.spring.boot</groupId>
43             <artifactId>mybatis-spring-boot-starter</artifactId>
44         </dependency>
45         <dependency>
46             <groupId>org.projectlombok</groupId>
47             <artifactId>lombok</artifactId>
48             <optional>true</optional>
49         </dependency>
50         <!-- mysql -->
51         <dependency>
52             <groupId>mysql</groupId>
53             <artifactId>mysql-connector-java</artifactId>
54         </dependency>
55         <!-- druid -->
56         <dependency>
57             <groupId>com.alibaba</groupId>
58             <artifactId>druid-spring-boot-starter</artifactId>
59         </dependency>
60         <dependency>
61             <groupId>org.springframework.boot</groupId>
62             <artifactId>spring-boot-starter-test</artifactId>
63             <scope>test</scope>
64         </dependency>
65 
66     </dependencies>
67 
68     <build>
69         <finalName>test-springcloud-provider-payment8001</finalName>
70     </build>
71 </project>

View Code

　　3、编辑application.yml配置文件

 1 # 端口
 2 server:
 3   port: 8001
 4 
 5 spring:
 6   application:
 7     name: cloud-payment-service
 8   #   数据源基本配置
 9   datasource:
10     driver-class-name: com.mysql.cj.jdbc.Driver
11     url: jdbc:mysql://localhost:3306/test_springcloud?allowPublicKeyRetrieval=true&useSSL=true
12     username: admin
13     password: 123456
14 
15 eureka:
16   client:
17     # 表示将自己注册进Eureka Server默认为true
18     register-with-eureka: true
19     # 是否从Eureka Server抓去已有的注册信息，默认是true
20     fetch-registry: true
21     # 设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址
22     service-url:
23       defaultZone: http://localhost:8761/eureka
24 
25 mybatis:
26   mapperLocations: classpath:mapper/*Mapper.xml
27   # 所有entity别名类所在的包
28   type-aliases-pachage: com.test.springcloud.entities

　　4、编写启动类

1 // Eureka客户端
2 @EnableEurekaClient
3 @SpringBootApplication
4 public class PaymentMain8001 {
5     public static void main(String[] args) {
6         SpringApplication.run(PaymentMain8001.class, args);
7     }
8 }

　　5、新建一个实体类Payment.java

1 @Data
2 @AllArgsConstructor
3 @NoArgsConstructor
4 public class Payment {
5     private Long id;
6     private String serial;
7 }

View Code

　　6、新建一个实体类映射文件 src/main/resources/mapper/PaymentMapper.xml

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 3 
 4 <mapper namespace="com.test.springcloud.dao.PaymentDao">
 5 
 6     <resultMap id="BaseResultMap" type="com.test.springcloud.entities.Payment" >
 7         <id property="id" jdbcType="BIGINT" column="id" />
 8         <result property="serial" jdbcType="VARCHAR" column="serial" />
 9     </resultMap>
10 
11     <insert id="insert" parameterType="com.test.springcloud.entities.Payment" useGeneratedKeys="true" keyProperty="id">
12         INSERT INTO payment(serial) values(#{serial})
13     </insert>
14 
15     <select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap" >
16         SELECT * FROM payment WHERE id = #{id}
17     </select>
18 </mapper>

View Code

　　7、新建一个dao接口

1 @Mapper
2 public interface PaymentDao {
3     // 插入
4     public int insert(Payment payment);
5     // 获取
6     public Payment getPaymentById(@Param("id") Long id);
7 }

View Code

　　8、新建一个service接口

1 public interface PaymentService {
2     // 插入
3     public int insert(Payment payment);
4     // 获取
5     public Payment getPaymentById(Long id);
6 }

View Code

　　9、编写一个接口实现类

 1 @Service
 2 public class PaymentServiceImpl implements PaymentService {
 3 
 4     @Autowired
 5     private PaymentDao paymentDao;
 6 
 7     public int insert(Payment payment) {
 8         return paymentDao.insert(payment);
 9     }
10 
11     public Payment getPaymentById(Long id) {
12         return paymentDao.getPaymentById(id);
13     }
14 }

View Code

　　10、编辑一个通用结果类CommonResult.java

 1 /**
 2  * 通用结果
 3  * @param <T>
 4  */
 5 @Data
 6 @AllArgsConstructor
 7 @NoArgsConstructor
 8 public class CommonResult<T> {
 9 
10     private int code;
11     private String msg;
12     private T data;
13 
14     public CommonResult(int code, String msg) {
15         this.code = code;
16         this.msg = msg;
17     }
18 }

View Code

　　11、新增一个Controller

 1 @Slf4j
 2 @RestController
 3 public class PaymentController {
 4 
 5 
 6     @Autowired
 7     private PaymentService paymentService;
 8 
 9     @Value("${server.port}")
10     private String serverPort;
11 
12     @PostMapping("/payment/insert")
13     public CommonResult insert(@RequestBody Payment payment) {
14         int result = paymentService.insert(payment);
15         log.info("====== 插入结果：" + result);
16         if(result > 0) {
17             return new CommonResult(200, "插入数据成功，服务端口：" + serverPort);
18         }else {
19             return new CommonResult(500, "插入数据失败");
20         }
21 
22     }
23 
24     @GetMapping("/payment/get/{id}")
25     public CommonResult getPaymentById(@PathVariable("id") Long id) {
26         Payment result = paymentService.getPaymentById(id);
27 
28         log.info("====== 查询结果：" + result);
29         if(result != null) {
30             return new CommonResult(200, "查询成功，服务端口：" + serverPort, result);
31         }else {
32             return new CommonResult(500, "查询失败");
33         }
34 
35     }
36 }

View Code

　　12、启动payment模块，查看Eureka注册中心

　　　　访问地址：http://localhost:8001/payment/get/1　　　

搭建订单模块、服务消费

　　1、在父项目上，new module 新建一个模块订单模块，即Eureka客户端 test-springcloud-order8000

　　2、编写order模块的pom.xml文件，引入Eureka 客户端依赖

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          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>test-springcloud</artifactId>
 7         <groupId>com.test</groupId>
 8         <version>1.0-SNAPSHOT</version>
 9     </parent>
10     <modelVersion>4.0.0</modelVersion>
11 
12     <artifactId>test-springcloud-order8000</artifactId>
13 
14 
15     <dependencies>
16 
17         <!-- eureka client -->
18         <dependency>
19             <groupId>org.springframework.cloud</groupId>
20             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
21         </dependency>
22 
23         <!-- spring boot -->
24         <dependency>
25             <groupId>org.springframework.boot</groupId>
26             <artifactId>spring-boot-starter-web</artifactId>
27         </dependency>
28         <dependency>
29             <groupId>org.springframework.boot</groupId>
30             <artifactId>spring-boot-starter-actuator</artifactId>
31         </dependency>
32         <dependency>
33             <groupId>org.springframework.boot</groupId>
34             <artifactId>spring-boot-devtools</artifactId>
35             <scope>runtime</scope>
36             <optional>true</optional>
37         </dependency>
38 
39         <dependency>
40             <groupId>org.projectlombok</groupId>
41             <artifactId>lombok</artifactId>
42             <optional>true</optional>
43         </dependency>
44         <dependency>
45             <groupId>org.springframework.boot</groupId>
46             <artifactId>spring-boot-starter-test</artifactId>
47             <scope>test</scope>
48         </dependency>
49 
50     </dependencies>
51 
52     <build>
53         <finalName>test-springcloud-order8000</finalName>
54     </build>
55 
56 </project>

View Code

　　3、编写application.yml配置文件

 1 # 端口
 2 server:
 3   port: 8000
 4 
 5 spring:
 6   application:
 7     name: cloud-order
 8 
 9 eureka:
10   client:
11     # 表示将自己注册进Eureka Server默认为true
12     register-with-eureka: true
13     # 是否从Eureka Server抓去已有的注册信息，默认是true
14     fetch-registry: true
15     # 设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址
16     service-url:
17       defaultZone: http://localhost:8761/eureka

　　4、编写启动类

1 @EnableEurekaClient
2 @SpringBootApplication
3 public class OrderMain80 {
4     public static void main(String[] args) {
5         SpringApplication.run(OrderMain80.class, args);
6     }
7 }

　　5、编写一个服务调用配置类，注入RestTemplate，调用服务

 1 @Configuration
 2 public class AppConfig {
 3 
 4     /**
 5      * 注入restTemplate，请用请求rest接口
 6      * @return
 7      */
 8     @Bean
 9     // 标注此注解后，RestTemplate就具有了客户端负载均衡能力
10     // 负载均衡技术依赖于的是Ribbon组件~
11     // RestTemplate都塞入一个loadBalancerInterceptor 让其具备有负载均衡的能力
12     @LoadBalanced
13     public RestTemplate restTemplate(){
14         return new RestTemplate();
15     }
16 }

　　6、编写实体类Payment.java

1 @Data
2 @AllArgsConstructor
3 @NoArgsConstructor
4 public class Payment {
5     private Long id;
6     private String serial;
7 }

View Code

　　7、编写通用返回类

 1 @Data
 2 @AllArgsConstructor
 3 @NoArgsConstructor
 4 public class CommonResult<T> {
 5 
 6     private int code;
 7     private String msg;
 8     private T data;
 9 
10     public CommonResult(int code, String msg) {
11         this.code = code;
12         this.msg = msg;
13     }
14 }

View Code

　　8、编写Controller，使用RestTemplate调用服务

 1 @RestController
 2 @Slf4j
 3 public class OrderController {
 4 
 5 //    public static final String PAYMENT_URL = "http://localhost:8001";
 6     public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";
 7 
 8 
 9     @Autowired
10     private RestTemplate restTemplate;
11 
12     @PostMapping("/consumer/payment/insert")
13     public CommonResult<Payment> insert(Payment payment){
14         log.info("====== 请求插入：" + payment);
15         return restTemplate.postForObject(PAYMENT_URL + "/payment/insert", payment, CommonResult.class);
16     }
17 
18     @GetMapping("/consumer/payment/get/{id}")
19     public CommonResult<Payment> getPayment(@PathVariable("id") Long id){
20         return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
21     }
22 }

　　9、启动order模块，查看Eureka注册中心

　　　　访问地址：http://localhost:8000/consumer/payment/get/1

查看全文

相关阅读:
为什么转速环经过pi调节后输出的是电流？
如何将mysql、php、nginx设置为开机自启动
 rm-rf /*
2020/4/23-linux中的定时任务详解
 2020/4/20 一键部署服务
 2020/4/20-ansible一键部署nfs
2020/4/20-backup之rsync
2020/4/19-linux中/etc/hosts
2020/4/18-linux中的selinux
2020/4/18-linux中的iptables

原文地址：https://www.cnblogs.com/h--d/p/12635204.html