Spring Cloud学习笔记
文章目录
- Spring Cloud学习笔记
- 1. 什么是微服务
- 2. 为什么会出现微服务
- 1. 单体架构
- 2. 架构的演变
- 3. 微服务架构的拆分
- 4. 微服务解决方案
- 5. 什么是Spring Could
- 6. Spring Cloud组件之Eureka
- 1. Spring Cloud中的Eureka Server开发
- 2. Spring Cloud中的Eureka Service Client开发
- 3. Spring Cloud中的Eureka Customer Client开发
- 4. Spring Cloud中的Eureka Server（注册中心）的高可用
- 5. 使用jar包的方式启动注册中心Eureka Server服务
- 6. Spring Cloud中的Eureka Service Client（服务提供客户端）的高可用
- 7. Spring Cloud中的Eureka集群的Ribbon的负载均衡策略
- 8. Spring Cloud中服务消费方式之Feign
Spring Cloud学习笔记
1. 什么是微服务
- 有一系列微小的服务共同组成
- 跑在自己的进程里
- 每个服务为独立的业务开发
- 每个服务可以独立部署
- 分布式管理 （分布式：跨机器之间的调用）
微服务官方定义的解释
微服务就是由一系列服务功能组成，能单独跑在自己的进程里，独立开发，独立部署，分布式的管理
注意：微服务并不是什么框架、技术而是一种架构风格
2. 为什么会出现微服务
1. 单体架构
单体架构的所有业务的功能代码都放在一个应用当中
优点：
容易测试
容易部署
缺点：
开发效率低（需要等待上一层代码完成）
代码维护难（需要梳理整个应用代码）
部署不灵活（针对每一个功能模块）
稳定性不高（一个业务功能出问题，整个业务不可用）
扩展性不够（添加业务功能不方便）
2. 架构的演变
3. 微服务架构的拆分
单体架构根据业务功能的需求做拆分。
拆分完成后如何解决如下问题：
1. 服务之间的调用
2. 单一服务出现故障容错问题
3. 服务的负载均衡问题
4. 。。。。。。
4. 微服务解决方案
| 阿里-Dubbo | Spring Cloud |
|---|---|
| Zookeeper +SpringMVC 或 SpringBoot | SpringCould + SpringBoot |
5. 什么是Spring Could
Spring Cloud 是一个涵盖多个子项目的开发工具集，集合了众多开源框架，它利用Spring Boot开发的便利性实现了很多的功能，如服务注册、服务注册发现、负载均衡等，Spring Cloud在整合过程中主要是针对NetFix（耐非）开源组件的封装。
NetFix是美国的一个在线视频网站，微服务业的翘楚，它是公认的大规模生产级微服务的杰出实践者，NetFix的开源组件已经在它大规模分布式微服务环境中经过多年的生产实战验证，因此Spring Cloud中很多组件都是基于NetFix组件的封装。
Spring Cloud的出现真正的简化了分布式架构的开发，降低微服务的入门。
6. Spring Cloud组件之Eureka
Eureka是Spring Cloud的服务注册中心
Spring Cloud的相关依赖版本需要与Spring Boot的相关依赖版本对应才能兼容使用，详情参考Spring Cloud官网：
1. Spring Cloud中的Eureka Server开发
1. 引入Spring Boot的父项目
<!-- 引入springboot-parent的父项目 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.7.RELEASE</version>
</parent>
2. 引入spring cloud eureka server的依赖
1). 添加spring cloud的下载源 和 版本限制
<!-- 指定 spring cloud的下载源 和 spring cloud的版本 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Edgware.SR5</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
2). 引入Eureka server依赖
<!-- 引入springcloud的Eureka server依赖 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
3. 引入springboot的配置文件
application.yml 或 application.properties
server:
port: 8989
4. 开发springboot的入口类EurekaServerApplication.java
需要在入口类上加 @EnableEurekaServer 注解，说明当前应用为Eureka的server
@SpringBootApplication
@EnableEurekaServer //注解作用：代表当前应用是Eureka的server
public class EurekaServerApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServerApplication.class,args);
}
}
5. 访问EurekaServer
6. 异常产生原因及处理
-
异常产生及原因
以上操作完成并访问成功后，会发现后台出现异常，如下：
该异常产生原因是因为EurekaServer应用在启动时默认自身既是服务端也是客户端，所以启动时就将自身客户端注册到服务端中，但是此时服务还没启动完成，所以报错；之后每隔一会会产生一个相同的错误，因为客户端（查看源码知默认注册的服务端地址为：http://localhost:8761/eureka/ ）无法注册到服务端（配置的服务端地址为：http://localhost:8989/eureka/ ），所以报错。
-
异常处理
- 处理启动后产生的异常
-
修改springboot的配置文件application.yml中的访问端口为默认的8761
server: port: 8761
-
指定当前Eureka的客户端注册地址
# 设置应用访问端口 server: port: 8989 # 指定当前Eureka客户端的注册地址 eureka: client: service-url: defaultZone: http://localhost:8989/eureka/
也可以通过以下方式将访问地址与端口写活：# 设置应用访问端口 server: port: 8989 # 指定当前Eureka客户端的注册地址 eureka: client: service-url: defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ register-with-eureka: false # 禁止 自身作为客户端向自身作为服务端 注册 fetch-registry: false # 启动时禁用client注册 instance: hostname: myhost # 为当前主机起别名- 修改注册到服务端的应用的应用名称
配置springboot的配置文件application.yml# 指定应用名称 spring: application: name: eureka-server
- 修改注册到服务端的应用的应用名称
-
- 处理启动时产生的异常
配置springboot的配置文件application.ymleureka: client: register-with-eureka: false # 禁止 自身作为客户端向自身作为服务端 注册 fetch-registry: false # 启动时禁用client注册
此时的后台异常全部处理完毕，同时禁止eureka自身作为客户端向自身作为服务端注册的功能，使其成为一个纯粹的等待其他服务注册的注册中心
- 处理启动后产生的异常
Spring Cloud中的Eureka Server开发完整的pom.xml文件配置
如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.demo</groupId>
<artifactId>springcloud_eureka_server</artifactId>
<version>1.0-SNAPSHOT</version>
<name>springcloud_eureka_server</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<!-- 引入springboot-parent的父项目 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.7.RELEASE</version>
</parent>
<dependencies>
<!-- 引入springcloud的Eureka server依赖 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
</dependencies>
<!-- 指定 spring cloud的下载源 和 spring cloud的版本 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Edgware.SR5</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>
Spring Cloud中的Eureka Server开发完整的application.yml文件配置
如下：
# 指定访问端口
server:
port: 8989
# 指定当前Eureka客户端的注册地址
eureka:
client:
service-url:
defaultZone: http://localhost:${server.port}/eureka/
register-with-eureka: false # 禁止 自身作为客户端向自身作为服务端 注册
fetch-registry: false # 启动时禁用client注册
# 指定应用名称
spring:
application:
name: eureka-server
2. Spring Cloud中的Eureka Service Client开发
1. 配置pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.demo</groupId>
<artifactId>springcloud_eureka_service_client</artifactId>
<version>1.0-SNAPSHOT</version>
<name>springcloud_eureka_service_client</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<!-- 引入springboot-parent的父项目 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.7.RELEASE</version>
</parent>
<dependencies>
<!-- 引入springcloud的Eureka server依赖 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
</dependencies>
<!-- 指定 spring cloud的下载源 和 spring cloud的版本 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Edgware.SR5</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>
2. 配置springboot的配置文件application.yml
#设置访问端口，不要与Eureka的server端端口一样
server:
port: 9090
3. 开发springboot的入口类EurekaServiceApplication.java
需要在入口类上加 @EnableDiscoveryClient 注解，说明当前应用为Eureka的client
建议使用@EnableDiscoveryClient注解，不用@EnableEurekaClient注解
@SpringBootApplication
@EnableDiscoveryClient //代表当前应用是一个Eureka客户端
public class EurekaServiceApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServiceApplication.class,args);
}
}
4. 配置application.yml将当前应用注册到eureka的server中
# 指定访问端口，不要与Eureka的server端端口一样
server:
port: 9090
# 向eureka的server注册服务
eureka:
client:
service-url:
defaultZone: http://localhost:8989/eureka/
# 指定当前服务的名称
spring:
application:
name: hello-service
5. 开发controller，相当于client对外暴露服务
@RestController // = @Controller + @ResponseBody 代表controller中所有返回值都是json格式
@RequestMapping("/hello")
public class HelloController {
@RequestMapping("/sayHello")
public String sayHello(String name){
System.out.println("姓名：" + name);
return "hello" + name;
}
}
3. Spring Cloud中的Eureka Customer Client开发
1. 配置pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.demo</groupId>
<artifactId>springcloud_eureka_customer_client</artifactId>
<version>1.0-SNAPSHOT</version>
<name>springcloud_eureka_customer_client</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<!-- 引入springboot-parent的父项目 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.7.RELEASE</version>
</parent>
<dependencies>
<!-- 引入springcloud的Eureka server依赖 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!-- 引入ribbon的依赖 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-ribbon</artifactId>
</dependency>
</dependencies>
<!-- 指定 spring cloud的下载源 和 spring cloud的版本 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Edgware.SR5</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>
2. 配置springboot的配置文件application.yml文件
# 指定当前应用的访问端口
server:
port: 9091
# 向eureka中注册当前应用
eureka:
client:
service-url:
defaultZone: http://localhost:8989/eureka/
# 指定当前应用的服务名称
spring:
application:
name: hello-customer
3. 开发springboot入口类EurekaCustomerApplication.java
@SpringBootApplication
@EnableDiscoveryClient //作用：说明自己是一个Eureka的Client
public class EurekaCustomerApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaCustomerApplication.class,args);
}
}
4. 开发controller，测试服务方法的调用
客户端调用服务的方式有两种：
1、Ribbon + RestTemplate
2、Feign 底层自动实现负载均衡
1. Ribbon + RestTemplate的第一种服务调用方式
直接通过服务的ip+端口进行调用，不经过注册中心
/**
* Ribbon + RestTemplate的第一种服务调用方式
* 直接通过服务的ip+端口进行调用，不经过注册中心
*/
@RestController
@RequestMapping("/hello")
public class HelloController {
@RequestMapping("/sayHello")
public String sayHello(String name){
RestTemplate restTemplate = new RestTemplate();
//参数一:调用的服务的url； 参数二：响应的数据类型
String forObject = restTemplate.getForObject("http://localhost:9090/hello/sayHello?name=" + name, String.class);
System.out.println(forObject);
return forObject;
}
}
2. Ribbon + RestTemplate的第二种服务调用方式
通过需要调用的服务名称获取服务的ip与端口，然后进行调用，经过注册中心
/**
* Ribbon + RestTemplate的第二种服务调用方式
* 通过需要调用的服务名称获取服务的ip与端口，然后进行调用，经过注册中心
*/
@RestController
@RequestMapping("/hello")
public class HelloController {
@Autowired
private LoadBalancerClient loadBalancerClient;
@RequestMapping("/sayHello")
public String sayHello(String name){
RestTemplate restTemplate = new RestTemplate();
//通过需要调用的服务名称获取服务对象的实例，其中包含ip与端口
ServiceInstance serviceInstance = loadBalancerClient.choose("HELLO-SERVICE");
//获取服务的 IP 与 端口
String host = serviceInstance.getHost();
int port = serviceInstance.getPort();
//参数一:调用的服务的url； 参数二：响应的数据类型
String forObject = restTemplate.getForObject("http://" + host + ":" + port + "/hello/sayHello?name=" + name, String.class);
System.out.println(forObject);
return forObject;
}
}
3. Ribbon + RestTemplate的第三种服务调用方式
将RestTemplate交给spring管理，由Spring管理并自动注入RestTemplate对象，简化代码编写，同样通过需要调用的服务名称获取服务的ip与端口，然后进行调用，经过注册中心。
-
创建配置类
@Configuration public class MyBeans { //管理简单对象 @Bean //在工厂中创建一个实例 @LoadBalanced //将服务列表拉取到本地缓存 public RestTemplate getRestTemplate(){ return new RestTemplate(); } } -
调用服务
/** * Ribbon + RestTemplate的第三种服务调用方式 * 将RestTemplate交给spring管理，由Spring管理并自动注入RestTemplate对象，简化代码编写，同样通过需要调用的服务名称获取服务的ip与端口，然后进行调用，经过注册中心 */ @RestController @RequestMapping("/hello") public class HelloController { @Autowired private LoadBalancerClient loadBalancerClient; //由Spring管理RestTemplate，并自动注入RestTemplate对象 @Autowired private RestTemplate restTemplate; @RequestMapping("/sayHello") public String sayHello(String name){ String forObject = restTemplate.getForObject("http://HELLO-SERVICE/hello/sayHello?name=" + name, String.class); System.out.println(forObject); return forObject; } }以上第二种与第三种访问时会将注册中心中对应的服务列表缓存到本地（只第一次缓存，从第二次开始不会缓存，除非注册中心有服务宕掉，此时注册中心会通过心跳检测知道服务宕掉，并通知客户端重新缓存服务列表，去掉宕掉的服务IP），并在客户端进行负载均衡，默认是轮询分配的。
-
启动Eureka注册中心服务、EurekaClient服务、EurekaCustomer服务
4. Spring Cloud中的Eureka Server（注册中心）的高可用
Eureka自身支持高可用
1. 实现Eureka高可用，需多个Eureka Server,并且相互注册
可以快速复制启动类，并启动，如下图所示：
分别启动启动类时，需要按如下配置文件配置：
- Eureka Server_1的application.yml配置文件
# 指定访问端口 server: port: 8990 # 指定当前Eureka客户端的注册地址 eureka: client: service-url: # 将Eureka Server_1注册到另外两个server中 defaultZone: http://127.0.0.1:8991/eureka/,http://localhost:8991/eureka/ register-with-eureka: false # 禁止 自身作为客户端向自身作为服务端 注册 fetch-registry: false # 启动时禁用client注册 # 指定应用名称 spring: application: name: eureka-server-1 - Eureka Server_2的application.yml配置文件
# 指定访问端口 server: port: 8991 # 指定当前Eureka客户端的注册地址 eureka: client: service-url: # 将Eureka Server_1注册到另外两个server中 defaultZone: http://127.0.0.1:8990/eureka/,http://127.0.0.1:8992/eureka/ register-with-eureka: false # 禁止 自身作为客户端向自身作为服务端 注册 fetch-registry: false # 启动时禁用client注册 # 指定应用名称 spring: application: name: eureka-server-2 - Eureka Server_3的application.yml配置文件
# 指定访问端口 server: port: 8992 # 指定当前Eureka客户端的注册地址 eureka: client: service-url: # 将Eureka Server_1注册到另外两个server中 defaultZone: http://127.0.0.1:8990/eureka/,http://127.0.0.1:8991/eureka/ register-with-eureka: false # 禁止 自身作为客户端向自身作为服务端 注册 fetch-registry: false # 启动时禁用client注册 # 指定应用名称 spring: application: name: eureka-server-3
分别启动三个Eureka Server，如所有Eureka Server的启动日志都出现下图所示情况，表示server高可用集群搭建成功
2. 配置Eureka的提供服务的客户端的application.yml，并启动服务
# 指定当前应用的访问端口，不要与Eureka的server端端口一样
server:
port: 9090
# 向eureka的server注册服务
eureka:
client:
service-url:
# 需要将该应用注册到Eureka Server集群的每个server中
defaultZone: http://localhost:8990/eureka/,http://localhost:8991/eureka/,http://localhost:8992/eureka/
# 指定当前服务的名称
spring:
application:
name: hello-service
3. 配置Eureka的调用服务的客户端的application.yml，并启动服务
# 指定当前应用的访问端口
server:
port: 9091
# 向eureka的server注册服务
eureka:
client:
service-url:
# 需要将该应用注册到Eureka Server集群的每个server中
defaultZone: http://localhost:8990/eureka/,http://localhost:8991/eureka/,http://localhost:8992/eureka/
# 指定当前服务的名称
spring:
application:
name: hello-customer
注意：在使用Eureka Server高可用时，必须将服务同时注册到多个Eureka Server中才能使用高可用
5. 使用jar包的方式启动注册中心Eureka Server服务
6. Spring Cloud中的Eureka Service Client（服务提供客户端）的高可用
注意：
1. 要求多个服务之间代码完全一致
2. 启动多个服务自动构建一个集群环境
3. 同一个服务集群要求在集群中服务名称必须相同
1. 复制、添加，并修改项目名称
2. 修改三个项目的端口
分别修改复制得到的三个项目的application.yml配置文件，指定访问端口,分别为9091、9092、9093：
# 指定访问端口，不要与Eureka的server端端口一样
server:
port: 9091/9092/9093
注意：必须保证三个项目的服务名称一致，否则不能构成集群
3. 分别通过启动类启动三个服务提供客户端项目Eureka Service Client
通过访问Eureka Server注册中心可以看到三个服务提供客户端已启动并注册：
4. 启动服务调用客户端项目Eureka Customer Client
5. 访问服务调用客户端Eureka Customer Client测试
7. Spring Cloud中的Eureka集群的Ribbon的负载均衡策略
由于之前开发时，使用里Ribbon+RestTemplate的客户端调用服务方式，所以可以知道，Ribbon的负载均衡策略默认是轮询策略。
Eureka 集群的负载均衡是在客户端进行的
Ribbon组件中有三个强大的类，如下：
i. ServerList ：用来存储从注册中心缓存到本地的服务的 IP+port
ii. IRule ：用来决定负载均衡策略
iii. ServerListFilter ： 剔除不可用的服务IP
修改Ribbon的负载均衡策略
由于Eureka的负载均衡在客户端进行，所以配置客户端的application.yml即可，加入如下配置：
# 设置某一个服务的负载均衡策略
HELLO-SERVICE:
ribbon:
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
注意：由于Eureka的自我保护机制存在，所以即使Eureka中的某一服务宕掉，但不会进行剔除（比如Eureka认为是网络波动导致的一定时间内的网络延迟，才没有接受的该服务的心跳信号，而并不是宕掉了），即宁可信其有，不可信其无的机制。
该机制可以通过配置application.yml进行关闭
关闭Eureka Server的自我保护机制
配置spring boot的配置文件application.yml关闭自我保护机制：
eureka:
server:
enable-self-preservation: false # 关闭eureka的自我保护机制
注意：测试时关闭，上线时建议开启
修改Eureka Server的心跳检测时间
配置spring boot的application.yml配置文件：
eureka:
server:
eviction-interval-timer-in-ms: 5000 # 超过5s检测eureka中失败的服务并自动剔除
instance:
lease-expiration-duration-in-seconds: 1 # 每间隔1s，向服务器发送一次心跳，证明自己还活着
lease-renewal-interval-in-seconds: 2 # 告诉服务端，如果我2s内没有给你发送心跳，代表服务宕掉，可以剔除
8. Spring Cloud中服务消费方式之Feign
服务的消费方式有两种：一是使用RestTemplate+Ribbon，二是Feign
1. Feign简介
**Feign是一个声明式的伪HTTP客户端，它使得写HTTP客户端变得更简单。**使用Feign，只需要创建一个接口并注解。它具有可插拔的注解特性，可使用Feign注解和JAX-RX注解。Feign支持可插拔的编码器和解码器。Feign默认集成了Ribbon，并和Eureka结合，默认实现了负载均衡的效果。
2. 使用Feign调用服务
1. 创建spring boot项目
2. 配置pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.demo</groupId>
<artifactId>springcloud_eureka_feign_client</artifactId>
<version>1.0-SNAPSHOT</version>
<name>springcloud_eureka_feign_client</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<!-- 引入springboot-parent的父项目 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.7.RELEASE</version>
</parent>
<dependencies>
<!-- 引入springcloud的Eureka client依赖 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!-- 引入Feign -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-feign</artifactId>
</dependency>
</dependencies>
<!-- 指定 spring cloud的下载源 和 spring cloud的版本 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Edgware.SR5</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>
3. 配置application.yml文件
# 指定当前应用的访问端口
server:
port: 9797
# 指定服务注册中心
eureka:
client:
service-url:
defaultZone: http://localhost:8989/eureka/
# 指定应用名称
spring:
application:
name: feign-client
4. 开发入口类FeignClientApplication.java
@SpringBootApplication
@EnableDiscoveryClient //作用：说明自己是一个Eureka的Client
@EnableFeignClients //作用：说明自己是一个使用Feign的Eureka的Client
public class FeignClientApplication {
public static void main(String[] args) {
SpringApplication.run(FeignClientApplication.class,args);
}
}
5. 开发调用服务的接口 HelloServiceInterface.java
// hello-service 为需要调用的服务应用名
@FeignClient("hello-service")
public interface HelloServiceInterface {
// "/hello/sayHello" 为需要访问的服务功能url
@RequestMapping("/hello/sayHello")
// 需要传递参数时，要在参数上加@RequestParam("name")注解
public String sayHello(@RequestParam("name") String name);
}
6. 开发controller，调用服务
@RestController
@RequestMapping("/hello")
public class HelloController {
// 注入调用服务的接口
@Autowired
private HelloServiceInterface helloServiceInterface;
@RequestMapping("/sayHello")
public String sayHello(String name){
//调用服务方法/功能
String hello = helloServiceInterface.sayHello(name);
System.out.println(hello);
return hello;
}
}
浙公网安备 33010602011771号