04-负载均衡及Ribbon&自定义负载均衡算法

负载均衡及Ribbon

ribbon是什么？

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。

ribbon能干吗？

• LB，即负载均衡(Load Balance)，在微服务或分布式集群中经常用的一种应用。
• 负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用)。
• 常见的负载均衡软件有Nginx, Lvs等等
• dubbo、SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义

第一步、80项目 加依赖

    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-ribbonartifactId>
        <version>1.4.6.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-eurekaartifactId>
        <version>1.4.6.RELEASEversion>
    dependency>

第二步、80 application.xml加配置

#erueka配置
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/

第三步、80 com.tian.springcloud.config;

• 配置类

@Configuration
public class ConfigBean { //@Configuration --- spring applicationContext.xml
    //配置负载均衡实现Template
    @LoadBalanced //Ribbon
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

第四步、controller

 @Autowired
    private RestTemplate restTemplate;//提供多种便捷访问远程http服务的方法，简单的restful服务模板~

    //这里的地址，一百个该市一个变量，通过服务名来访问
    //private static final String REST_URL_PREFIX="http://localhost:8001";
    private static final String REST_URL_PREFIX="http://SPRINGCLOUD-PROVIDER-DEPT";

第五步、主启动类加注解 @EnableEurekaClient

//ribbon 和 eureka 整合以后，客户端可以直接调用，不用IP地址
@SpringBootApplication
@EnableEurekaClient 
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

---

使用Ribbon实现负载均衡

第一步、创建db02 db03数据库 数据和db01一样，db_source不一样

第二步、new module 8002 8003

copy

pom依赖
resource下面的资源   
application.xml 里面更改对应的数据库和端口号和 instance-id

三个application：
		name 是一样的 

copy    DeptMapper.xml
copy    java 代码 （dao service controller）
改一下主启动类 即可

7001 8001 8002 8003 启动 80启动~

测试访问 轮询

---

自定义负载均衡算法

默认是轮询

所以不和主启动类放在一个包下

第一步、自定义一个算法类 TianRandomRule

package com.tian.myrule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class TianRandomRule extends AbstractLoadBalancerRule {
    /*每个服务，访问5次 换下一个服务（3个）
     * total=0 默认=0 如果等于5 就指向下一个服务节点
     * index=0 默认为0 如果total=5 index+1
     * */
    private int total=0; //被调用的次数
    private int currentIndex=0; //当前是谁在提供服务

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        } else {
            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;
                }
//-----------------
                if (total<5){
                    server=upList.get(currentIndex);
                    total++;
                }else {
                    total=0;
                    currentIndex++;
                    if(currentIndex>upList.size()-1){
                        currentIndex=0;
                    }
                }
//-------------
//                int index = this.chooseRandomInt(serverCount);
//                server = (Server)upList.get(index);



                if (server == null) {
                    Thread.yield();
                } else {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                    Thread.yield();
                }
            }

            return server;
        }
    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

第二步、配置到spring中~

return new TianRandomRule();