个人理解：Ribbon它是一种基于消费端的负载均衡。怎么来理解基于消费端和基于客户端呢？1.基于消费端就是说请求一到消费端，是消费端这边先从注册中心拿到服务列表，直接在消费端就做了负载均衡。2.而基于服务端的负载均衡就像nginx(软件)和F5(硬件)这样的对服务器做反向代理的方式。
springcloud-consumer-dept-80向pom.xml中添加Ribbon和Eureka依赖
<!--消费方集成Ribbon依赖实现负载均衡-->
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-ribbon -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-ribbon</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!--需要从eureka发现具体提供的服务,配一个eureka客户端依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
在application.yml文件中配置Eureka
# Eureka配置
eureka:
client:
register-with-eureka: false # 不向 Eureka注册自己
service-url: # 从三个注册中心中随机取一个去访问
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
主启动类加上@EnableEurekaClient注解，开启Eureka
/**
* 采用Ribbon做负载均衡以及配合RestTemplate来调用提供方接口,
* 消费端可以直接通过提供方在注册中心的服务名调用.而不用关心提供方的IP地址和端口号了
*/
@SpringBootApplication
@EnableEurekaClient //开启eureka的客户端
public class DeptConsumer_80 {
public static void main(String[] args) {
SpringApplication.run(DeptConsumer_80.class,args);
}
}
添加@LoadBalanced注解：使用Ribbon让RestTemplate负载均衡
@Configuration
public class ConfigBean {
@Bean
@LoadBalanced //使用Ribbon让RestTemplate负载均衡
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
}
修改conroller：DeptConsumerController.java
// private static final String REST_URL_PREFIX = "http://localhost:8001/";
//通过Ribbon做负载均衡后,直接可以通过提供者的服务名来访问
private static final String REST_URL_PREFIX = "http://springcloud-provider-dept";
现在我们多新建两个服务提供者，来测试Ribbon的负载均衡
流程图:
1.新建两个服务提供者Moudle：springcloud-provider-dept-8003、springcloud-provider-dept-8002
2.参照springcloud-provider-dept-8001 依次为另外两个Moudle添加pom.xml依赖 、resourece下的mybatis和application.yml配置，Java代码
3.启动所有服务测试(根据自身电脑配置决定启动服务的个数)，访问http://eureka7001.com:7001/查看结果如下图：
测试访问消费端http://localhost/consumer/dept/list 这时候随机访问的是服务提供者8001
经过测试发现，以上这种每次访问http://localhost/consumer/dept/list随机访问集群中某个服务提供者，这种情况叫做轮询，轮询算法是Ribbon的默认负载均衡算法!
如何切换或者自定义规则呢？
在springcloud-provider-dept-80模块下的ConfigBean中进行配置，切换使用不同的规则
@Configuration
public class ConfigBean {
//IRule 接口,下面的是实现类
//RoundRobinRule: 轮询
//RandomRule: 随机
//RetryRule: 重试。会先按照轮询获取服务，如果服务获取失败，则会在指定的时间内进行重试
//AvailabilityFilteringRule: 会先过滤掉跳闸或者访问很慢的服务,对剩下的服务进行轮询
@Bean
@LoadBalanced //使用Ribbon让RestTemplate负载均衡
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
// @Bean
// public IRule myRule(){
// return new RandomRule();
// }
}
也可以自定义规则，针对某个服务提供者使用我们自定义的Ribbon均衡算法类
在myRule包下自定义一个配置类MyRule.java，注意：该包不要和主启动类所在的包同级，要跟启动类所在包同级：
原因：
? 我们要的效果是针对这个提供者服务，我们使用这种负载均衡策略,所以自定义均衡算法KuangRule不能与主启动类在一个包下，因为如果在一个包下,这个自定义均衡算法会针对所有提供者服务生效，这是官方文档的原话!
主启动类开启负载均衡并指定自定义的MyRule配置类
@SpringBootApplication
@EnableEurekaClient //开启eureka的客户端
/**
* 在微服务启动的时候去加载我们自定义的Ribbon均衡算法类
* 此方法能够针对某个服务提供者使用我们自定义的Ribbon均衡算法类
* (此注解可以不加也可以像之前那样负载均衡,加上是为了针对某个提供者服务可以采取某种自定义均衡策略)
* (而且我们要的效果是针对这个提供者服务，我们使用这种负载均衡策略,所以自定义均衡算法KuangRule不能与主启动类在一个包下，
* 因为如果在一个包下,这个自定义均衡算法会针对所有提供者服务生效，这是官方文档的原话)
*/
@RibbonClient(name = "springcloud-provider-dept",configuration = KuangRule.class)
public class DeptConsumer_80 {
public static void main(String[] args) {
SpringApplication.run(DeptConsumer_80.class,args);
}
}
KuangRule.java
@Configuration
public class KuangRule {
@Bean
public IRule myRule(){
return new KuangRandomRule(); //默认是轮询，现在我们用了自定义的KuangRandomRule
}
}
自定义的规则(这里我们参考Ribbon中默认的规则RandomRule.java的代码自己稍微改动)：KuangRandomRule.java
规则: 每个服务访问5次则换下一个服务
public class KuangRandomRule extends AbstractLoadBalancerRule {
/**
* 自定义均衡算法(很简单的)：这个小自定义好像也有线程安全的问题,只做测试暂不考虑
* 现在我们想达到这样的一个效果: 每个提供者服务访问5次，访问5次之后换下一个提供者服务,
* 那这样我们有3个服务，服务访问到最后一个，我们搞个指针让他置为0
* total=0,默认=0,如果=5,我们指向下一个服务节点
* index=0,默认=0，如果total=5，index+1, 如果index=3,就把total置为0
*/
private int total=0; //被调用的次数
private int currentIndex=0; //当前是谁在提供服务
//@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
public Server choose(ILoadBalancer lb, Object key) {
if (lb == null) {
return null;
}
Server server = null;
while (server == null) {
if (Thread.interrupted()) {
return null;
}
List<Server> upList = lb.getReachableServers(); //获得活着的服务
List<Server> allList = lb.getAllServers(); //获得全部的服务
int serverCount = allList.size();
if (serverCount == 0) {
return null;
}
// int index = chooseRandomInt(serverCount); //生成区间随机数
// server = upList.get(index); //从活着的服务中随机获取一个
//自定义均衡算法：
//========================================
if(total<5){
server = upList.get(currentIndex);
total++;
}else{
total = 0;
currentIndex++;
if(currentIndex > upList.size()-1){
currentIndex = 0;
}
server = upList.get(currentIndex); //从活着的服务中获取指定的服务来进行操作
total++;
}
//========================================
if (server == null) {
Thread.yield();
continue;
}
if (server.isAlive()) {
return (server);
}
server = null;
Thread.yield();
}
return server;
}
protected int chooseRandomInt(int serverCount) {
return ThreadLocalRandom.current().nextInt(serverCount);
}
@Override
public Server choose(Object key) {
return choose(getLoadBalancer(), key);
}
@Override
public void initWithNiwsConfig(IClientConfig clientConfig) {
// TODO Auto-generated method stub
}
}
测试完美没问题!
Feign是声明式Web Service客户端，它让微服务之间的调用变得更简单，类似controller调用service。SpringCloud集成了Ribbon和Eureka，可以使用Feigin提供负载均衡的http客户端
只需要创建一个接口，然后添加注解即可~
Feign，主要是社区版，大家都习惯面向接口编程。这个是很多开发人员的规范。调用微服务访问两种方法
Feign默认集成了Ribbon
pom.xml添加feign依赖
<!--Feign的依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-feign</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
新建service包，并新建DeptClientService.java接口，
@Component
// @FeignClient:Feign微服务客户端注解,value:指定微服务的名字,这样就可以使Feign客户端直接找到对应的微服务
@FeignClient(value = "springcloud-provider-dept")
public interface DeptClientService {
@GetMapping("/dept/get/{id}")
public Dept queryById(@PathVariable("id") Long id);
@GetMapping("/dept/list")
public List<Dept> queryAll();
@PostMapping("/dept/add")
public boolean addDept(Dept dept);
}
拷贝springcloud-consumer-dept-80模块下的pom.xml，resource，以及java代码到springcloud-consumer-dept--feign模块，并添加feign依赖。
<!--Feign的依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-feign</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
通过Ribbon实现原来的controller：DeptConsumerController.java:
@RestController
public class DeptConsumerController {
@Autowired
private DeptClientService deptClientService;
@RequestMapping("/consumer/dept/get/{id}")
public Dept get(@PathVariable("id") Long id){
return deptClientService.queryById(id);
}
@RequestMapping("/consumer/dept/add")
public boolean add(Dept dept){
return deptClientService.addDept(dept);
}
@RequestMapping("/consumer/dept/list")
public List<Dept> list(){
return deptClientService.queryAll();
}
}
在主启动类添加@EnableFeignClients注解
@SpringBootApplication
@EnableEurekaClient //开启eureka的客户端
@EnableFeignClients(basePackages={"com.kuang.springcloud"})
public class FeignDeptConsumer_80 {
public static void main(String[] args) {
SpringApplication.run(FeignDeptConsumer_80.class,args);
}
}
测试一下，完美运行!
根据个人习惯而定，如果喜欢REST风格使用Ribbon；如果喜欢社区版的面向接口风格使用Feign.
Feign 本质上也是实现了 Ribbon，只不过后者是在调用方式上，为了满足一些开发者习惯的接口调用习惯！
原文：https://www.cnblogs.com/laiyw/p/15142407.html